server/hiscore.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>

typedef struct scr
{
    char name[BIG_NAME];

    char title[BIG_NAME];

    char killer[BIG_NAME];

    char maplevel[MAX_BUF];

    uint64 exp;

    int maxhp, maxsp, maxgrace;

    int position;
} score;

typedef struct
{
    char fname[MAX_BUF];

    score entry[HIGHSCORE_LENGTH];
} score_table;

static score_table hiscore_table;

static void put_score(const score *sc, char *buf, int size)
{
    snprintf(buf, size, "%s:%s:%"FMT64U":%s:%s:%d:%d:%d", sc->name, sc->title, sc->exp, sc->killer, sc->maplevel, sc->maxhp, sc->maxsp, sc->maxgrace);
}

static void hiscore_save(const score_table *table)
{
    FILE *fp;
    size_t i;
    char buf[MAX_BUF];

    LOG(llevDebug, "Writing highscore file %s\n", table->fname);
    fp = fopen(table->fname, "w");

    if (!fp)
    {
        LOG(llevBug, "Cannot create highscore file %s: %s\n", table->fname, strerror_local(errno));
        return;
    }

    for (i = 0; i < HIGHSCORE_LENGTH; i++)
    {
        if (table->entry[i].name[0] == '\0')
        {
            break;
        }

        put_score(&table->entry[i], buf, sizeof(buf));
        fprintf(fp, "%s\n", buf);
    }

    if (ferror(fp))
    {
        LOG(llevBug, "Cannot write to highscore file %s: %s\n", table->fname, strerror_local(errno));
        fclose(fp);
    }
    else if (fclose(fp) != 0)
    {
        LOG(llevBug, "Cannot write to highscore file %s: %s\n", table->fname, strerror_local(errno));
    }
}

static int get_score(char *bp, score *sc)
{
    char *cp, *tmp[8];

    cp = strchr(bp, '\n');

    if (cp)
    {
        *cp = '\0';
    }

    if (split_string(bp, tmp, 8, ':') != 8)
    {
        return 0;
    }

    strncpy(sc->name, tmp[0], sizeof(sc->name));
    sc->name[sizeof(sc->name) - 1] = '\0';

    strncpy(sc->title, tmp[1], sizeof(sc->title));
    sc->title[sizeof(sc->title) - 1] = '\0';

    sscanf(tmp[2], "%"FMT64U, &sc->exp);

    strncpy(sc->killer, tmp[3], sizeof(sc->killer));
    sc->killer[sizeof(sc->killer) - 1] = '\0';

    strncpy(sc->maplevel, tmp[4], sizeof(sc->maplevel));
    sc->maplevel[sizeof(sc->maplevel) - 1] = '\0';

    sscanf(tmp[5], "%d", &sc->maxhp);
    sscanf(tmp[6], "%d", &sc->maxsp);
    sscanf(tmp[7], "%d", &sc->maxgrace);
    return 1;
}

static char *draw_one_high_score(const score *sc, char *buf, size_t size)
{
    if (sc->killer[0] == '\0')
    {
        snprintf(buf, size, "<green>%3d</green> %s <green>%s</green> the %s (%s) <%d><%d><%d>.", sc->position, format_number_comma(sc->exp), sc->name, sc->title, sc->maplevel, sc->maxhp, sc->maxsp, sc->maxgrace);
    }
    else
    {
        const char *s1, *s2;

        if (!strcmp(sc->killer, "left"))
        {
            s1 = sc->killer;
            s2 = "the game";
        }
        else
        {
            s1 = "was killed by";
            s2 = sc->killer;
        }

        snprintf(buf, size, "<green>%3d</green> %s <green>%s</green> the %s %s %s on map %s <%d><%d><%d>.", sc->position, format_number_comma(sc->exp), sc->name, sc->title, s1, s2, sc->maplevel, sc->maxhp, sc->maxsp, sc->maxgrace);
    }

    return buf;
}

static void add_score(score_table *table, score *new_score, score *old_score)
{
    size_t i;

    new_score->position = HIGHSCORE_LENGTH + 1;
    memset(old_score, 0, sizeof(*old_score));
    old_score->position = -1;

    /* Find existing entry by name */
    for (i = 0; i < HIGHSCORE_LENGTH; i++)
    {
        if (table->entry[i].name[0] == '\0')
        {
            table->entry[i] = *new_score;
            table->entry[i].position = i + 1;
            break;
        }

        if (strcmp(new_score->name, table->entry[i].name) == 0)
        {
            *old_score = table->entry[i];

            if (table->entry[i].exp <= new_score->exp)
            {
                table->entry[i] = *new_score;
                table->entry[i].position = i + 1;
            }

            break;
        }
    }

    /* Entry for unknown name */
    if (i >= HIGHSCORE_LENGTH)
    {
        /* New exp is less than lowest hiscore entry => drop */
        if (new_score->exp < table->entry[i - 1].exp)
        {
            return;
        }

        /* New exp is not less than lowest hiscore entry => add */
        i--;
        table->entry[i] = *new_score;
        table->entry[i].position = i + 1;
    }

    /* Move entry to correct position */
    while (i > 0 && new_score->exp >= table->entry[i - 1].exp)
    {
        score tmp;

        tmp = table->entry[i - 1];
        table->entry[i - 1] = table->entry[i];
        table->entry[i] = tmp;

        table->entry[i - 1].position = i;
        table->entry[i].position = i + 1;

        i--;
    }

    new_score->position = table->entry[i].position;
    hiscore_save(table);
}

