readable.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>.
 */

/* laid down initial file - dec 1995. -b.t. thomas@astro.psu.edu */

#include "global.h"

#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>

#include "book.h"
#include "living.h"
#include "output_file.h"
#include "spells.h"
#include "assets.h"
#include "AssetsManager.h"

/* Define this if you want to archive book titles by contents.
 * This option should enforce UNIQUE combinations of titles,authors and
 * msg contents during and *between *game sessions.
 * Note: a slight degeneracy exists since books are archived based on an integer
 * index value calculated from the message text (similar to alchemy formulae).
 * Sometimes two widely different messages have the same index value (rare). In
 * this case,  it is possible to occasionally generate 2 books with same title and
 * different message content. Not really a bug, but rather a feature. This action
 * should  keeps player on their toes ;).
 * Also, note that there is *finite *space available for archiving message and titles.
 * Once this space is used, books will stop being archived. Not a serious problem
 * under the current regime, since there are generally fewer possible (random)
 * messages than space available on the titlelists.
 * One exception (for sure) are the monster messages. But no worries, you should
 * see all of the monster info in some order (but not all possble combinations)
 * before the monster titlelist space is run out. You can increase titlelist
 * space by increasing the array sizes for the monster book_authours and book_names
 * (see  max_titles[] array and include/read.h). Since the unique_book algorthm is
 * kinda stupid, this program *may *slow down program execution if defined (but I don't
 * think its a significant problem, at least, I have no problems running this option
 * on a Sparc 10! Also, once archive title lists are filled and/or all possible msg
 * combinations have been generated, unique_book isnt called anymore. It takes 5-10
 * sessions for this to happen).
 * Final note: the game remembers book/title/msg combinations from reading the
 * file lib/bookarch. If you REMOVE this file, you will lose your archive. So
 * be sure to copy it over to the new lib directory when you change versions.
 * -b.t.
 */

/* This flag is useful to see what kind of output messages are created */
/* #define BOOK_MSG_DEBUG */

/* This flag is useful for debugging archiving action */
/* #define ARCHIVE_DEBUG */

#define MAX_TITLE_CHECK 20

#define MSGTYPE_LIB 0

#define MSGTYPE_MONSTER 1

#define MSGTYPE_ARTIFACT 2

#define MSGTYPE_SPELLPATH 3

#define MSGTYPE_ALCHEMY 4

#define MSGTYPE_GODS 5

#define MSGTYPE_MSGFILE 6

#define arraysize(arrayname) (sizeof(arrayname)/sizeof(*(arrayname)))

/* Moved these structures from struct.h to this file in 0.94.3 - they
 * are not needed anyplace else, so why have them globally declared?
 */

struct title {
    const char *name;      
    const char *authour;   
    const char *archname;  
    unsigned int level;    
    size_t size;           
    int msg_index;         
    title *next;           
};

struct titlelist {
    int number;       
    title *first_book;      
    titlelist *next;        
};

struct arttypename {
    const char *name;  
    int type;          
};

static void add_book(title *book, int type, const char *fname, int lineno);

static titlelist *booklist = NULL;

static std::vector<object *> monsters;

static int need_to_write_bookarchive = 0; 
static const uint32_t spellpathdef[NRSPELLPATHS] = {
    PATH_PROT,
    PATH_FIRE,
    PATH_FROST,
    PATH_ELEC,
    PATH_MISSILE,
    PATH_SELF,
    PATH_SUMMON,
    PATH_ABJURE,
    PATH_RESTORE,
    PATH_DETONATE,
    PATH_MIND,
    PATH_CREATE,
    PATH_TELE,
    PATH_INFO,
    PATH_TRANSMUTE,
    PATH_TRANSFER,
    PATH_TURNING,
    PATH_WOUNDING,
    PATH_DEATH,
    PATH_LIGHT
};

static const char *const path_book_name[] = {
    "codex",
    "compendium",
    "documentary",
    "exposition",
    "tables",
    "treatise"
};

static const char *const path_author[] = {
    "aether",
    "arcana",
    "astral byways",
    "connections",
    "the Grey Council",
    "deep pathways",
    "knowledge",
    "magic",
    "mystic ways",
    "pathways",
    "power",
    "spells",
    "transforms",
    "the mystic veil",
    "unknown spells"
};

static const arttypename art_name_array[] = {
    { "Helmet", HELMET },
    { "Amulet", AMULET },
    { "Shield", SHIELD },
    { "Bracers", BRACERS },
    { "Boots", BOOTS },
    { "Cloak", CLOAK },
    { "Gloves", GLOVES },
    { "Gridle", GIRDLE },
    { "Ring", RING },
    { "Horn", ROD },
    { "Missile Weapon", BOW },
    { "Missile", ARROW },
    { "Hand Weapon", WEAPON },
    { "Artifact", SKILL },
    { "Food", FOOD },
    { "Body Armour", ARMOUR }
};

static const char *const art_book_name[] = {
    "assemblage",
    "collection",
    "file",
    "files",
    "guide",
    "handbook",
    "index",
    "inventory",
    "list",
    "listing",
    "omnibus",
    "record",
    "record book",
    "trove"
};

static const char *const art_author[] = {
    "ancient things",
    "artifacts",
    "equipment",
    "Havlor",   /* ancient warrior scribe :) */
    "hoards",
    "items",
    "lost artifacts",
    "the ancients",
    "treasures",
    "useful things"
};

static const char *const mon_book_name[] = {
    "beastuary",
    "catalog",
    "compilation",
    "collection",
    "encyclopedia",
    "field notes",
    "guide",
    "handbook",
    "list",
    "manual",
    "notes",
    "omnibus",
    "record",
    "reference",
    "register",
    "traveller's guide",
    "volume"
};

static const char *const mon_author[] = {
    "beasts",
    "beings",
    "creatures",
    "dezidens",
    "dwellers",
    "evil nature",
    "Inioda",     /* ancient wizard and biologist */
    "life",
    "monsters",
    "nature",
    "new life",
    "residents",
    "the spawn",
    "the living",
    "the wilds",
    "things"
};

static const char *const gods_book_name[] = {
    "devotional",
    "devout notes",
    "divine text",
    "divine work",
    "holy book",
    "holy record",
    "hymnal",
    "illuminated text",
    "moral text",
    "pious pamphlet",
    "sacred guide",
    "testament",
    "transcript",
};

static const char *const gods_author[] = {
    "cults",
    "dieties",
    "joy",
    "lasting curse",
    "madness",
    "religions",
    "rituals",
    "the dead",
    "the gods",
    "the heirophant",
    "the poor priest",
    "the priestess",
    "pain",
    "white",
    "worship"
};

