knowledge.cpp

Go to the documentation of this file.

/*
 * Crossfire -- cooperative multi-player graphical RPG and adventure game
 *
 * Copyright (c) 1999-2014 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 <ctype.h>
#include <stdlib.h>
#include <string.h>

#include "sproto.h"
#include "output_file.h"

/* Media tags for information messages prefix. */
#define TAG_START   "[color=#ff6611]"
#define TAG_END     "[/color]"

struct knowledge_player;
struct knowledge_type;

typedef void (*knowledge_summary)(const char *code, StringBuffer *buf);

typedef void (*knowledge_detail)(const char *code, StringBuffer *buf);

typedef int (*knowledge_is_valid_item)(const char *code);

typedef int (*knowledge_add_item)(knowledge_player *current, const char *item, const knowledge_type *type);

typedef StringBuffer* (*knowledge_can_use_alchemy)(sstring code, const char *item, StringBuffer *buf, int index);

typedef const Face *(*knowledge_face)(sstring code);

struct knowledge_item;

typedef void (*knowledge_attempt)(player *pl, const knowledge_item *item);

struct knowledge_type {
    const char *type;                   
    knowledge_summary summary;          
    knowledge_detail detail;            
    knowledge_is_valid_item validate;   
    knowledge_add_item add;             
    const char *name;                   
    knowledge_can_use_alchemy use_alchemy; 
    knowledge_attempt attempt_alchemy;
    const char *face;                   
    knowledge_face item_face;           
};


struct knowledge_item {
    sstring item;                   
    const knowledge_type* handler;  
};

struct knowledge_player {
    sstring player_name;            
    knowledge_item **items;         
    int item_count;                 
    int item_allocated;             
    int sent_up_to;                 
    knowledge_player *next;         
};

static knowledge_player *knowledge_global = NULL;


static const recipe* knowledge_alchemy_get_recipe(const char *value) {
    const recipe *rec;
    recipelist *rl;
    int count, index;
    const char *dot;

    dot = strchr(value, ':');
    if (!dot) {
        /* warn? */
        return NULL;
    }

    count = atoi(value);
    index = atoi(dot + 1);
    dot = strchr(dot + 1, ':');
    if (!dot)
        /* warn? */
        return NULL;
    dot++;

    rl = get_formulalist(count);
    rec = rl->items;
    while (rec) {
        if (rec->index == index && strcmp(rec->title, dot) == 0)
            return rec;

        rec = rec->next;
    }

    return NULL;
}

static void knowledge_alchemy_summary(const char *value, StringBuffer *buf) {
    const recipe *rec = knowledge_alchemy_get_recipe(value);
    const archetype *arch;

    if (!rec)
        /* warn? */
        return;

    arch = try_find_archetype(rec->arch_name[RANDOM()%rec->arch_names]);
    if (!arch)
        /* not supposed to happen */
        return;

    if (strcmp(rec->title, "NONE"))
        stringbuffer_append_printf(buf, "%s of %s", arch->clone.name, rec->title);
    else {
        if (arch->clone.title != NULL) {
            stringbuffer_append_printf(buf, "%s %s", arch->clone.name, arch->clone.title);
        }
        else
            stringbuffer_append_printf(buf, "%s", arch->clone.name);
    }
}

static void knowledge_alchemy_detail(const char *value, StringBuffer *buf) {
    const recipe *rec = knowledge_alchemy_get_recipe(value);
    const linked_char *next;
    const archetype *arch;
    char name[MAX_BUF];


    if (!rec)
        /* warn? */
        return;

    arch = try_find_archetype(rec->arch_name[RANDOM()%rec->arch_names]);
    if (!arch)
        /* not supposed to happen */
        return;

    if (strcmp(rec->title, "NONE"))
        stringbuffer_append_printf(buf, "The %s of %s", arch->clone.name, rec->title);
    else {
        if (arch->clone.title != NULL) {
            stringbuffer_append_printf(buf, "The %s %s", arch->clone.name, arch->clone.title);
        }
        else
            stringbuffer_append_printf(buf, "The %s", arch->clone.name);
    }

    arch = try_find_archetype(rec->cauldron);
    if (arch)
        query_name(&arch->clone, name, MAX_BUF);
    else
        snprintf(name, sizeof(name), "an unknown place");

    stringbuffer_append_printf(buf, ", a%s %s recipe, is made with %s at %s and uses the following ingredients:",
      rec->diff >= 10 && rec->diff < 15 ? "n" : "",
      recipe_get_difficulty_string(rec->diff),
      rec->skill ? rec->skill : "an unknown skill", name);

    for (next = rec->ingred; next != NULL; next = next->next) {
        stringbuffer_append_printf(buf, "\n - %s", next->name);
    }

}

static int knowledge_alchemy_validate(const char *item) {
    return knowledge_alchemy_get_recipe(item) != NULL;
}

