account_char.c

Go to the documentation of this file.

/*
 * Crossfire -- cooperative multi-player graphical RPG and adventure game
 *
 * Copyright (c) 1999-2013 Mark Wedel and the Crossfire Development Team
 * Copyright (c) 1992 Frank Tore Johansen
 *
 * Crossfire is free software and comes with ABSOLUTELY NO WARRANTY. You are
 * welcome to redistribute it under certain conditions. For details, please
 * see COPYING and LICENSE.
 *
 * The authors can be reached via e-mail at <crossfire@metalforge.org>.
 */
 
#include "global.h"
 
#include <assert.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
 
#include "account_char.h"
#include "object.h"
#include "output_file.h"
#include "sproto.h"
#include "player.h"
 
#define NUM_ACCOUNT_CHAR_FIELDS 8
 
#define ACCOUNT_DIR "account"
 
static Account_Chars **chars_loaded = NULL; 
static size_t chars_loaded_count = 0;       
static size_t chars_loaded_allocated = 0;   
static void account_char_load_from_file(Account_Chars *chars) {
    char fname[MAX_BUF], buf[VERY_BIG_BUF];
    FILE *fp;
    Account_Char *ac, *last = NULL;
 
    snprintf(fname, MAX_BUF, "%s/%s/%s", settings.localdir, ACCOUNT_DIR, chars->account_name);
    fp = fopen(fname, "r");
    if (!fp) {
        /* This may not in fact be a critical error - for a new account, there
         * may not be any data associated with it.
         */
        LOG(llevInfo, "Warning: Unable to open %s: %s\n", fname, strerror(errno));
        return;
    }
    while (fgets(buf, VERY_BIG_BUF, fp)) {
        char *tmp[NUM_ACCOUNT_CHAR_FIELDS], *cp;
 
        /* Ignore any comment lines */
        if (buf[0] == '#') continue;
 
        /* remove newline */
        cp = strchr(buf, '\n');
        if (cp) *cp = '\0';
 
        if (split_string(buf, tmp, NUM_ACCOUNT_CHAR_FIELDS, ':') != NUM_ACCOUNT_CHAR_FIELDS) {
            if (!tmp[7]) {
                LOG(llevInfo, "Outdated entry in %s: %s\n", fname, buf);
                tmp[7] = (char *) add_string("0");
            } else {
                LOG(llevError, "Corrupt entry in %s: %s\n", fname, buf);
                continue;
            }
        }
        ac = malloc(sizeof (Account_Char));
        ac->name = add_string(tmp[0]);
        ac->character_class = add_string(tmp[1]);
        ac->race = add_string(tmp[2]);
        ac->level = strtoul(tmp[3], (char**) NULL, 10);
        ac->face = add_string(tmp[4]);
        ac->party = add_string(tmp[5]);
        ac->map = add_string(tmp[6]);
        ac->isDead = strtoul(tmp[7], (char**) NULL, 10);
 
        ac->next = NULL;
 
        /* We tack on to the end of the list - in this way,
         * the order of the file remains the same.
         */
        if (last)
            last->next = ac;
        else
            chars->chars = ac;
        last = ac;
 
    }
    fclose(fp);
}
 
Account_Chars *account_char_load(const char *account_name) {
    for (size_t loaded = 0; loaded < chars_loaded_count; loaded++) {
        if (strcmp(chars_loaded[loaded]->account_name, account_name) == 0) {
            chars_loaded[loaded]->ref_count++;
            return chars_loaded[loaded];
        }
    }
 
    Account_Chars *ac = calloc(1, sizeof(*ac));
    ac->ref_count++;
    ac->account_name = add_string(account_name);
    account_char_load_from_file(ac);
 
    if (chars_loaded_count == chars_loaded_allocated) {
        chars_loaded_allocated += 10;
        chars_loaded = realloc(chars_loaded, chars_loaded_allocated * sizeof(chars_loaded[0]));
        if (!chars_loaded) {
            LOG(llevError, "Out of memory allocating %d account chars\n", chars_loaded_allocated);
            fatal(OUT_OF_MEMORY);
        }
    }
    chars_loaded[chars_loaded_count] = ac;
    chars_loaded_count++;
 
    return ac;
}
 
void account_char_save(Account_Chars *chars) {
    char fname[MAX_BUF];
    FILE *fp;
    OutputFile of;
    Account_Char *ac;
 
    snprintf(fname, MAX_BUF, "%s/%s/%s", settings.localdir, ACCOUNT_DIR, chars->account_name);
 
    /* It is certanly possibly that all characters for an account have
     * been removed/deleted - in that case, we just want to remove this
     * file.
     */
    if (chars->chars == NULL) {
        unlink(fname);
        return;
    }
 
    fp = of_open(&of, fname);
    if (fp == NULL)
        return;
 
    fprintf(fp, "# IMPORTANT: Do not edit this file while the server is running. This file is\n"
                "# only read when the server starts, and any changes will be overwritten when\n"
                "# the server exits.\n");
    for (ac = chars->chars; ac; ac = ac->next) {
        fprintf(fp, "%s:%s:%s:%d:%s:%s:%s:%d\n",
                ac->name, ac->character_class, ac->race, ac->level,
                ac->face, ac->party, ac->map, ac->isDead);
    }
    of_close(&of);
}
 