static const char *const formula_book_name[] = {
    "cookbook",
    "formulary",
    "lab book",
    "lab notes",
    "recipe book",
    "experiment record",
    "work plan",
    "design notes",
    "research notes",
    "crafting manual"
};

static const char *const formula_author[] = {
    "Albertus Magnus",
    "alchemy",
    "balms",
    "creation",
    "dusts",
    "magical manufacture",
    "making",
    "philosophical items",
    "potions",
    "powders",
    "the cauldron",
    "the lamp black",
    "transmutation",
    "waters"
};

static const char *const light_book_name[] = {
    "calendar",
    "datebook",
    "diary",
    "essay",
    "guidebook",
    "handbook",
    "ledger",
    "notes",
    "notebook",
    "octavo",
    "opuscule",
    "pamphlet",
    "practicum",
    "script",
    "transcript"
};

static const char *const heavy_book_name[] = {
    "catalog",
    "compendium",
    "dissertation",
    "guide",
    "manual",
    "opus",
    "tome",
    "treatise",
    "volume",
    "work"
};

static const char *const book_author[] = {
    "Abdulah",
    "Al'hezred",
    "Alywn",
    "Arundel",
    "Arvind",
    "Aerlingas",
    "Bacon",
    "Baliqendii",
    "Bosworth",
    "Beathis",
    "Bertil",
    "Cauchy",
    "Chakrabarti",
    "der Waalis",
    "Dirk",
    "Djwimii",
    "Eisenstaadt",
    "Fendris",
    "Frank",
    "Habbi",
    "Harlod",
    "Ichibod",
    "Janus",
    "June",
    "Laplace",
    "Magnuson",
    "Nandii",
    "Nitfeder",
    "Norris",
    "Parael",
    "Penhew",
    "Sophia",
    "Skilly",
    "Tahir",
    "Thockmorton",
    "Thomas",
    "van Helsing",
    "van Pelt",
    "Voormis",
    "Xavier",
    "Xeno",
    "Zardoz",
    "Zagy"
};

static const char *const book_descrpt[] = {
    "ancient",
    "cryptic",
    "cryptical",
    "dusty",
    "hierarchical",
    "grizzled",
    "gold-gilt",
    "great",
    "lost",
    "magnificent",
    "musty",
    "mythical",
    "mystical",
    "rustic",
    "stained",
    "silvered",
    "transcendental",
    "weathered"
};

static const readable_message_type readable_message_types[] = {
    /*subtype 0  */ { 0, 0 },
                    /* book messages subtypes */
    /*subtype 1  */ { MSG_TYPE_BOOK, MSG_TYPE_BOOK_CLASP_1 },
                    { MSG_TYPE_BOOK, MSG_TYPE_BOOK_CLASP_2 },
                    { MSG_TYPE_BOOK, MSG_TYPE_BOOK_ELEGANT_1 },
                    { MSG_TYPE_BOOK, MSG_TYPE_BOOK_ELEGANT_2 },
                    { MSG_TYPE_BOOK, MSG_TYPE_BOOK_QUARTO_1 },
                    { MSG_TYPE_BOOK, MSG_TYPE_BOOK_QUARTO_2 },
                    { MSG_TYPE_BOOK, MSG_TYPE_BOOK_SPELL_EVOKER },
                    { MSG_TYPE_BOOK, MSG_TYPE_BOOK_SPELL_PRAYER },
                    { MSG_TYPE_BOOK, MSG_TYPE_BOOK_SPELL_PYRO },
    /*subtype 10 */ { MSG_TYPE_BOOK, MSG_TYPE_BOOK_SPELL_SORCERER },
                    { MSG_TYPE_BOOK, MSG_TYPE_BOOK_SPELL_SUMMONER },
                    /* card messages subtypes*/
                    { MSG_TYPE_CARD, MSG_TYPE_CARD_SIMPLE_1 },
                    { MSG_TYPE_CARD, MSG_TYPE_CARD_SIMPLE_2 },
                    { MSG_TYPE_CARD, MSG_TYPE_CARD_SIMPLE_3 },
                    { MSG_TYPE_CARD, MSG_TYPE_CARD_ELEGANT_1 },
                    { MSG_TYPE_CARD, MSG_TYPE_CARD_ELEGANT_2 },
                    { MSG_TYPE_CARD, MSG_TYPE_CARD_ELEGANT_3 },
                    { MSG_TYPE_CARD, MSG_TYPE_CARD_STRANGE_1 },
                    { MSG_TYPE_CARD, MSG_TYPE_CARD_STRANGE_2 },
    /*subtype 20 */ { MSG_TYPE_CARD, MSG_TYPE_CARD_STRANGE_3 },
                    { MSG_TYPE_CARD, MSG_TYPE_CARD_MONEY_1 },
                    { MSG_TYPE_CARD, MSG_TYPE_CARD_MONEY_2 },
                    { MSG_TYPE_CARD, MSG_TYPE_CARD_MONEY_3 },
                    /* Paper messages subtypes */
                    { MSG_TYPE_PAPER, MSG_TYPE_PAPER_NOTE_1 },
                    { MSG_TYPE_PAPER, MSG_TYPE_PAPER_NOTE_2 },
                    { MSG_TYPE_PAPER, MSG_TYPE_PAPER_NOTE_3 },
                    { MSG_TYPE_PAPER, MSG_TYPE_PAPER_LETTER_OLD_1 },
                    { MSG_TYPE_PAPER, MSG_TYPE_PAPER_LETTER_OLD_2 },
                    { MSG_TYPE_PAPER, MSG_TYPE_PAPER_LETTER_NEW_1 },
    /*subtype 30 */ { MSG_TYPE_PAPER, MSG_TYPE_PAPER_LETTER_NEW_2 },
                    { MSG_TYPE_PAPER, MSG_TYPE_PAPER_ENVELOPE_1 },
                    { MSG_TYPE_PAPER, MSG_TYPE_PAPER_ENVELOPE_2 },
                    { MSG_TYPE_PAPER, MSG_TYPE_PAPER_SCROLL_OLD_1 },
                    { MSG_TYPE_PAPER, MSG_TYPE_PAPER_SCROLL_OLD_2 },
                    { MSG_TYPE_PAPER, MSG_TYPE_PAPER_SCROLL_NEW_1 },
                    { MSG_TYPE_PAPER, MSG_TYPE_PAPER_SCROLL_NEW_2 },
                    { MSG_TYPE_PAPER, MSG_TYPE_PAPER_SCROLL_MAGIC },
                    /* road signs messages subtypes */
                    { MSG_TYPE_SIGN, MSG_TYPE_SIGN_BASIC },
                    { MSG_TYPE_SIGN, MSG_TYPE_SIGN_DIR_LEFT },
    /*subtype 40 */ { MSG_TYPE_SIGN, MSG_TYPE_SIGN_DIR_RIGHT },
                    { MSG_TYPE_SIGN, MSG_TYPE_SIGN_DIR_BOTH },
                    /* stones and monument messages */
                    { MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_STONE_1 },
                    { MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_STONE_2 },
                    { MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_STONE_3 },
                    { MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_STATUE_1 },
                    { MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_STATUE_2 },
                    { MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_STATUE_3 },
                    { MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_GRAVESTONE_1 },
                    { MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_GRAVESTONE_2 },
    /*subtype 50 */ { MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_GRAVESTONE_3 },
                    { MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_WALL_1 },
                    { MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_WALL_2 },
                    { MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_WALL_3 },
                    { MSG_TYPE_SIGN, MSG_TYPE_SIGN_MAGIC_MOUTH }
};