static StringBuffer* knowledge_alchemy_can_use_item(sstring code, const char *item, StringBuffer *buf, int index) {
    const recipe *rec = knowledge_alchemy_get_recipe(code);
    const linked_char *next;
    const archetype *arch;
    const char *name;

    if (!item)
        return NULL;

    if (!rec)
        /* warn? */
        return buf;

    arch = try_find_archetype(rec->arch_name[RANDOM()%rec->arch_names]);
    if (!arch)
        /* not supposed to happen */
        return buf;

    for (next = rec->ingred; next != NULL; next = next->next) {
        name = next->name;
        while ((*name) != '\0' && (isdigit(*name) || (*name) == ' '))
            name++;

        if (strcmp(item, name) == 0) {
            if (buf == NULL) {
                buf = stringbuffer_new();
                stringbuffer_append_string(buf, "It can be used in the following recipes: ");
            } else
                stringbuffer_append_string(buf, ", ");

            if (strcmp(rec->title, "NONE"))
                stringbuffer_append_printf(buf, "%s of %s", arch->clone.name, rec->title);
            else {
                if (arch->clone.title != NULL) {
                    stringbuffer_append_printf(buf, "%s %s", arch->clone.name, arch->clone.title);
                }
                else
                    stringbuffer_append_printf(buf, "%s", arch->clone.name);
            }
            stringbuffer_append_printf(buf, " (%d)", index);

            break;
        }
    }

    return buf;
}

static void knowledge_alchemy_attempt(player *pl, const knowledge_item *item) {
    const recipe *rp = knowledge_alchemy_get_recipe(item->item);
    object *cauldron = NULL, *inv;
    object *ingredients[50];
    int index, x, y;
    uint32_t count, counts[50];
    char name[MAX_BUF];
    const char *ingname;
    linked_char *ing;
    tag_t cauldron_tag;
    mapstruct *map;

    if (!rp) {
        LOG(llevError, "knowledge: couldn't find recipe for %s", item->item);
        return;
    }

    if (rp->ingred_count > 50) {
        LOG(llevError, "knowledge: recipe %s has more than 50 ingredients!", item->item);
        draw_ext_info(NDI_UNIQUE, 0, pl->ob, MSG_TYPE_COMMAND, MSG_TYPE_COMMAND_INFO, "This recipe is too complicated.");
        return;
    }

    /* first, check for a cauldron */
    for (cauldron = pl->ob->below; cauldron; cauldron = cauldron->below) {
        if (strcmp(rp->cauldron, cauldron->arch->name) == 0)
            break;
    }

    if (cauldron == NULL) {
        draw_ext_info_format(NDI_UNIQUE, 0, pl->ob, MSG_TYPE_COMMAND, MSG_TYPE_COMMAND_INFO, "You are not on a %s", rp->cauldron);
        return;
    }

    cauldron_tag = cauldron->count;

    /* find ingredients in player's inventory */
    for (index = 0; index < 50; index++) {
        ingredients[index] = NULL;
    }
    for (inv = pl->ob->inv; inv != NULL; inv = inv->below) {

        if (inv->invisible || QUERY_FLAG(inv, FLAG_INV_LOCKED) || QUERY_FLAG(inv, FLAG_STARTEQUIP))
            continue;

        if (inv->title == NULL)
            safe_strncpy(name, inv->name, sizeof(name));
        else
            snprintf(name, sizeof(name), "%s %s", inv->name, inv->title);

        index = 0;
        for (ing = rp->ingred; ing != NULL; ing = ing->next) {

            if (ingredients[index] != NULL) {
                index++;
                continue;
            }

            ingname = ing->name;
            count = 0;
            while (isdigit(*ingname)) {
                count = 10 * count + (*ingname - '0');
                ingname++;
            }
            if (count == 0)
                count = 1;
            while (*ingname == ' ')
                ingname++;

            if (strcmp(name, ingname) == 0 && ((inv->nrof == 0 && count == 1) || (inv->nrof >= count))) {
                ingredients[index] = inv;
                // If nrof is 0, we want to keep a count of 0 so put_object_in_sack() later doesn't call
                // object_split() which would destroy tmp and mess up our tags.
                counts[index] = inv->nrof == 0 ? 0 : count;
                break;
            }

            index++;
        }
    }

    index = 0;
    for (ing = rp->ingred; ing != NULL; ing = ing->next) {
        if (ingredients[index] == NULL) {
            draw_ext_info_format(NDI_UNIQUE, 0, pl->ob, MSG_TYPE_COMMAND, MSG_TYPE_COMMAND_INFO, "You don't have %s.", ing->name);
            return;
        }

        index++;
    }

    /* ensure cauldron is applied */
    if (pl->ob->container != cauldron) {
        apply_by_living_below(pl->ob);
        if (pl->ob->container != cauldron) {
            draw_ext_info_format(NDI_UNIQUE, 0, pl->ob, MSG_TYPE_COMMAND, MSG_TYPE_COMMAND_INFO, "Couldn't activate the %s.", rp->cauldron);
            return;
        }
    }

    /* ensure cauldron is empty */
    while (cauldron->inv != NULL) {
        inv = cauldron->inv;
        command_take(pl->ob, "");
        if (cauldron->inv == inv) {
            draw_ext_info_format(NDI_UNIQUE, 0, pl->ob, MSG_TYPE_COMMAND, MSG_TYPE_COMMAND_INFO, "Couldn't empty the %s", rp->cauldron);
            return;
        }
    }

    /* drop ingredients */
    for (index = 0; index < rp->ingred_count; index++) {
        tag_t tag = ingredients[index]->count;
        count = ingredients[index]->nrof;
        put_object_in_sack(pl->ob, cauldron, ingredients[index], counts[index]);
        if (object_was_destroyed(ingredients[index], tag)) {
            draw_ext_info(NDI_UNIQUE, 0, pl->ob, MSG_TYPE_COMMAND, MSG_TYPE_COMMAND_INFO, "Hum, some item disappeared, stopping the attempt.");
            return;

        }
        if (count == ingredients[index]->nrof && ingredients[index]->env == pl->ob) {
            draw_ext_info(NDI_UNIQUE, 0, pl->ob, MSG_TYPE_COMMAND, MSG_TYPE_COMMAND_INFO, "Hum, couldn't drop some items, stopping the attempt.");
            return;
        }
    }

    map = pl->ob->map;
    x = pl->ob->x;
    y = pl->ob->y;

    /* do alchemy */
    use_alchemy(pl->ob);

    /* don't forget to slow the player: 1 for alchemy itself, 1 for each ingredient put,
     * ingredients taken are handled by command_take() */
    pl->ob->speed_left -= 1.0 * (rp->ingred_count + 1);

    /* safety: ensure cauldron is still there, and player is still above */
    if (object_was_destroyed(cauldron, cauldron_tag) || map != pl->ob->map || x != pl->ob->x || y != pl->ob->y) {
        return;
    }

    /* get back the result */
    while (cauldron->inv) {
        /* Examining may lead to identifying part of items and thus introducing
         * extra items in the cauldron. Therefore we'll set inv only after examining,
         * even if that means that potentially the player will examine twice some items. */
        examine(pl->ob, cauldron->inv);
        inv = cauldron->inv;
        command_take(pl->ob, "");
        pl->ob->speed_left -= 1.0;
        if (inv == cauldron->inv)
            break;
    }
}

