plugins/plugin_arena/plugin_arena.c

Go to the documentation of this file.

/************************************************************************
*            Atrinik, a Multiplayer Online Role Playing Game            *
*                                                                       *
*    Copyright (C) 2009-2011 Alex Tokar and Atrinik Development Team    *
*                                                                       *
* Fork from Daimonin (Massive Multiplayer Online Role Playing Game)     *
* and Crossfire (Multiplayer game for X-windows).                       *
*                                                                       *
* This program is free software; you can redistribute it and/or modify  *
* it under the terms of the GNU General Public License as published by  *
* the Free Software Foundation; either version 2 of the License, or     *
* (at your option) any later version.                                   *
*                                                                       *
* This program is distributed in the hope that it will be useful,       *
* but WITHOUT ANY WARRANTY; without even the implied warranty of        *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
* GNU General Public License for more details.                          *
*                                                                       *
* You should have received a copy of the GNU General Public License     *
* along with this program; if not, write to the Free Software           *
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.             *
*                                                                       *
* The author can be reached at admin@atrinik.org                        *
************************************************************************/

#include <global.h>
#include <stdarg.h>

#define PLUGIN_NAME "Arena"

#define PLUGIN_VERSION "Arena plugin 1.0"

typedef struct arena_map_players
{
    object *op;

    struct arena_map_players *next;
} arena_map_players;

typedef struct arena_maps_struct
{
    char path[HUGE_BUF];

    int players;

    int parties;

    arena_map_players *player_list;

    int max_players;

    int max_parties;

    uint32 flags;

    char message_arena_full[MAX_BUF];

    char message_arena_party[MAX_BUF];

    struct arena_maps_struct *next;
} arena_maps_struct;

#define ARENA_FLAG_NONE             0

#define ARENA_FLAG_PARTY            1

#define ARENA_FLAG_PARTY_PLAYERS    2

arena_maps_struct *arena_maps;

struct plugin_hooklist *hooks;

#undef LOG
#define LOG hooks->LOG

MODULEAPI void initPlugin(struct plugin_hooklist *hooklist)
{
    hooks = hooklist;

    LOG(llevDebug, "Arena: Atrinik Arena Plugin loading...\n");
    LOG(llevDebug, "Arena:  [Done]\n");
}

MODULEAPI void closePlugin()
{
    LOG(llevDebug, "Arena: Arena Plugin closing.\n");
}

MODULEAPI void *getPluginProperty(int *type, ...)
{
    va_list args;
    const char *propname;
    int size;
    char *buf;

    va_start(args, type);
    propname = va_arg(args, const char *);

    if (!strcmp(propname, "Identification"))
    {
        buf = va_arg(args, char *);
        size = va_arg(args, int);
        va_end(args);
        snprintf(buf, size, PLUGIN_NAME);
        return NULL;
    }
    else if (!strcmp(propname, "FullName"))
    {
        buf = va_arg(args, char *);
        size = va_arg(args, int);
        va_end(args);
        snprintf(buf, size, PLUGIN_VERSION);
        return NULL;
    }

    va_end(args);
    return NULL;
}

MODULEAPI void postinitPlugin()
{
    LOG(llevDebug, "Arena: Start postinitPlugin.\n");

    hooks->register_global_event(PLUGIN_NAME, GEVENT_LOGOUT);
}

static int check_arena_player(object *op, arena_map_players *player_list)
{
    arena_map_players *player_list_tmp;

    /* Go through the list of players. */
    for (player_list_tmp = player_list; player_list_tmp; player_list_tmp = player_list_tmp->next)
    {
        if (player_list_tmp->op == op)
        {
            return 1;
        }
    }

    return 0;
}

static void remove_arena_player(object *op, arena_map_players **player_list)
{
    arena_map_players *currP, *prevP = NULL;

    for (currP = *player_list; currP; prevP = currP, currP = currP->next)
    {
        if (currP->op == op)
        {
            if (!prevP)
            {
                *player_list = currP->next;
            }
            else
            {
                prevP->next = currP->next;
            }

            free(currP);
            break;
        }
    }
}