static const int last_readable_subtype = arraysize(readable_message_types);

static const int max_titles[6] = {
    (arraysize(light_book_name)+arraysize(heavy_book_name))*arraysize(book_author), /* MSGTYPE_LIB */
    arraysize(mon_book_name)*arraysize(mon_author), /* MSGTYPE_MONSTER */
    arraysize(art_book_name)*arraysize(art_author), /* MSGTYPE_ARTIFACT */
    arraysize(path_book_name)*arraysize(path_author), /* MSGTYPE_SPELLPATH */
    arraysize(formula_book_name)*arraysize(formula_author), /* MSGTYPE_ALCHEMY */
    arraysize(gods_book_name)*arraysize(gods_author), /* MSGTYPE_GODS */
};

/******************************************************************************
 *
 * Start of misc. readable functions used by others functions in this file
 *
 *****************************************************************************/

static titlelist *get_empty_booklist(void) {
    titlelist *bl = (titlelist *)calloc(1, sizeof(titlelist));

    if (bl == NULL)
        fatal(OUT_OF_MEMORY);
    return bl;
}

static title *get_empty_book(void) {
    title *t = (title *)calloc(1, sizeof(title));

    if (t == NULL)
        fatal(OUT_OF_MEMORY);
    return t;
}

static titlelist *get_titlelist(int i) {
    titlelist *tl;
    int number;

    if (i < 0 || i >= (int)arraysize(max_titles)) {
        LOG(llevInfo, "Warning: invalid book index %d, using 0 instead\n", i);
        return booklist;
    }

    for (tl = booklist, number = i; tl && number; tl = tl->next, number--) {
        if (!tl->next)
            tl->next = get_empty_booklist();
    }

    return tl;
}

/* HANDMADE STRING FUNCTIONS.., perhaps these belong in another file
 * (shstr.c ?), but the quantity BOOK_BUF will need to be defined. */

int nstrtok(const char *buf1, const char *buf2) {
    char *tbuf, buf[MAX_BUF];
    int number = 0;

    if (!buf1 || !buf2)
        return 0;

    strlcpy(buf, buf1, sizeof(buf));
    for (tbuf = strtok(buf, buf2); tbuf; tbuf = strtok(NULL, buf2)) {
        number++;
    }
    return number;
}

const char *trim(const char *buf) {
    while ((*buf) == ' ') {
        buf++;
    }
    return buf;
}

char *strtoktolin(const char *buf1, const char *buf2, char *retbuf, size_t size) {
    int maxi, i = nstrtok(buf1, buf2);
    char *tbuf, buf[MAX_BUF];

    maxi = i;
    strlcpy(buf, buf1, sizeof(buf));
    snprintf(retbuf, size, " ");
    for (tbuf = strtok(buf, buf2); tbuf && i > 0; tbuf = strtok(NULL, buf2)) {
        snprintf(retbuf+strlen(retbuf), size-strlen(retbuf), "%s", trim(tbuf));
        i--;
        if (i == 1 && maxi > 1)
            snprintf(retbuf+strlen(retbuf), size-strlen(retbuf), " and ");
        else if (i > 0 && maxi > 1)
            snprintf(retbuf+strlen(retbuf), size-strlen(retbuf), ", ");
        else {
            // Remove a trailing newline if it is there.
            int end = strlen(retbuf);
            if (retbuf[end-1] == '\n')
                end--;
            snprintf(retbuf+end, size-end, ".");
        }
    }
    return retbuf;
}

int book_overflow(const char *buf1, const char *buf2, size_t booksize) {
    if (buf_overflow(buf1, buf2, BOOK_BUF-2)   /* 2 less so always room for trailing \n */
    || buf_overflow(buf1, buf2, booksize))
        return 1;
    return 0;
}

/*****************************************************************************
 *
 * Start of initialization related functions.
 *
 ****************************************************************************/

static void init_book_archive(void) {
    FILE *fp;
#ifdef BOOK_MSG_DEBUG
    int nroftitle = 0;
#endif
    char buf[MAX_BUF], fname[MAX_BUF], *cp;
    static int did_init_barch = 0;

    if (did_init_barch)
        return;
    did_init_barch = 1;

    if (!booklist)
        booklist = get_empty_booklist();

    snprintf(fname, sizeof(fname), "%s/bookarch", settings.localdir);
    LOG(llevDebug, " Reading bookarch from %s...\n", fname);

    fp = fopen(fname, "r");
    if (fp != NULL) {
        int type;
        size_t i;
        titlelist *bl;
        int lineno;
        title *book;
        int skipping;

        skipping = 0;
        book = NULL;
        type = -1;
        for (lineno = 1; fgets(buf, MAX_BUF, fp) != NULL; lineno++) {
            int len;
            int value;

            if (*buf == '#')
                continue;
            cp = strchr(buf, '\n');
            if (cp != NULL) {
                while (cp > buf && (cp[-1] == ' ' || cp[-1] == '\t'))
                    cp--;
                *cp = '\0';
            }
            cp = buf;
            if (strncmp(buf, "title ", 6) == 0) {
                skipping = 0;
                cp = buf+6;
                while (*cp == ' ' || *cp == '\t')
                    cp++;
                if (*cp == '\0') {
                    LOG(llevInfo, "Warning: missing book title at %s, line %d\n", fname, lineno);
                    book = NULL;
                } else {
                    book = get_empty_book();   /* init new book entry */
                    book->name = add_string(cp);
                    type = -1;
#ifdef BOOK_MSG_DEBUG
                    nroftitle++;
#endif
                }
            } else if (book == NULL) {
                if (!skipping) {
                    skipping = 1;
                    LOG(llevInfo, "Warning: expecting 'title' at %s, line %d\n", fname, lineno);
                }
            } else if (strncmp(buf, "authour ", 8) == 0) {
                cp = buf+8;
                while (*cp == ' ' || *cp == '\t')
                    cp++;
                if (*cp == '\0') {
                    LOG(llevInfo, "Warning: missing book authour at %s, line %d\n", fname, lineno);
                } else {
                    book->authour = add_string(cp);
                }
            } else if (strncmp(buf, "arch ", 5) == 0) {
                cp = buf+5;
                while (*cp == ' ' || *cp == '\t')
                    cp++;
                if (*cp == '\0') {
                    LOG(llevInfo, "Warning: missing book arch at %s, line %d\n", fname, lineno);
                } else {
                    book->archname = add_string(cp);
                }
            } else if (sscanf(buf, "level %d%n", &value, &len) == 1 && len == (int)strlen(buf)) {
                book->level = value;
            } else if (sscanf(buf, "type %d%n", &value, &len) == 1 && len == (int)strlen(buf)) {
                type = value;
            } else if (sscanf(buf, "size %d%n", &value, &len) == 1 && len == (int)strlen(buf)) {
                book->size = value;
            } else if (sscanf(buf, "index %d%n", &value, &len) == 1 && len == (int)strlen(buf)) {
                book->msg_index = value;
            } else if (strcmp(buf, "end") == 0) { /* link it */
                add_book(book, type, fname, lineno);
                book = NULL;
                type = -1;
            } else {
                LOG(llevInfo, "Warning: syntax error at %s, line %d\n", fname, lineno);
            }
        }
        if (book != NULL) {
            LOG(llevInfo, "Warning: missing 'end' at %s, line %d\n", fname, lineno);
            add_book(book, type, fname, lineno);
        }
        LOG(llevDebug, " book archives(used/avail):\n");
        for (bl = booklist, i = 0; bl != NULL && i < arraysize(max_titles); bl = bl->next, i++) {
            LOG(llevDebug, "(%d/%d)\n", bl->number, max_titles[i]);
        }
        fclose(fp);
    }

#ifdef BOOK_MSG_DEBUG
    LOG(llevDebug, "\n init_book_archive() got %d titles.\n", nroftitle);
#endif
    LOG(llevDebug, " done.\n");
}