static const Face *knowledge_alchemy_face(sstring code) {
    const recipe *rp = knowledge_alchemy_get_recipe(code);

    if (!rp) {
        LOG(llevError, "knowledge: couldn't find recipe for %s", code);
        return NULL;
    }

    return recipe_get_face(rp);
}

static int knowledge_known(const knowledge_player *current, const char *item, const knowledge_type *kt) {
    int i;
    for (i = 0; i < current->item_count; i++) {
        if (strcmp(kt->type, current->items[i]->handler->type) == 0 && strcmp(item, current->items[i]->item) == 0) {
            /* already known, bailout */
            return 1;
        }
    }
    return 0;
}

static int knowledge_add(knowledge_player *current, const char *item, const knowledge_type *kt) {
    knowledge_item *check;

    if (knowledge_known(current, item, kt)) {
        return 0;
    }

    /* keep the knowledge */
    check = static_cast<knowledge_item *>(malloc(sizeof(knowledge_item)));
    check->item = add_string(item);
    check->handler = kt;
    if (current->item_count >= current->item_allocated) {
        current->item_allocated += 10;
        current->items = static_cast<knowledge_item **>(realloc(current->items, current->item_allocated * sizeof(knowledge_item*)));
    }
    current->items[current->item_count] = check;
    current->item_count++;

    return 1;
}

static void knowledge_monster_summary(const char *item, StringBuffer *buf) {
    archetype *monster = try_find_archetype(item);
    if (!monster)
        return;

    stringbuffer_append_printf(buf, "%s", monster->clone.name);
}

static void knowledge_monster_detail(const char *item, StringBuffer *buf) {
    archetype *monster = try_find_archetype(item);

    if (!monster)
        return;

    stringbuffer_append_printf(buf, " *** %s ***\n", monster->clone.name);
    describe_item(&monster->clone, NULL, 1, buf);
}

static int knowledge_monster_validate(const char *item) {
    const archetype *monster = try_find_archetype(item);
    if (monster == NULL || monster->clone.type != 0 || monster->head || object_get_value(&monster->clone, MONSTER_EXCLUDE_FROM_READABLE_KEY) != NULL)
        return 0;
    return 1;
}

static int knowledge_monster_add(struct knowledge_player *current, const char *item, const struct knowledge_type *type) {
    char *dup = strdup_local(item);
    char *pos, *first = dup;
    int added = 0;

    while (first) {
        pos = strchr(first, ':');
        if (pos)
            *pos = '\0';
        added += knowledge_add(current, first, type);
        first = pos ? pos + 1 : NULL;
    }

    free(dup);
    return added;
}