static void hiscore_load(score_table *table)
{
    FILE *fp;
    size_t i = 0;

    fp = fopen(table->fname, "r");

    if (!fp)
    {
        if (errno == ENOENT)
        {
            LOG(llevDebug, "Highscore file %s does not exist\n", table->fname);
        }
        else
        {
            LOG(llevBug, "Cannot open highscore file %s: %s\n", table->fname, strerror_local(errno));
        }
    }
    else
    {
        LOG(llevDebug, "Reading highscore file %s\n", table->fname);

        while (i < HIGHSCORE_LENGTH)
        {
            char buf[MAX_BUF];

            if (!fgets(buf, sizeof(buf), fp))
            {
                break;
            }

            if (!get_score(buf, &table->entry[i]))
            {
                break;
            }

            table->entry[i].position = i + 1;
            i++;
        }

        fclose(fp);
    }

    while (i < HIGHSCORE_LENGTH)
    {
        memset(&table->entry[i], 0, sizeof(table->entry[i]));
        table->entry[i].position = i + 1;
        i++;
    }
}

void hiscore_init()
{
    snprintf(hiscore_table.fname, sizeof(hiscore_table.fname), "%s/%s", settings.localdir, HIGHSCORE);
    hiscore_load(&hiscore_table);
}

void hiscore_check(object *op, int quiet)
{
    score new_score, old_score;
    char bufscore[MAX_BUF], race[MAX_BUF];
    const char *message;

    if (!op->stats.exp)
    {
        return;
    }

    if (QUERY_FLAG(op, FLAG_WAS_WIZ))
    {
        if (!quiet)
        {
            new_draw_info(0, COLOR_WHITE, op, "Since you have been in wizard mode, you can't enter the high-score list.");
        }

        return;
    }

    strncpy(new_score.name, op->name, sizeof(new_score.name));
    new_score.name[sizeof(new_score.name) - 1] = '\0';

    strncpy(new_score.title, player_get_race_class(op, race, sizeof(race)), sizeof(new_score.title));
    new_score.title[sizeof(new_score.title) - 1] = '\0';

    strncpy(new_score.killer, CONTR(op)->killer, sizeof(new_score.killer));
    new_score.killer[sizeof(new_score.killer) - 1] = '\0';

    new_score.exp = calculate_total_exp(op);

    if (op->map == NULL)
    {
        *new_score.maplevel = '\0';
    }
    else
    {
        size_t i;

        strncpy(new_score.maplevel, op->map->name ? op->map->name : op->map->path, sizeof(new_score.maplevel) - 1);
        new_score.maplevel[sizeof(new_score.maplevel) - 1] = '\0';

        /* Replace ':' in the map name with ' ' so it doesn't break the loading. */
        for (i = 0; new_score.maplevel[i]; i++)
        {
            if (new_score.maplevel[i] == ':')
            {
                new_score.maplevel[i] = ' ';
            }
        }
    }

    new_score.maxhp = (int) op->stats.maxhp;
    new_score.maxsp = (int) op->stats.maxsp;
    new_score.maxgrace = (int) op->stats.maxgrace;
    add_score(&hiscore_table, &new_score, &old_score);

    /* Everything below here is just related to print messages
     * to the player.  If quiet is set, we can just return
     * now. */
    if (quiet)
    {
        return;
    }

    if (old_score.position == -1)
    {
        if (new_score.position > HIGHSCORE_LENGTH)
        {
            message = "You didn't enter the highscore list:";
        }
        else
        {
            message = "You entered the highscore list:";
        }
    }
    else
    {
        if (new_score.position > HIGHSCORE_LENGTH)
        {
            message = "You left the highscore list:";
        }
        else if (new_score.exp  > old_score.exp)
        {
            message = "You beat your last score:";
        }
        else
        {
            message = "You didn't beat your last score:";
        }
    }

    new_draw_info(0, COLOR_WHITE, op, message);

    if (old_score.position != -1)
    {
        new_draw_info(0, COLOR_WHITE, op, draw_one_high_score(&old_score, bufscore, sizeof(bufscore)));
    }

    new_draw_info(0, COLOR_WHITE, op, draw_one_high_score(&new_score, bufscore, sizeof(bufscore)));
}

void hiscore_display(object *op, int max, const char *match)
{
    int printed_entries = 0;
    size_t j;

    new_draw_info(0, COLOR_WHITE, op, "Nr    Score   Who <max hp><max sp><max grace>");

    for (j = 0; j < HIGHSCORE_LENGTH && hiscore_table.entry[j].name[0] != '\0' && printed_entries < max; j++)
    {
        char scorebuf[MAX_BUF];

        if (match && !strcasestr_local(hiscore_table.entry[j].name, match) && !strcasestr_local(hiscore_table.entry[j].title, match))
        {
            continue;
        }

        draw_one_high_score(&hiscore_table.entry[j], scorebuf, sizeof(scorebuf));
        printed_entries++;

        if (op == NULL)
        {
            LOG(llevDebug, "%s\n", scorebuf);
        }
        else
        {
            new_draw_info(0, COLOR_WHITE, op, scorebuf);
        }
    }
}