static void add_book(title *book, int type, const char *fname, int lineno) {
    titlelist *bl;

    if (type == -1) {
        LOG(llevInfo, "Warning: book with no type at %s, line %d; using type 0\n", fname, lineno);
        type = 0;
    }

    bl = get_titlelist(type);
    book->next = bl->first_book;
    bl->first_book = book;
    bl->number++;
}

static void do_monster(archetype *at) {
    if (QUERY_FLAG(&at->clone, FLAG_MONSTER) && (!at->head)
    && (object_get_value(&at->clone, MONSTER_EXCLUDE_FROM_READABLE_KEY) == NULL)
    && (!QUERY_FLAG(&at->clone, FLAG_CHANGING) || QUERY_FLAG(&at->clone, FLAG_UNAGGRESSIVE))) {
        monsters.push_back(&at->clone);
    }
}

static void init_mon_info(void) {
    static int did_init_mon_info = 0;

    if (did_init_mon_info)
        return;
    did_init_mon_info = 1;

    archetypes_for_each(do_monster);

    LOG(llevDebug, "init_mon_info() got %zu monsters\n", monsters.size());
}

void init_readable(void) {
    static int did_this = 0;

    if (did_this)
        return;
    did_this = 1;

    LOG(llevDebug, "Initializing reading data...\n");
    init_book_archive();
    init_mon_info();
    LOG(llevDebug, " done reading data\n");
}

/*****************************************************************************
 *
 * This is the start of the administrative functions when creating
 * new books (ie, updating title and the like)
 *
 *****************************************************************************/

static title *find_title(const object *book, int msgtype) {
    title *t;
    titlelist *tl;
    size_t length;
    int index;

    if (msgtype < 0)
        return (title *)NULL;

    tl = get_titlelist(msgtype);
    if (!tl)
        return (title *)NULL;

    length = strlen(book->msg);
    index = strtoint(book->msg);
    for (t = tl->first_book; t; t = t->next)
        if (t->size == length && t->msg_index == index) {
#ifdef ARCHIVE_DEBUG
            LOG(llevDebug, "Found title match (list %d): %s %s (%d)\n", msgtype, t->name, t->authour, t->msg_index);
#endif
            return t;
        }

    return (title *)NULL;
}

static void new_text_name(object *book, int msgtype) {
    const char *name;

    if (book->type != BOOK)
        return;

    switch (msgtype) {
    case MSGTYPE_MONSTER:
        name = mon_book_name[RANDOM()%arraysize(mon_book_name)];
        break;

    case MSGTYPE_ARTIFACT:
        name = art_book_name[RANDOM()%arraysize(art_book_name)];
        break;

    case MSGTYPE_SPELLPATH:
        name = path_book_name[RANDOM()%arraysize(path_book_name)];
        break;

    case MSGTYPE_ALCHEMY:
        name = formula_book_name[RANDOM()%arraysize(formula_book_name)];
        break;

    case MSGTYPE_GODS:
        name = gods_book_name[RANDOM()%arraysize(gods_book_name)];
        break;

    case MSGTYPE_MSGFILE:
    default:
        if (book->weight > 2000) {  /* based on weight */
            name = heavy_book_name[RANDOM()%arraysize(heavy_book_name)];
        } else {
            name = light_book_name[RANDOM()%arraysize(light_book_name)];
        }
        break;
    }
    free_string(book->name);
    book->name = add_string(name);
}

static void add_author(object *op, int msgtype) {
    char title[MAX_BUF];
    const char *name;

    if (msgtype < 0 || strlen(op->msg) < 5)
        return;

    switch (msgtype) {
    case MSGTYPE_MONSTER:
        name = mon_author[RANDOM()%arraysize(mon_author)];
        break;

    case MSGTYPE_ARTIFACT:
        name = art_author[RANDOM()%arraysize(art_author)];
        break;

    case MSGTYPE_SPELLPATH:
        name = path_author[RANDOM()%arraysize(path_author)];
        break;

    case MSGTYPE_ALCHEMY:
        name = formula_author[RANDOM()%arraysize(formula_author)];
        break;

    case MSGTYPE_GODS:
        name = gods_author[RANDOM()%arraysize(gods_author)];
        break;

    case MSGTYPE_MSGFILE:
    default:
        name = book_author[RANDOM()%arraysize(book_author)];
    }

    snprintf(title, sizeof(title), "of %s", name);
    op->title = add_string(title);
}

static int unique_book(const object *book, int msgtype) {
    title *test;

    if (!booklist)
        return 1;  /* No archival entries! Must be unique! */

    /* Go through the booklist.  If the author and name match, not unique so
     * return 0.
     */
    for (test = get_titlelist(msgtype)->first_book; test; test = test->next) {
        if (!strcmp(test->name, book->name) && !strcmp(book->title, test->authour))
            return 0;
    }
    return 1;
}