static const Face *knowledge_monster_face(sstring code) {
    const archetype *monster = try_find_archetype(code);

    if (!monster || monster->clone.face == blank_face || monster->clone.face == NULL)
        return NULL;

    return monster->clone.face;
}

static void knowledge_god_summary(const char *item, StringBuffer *buf) {
    char *dup = strdup_local(item), *pos = strchr(dup, ':');

    if (pos)
        *pos = '\0';

    stringbuffer_append_printf(buf, "%s [god]", dup);
    free(dup);
}

static void knowledge_god_detail(const char *item, StringBuffer *buf) {
    char *dup = strdup_local(item), *pos = strchr(dup, ':');
    const archetype *god;
    int what;

    if (!pos) {
        LOG(llevError, "knowledge_god_detail: invalid god item %s\n", item);
        free(dup);
        return;
    }

    *pos = '\0';
    what = atoi(pos + 1);
    god = find_archetype_by_object_name(dup);
    free(dup);

    if (!god) {
        LOG(llevError, "knowledge_god_detail: couldn't find god %s?\n", item);
        return;
    }

    describe_god(&god->clone, what, buf, 0);
}

static int knowledge_god_validate(const char *item) {
    char *dup = strdup_local(item), *pos = strchr(dup, ':');
    int valid;

    if (!pos) {
        LOG(llevError, "knowledge_god_validate: invalid god item %s\n", item);
        free(dup);
        return 0;
    }
    *pos = '\0';
    valid = find_archetype_by_object_name(dup) != NULL;
    free(dup);
    return valid;
}

static int knowledge_god_add(struct knowledge_player *current, const char *item, const struct knowledge_type *type) {
    char *dup = strdup_local(item), *pos = const_cast<char *>(strchr(dup, ':'));
    StringBuffer *buf;
    int what, i;
    knowledge_item* check;

    if (!pos) {
        LOG(llevError, "knowledge_god_add: invalid god item %s\n", item);
        free(dup);
        return 0;
    }

    *pos = '\0';
    what = atoi(pos + 1);

    for (i = 0; i < current->item_count; i++) {
        check = current->items[i];
        if (check->handler != type)
            /* Only consider our own type. */
            continue;
        if (strncmp(check->item, dup, strlen(dup)) == 0) {
            /* Already known, update information. */
            int known, result;
            pos = const_cast<char *>(strchr(check->item, ':'));
            known = atoi(pos + 1);
            result = known | what;
            buf = stringbuffer_new();
            stringbuffer_append_printf(buf, "%s:%d", dup, result);
            free_string(check->item);
            check->item = stringbuffer_finish_shared(buf);
            free(dup);
            return (result != known);
        }
    }

    free(dup);

    /* Not known, so just add it regularly. */
    return knowledge_add(current, item, type);
}

static const Face *knowledge_god_face(sstring code) {
    char buf[MAX_BUF];
    size_t letter;
    const archetype *altar_arch;

    snprintf(buf, MAX_BUF, "altar_");
    letter = strlen(buf);
    strncpy(buf+letter, code, MAX_BUF-letter);
    for (; letter < strlen(buf); letter++) {
        if (buf[letter] == ':') {
            buf[letter] = '\0';
            break;
        }
        buf[letter] = tolower(buf[letter]);
    }
    altar_arch = try_find_archetype(buf);
    if (altar_arch == NULL)
        return NULL;

    return altar_arch->clone.face;
}

static void knowledge_message_summary(const char *value, StringBuffer *buf) {
    const GeneralMessage *msg = get_message_from_identifier(value);

    if (!msg)
        /* warn? */
        return;

    stringbuffer_append_printf(buf, "%s", get_message_title(msg));
}

static void knowledge_message_detail(const char *value, StringBuffer *buf) {
    const GeneralMessage *msg = get_message_from_identifier(value);

    if (!msg)
        /* warn? */
        return;

    stringbuffer_append_printf(buf, "%s", get_message_body(msg));
}

static int knowledge_message_validate(const char *item) {
    return get_message_from_identifier(item) != NULL;
}

static const Face *knowledge_message_face(sstring code) {
    const GeneralMessage *msg = get_message_from_identifier(code);

    if (!msg)
        /* warn? */
        return NULL;

    return get_message_face(msg);
}

static const knowledge_type knowledges[] = {
    { "alchemy", knowledge_alchemy_summary, knowledge_alchemy_detail, knowledge_alchemy_validate, knowledge_add, "recipes", knowledge_alchemy_can_use_item, knowledge_alchemy_attempt, "knowledge_recipes.111", knowledge_alchemy_face },
    { "monster", knowledge_monster_summary, knowledge_monster_detail, knowledge_monster_validate, knowledge_monster_add, "monsters", NULL, NULL, "knowledge_monsters.111", knowledge_monster_face },
    { "god", knowledge_god_summary, knowledge_god_detail, knowledge_god_validate, knowledge_god_add, "gods", NULL, NULL, "knowledge_gods.111", knowledge_god_face },
    { "message", knowledge_message_summary, knowledge_message_detail, knowledge_message_validate, knowledge_add, "messages", NULL, NULL, "knowledge_messages.111", knowledge_message_face },
    { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL }
};