static void arena_map_parse_line(arena_maps_struct *arena_map, const char *line)
{
    /* Maximum number of players */
    if (strncmp(line, "max_players ", 12) == 0)
    {
        arena_map->max_players = atoi(line + 12);
    }
    /* Maximum number of parties */
    else if (strncmp(line, "max_parties ", 12) == 0)
    {
        arena_map->max_parties = atoi(line + 12);
    }
    /* Whether to allow arena party mode */
    else if (strncmp(line, "party ", 6) == 0)
    {
        line += 6;

        if (!strcmp(line, "true") || *line == '1')
        {
            arena_map->flags |= ARENA_FLAG_PARTY;
        }
    }
    /* Or even party players? */
    else if (strncmp(line, "party_players ", 14) == 0)
    {
        line += 14;

        if (!strcmp(line, "true") || *line == '1')
        {
            arena_map->flags |= ARENA_FLAG_PARTY_PLAYERS;
        }
    }
    /* Message for when the arena is full */
    else if (strncmp(line, "message_full ", 13) == 0)
    {
        strncpy(arena_map->message_arena_full, line + 13, sizeof(arena_map->message_arena_full) - 1);
    }
    /* Message when you need to join a party to enter */
    else if (strncmp(line, "message_party ", 14) == 0)
    {
        strncpy(arena_map->message_arena_party, line + 13, sizeof(arena_map->message_arena_party) - 1);
    }
}

static void arena_map_parse_script(const char *arena_script, object *exit_ob, arena_maps_struct *arena_map)
{
    FILE *fh;
    char buf[MAX_BUF], tmp_path[HUGE_BUF];
    char *arena_script_path;

    /* Normalize the path to the script, allowing relative paths */
    hooks->normalize_path(exit_ob->map->path, arena_script, tmp_path);

    /* Create path name to the script in maps directory */
    arena_script_path = hooks->create_pathname(tmp_path);

    /* Initialize defaults */
    arena_map->max_players = 0;
    arena_map->max_parties = 0;
    arena_map->players = 0;
    arena_map->parties = 0;
    arena_map->flags = ARENA_FLAG_NONE;
    strncpy(arena_map->message_arena_full, "Sorry, this arena seems to be full.", sizeof(arena_map->message_arena_full) - 1);
    strncpy(arena_map->message_arena_party, "You must be in a party in order to enter this arena.", sizeof(arena_map->message_arena_party) - 1);

    fh = fopen(arena_script_path, "r");

    if (!fh)
    {
        LOG(llevBug, "Arena: Could not open arena script: %s\n", arena_script_path);
        return;
    }

    while (fgets(buf, sizeof(buf), fh))
    {
        /* Ignore comments and empty lines */
        if (*buf == '#' || *buf == '\n')
        {
            continue;
        }

        /* Remove newline and parse the line */
        buf[strlen(buf) - 1] = '\0';
        arena_map_parse_line(arena_map, buf);
    }

    fclose(fh);
}

static int arena_full(arena_maps_struct *arena_map)
{
    /* Simple case: The map has nothing to do with parties. */
    if (!(arena_map->flags & ARENA_FLAG_PARTY) && !(arena_map->flags & ARENA_FLAG_PARTY_PLAYERS) && arena_map->players == arena_map->max_players)
    {
        return 1;
    }
    /* Otherwise a party map. */
    else if (arena_map->flags & ARENA_FLAG_PARTY)
    {
        /* If this is party players arena, count in players. */
        if (arena_map->flags & ARENA_FLAG_PARTY_PLAYERS && arena_map->players == arena_map->max_players)
        {
            return 1;
        }

        /* Always check for maximum parties, even if this is party players arena. */
        if (arena_map->parties == arena_map->max_parties)
        {
            return 1;
        }
    }

    return 0;
}