static void add_book_to_list(const object *book, int msgtype) {
    titlelist *tl = get_titlelist(msgtype);
    title *t;

    if (!tl) {
        LOG(llevError, "add_book_to_list can't get booklist!\n");
        return;
    }

    t = get_empty_book();
    t->name = add_string(book->name);
    t->authour = add_string(book->title);
    t->size = strlen(book->msg);
    t->msg_index = strtoint(book->msg);
    t->archname = add_string(book->arch->name);
    t->level = book->level;

    t->next = tl->first_book;
    tl->first_book = t;
    tl->number++;

    /* We have stuff we need to write now */
    need_to_write_bookarchive = 1;

#ifdef ARCHIVE_DEBUG
    LOG(llevDebug, "Archiving new title: %s %s (%d)\n", book->name, book->title, msgtype);
#endif
}

static void change_book(object *book, int msgtype) {
    titlelist *tl;
    title *t;
    int tries;

    if (book->type != BOOK) {
        LOG(llevError, "change_book_name() called w/ illegal obj type.\n");
        return;
    }

    tl = get_titlelist(msgtype);
    t = NULL;
    tries = 0;

    /* look to see if our msg already been archived. If so, alter
     * the book to match the archival text. If we fail to match,
     * then we archive the new title/name/msg combo if there is
     * room on the titlelist.
     */

    if (strlen(book->msg) > 5 && (t = find_title(book, msgtype))) {
        object *tmpbook;
        sstring marker = object_get_value(book, "knowledge_marker");

        /* alter book properties */
        tmpbook = create_archetype(t->archname);
        if (marker != NULL)
            /* need to copy the knowledge_marker */
            object_set_value(tmpbook, "knowledge_marker", marker, 1);
        object_set_msg(tmpbook, book->msg);
        object_copy(tmpbook, book);
        object_free_drop_inventory(tmpbook);

        book->title = add_string(t->authour);
        free_string(book->name);
        book->name = add_string(t->name);
        book->level = t->level;
    } else { /* Don't have any default title, so lets make up a new one */
        int numb, maxnames = max_titles[msgtype];
        const char *old_title;
        const char *old_name;

        old_title = book->title ? add_string(book->title) : NULL;
        old_name = add_string(book->name);

        /* some pre-generated books have title already set (from
         * maps), also don't bother looking for unique title if
         * we already used up all the available names! */

        if (!tl) {
            LOG(llevError, "change_book_name(): can't find title list\n");
            numb = 0;
        } else
            numb = tl->number;

        if (numb == maxnames) {
#ifdef ARCHIVE_DEBUG
            LOG(llevDebug, "titles for list %d full (%d possible).\n", msgtype, maxnames);
#endif
            // Set tries to maximum. That way we get the descriptors on books when the
            // title set is full, too.
            tries = MAX_TITLE_CHECK;
        }
        /* shouldnt change map-maker books */
        else if (!book->title)
            do {
                /* random book name */
                new_text_name(book, msgtype);
                add_author(book, msgtype);  /* random author */
                tries++;
            } while (!unique_book(book, msgtype) && tries < MAX_TITLE_CHECK);

        /* Now deal with 2 cases.
         * 1) If no space for a new title exists lets just restore
         * the old book properties. Remember, if the book had
         * matchd an older entry on the titlelist, we shouldnt
         * have called this routine in the first place!
         * 2) If we got a unique title, we need to add it to
         * the list.
         */

        if (tries == MAX_TITLE_CHECK) {
#ifdef ARCHIVE_DEBUG
            LOG(llevDebug, "Failed to obtain unique title for %s %s (names:%d/%d)\n", book->name, book->title, numb, maxnames);
#endif
            /* restore old book properties here */
            free_string(book->name);
            if (book->title)
                free_string(book->title);
            book->title = old_title != NULL ? add_string(old_title) : NULL;

            if (RANDOM()%4) {
                /* Lets give the book a description to individualize it some */
                char new_name[MAX_BUF];

                snprintf(new_name, MAX_BUF, "%s %s", book_descrpt[RANDOM()%arraysize(book_descrpt)], old_name);
                book->name = add_string(new_name);
            } else {
                book->name = add_string(old_name);
            }
        } else if (book->title && strlen(book->msg) > 5) { /* archive if long msg texts */
            add_book_to_list(book, msgtype);
        }

        if (old_title != NULL)
            free_string(old_title);
        free_string(old_name);
    }
}

/*****************************************************************************
 *
 * This is the start of the area that generates the actual contents
 * of the book.
 *
 *****************************************************************************/

/*****************************************************************************
 * Monster msg generation code.
 ****************************************************************************/

object *get_random_mon(int level) {

    /* safety check.  Problem w/ init_mon_info list? */
    if (monsters.empty())
        return (object *)NULL;

    if (!level) {
        return monsters[RANDOM() % monsters.size()];
    }

    std::vector<object *> select;
    std::copy_if(monsters.cbegin(), monsters.cend(), std::back_inserter(select), [&] (auto ob) { return ob->level >= level; });

    if (select.empty()) {
        LOG(llevError, "get_random_mon() couldn't return monster for level %d\n", level);
        return NULL;
    }
    return select[RANDOM() % select.size()];
}

static StringBuffer *mon_desc(const object *mon) {
    StringBuffer *desc = stringbuffer_new();
    stringbuffer_append_printf(desc, "\n---\n *** %s ***\n", mon->name);
    describe_item(mon, NULL, 0, desc);
    // If a monster has lore, print it here.
    if (mon->lore) {
        stringbuffer_append_printf(desc, "\n ^ %s", mon->lore);
    }
    return desc;
}

static object *get_next_mon(const object *tmp) {
    auto it = std::find(monsters.begin(), monsters.end(), tmp);
    if (it == monsters.end())
        return nullptr;
    ++it;
    if (it == monsters.end())
        it = monsters.begin();

    return *it;
}

static StringBuffer *mon_info_msg(int level, size_t booksize, object *book) {
    object *tmp;
    StringBuffer *marker = stringbuffer_new(), *desc = stringbuffer_new(), *mon = NULL;
    int added = 0;
    sstring final;
    const char *sep = ":";

    /*preamble */
    stringbuffer_append_string(desc, "This beastiary contains:");
    stringbuffer_append_string(marker, "monster");

    /* lets print info on as many monsters as will fit in our
     * document.
     * 8-96 Had to change this a bit, otherwise there would
     * have been an impossibly large number of combinations
     * of text! (and flood out the available number of titles
     * in the archive in a snap!) -b.t.
     */
    for (tmp = get_random_mon(level*3); tmp; tmp = get_next_mon(tmp)) {
        /* monster description */
        mon = mon_desc(tmp);

        if (stringbuffer_length(desc) + stringbuffer_length(mon) >= booksize)
            break;
        added++;
        stringbuffer_append_printf(marker, "%s%s", sep, tmp->arch->name);
        sep = "/";
        stringbuffer_append_stringbuffer(desc, mon);
        stringbuffer_delete(mon);
        mon = NULL;
    }

    if (mon != NULL) {
        stringbuffer_delete(mon);
    }

    final = stringbuffer_finish_shared(marker);
    if (added)
        object_set_value(book, "knowledge_marker", final, 1);
    free_string(final);

    return desc;
}