static const knowledge_type *knowledge_find(const char *type) {
    int i = 0;
    while (knowledges[i].type != NULL) {
        if (strcmp(knowledges[i].type, type) == 0)
            return &knowledges[i];
        i++;
    }

    return NULL;
}

static void knowledge_write_player_data(const knowledge_player *kp) {
    FILE *file;
    OutputFile of;
    char fname[MAX_BUF];
    const knowledge_item *item;
    int i;

    snprintf(fname, sizeof(fname), "%s/%s/%s/%s.knowledge", settings.localdir, settings.playerdir, kp->player_name, kp->player_name);

    file = of_open(&of, fname);
    if (!file) {
        draw_ext_info(NDI_UNIQUE | NDI_ALL_DMS, 0, NULL, MSG_TYPE_ADMIN, MSG_TYPE_ADMIN_LOADSAVE, "File write error on server!");
        return;
    }

    for (i = 0; i < kp->item_count; i++) {
        item = kp->items[i];
        fprintf(file, "%s:%s\n", item->handler->type, item->item);
    }

    if (!of_close(&of)) {
        draw_ext_info(NDI_UNIQUE | NDI_ALL_DMS, 0, NULL, MSG_TYPE_ADMIN, MSG_TYPE_ADMIN_LOADSAVE, "File write error on server!");
        return;
    }
}

static void knowledge_read_player_data(knowledge_player *kp) {
    FILE *file;
    char final[MAX_BUF], read[MAX_BUF], *dot;
    knowledge_item *item;
    const knowledge_type *type;

    snprintf(final, sizeof(final), "%s/%s/%s/%s.knowledge", settings.localdir, settings.playerdir, kp->player_name, kp->player_name);

    file = fopen(final, "r");
    if (!file) {
        /* no knowledge yet, no big deal */
        return;
    }

    while (fgets(read, sizeof(read), file) != NULL) {
        if (strlen(read) > 0)
            read[strlen(read) - 1] = '\0';

        dot = strchr(read, ':');
        if (!dot) {
            LOG(llevError, "knowledge: invalid line in file %s\n", final);
            continue;
        }

        *dot = '\0';

        type = knowledge_find(read);
        if (!type) {
            LOG(llevError, "knowledge: invalid type %s in file %s\n", read, final);
            continue;
        }
        if (!type->validate(dot + 1)) {
            LOG(llevDebug, "knowledge: ignoring now invalid %s in file %s\n", read, final);
            continue;
        }

        item = static_cast<knowledge_item *>(malloc(sizeof(knowledge_item)));
        item->item = add_string(dot + 1);
        item->handler = type;
        if (kp->item_count == kp->item_allocated) {
            kp->item_allocated += 10;
            kp->items = static_cast<knowledge_item **>(realloc(kp->items, kp->item_allocated * sizeof(knowledge_item*)));
        }
        kp->items[kp->item_count] = item;
        kp->item_count++;
    }
    fclose(file);
}

static knowledge_player *knowledge_get_or_create(const player *pl) {
    knowledge_player *cur = knowledge_global;

    while (cur) {
        if (cur->player_name == pl->ob->name)
            return cur;
        cur = cur->next;
    }

    cur = static_cast<knowledge_player *>(calloc(1, sizeof(knowledge_player)));
    if (!cur)
        fatal(OUT_OF_MEMORY);
    cur->player_name = add_refcount(pl->ob->name);
    cur->next = knowledge_global;
    knowledge_global = cur;
    /* read knowledge for this player */
    knowledge_read_player_data(cur);
    if (pl->socket->notifications < 2)
        cur->sent_up_to = -1;
    return cur;
}

void knowledge_give(player *pl, const char *marker, const object *book) {
    char *copy, *code, *dot;
    const knowledge_type *type;
    int none, added = 0;
    knowledge_player *current = knowledge_get_or_create(pl);

    /* process marker, find if already known */
    dot = const_cast<char *>(strchr(marker, ':'));
    if (dot == NULL)
        return;

    copy = strdup(marker);
    if (!copy)
        fatal(OUT_OF_MEMORY);

    dot = const_cast<char *>(strchr(copy, ':'));
    *dot = '\0';
    dot++;

    type = knowledge_find(copy);
    if (!type) {
        LOG(llevError, "knowledge: invalid marker type %s in %s\n", copy, book == NULL ? "(null)" : book->name);
        free(copy);
        return;
    }

    none = (current->items == NULL);

    code = dot;
    while (code && code[0] != '\0') {
        dot = strchr(code, '/');
        if (dot) {
            *dot = '\0';
            dot++;
        }
        if (type->validate(code)) {
            added += type->add(current, code, type);
        }
        code = dot;
    }

    free(copy);

    if (added) {
        draw_ext_info_format(NDI_UNIQUE, 0, pl->ob, MSG_TYPE_MISC, MSG_TYPE_CLIENT_NOTICE, TAG_START "%s" TAG_END, "You keep that in mind for future reference.");
        if (none) {
            /* first information ever written down, be nice and give hint to recover it. */
            draw_ext_info_format(NDI_UNIQUE, 0, pl->ob, MSG_TYPE_MISC, MSG_TYPE_CLIENT_NOTICE, TAG_START "%s" TAG_END, "Use the 'knowledge' command to see what you keep in mind (this message will not appear anymore).");
        }
    }

    if (pl->has_directory)
        knowledge_write_player_data(current);
}