int arena_enter(object *who, object *exit_ob, const char *arena_script)
{
    char tmp_path[HUGE_BUF];
    arena_maps_struct *arena_maps_tmp;

    /* The exit must have a path */
    if (!exit_ob->slaying)
    {
        return 0;
    }

    /* Normalize the map's path */
    hooks->normalize_path(exit_ob->map->path, EXIT_PATH(exit_ob), tmp_path);

    /* Go through the list of arenas */
    for (arena_maps_tmp = arena_maps; arena_maps_tmp; arena_maps_tmp = arena_maps_tmp->next)
    {
        /* If the exit's path matches this arena */
        if (!strcmp(arena_maps_tmp->path, tmp_path))
        {
            /* If the arena is full, show a message to the player */
            if (arena_full(arena_maps_tmp))
            {
                hooks->new_draw_info(0, COLOR_WHITE, who, arena_maps_tmp->message_arena_full);
                return 1;
            }
            /* Not full but it's party arena and the player is not in a party? */
            else if (arena_maps_tmp->flags & ARENA_FLAG_PARTY && !CONTR(who)->party)
            {
                hooks->new_draw_info(0, COLOR_WHITE, who, arena_maps_tmp->message_arena_party);
                return 1;
            }
            /* Add the player to the list of players and increase the number of players/parties */
            else
            {
                arena_map_players *player_list_tmp = (arena_map_players *) malloc(sizeof(arena_map_players));

                /* For party arenas, also increase the parties count */
                if (arena_maps_tmp->flags & ARENA_FLAG_PARTY)
                {
                    arena_map_players *player_list_party;
                    int new_party = 1;

                    /* Loop through the player list */
                    for (player_list_party = arena_maps_tmp->player_list; player_list_party; player_list_party = player_list_party->next)
                    {
                        /* If we found a match for this party number, do not increase the count */
                        if (CONTR(who)->party && CONTR(who)->party == CONTR(player_list_party->op)->party)
                        {
                            new_party = 0;
                            break;
                        }
                    }

                    /* Increase the count, if this is a new party in the arena */
                    if (new_party)
                    {
                        arena_maps_tmp->parties++;
                    }
                }

                /* Increase the number of players */
                arena_maps_tmp->players++;

                player_list_tmp->next = arena_maps_tmp->player_list;
                arena_maps_tmp->player_list = player_list_tmp;

                /* Store the player object */
                player_list_tmp->op = who;
                return 0;
            }
        }
    }

    /* If we are here, the arena doesn't have an entry in the linked list -- create it */
    arena_maps_tmp = (arena_maps_struct *) malloc(sizeof(arena_maps_struct));
    strncpy(arena_maps_tmp->path, tmp_path, sizeof(arena_maps_tmp->path) - 1);

    /* Parse script options */
    arena_map_parse_script(arena_script, exit_ob, arena_maps_tmp);

    /* If this arena is full, show a message and return */
    if (arena_full(arena_maps_tmp))
    {
        hooks->new_draw_info(0, COLOR_WHITE, who, arena_maps_tmp->message_arena_full);
        free(arena_maps_tmp);
        return 1;
    }
    /* Otherwise if not full and the player is not in party */
    else if (arena_maps_tmp->flags & ARENA_FLAG_PARTY && !CONTR(who)->party)
    {
        hooks->new_draw_info(0, COLOR_WHITE, who, arena_maps_tmp->message_arena_party);
        free(arena_maps_tmp);
        return 1;
    }

    /* Add this player to the player count */
    arena_maps_tmp->players++;

    /* Add to the party count, if this is party arena */
    if (arena_maps_tmp->flags & ARENA_FLAG_PARTY)
    {
        arena_maps_tmp->parties++;
    }

    /* Make a list of players in this arena */
    arena_maps_tmp->player_list = (arena_map_players *) malloc(sizeof(arena_map_players));

    /* Store the player */
    arena_maps_tmp->player_list->op = who;

    arena_maps_tmp->player_list->next = NULL;

    arena_maps_tmp->next = arena_maps;
    arena_maps = arena_maps_tmp;

    return 0;
}

int arena_sign(object *who, const char *path)
{
    arena_maps_struct *arena_maps_tmp;

    /* Sanity check */
    if (!path || path[0] == '\0')
    {
        return 1;
    }

    for (arena_maps_tmp = arena_maps; arena_maps_tmp; arena_maps_tmp = arena_maps_tmp->next)
    {
        /* If the path matches */
        if (!strcmp(arena_maps_tmp->path, path) && arena_maps_tmp->player_list)
        {
            arena_map_players *player_list_tmp;

            hooks->new_draw_info(0, COLOR_YELLOW, who, "This arena has the following players in:\n");

            /* Now go through the list of players in this arena */
            for (player_list_tmp = arena_maps_tmp->player_list; player_list_tmp; player_list_tmp = player_list_tmp->next)
            {
                hooks->new_draw_info_format(0, COLOR_YELLOW, who, "%s (level %d)", player_list_tmp->op->name, player_list_tmp->op->level);
            }

            if (!(arena_maps_tmp->flags & ARENA_FLAG_PARTY) || (arena_maps_tmp->flags & ARENA_FLAG_PARTY && arena_maps_tmp->flags & ARENA_FLAG_PARTY_PLAYERS))
            {
                hooks->new_draw_info_format(0, COLOR_YELLOW, who, "\nTotal players: %d\nMaximum players:  %d", arena_maps_tmp->players, arena_maps_tmp->max_players);
            }

            if (arena_maps_tmp->flags & ARENA_FLAG_PARTY)
            {
                hooks->new_draw_info_format(0, COLOR_YELLOW, who, "\nTotal parties: %d\nMaximum parties:  %d", arena_maps_tmp->parties, arena_maps_tmp->max_parties);
            }

            return 1;
        }
    }

    hooks->new_draw_info(0, COLOR_YELLOW, who, "This arena is currently empty.");
    return 1;
}