/*****************************************************************************
 * Artifact msg generation code.
 ****************************************************************************/

static StringBuffer *artifact_describe(const artifact *art, const artifactlist *al, int message, int art_name, int separator) {
    object *tmp;
    int chance;
    StringBuffer *desc = stringbuffer_new(), *sbuf;

    if (separator)
        stringbuffer_append_string(desc, "---\n");

    /* Name */
    if (!art->allowed.empty()) {
        archetype *arch;
        auto name = art->allowed[RANDOM() % art->allowed.size()];
        int inv = 0;

        if (name[0] == '!')
            inv = 1;

        arch = try_find_archetype(name + inv);
        if (!arch)
            arch = find_archetype_by_object_name(name + inv);

        if (!arch)
            LOG(llevError, "artifact_msg: missing archetype %s for artifact %s (type %d)\n", name + inv, art->item->name, art->item->type);
        else {
            if (inv)
                stringbuffer_append_printf(desc, " A %s (excepted %s) of %s", art_name_array[art_name].name, arch->clone.name_pl, art->item->name);
            else
                stringbuffer_append_printf(desc, " A %s of %s", arch->clone.name, art->item->name);
        }
    } else {  /* default name is used */
        /* use the base 'generic' name for our artifact */
        stringbuffer_append_printf(desc, " The %s of %s", art_name_array[art_name].name, art->item->name);
    }

    /* chance of finding */
    stringbuffer_append_string(desc, " is ");
    chance = 100*((float)art->chance/al->total_chance);
    if (chance >= 20)
        stringbuffer_append_string(desc, "an uncommon");
    else if (chance >= 10)
        stringbuffer_append_string(desc, "an unusual");
    else if (chance >= 5)
        stringbuffer_append_string(desc, "a rare");
    else
        stringbuffer_append_string(desc, "a very rare");

    /* value of artifact */
    stringbuffer_append_printf(desc, " item with a value that is %d times normal.\n", art->item->value);

    /* include the message about the artifact, if exists, and book
    * level is kinda high */
    if (message && !(strlen(art->item->msg) > BOOK_BUF))
        stringbuffer_append_string(desc, art->item->msg);

    /* properties of the artifact */
    tmp = object_new();
    add_abilities(tmp, art->item);
    tmp->type = al->type;
    SET_FLAG(tmp, FLAG_IDENTIFIED);
    sbuf = describe_item(tmp, NULL, 0, NULL);
    if (stringbuffer_length(sbuf) > 1) {
        stringbuffer_append_string(desc, " Properties of this artifact include:\n ");
        stringbuffer_append_stringbuffer(desc, sbuf);
        stringbuffer_append_string(desc, "\n");
    }
    free(stringbuffer_finish(sbuf));
    object_free_drop_inventory(tmp);

    return desc;
}

static StringBuffer *artifact_msg(unsigned int level, size_t booksize) {
    const artifactlist *al;
    const artifact *art;
    int i, type, index;
    int book_entries = level > 5 ? RANDOM()%3+RANDOM()%3+2 : RANDOM()%level+1;
    StringBuffer *desc, *message = stringbuffer_new();

    /* values greater than 5 create msg buffers that are too big! */
    if (book_entries > 5)
        book_entries = 5;

    /* lets determine what kind of artifact type randomly.
     * Right now legal artifacts only come from those listed
     * in art_name_array. Also, we check to be sure an artifactlist
     * for that type exists!
     */
    i = 0;
    do {
        index = RANDOM()%arraysize(art_name_array);
        type = art_name_array[index].type;
        al = find_artifactlist(type);
        i++;
    } while (al == NULL && i < 10);

    if (i == 10) { /* Unable to find a message */
        stringbuffer_append_string(message, "None");
        return message;
    }

    /* There is no reason to start on the artifact list at the beginning. Lets
     * take our starting position randomly... */
    auto iart = al->items.cbegin();
    for (i = RANDOM()%level+RANDOM()%2+1; i > 0; i--) {
        if (iart == al->items.cend())
            iart = al->items.cbegin(); /* hmm, out of stuff, loop back around */
        ++iart;
    }

    /* Ok, lets print out the contents */
    stringbuffer_append_printf(message, "Herein %s detailed %s...\n", book_entries > 1 ? "are" : "is", book_entries > 1 ? "some artifacts" : "an artifact");

    i = 0;
    /* artifact msg attributes loop. Lets keep adding entries to the 'book'
     * as long as we have space up to the allowed max # (book_entires)
     */
    while (book_entries > 0) {
        int with_message;
        if (iart == al->items.cend())
            iart = al->items.cbegin();
        art = *iart;
        with_message = (art->item->msg && RANDOM()%4+1 < level) ? 1 : 0;

        desc = artifact_describe(art, al, with_message, index, i++);

        if (stringbuffer_length(message) + stringbuffer_length(desc) >= booksize) {
            stringbuffer_delete(desc);
            break;
        }

        stringbuffer_append_stringbuffer(message, desc);
        stringbuffer_delete(desc);

        ++iart;
        book_entries--;
    }

    return message;
}

/*****************************************************************************
 * Spellpath message generation
 *****************************************************************************/

static struct {
    int prayers;
    int did_first_sp;
    uint32_t pnum;
    int level;
    size_t booksize;
    StringBuffer *buf;
    int done;
} sp_params;

static void do_spellpath_msg(archetype *at) {
    /* Determine if this is an appropriate spell.  Must
     * be of matching path, must be of appropriate type (prayer
     * or not), and must be within the valid level range.
     */
    if (at->clone.type == SPELL
    && at->clone.path_attuned & sp_params.pnum
    && ((at->clone.stats.grace && sp_params.prayers) || (at->clone.stats.sp && !sp_params.prayers))
    && at->clone.level < sp_params.level*8) {
        if (strlen(at->clone.name) + stringbuffer_length(sp_params.buf) >= sp_params.booksize) {
            sp_params.done = 1;
            return;
        }

        if (sp_params.did_first_sp)
            stringbuffer_append_string(sp_params.buf, ",\n ");
        sp_params.did_first_sp = 1;
        stringbuffer_append_string(sp_params.buf,at->clone.name);
    }
}