void knowledge_read(player *pl, object *book) {
    sstring marker = object_get_value(book, "knowledge_marker");
    if (marker != NULL)
        knowledge_give(pl, marker, book);
}

static void knowledge_do_display(object *pl, const knowledge_type *show_only, const char *search) {
    knowledge_player *kp;
    knowledge_item *item;
    int header = 0, show, i;
    StringBuffer *summary;
    char *final;

    assert(search == NULL || search[0] != '\0');

    kp = knowledge_get_or_create(pl->contr);
    for (i = 0; i < kp->item_count; i++) {
        item = kp->items[i];
        show = 1;

        summary = stringbuffer_new();
        item->handler->summary(item->item, summary);
        final = stringbuffer_finish(summary);

        if (show_only != NULL && item->handler != show_only) {
            show = 0;
        }
        if (search != NULL && search[0] != '\0') {
            if (strstr(final, search) == NULL) {
                char *fd;
                StringBuffer *detail = stringbuffer_new();
                item->handler->detail(item->item, detail);
                fd = stringbuffer_finish(detail);
                if (strstr(fd, search) == NULL)
                    show = 0;
                free(fd);
            }
        }

        if (show == 1) {
            if (header == 0) {
                if (search != NULL)
                    draw_ext_info_format(NDI_UNIQUE, 0, pl, MSG_TYPE_MISC, MSG_TYPE_CLIENT_NOTICE, "You have knowledge of the following %s concerning '%s':", show_only == NULL ? "things" : show_only->type, search);
                else if (show_only != NULL)
                    draw_ext_info_format(NDI_UNIQUE, 0, pl, MSG_TYPE_MISC, MSG_TYPE_CLIENT_NOTICE, "You have knowledge of those %s:", show_only->name);
                else
                    draw_ext_info(NDI_UNIQUE, 0, pl, MSG_TYPE_MISC, MSG_TYPE_CLIENT_NOTICE, "You have knowledge of:");
                header = 1;
            }

            draw_ext_info_format(NDI_UNIQUE, 0, pl, MSG_TYPE_MISC, MSG_TYPE_CLIENT_NOTICE, "(%3d) %s", i + 1, final);
        }

        free(final);
    }

    if (header == 0) {
        if (search != NULL)
            draw_ext_info_format(NDI_UNIQUE, 0, pl, MSG_TYPE_MISC, MSG_TYPE_CLIENT_NOTICE, "You don't know yet any relevant information about '%s'.", search);
        else if (show_only != NULL)
            draw_ext_info_format(NDI_UNIQUE, 0, pl, MSG_TYPE_MISC, MSG_TYPE_CLIENT_NOTICE, "You don't know yet any relevant information about %s.", show_only->name);
        else
            draw_ext_info(NDI_UNIQUE, 0, pl, MSG_TYPE_MISC, MSG_TYPE_CLIENT_NOTICE, "You don't know yet any relevant information.");
    }
}

static void knowledge_display(object *pl, const char *params) {
    const knowledge_type *show_only = NULL;

    if (params && params[0] == ' ') {
        const char *type = params + 1;
        int idx = 0;
        for (; knowledges[idx].type != NULL; idx++) {
            if (strcmp(knowledges[idx].name, type) == 0) {
                show_only = &knowledges[idx];
                break;
            }
        }

        if (show_only == NULL) {
            draw_ext_info(NDI_UNIQUE, 0, pl, MSG_TYPE_MISC, MSG_TYPE_CLIENT_NOTICE, "Invalid type, valid types are:");
            for (idx = 0; knowledges[idx].type != NULL; idx++) {
                draw_ext_info_format(NDI_UNIQUE, 0, pl, MSG_TYPE_MISC, MSG_TYPE_CLIENT_NOTICE, "- %s", knowledges[idx].name);
            }
            return;
        }
    }

    knowledge_do_display(pl, show_only, NULL);
}