static int arena_event(object *who, object *exit_ob, const char *event_options, const char *arena_script)
{
    /* If the first 5 characters are "sign|", this is an arena sign */
    if (event_options && !strncmp(event_options, "sign|", 5))
    {
        event_options += 5;
        return arena_sign(who, event_options);
    }
    /* Otherwise arena entrance */
    else
    {
        return arena_enter(who, exit_ob, arena_script);
    }
}

static int arena_leave(object *who)
{
    arena_maps_struct *arena_maps_tmp;

    /* Sanity checks */
    if (!who || !who->map || !who->map->path || !who->name)
    {
        return 0;
    }

    /* Go through the list of arenas */
    for (arena_maps_tmp = arena_maps; arena_maps_tmp; arena_maps_tmp = arena_maps_tmp->next)
    {
        /* If it matches, and the player really is in the arena */
        if (!strcmp(arena_maps_tmp->path, who->map->path) && check_arena_player(who, arena_maps_tmp->player_list))
        {
            /* If this is party arena, we will want to see if we have to decrease the parties count */
            if (arena_maps_tmp->flags & ARENA_FLAG_PARTY)
            {
                arena_map_players *player_list_party;
                int do_remove = 1;

                /* Loop through the player list for this map */
                for (player_list_party = arena_maps_tmp->player_list; player_list_party; player_list_party = player_list_party->next)
                {
                    /* If the party number matches, we're not going to remove this party */
                    if (player_list_party->op != who && CONTR(who)->party && CONTR(who)->party == CONTR(player_list_party->op)->party)
                    {
                        do_remove = 0;
                        break;
                    }
                }

                /* Removing the party? Then decrease the count. */
                if (do_remove)
                {
                    arena_maps_tmp->parties--;
                }
            }

            /* Decrease the count of players */
            arena_maps_tmp->players--;

            /* Remove the player from this the arena's player list */
            remove_arena_player(who, &arena_maps_tmp->player_list);
            return 0;
        }
    }

    return 0;
}

MODULEAPI void *triggerEvent(int *type, ...)
{
    object *activator, *who, *other, *event;
    va_list args;
    int eventcode, event_type;
    static int result = 0;

    va_start(args, type);
    event_type = va_arg(args, int);
    eventcode = va_arg(args, int);
    LOG(llevDebug, "Arena: triggerEvent(): eventcode %d\n", eventcode);

    activator = va_arg(args, object *);

    if (event_type == PLUGIN_EVENT_NORMAL)
    {
        switch (eventcode)
        {
            case EVENT_APPLY:
            case EVENT_TRIGGER:
            {
                char *text, *script, *options;
                int parm1, parm2, parm3, parm4;

                who = va_arg(args, object *);
                other = va_arg(args, object *);
                event = va_arg(args, object *);
                text = va_arg(args, char *);
                parm1 = va_arg(args, int);
                parm2 = va_arg(args, int);
                parm3 = va_arg(args, int);
                parm4 = va_arg(args, int);
                script = va_arg(args, char *);
                options = va_arg(args, char *);

                (void) other;
                (void) event;
                (void) text;
                (void) parm1;
                (void) parm2;
                (void) parm3;
                (void) parm4;

                result = arena_event(activator, who, options, script);
                break;
            }
        }
    }
    else if (event_type == PLUGIN_EVENT_MAP)
    {
        switch (eventcode)
        {
            case MEVENT_LEAVE:
                result = arena_leave(activator);
                break;
        }
    }
    else if (event_type == PLUGIN_EVENT_GLOBAL)
    {
        switch (eventcode)
        {
            case GEVENT_PLAYER_DEATH:
            case GEVENT_LOGOUT:
                result = arena_leave(activator);
                break;
        }
    }

    va_end(args);
    return &result;
}