void account_char_add(Account_Chars *chars, player *pl) {
 
    Account_Char *ap, *last = NULL;
 
    for (ap = chars->chars; ap; ap = ap->next) {
        if (!strcmp(ap->name, pl->ob->name)) break;
        last = ap;
    }
    /* If ap is not NULL, it means we found a match.
     * Rather than checking to see if values have changed, just
     * update them.
     */
    if (ap) {
        /* We know the name can not be changing, as otherwise
         * we wouldn't have gotten a match. So no need to
         * update that.
         */
#if 0
        /* As of right now, the class of the character is not stored
         * anyplace, so we don't know what it is.  Keep this code here
         * until it can be determined.
         */
        free_string(ap->character_class);
        ap->character_class = add_string();
#else
        ap->character_class = add_string("");
#endif
 
        free_string(ap->race);
        /* This looks pretty nasty.  Basically, the player object is
         * the race archetype, but its name has been changed to the player
         * name.  So we have to go back to the actual original archetype,
         * the clone object in there, to get the name.
         */
        ap->race = add_string(pl->ob->arch->clone.name);
 
        ap->level = pl->ob->level;
 
        /* We should try and get the best face (front view) of
         * the character - right now, we just get whatever view the character
         * happens to be facing.  Unfortunately, the animation code is such
         * that it isn't a simple matter as most of that logic is not
         * conveniently exposed.
         */
        free_string(ap->face);
        ap->face = add_string(pl->ob->face->name);
 
        free_string(ap->party);
        if (pl->party)
            ap->party = add_string(pl->party->partyname);
        else
            ap->party = add_string("");
 
        free_string(ap->map);
 
        /* If there is a real name set for the map, use that instead
         * of the pathname, which is what maplevel holds.  This is
         * more friendly (eg, Scorn Inn vs /scorn/inns/....)
         */
        if (pl->ob->map && pl->ob->map->name) {
            ap->map = add_string(pl->ob->map->name);
        } else {
            /* Use the stored value - this may not be as up to date, but is
             * probably more reliable, as depending when this charapter is added,
             * it may not really be on any map.
             */
            ap->map = add_string(pl->maplevel);
        }
    } else {
        /* In this case, we are adding a new entry */
        ap = malloc(sizeof (Account_Char));
        ap->name = add_string(pl->ob->name);
        ap->character_class = add_string("");
        ap->race = add_string(pl->ob->arch->clone.name);
        ap->level = pl->ob->level;
        ap->face = add_string(pl->ob->face->name);
        if (pl->party)
            ap->party = add_string(pl->party->partyname);
        else
            ap->party = add_string("");
        ap->map = add_string(pl->maplevel);
        /* The character cannot be dead already */
        ap->isDead = 0;
 
        ap->next = NULL;
        if (last)
            last->next = ap;
        else
            chars->chars = ap;
    }
}
 
void account_char_remove(Account_Chars *chars, const char *pl_name) {
    Account_Char *ap, *last = NULL;
 
    for (ap = chars->chars; ap; ap = ap->next) {
        if (!strcmp(ap->name, pl_name)) break;
        last = ap;
    }
    /* If we didn't find this character, nothing to do */
    if (!ap) return;
 
    /* As per previous notes, these should never be NULL */
    free_string(ap->name);
    free_string(ap->character_class);
    free_string(ap->race);
    free_string(ap->face);
    free_string(ap->party);
    free_string(ap->map);
 
    /* remove this link, or update head of list as appropriate */
    if (last) {
        last->next = ap->next;
    } else {
        chars->chars = ap->next;
    }
    free(ap);
}
 
void account_char_free(Account_Chars *chars) {
    if (chars->ref_count > 1) {
        chars->ref_count--;
        return;
    }
 
    for (size_t p = 0; p < chars_loaded_count; p++) {
        if (chars_loaded[p] == chars) {
            if (p < chars_loaded_count - 1) {
                chars_loaded[p] = chars_loaded[chars_loaded_count - 1];
            }
            chars_loaded_count--;
            break;
        }
    }
 
    Account_Char *ap, *next;
 
    for (ap = chars->chars; ap; ap = next) {
        next = ap->next;
 
        free_string(ap->name);
        free_string(ap->character_class);
        free_string(ap->race);
        free_string(ap->face);
        free_string(ap->party);
        free_string(ap->map);
        free(ap);
    }
    free_string(chars->account_name);
    free(chars);
}
 
int make_perma_dead(object *op) {
    player *pl = op->contr;
    Account_Chars *chars;
    Account_Char *ac;
 
    if (!pl) {
        return 1;
    }
    /* Is this necessary? I'm not sure. It was in the code I found to use as an example */
    pl = get_player(pl);
    /* Make sure there is an account name to do things to */
    if (!pl->socket.account_name) {
        return 1;
    }
 
    /* Load the appropriate account for the action. */
    chars = account_char_load(pl->socket.account_name);
 
    /* Find the right character. */
    for (ac = chars->chars; ac; ac = ac->next) {
        if (strcmp(ac->name, op->name) == 0)
            break;
    }
 
    /* This character is dead */
    ac->isDead = 1;
    account_char_save(chars);
    account_char_free(chars);
    return 0;
}
 
int unmake_perma_dead(char *account, char *player) {
    Account_Chars *chars;
    Account_Char *ac;
 
    /*
     * If no account name, then there is nothing to do here.
     * The character was dead before the account was kept track of.
     */
    if (!account) {
        return 1;
    }
 
    chars = account_char_load(account);
 
    /* Find the right character. */
    for (ac = chars->chars; ac; ac = ac->next) {
        if (strcmp(ac->name, player) == 0)
            break;
    }
 
    /* This character is alive */
    ac->isDead = 0;
    account_char_save(chars);
    account_char_free(chars);
    return 0;
}