static void knowledge_show(object *pl, const char *params) {
    knowledge_player *kp;
    knowledge_item *item;
    int count = atoi(params) - 1;
    StringBuffer *buf;
    char *final;

    kp = knowledge_get_or_create(pl->contr);
    if (count < 0 || count >= kp->item_count) {
        draw_ext_info(NDI_UNIQUE, 0, pl, MSG_TYPE_COMMAND, MSG_TYPE_COMMAND_INFO, "Invalid knowledge number");
        return;
    }

    item = kp->items[count];
    buf = stringbuffer_new();
    item->handler->detail(item->item, buf);
    final = stringbuffer_finish(buf);
    draw_ext_info(NDI_UNIQUE, 0, pl, MSG_TYPE_MISC, MSG_TYPE_CLIENT_NOTICE, final);
    free(final);
}

static void knowledge_do_attempt(object *pl, const char *params) {
    knowledge_player *kp;
    knowledge_item *item;
    int count = atoi(params) - 1;

    kp = knowledge_get_or_create(pl->contr);
    if (count < 0 || count >= kp->item_count) {
        draw_ext_info(NDI_UNIQUE, 0, pl, MSG_TYPE_COMMAND, MSG_TYPE_COMMAND_INFO, "Invalid knowledge number");
        return;
    }

    item = kp->items[count];
    if (item->handler->attempt_alchemy == NULL) {
        draw_ext_info(NDI_UNIQUE, 0, pl, MSG_TYPE_COMMAND, MSG_TYPE_COMMAND_INFO, "You can't do anything with that knowledge.");
    } else {
        item->handler->attempt_alchemy(pl->contr, item);
    }
}

void command_knowledge(object *pl, const char *params) {

    if (!pl->contr) {
        LOG(llevError, "command_knowledge: called for %s not a player!\n", pl->name);
        return;
    }

    if (!params || *params == '\0') {
        command_help(pl, "knowledge");
        return;
    }

    if (strncmp(params, "list", 4) == 0) {
        knowledge_display(pl, params + 4);
        return;
    }

    if (strncmp(params, "search ", 7) == 0) {
        knowledge_do_display(pl, NULL, params + 7);
        return;
    }

    if (strncmp(params, "show ", 5) == 0) {
        knowledge_show(pl, params + 5);
        return;
    }

    if (strncmp(params, "attempt ", 8) == 0) {
        knowledge_do_attempt(pl, params + 8);
        return;
    }

    command_help(pl, "knowledge");
}

static void free_knowledge_items(knowledge_player *kp) {
    knowledge_item *item;
    int i;

    for (i = 0; i < kp->item_count; i++) {
        item = kp->items[i];
        free_string(item->item);
        free(item);
    }
    free(kp->items);
    kp->items = NULL;
    kp->item_count = 0;
    kp->item_allocated = 0;
}

static void free_knowledge_player(knowledge_player *kp) {
    free_knowledge_items(kp);
    free_string(kp->player_name);
    free(kp);
}

void free_knowledge(void) {
    knowledge_player *kp, *next;

    kp = knowledge_global;
    while (kp) {
        next = kp->next;
        free_knowledge_player(kp);
        kp = next;
    }
    knowledge_global = NULL;
}

int knowledge_player_knows(const player *pl, const char *knowledge) {
    const knowledge_type *type;
    char copy[MAX_BUF], *pos;
    const knowledge_player *current;

    if (strlen(knowledge) >= MAX_BUF - 1) {
        LOG(llevError, "knowledge_player_knows: too long knowledge %s\n", knowledge);
        return 0;
    }

    strlcpy(copy, knowledge, sizeof(copy));
    pos = strchr(copy, ':');
    if (pos == NULL) {
        LOG(llevError, "knowledge_player_knows: invalid knowledge item %s\n", knowledge);
        return 0;
    }

    *pos = '\0';
    pos++;

    type = knowledge_find(copy);
    if (type == NULL) {
        LOG(llevError, "knowledge_player_knows: invalid knowledge type %s\n", knowledge);
        return 0;
    }

    current = knowledge_get_or_create(pl);

    return knowledge_known(current, pos, type);
}

void knowledge_item_can_be_used_alchemy(object *op, const object *item) {
    knowledge_player *cur;
    knowledge_item *ki;
    char item_name[MAX_BUF], *result;
    const char *name;
    StringBuffer *buf = NULL;
    int i;

    if (op->type != PLAYER || op->contr == NULL)
        return;

    cur = knowledge_get_or_create(op->contr);

    if (item->title != NULL) {
        snprintf(item_name, sizeof(item_name), "%s %s", item->name, item->title);
        name = item_name;
    } else
        name = item->name;

    for (i = 0; i < cur->item_count; i++) {
        ki = cur->items[i];
        if (ki->handler->use_alchemy != NULL) {
            buf = ki->handler->use_alchemy(ki->item, name, buf, i + 1);
        }
    }

    if (buf == NULL)
        return;

    stringbuffer_append_string(buf, ".");
    result = stringbuffer_finish(buf);
    draw_ext_info(NDI_UNIQUE, 0, op, MSG_TYPE_COMMAND, MSG_TYPE_COMMAND_EXAMINE,
        result);
    free(result);
}