static StringBuffer *spellpath_msg(int level, size_t booksize, StringBuffer *buf) {
    int path = RANDOM()%NRSPELLPATHS;
    sp_params.prayers = RANDOM()%2;
    sp_params.did_first_sp = 0;
    sp_params.pnum = spellpathdef[path];
    sp_params.done = 0;

    if (buf == NULL) {
        buf = stringbuffer_new();
        /* Preamble */
        stringbuffer_append_printf(buf, "Herein are detailed the names of %s", sp_params.prayers ? "prayers" : "incantations");
        stringbuffer_append_printf(buf, " belonging to the path of %s:\n ", spellpathnames[path]);
    }
    sp_params.level = level;
    sp_params.booksize = booksize;
    sp_params.buf = buf;

    archetypes_for_each(do_spellpath_msg);

    /* Geez, no spells were generated. */
    if (!sp_params.did_first_sp) {
        if (RANDOM()%4) {  /* usually, lets make a recursive call... */
            // If we do a recursive call, we reset the spell path, so we will want to reset our text as well.
            stringbuffer_delete(buf);
            return spellpath_msg(level, booksize, NULL);
        }
        /* give up, cause knowing no spells exist for path is info too. need the header too. */
        stringbuffer_append_string(buf, "- no known spells exist -\n");
    }
    return buf;
}

void formula_knowledge_code(const recipe *r, char *buf, size_t len) {
    snprintf(buf, len, "alchemy:%d:%d:%s", r->ingred_count, r->index, r->title);
}

static void make_formula_book(object *book, int level) {
    recipelist *fl;
    recipe *formula;
    int chance, count = 0;
    const char *op_name;
    archetype *at;
    StringBuffer *text, *title;
    char *final, km[MAX_BUF];

    /* the higher the book level, the more complex (ie number of
     * ingredients) the formula can be.
     */
    fl = get_formulalist((RANDOM()%level)/3+1);
    if (!fl)
        fl = get_formulalist(1);  /* safety */

    if (fl->total_chance == 0) {
        object_set_msg(book, " <indecipherable text>\n");
        new_text_name(book, MSGTYPE_ALCHEMY);
        add_author(book, MSGTYPE_ALCHEMY);
        return;
    }

    /* get a random formula, weighted by its bookchance */
    chance = RANDOM()%fl->total_chance;
    for (formula = fl->items; formula != NULL; formula = formula->next) {
        chance -= formula->chance;
        if (chance <= 0 && formula->chance != 0 && !formula->is_combination)
            break;
    }

    if (!formula || formula->arch_names <= 0) {
        object_set_msg(book, " <indecipherable text>\n");
        new_text_name(book, MSGTYPE_ALCHEMY);
        add_author(book, MSGTYPE_ALCHEMY);
        return;
    }

    /* looks like a formula was found. Base the amount
     * of information on the booklevel and the spellevel
     * of the formula. */

    op_name = formula->arch_name[RANDOM()%formula->arch_names];
    at = find_archetype(op_name);
    if (at == (archetype *)NULL) {
        LOG(llevError, "formula_msg() can't find arch %s for formula.\n", op_name);
        object_set_msg(book, " <indecipherable text>\n");
        new_text_name(book, MSGTYPE_ALCHEMY);
        add_author(book, MSGTYPE_ALCHEMY);
        return;
    }
    op_name = at->clone.name;

    text = stringbuffer_new();
    title = stringbuffer_new();

    /* preamble */
    stringbuffer_append_printf(text, "Herein is described a%s %s project using %s:\n",
      formula->diff >= 10 && formula->diff < 15 ? "n" : "",
      recipe_get_difficulty_string(formula->diff),
      formula->skill ? formula->skill : "an unknown skill");

    /* item name */
    if (strcmp(formula->title, "NONE")) {
        stringbuffer_append_printf(text, "The %s of %s", op_name, formula->title);
        /* This results in things like pile of philo. sulfur.
        * while philo. sulfur may look better, without this,
        * you get things like 'the wise' because its missing the
        * water of section.
        */
        stringbuffer_append_printf(title, "%s: %s of %s", formula_book_name[RANDOM()%arraysize(formula_book_name)], op_name, formula->title);
    } else {
        stringbuffer_append_printf(text, "The %s", op_name);
        stringbuffer_append_printf(title, "%s: %s", formula_book_name[RANDOM()%arraysize(formula_book_name)], op_name);
        if (at->clone.title) {
            stringbuffer_append_printf(text, " %s", at->clone.title);
            stringbuffer_append_printf(title, " %s", at->clone.title);
        }
    }
    /* Lets name the book something meaningful ! */
    if (book->name)
        free_string(book->name);
    book->name = stringbuffer_finish_shared(title);
    if (book->title) {
        free_string(book->title);
        book->title = NULL;
    }

    /* ingredients to make it */
    if (formula->ingred != NULL) {
        linked_char *next;
        archetype *at;
        char name[MAX_BUF];

        at = find_archetype(formula->cauldron);
        if (at)
            query_name(&at->clone, name, MAX_BUF);
        else
            snprintf(name, sizeof(name), "an unknown place");

        stringbuffer_append_printf(text, " may be made at %s using the following ingredients:\n", name);

        for (next = formula->ingred; next != NULL; next = next->next) {
            count++;
            stringbuffer_append_printf(text, "%s\n", next->name);
        }
    } else {
        LOG(llevError, "formula_msg() no ingredient list for object %s of %s\n", op_name, formula->title);
        stringbuffer_append_string(text, "\n");
    }

    final = stringbuffer_finish(text);
    object_set_msg(book, final);
    free(final);

    formula_knowledge_code(formula, km, sizeof(km));
    object_set_value(book, "knowledge_marker", km, 1);
}

static StringBuffer *msgfile_msg(object *book, size_t booksize) {
    StringBuffer *ret = stringbuffer_new();

    GeneralMessage *msg = getManager()->messages()->random();

    if (msg && strlen(msg->message) <= booksize) {
        stringbuffer_append_string(ret, msg->message);
        if (msg->identifier != NULL) {
            char km[HUGE_BUF];
            snprintf(km, sizeof(km), "message:%s", msg->identifier);
            object_set_value(book, "knowledge_marker", km, 1);
        }
        if (msg->quest_code) {
            /* add a 'apply' hook to launch the quest */
            archetype *at = find_archetype("quest_advance_apply");
            if (at != NULL) {
                object *event = object_create_arch(at);
                FREE_AND_COPY(event->name, msg->quest_code);
                object_insert_in_ob(event, book);
            }
        }
    } else {
#ifdef BOOK_MSG_DEBUG
        // If msg was defined when we got here, we overflowed a book.
        if (msg)
            LOG(llevDebug, "Could not fit message %s into %s (%ld > %ld)\n", msg->identifier, book->name, strlen(msg->message), booksize);
#endif
        stringbuffer_append_string(ret, "\n <undecipherable text>");
    }

    return ret;
}