void knowledge_send_info(socket_struct *ns) {
    int i;
    const Face *face;
    SockList sl;

    face = try_find_face("knowledge_generic.111", NULL);
    if (face != NULL && (!(ns->faces_sent[face->number] & NS_FACESENT_FACE)))
        esrv_send_face(ns, face, 0);

    SockList_Init(&sl);
    SockList_AddString(&sl, "replyinfo knowledge_info\n");
    SockList_AddPrintf(&sl, "::%u:0\n", face ? face->number : 0);

    for (i = 0; knowledges[i].type != NULL; i++) {
        face = try_find_face(knowledges[i].face, NULL);
        if (face != NULL && (!(ns->faces_sent[face->number] & NS_FACESENT_FACE)))
            esrv_send_face(ns, face, 0);

        SockList_AddPrintf(&sl, "%s:%s:%u:%s\n", knowledges[i].type, knowledges[i].name, face ? face->number : 0, knowledges[i].attempt_alchemy != NULL ? "1" : "0");
    }

    Send_With_Handling(ns, &sl);
    SockList_Term(&sl);
}

void knowledge_send_known(player *pl) {
    knowledge_player *kp;

    if (pl->socket->notifications < 2)
        return;

    /* merely loading the knowledge will mark it as to be sent through knowledge_process_incremental(),
     * but we need to reset the sent_up_to field if eg the player was the last one to leave
     * then joins again - no knowledge processing is done at that point. */
    kp = knowledge_get_or_create(pl);
    kp->sent_up_to = 0;
}

void knowledge_first_player_save(player *pl) {
    knowledge_player *cur = knowledge_global;

    while (cur) {
        if (cur->player_name == pl->ob->name) {
            knowledge_write_player_data(cur);
        }
        cur = cur->next;
    }

}

void knowledge_process_incremental(void) {
    int i, last;
    SockList sl;
    size_t size;
    const knowledge_item *item;
    StringBuffer *buf;
    char *title;
    const Face *face;
    knowledge_player *cur = knowledge_global, *prev = NULL;
    player *pl;

    while (cur) {

        for (pl = first_player; pl != NULL; pl = pl->next) {
            if (pl->ob->name == cur->player_name) {
                break;
            }
        }

        /* player left, remove knowledge */
        if (pl == NULL || pl->state != ST_PLAYING) {
            if (prev == NULL) {
                knowledge_global = cur->next;
            } else {
                prev->next = cur->next;
            }

            free_knowledge_player(cur);

            /* wait until next tick to do something else */
            return;
        }

        if (cur->sent_up_to == -1 || cur->sent_up_to == cur->item_count) {
            prev = cur;
            cur = cur->next;
            continue;
        }

        last = MIN(cur->sent_up_to + 50, cur->item_count);
        SockList_Init(&sl);
        SockList_AddString(&sl, "addknowledge ");
        for (i = cur->sent_up_to; i < last; i++) {
            item = cur->items[i];

            buf = stringbuffer_new();
            item->handler->summary(item->item, buf);
            title = stringbuffer_finish(buf);

            face = NULL;
            if (item->handler->item_face != NULL)
                face = item->handler->item_face(item->item);

            if (face == NULL)
                face = try_find_face(item->handler->face, NULL);

            size = 4 + (2 + strlen(item->handler->type)) + (2 + strlen(title)) + 4;

            if (SockList_Avail(&sl) < size) {
                Send_With_Handling(pl->socket, &sl);
                SockList_Reset(&sl);
                SockList_AddString(&sl, "addknowledge ");
            }

            SockList_AddInt(&sl, i + 1);
            SockList_AddLen16Data(&sl, item->handler->type, strlen(item->handler->type));
            if (face != NULL && !(pl->socket->faces_sent[face->number]&NS_FACESENT_FACE))
                esrv_send_face(pl->socket, face, 0);
            SockList_AddLen16Data(&sl, title, strlen(title));
            SockList_AddInt(&sl, face ? face->number : 0);

            free(title);
        }

        cur->sent_up_to = last;

        Send_With_Handling(pl->socket, &sl);
        SockList_Term(&sl);

        /* don't send more this tick */
        break;
    }
}

void knowledge_add_probe_monster(object *op, object *mon) {
    StringBuffer *buf = NULL;
    char *result;

    if (op->contr == NULL)
        return;

    buf = stringbuffer_new();
    stringbuffer_append_printf(buf, " *** %s ***\n", mon->name);
    describe_item(mon, NULL, 1, buf);
    result = stringbuffer_finish(buf);
    draw_ext_info(NDI_UNIQUE, 0, op, MSG_TYPE_COMMAND, MSG_TYPE_COMMAND_EXAMINE, result);
    free(result);

    /*
     * TODO: Add to player's knowledge. This is disabled for now because the
     * monster being probed could be custom, but when the player goes to query
     * their knowledge they will only get information about the monster's
     * archetype.
    knowledge_player *kp;
    kp = knowledge_get_or_create(op->contr);
    knowledge_add(kp, mon->name, &knowledges[1]);
    */
}