static StringBuffer *god_info_msg(int level, size_t booksize, object *book) {
    int what = 0;
    const object *god = get_rand_god();
    StringBuffer *desc = NULL;

    if (!god)
        return NULL; /* oops, problems... */

    if (booksize > BOOK_BUF) {
        LOG(llevError, "common/readable.c:god_info_msg() - passed in booksize (%lu) is larger than book buffer (%d)\n", (unsigned long)booksize, BOOK_BUF);
        booksize = BOOK_BUF;
    }

    if (level >= 2 && RANDOM()%2) {
        what |= GOD_ENEMY;
    }
    if (level >= 3 && RANDOM()%2) {
        what |= GOD_HOLYWORD;
    }
    if (level >= 4 && RANDOM()%2) {
        what |= GOD_RESISTANCES;
    }
    if (level >= 5 && RANDOM()%2) {
        what |= GOD_SACRED;
    }
    if (level >= 6 && RANDOM()%2) {
        what |= GOD_BLESSED;
    }
    if (level >= 8 && RANDOM()%2) {
        what |= GOD_IMMUNITIES;
    }
    if (level >= 12 && RANDOM()%2) {
        what |= GOD_PATHS;
    }

    desc = stringbuffer_new();
    what = describe_god(god, what, desc, booksize);

    /* check to be sure new buffer size dont exceed either
    * the maximum buffer size, or the 'natural' size of the
    * book... */
    if (stringbuffer_length(desc) > 1 && stringbuffer_length(desc) <= booksize) {
        char buf[BOOK_BUF];
        snprintf(buf, sizeof(buf), "god:%s:%d", god->name, what);
        object_set_value(book, "knowledge_marker", buf, 1);
        return desc;
    }

    stringbuffer_delete(desc);
    return NULL;
}

void tailor_readable_ob(object *book, int msg_type) {
    int level = book->level ? RANDOM()%book->level+1 : 1;
    size_t book_buf_size;
    StringBuffer *message = NULL;

    /* safety */
    if (book->type != BOOK)
        return;

    if (level <= 0)
        return;   /* if no level no point in doing any more... */

    /* Max text length this book can have. */
    book_buf_size = BOOKSIZE(book);
    book_buf_size -= strlen("\n"); /* Keep enough for final \n. */
    assert(book_buf_size < BOOK_BUF);

    /* &&& The message switch &&& */
    /* Below all of the possible types of messages in the "book"s.
     */
    /*
     * IF you add a new type of book msg, you will have to do several things.
     * 1) make sure there is an entry in the msg switch below!
     * 2) make sure there is an entry in max_titles[] array.
     * 3) make sure there are entries for your case in new_text_title()
     *    and add_authour().
     * 4) you may want separate authour/book name arrays in read.h
     */

    if (msg_type >= (int)arraysize(max_titles))
        msg_type = 0;

    msg_type = msg_type > 0 ? msg_type : (int)(RANDOM()%6);
    switch (msg_type) {
    case MSGTYPE_MONSTER:
        message = mon_info_msg(level, book_buf_size, book);
        break;

    case MSGTYPE_ARTIFACT:
        message = artifact_msg(level, book_buf_size);
        break;

    case MSGTYPE_SPELLPATH: /* grouping incantations/prayers by path */
        message = spellpath_msg(level, book_buf_size, NULL);
        break;

    case MSGTYPE_ALCHEMY: /* describe an alchemy formula */
        make_formula_book(book, level);
        /* make_formula_book already gives title */
        return;
        break;

    case MSGTYPE_GODS: /* bits of information about a god */
        message = god_info_msg(level, book_buf_size, book);
        break;

    case MSGTYPE_LIB: /* use info list in lib/ */
    default:
        message = msgfile_msg(book, book_buf_size);
        break;
    }

    if (message != NULL) {
        char *final;
        stringbuffer_append_string(message, "\n");
        final = stringbuffer_finish(message);
        object_set_msg(book, final);
        free(final);
        /* lets give the "book" a new name, which may be a compound word */
        change_book(book, msg_type);
    }
}

/*****************************************************************************
 *
 * Cleanup routine for readable stuff.
 *
 *****************************************************************************/

void free_all_readable(void) {
    titlelist *tlist, *tnext;
    title *title1, *titlenext;

    LOG(llevDebug, "freeing all book information\n");

    for (tlist = booklist; tlist != NULL; tlist = tnext) {
        tnext = tlist->next;
        for (title1 = tlist->first_book; title1; title1 = titlenext) {
            titlenext = title1->next;
            if (title1->name)
                free_string(title1->name);
            if (title1->authour)
                free_string(title1->authour);
            if (title1->archname)
                free_string(title1->archname);
            free(title1);
        }
        free(tlist);
    }
}

/*****************************************************************************
 *
 * Writeback routine for updating the bookarchive.
 *
 ****************************************************************************/

void write_book_archive(void) {
    FILE *fp;
    OutputFile of;
    int index;
    char fname[MAX_BUF];
    title *book;
    titlelist *bl;

    /* If nothing changed, don't write anything */
    if (!need_to_write_bookarchive)
        return;

    snprintf(fname, sizeof(fname), "%s/bookarch", settings.localdir);
    LOG(llevDebug, "Updating book archive: %s...\n", fname);

    fp = of_open(&of, fname);
    if (fp == NULL)
        return;

    for (bl = get_titlelist(0), index = 0; bl; bl = bl->next, index++) {
        for (book = bl->first_book; book; book = book->next)
            if (book && book->authour) {
                fprintf(fp, "title %s\n", book->name);
                fprintf(fp, "authour %s\n", book->authour);
                fprintf(fp, "arch %s\n", book->archname);
                fprintf(fp, "level %d\n", book->level);
                fprintf(fp, "type %d\n", index);
                /* C89 doesn't have %zu... */
                fprintf(fp, "size %lu\n", (unsigned long)book->size);
                fprintf(fp, "index %d\n", book->msg_index);
                fprintf(fp, "end\n");
            }
    }
    if (!of_close(&of))
        return;

    if (chmod(fname, SAVE_MODE) != 0) {
        LOG(llevError, "Could not set permissions on '%s'\n", fname);
    }

    need_to_write_bookarchive = 0;
}

const readable_message_type *get_readable_message_type(object *readable) {
    uint8_t subtype = readable->subtype;

    if (subtype > last_readable_subtype)
        return &readable_message_types[0];
    return &readable_message_types[subtype];
}

sstring get_message_title(const GeneralMessage *message) {
    return message->title;
}

sstring get_message_body(const GeneralMessage *message) {
    return message->message;
}

const Face *get_message_face(const GeneralMessage *message) {
    return message->face;
}