item.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 <bitset>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <cmath>
 
#include "living.h"
#include "spells.h"
 
body_locations_struct body_locations[NUM_BODY_LOCATIONS] = {
    { "body_range",    "in your range slot",     "in a human's range slot" },
    { "body_arm",      "on your arm",            "on a human's arm" },
    { "body_torso",    "on your body",           "on a human's torso" },
    { "body_head",     "on your head",           "on a human's head" },
    { "body_neck",     "around your neck",       "around a human's neck" },
    { "body_skill",    "in your skill slot",     "in a human's skill slot" },
    { "body_finger",   "on your finger",         "on a human's finger" },
    { "body_shoulder", "around your shoulders",  "around a human's shoulders" },
    { "body_foot",     "on your feet",           "on a human's feet" },
    { "body_hand",     "on your hands",          "on a human's hands" },
    { "body_wrist",    "around your wrists",     "around a human's wrist" },
    { "body_waist",    "around your waist",      "around a human's waist" },
    { "body_leg",      "around your legs",       "around a human's legs" },
    /*{"body_dragon_torso", "your body", "a dragon's body"} */
};
 
static const typedata item_types[] = {
    { 0, "none", "none", 0, 0 },
    { PLAYER, "player", "players", 0, 0 },
    { TRANSPORT, "transport", "transports", 0, 0 },
    { ROD, "rod", "rods", SK_THAUMATURGY, 0 },
    { TREASURE, "treasure", "treasure", 0, 0 },
    { POTION, "potion", "potions", SK_ALCHEMY, 0 },
    { FOOD, "food", "food", SK_WOODSMAN, 0 },
    { POISON, "poison", "poisons", SK_ALCHEMY, 0 },
    { BOOK, "book", "books", SK_LITERACY, 0 },
    { CLOCK, "clock", "clocks", 0, 0 },
    { ARROW, "arrow", "arrows", SK_BOWYER, 0 },
    { BOW, "bow", "bows", SK_BOWYER, 0 },
    { WEAPON, "weapon", "weapons", SK_SMITHERY, 0 },
    { ARMOUR, "armour", "armour", SK_SMITHERY, 0 },
    { PEDESTAL, "pedestal", "pedestals", 0, 0 },
    { ALTAR, "altar", "altars", 0, 0 },
    { LOCKED_DOOR, "locked door", "locked doors", 0, 0 },
    { SPECIAL_KEY, "special key", "special keys", 0, 0 },
    { MAP, "map", "maps", 0, 0 },
    { DOOR, "door", "doors", 0, 0 },
    { KEY, "key", "keys", 0, 0 },
    { TIMED_GATE, "timed_gate", "timed_gates", 0, 0 },
    { TRIGGER, "trigger", "triggers", 0, 0 },
    { GRIMREAPER, "grimreaper", "grimreapers", 0, 0 },
    { MAGIC_EAR, "magic ear", "magic ears", 0, 0 },
    { TRIGGER_BUTTON, "trigger button", "trigger buttons", 0, 0 },
    { TRIGGER_ALTAR, "trigger altar", "trigger altars", 0, 0 },
    { TRIGGER_PEDESTAL, "trigger pedestal", "trigger pedestals", 0, 0 },
    { SHIELD, "shield", "shields", SK_SMITHERY, 0 },
    { HELMET, "helmet", "helmets", SK_SMITHERY, 0 },
    { MONEY, "money", "money", 0, 0 },
    { CLASS, "class", "classes", 0, 0 },
    { AMULET, "amulet", "amulets", SK_JEWELER, 0 },
    { PLAYERMOVER, "player mover", "player movers", 0, 0 },
    { TELEPORTER, "teleporter", "teleporters", 0, 0 },
    { CREATOR, "creator", "creators", 0, 0 },
    { SKILL, "skill", "skills", 0, 0 },
    { EARTHWALL, "earthwall", "earthwalls", 0, 0 },
    { GOLEM, "golem", "golems", 0, 0 },
    { THROWN_OBJ, "projectile", "projectiles", 0, 0 },
    { BLINDNESS, "blindness", "blindness", 0, 0 },
    { GOD, "god", "gods", 0, 0 },
    { DETECTOR, "detector", "detectors", 0, 0 },
    { TRIGGER_MARKER, "trigger marker", "trigger markers", 0, 0 },
    { DEAD_OBJECT, "dead object", "dead objects", 0, 0 },
    { DRINK, "drink", "drinks", SK_WOODSMAN, SK_ALCHEMY },
    { MARKER, "marker", "markers", 0, 0 },
    { HOLY_ALTAR, "holy altar", "holy altars", 0, 0 },
    { PLAYER_CHANGER, "player changer", "player changers", 0, 0 },
    { BATTLEGROUND, "battleground", "battlegrounds", 0, 0 },
    { PEACEMAKER, "peacemaker", "peacemakers", 0, 0 },
    { GEM, "gem", "gems", SK_JEWELER, 0 },
    { FIREWALL, "firewall", "firewalls", 0, 0 },
    { CHECK_INV, "inventory checker", "inventory checkers", 0, 0 },
    { MOOD_FLOOR, "mood floor", "mood floors", 0, 0 },
    { EXIT, "exit", "exits", 0, 0 },
    { ENCOUNTER, "encounter", "encounters", 0, 0 },
    { SHOP_FLOOR, "shop floor", "shop floors", 0, 0 },
    { SHOP_MAT, "shop mat", "shop mats", 0, 0 },
    { RING, "ring", "rings", SK_JEWELER, 0 },
    { FLOOR, "floor", "floors", 0, 0 },
    { FLESH, "flesh", "flesh", SK_WOODSMAN, 0 },
    { INORGANIC, "inorganic", "inorganics", SK_ALCHEMY, 0 },
    { SKILL_TOOL, "skill tool", "skill tools", 0, 0 },
    { LIGHTER, "lighter", "lighters", 0, 0 },
    { WALL, "wall", "walls", 0, 0 },
    { MISC_OBJECT, "bric-a-brac", "bric-a-brac", 0, 0 },
    { MONSTER, "monster", "monsters", 0, 0 },
    { LAMP, "lamp", "lamps", 0, 0 },
    { DUPLICATOR, "duplicator", "duplicators", 0, 0 },
    { SPELLBOOK, "spellbook", "spellbooks", SK_LITERACY, 0 },
    { CLOAK, "cloak", "cloaks", SK_SMITHERY, 0 },
    { SPINNER, "spinner", "spinners", 0, 0 },
    { GATE, "gate", "gates", 0, 0 },
    { BUTTON, "button", "buttons", 0, 0 },
    { CF_HANDLE, "cf handle", "cf handles", 0, 0 },
    { HOLE, "hole", "holes", 0, 0 },
    { TRAPDOOR, "trapdoor", "trapdoors", 0, 0 },
    { SIGN, "sign", "signs", 0, 0 },
    { BOOTS, "boots", "boots", SK_SMITHERY, 0 },
    { GLOVES, "gloves", "gloves", SK_SMITHERY, 0 },
    { SPELL, "spell", "spells", 0, 0 },
    { SPELL_EFFECT, "spell effect", "spell effects", 0, 0 },
    { CONVERTER, "converter", "converters", 0, 0 },
    { BRACERS, "bracers", "bracers", SK_SMITHERY, 0 },
    { POISONING, "poisoning", "poisonings", 0, 0 },
    { SAVEBED, "savebed", "savebeds", 0, 0 },
    { WAND, "wand", "wands", SK_THAUMATURGY, 0 },
    { SCROLL, "scroll", "scrolls", SK_LITERACY, 0 },
    { DIRECTOR, "director", "directors", 0, 0 },
    { GIRDLE, "girdle", "girdles", SK_SMITHERY, 0 },
    { FORCE, "force", "forces", 0, 0 },
    { POTION_RESIST_EFFECT, "potion effect", "potion effects", 0, 0 },
    { CLOSE_CON, "closed container", "closed container", SK_ALCHEMY, 0 },
    { CONTAINER, "container", "containers", SK_ALCHEMY, 0 },
    { ARMOUR_IMPROVER, "armour improver", "armour improvers", SK_LITERACY, 0 },
    { WEAPON_IMPROVER, "weapon improver", "weapon improvers", SK_LITERACY, 0 },
    { SKILLSCROLL, "skillscroll", "skillscrolls", SK_LITERACY, 0 },
    { DEEP_SWAMP, "deep swamp", "deep swamps", 0, 0 },
    { IDENTIFY_ALTAR, "identify altar", "identify altars", 0, 0 },
    { SHOP_INVENTORY, "inventory list", "inventory lists", 0, 0 },
    { RUNE, "rune", "runes", 0, 0 },
    { TRAP, "trap", "traps", 0, 0 },
    { POWER_CRYSTAL, "power_crystal", "power_crystals", SK_THAUMATURGY, 0 },
    { CORPSE, "corpse", "corpses", 0, 0 },
    { DISEASE, "disease", "diseases", 0, 0 },
    { SYMPTOM, "symptom", "symptoms", 0, 0 },
    { BUILDER, "item builder", "item builders", 0, 0 },
    { MATERIAL, "building material", "building materials", 0, 0 },
    { MIMIC, "mimic", "mimics", SK_ALCHEMY, 0 },
    { LIGHTABLE, "lightable", "lightables", 0, 0 },
};
 
static const int item_types_size = sizeof(item_types)/sizeof(*item_types);
 
static const int enc_to_item_power[] = {
    0, 0, 1, 2, 3, 4,    /* 5 */
    5, 7, 9, 11, 13,    /* 10 */
    15, 18, 21, 24, 27, /* 15 */
    30, 35, 40, 45, 50  /* 20 */
};
 
int get_power_from_ench(int ench) {
    if (ench < 0)
        ench = 0;
    if (ench > (int)(sizeof(enc_to_item_power)/sizeof(*enc_to_item_power)-1))
        ench = sizeof(enc_to_item_power)/sizeof(*enc_to_item_power)-1;
    return enc_to_item_power[ench];
}
 
static int bits_set(uint32_t x) {
    std::bitset<32> xs = x;
    return xs.count();
}
 
int calc_item_enhancement(const object *op) {
    int i, tmp, enc;
 
    // If we get, for example, a pile of gypsum here,
    // don't give it an item power. Nothing in the inorganic
    // type can be applied; their resistances are just to avoid
    // or encourage destruction by specific attacktypes.
    if (op->type == INORGANIC)
        return 0;
 
    enc = 0;
    for (i = 0; i < NUM_STATS; i++)
        enc += get_attr_value(&op->stats, i);
 
    /* This protection logic is pretty flawed.  20% fire resistance
     * is much more valuable than 20% confusion, or 20% slow, or
     * several others.  Start at 1 - ignore physical - all that normal
     * armour shouldn't be counted against
     */
    tmp = 0;
    for (i = 1; i < NROFATTACKS; i++)
        tmp += op->resist[i];
 
    /* Add/substract 10 so that the rounding works out right */
    if (tmp > 0)
        enc += (tmp+10)/20;
    else if (tmp < 0)
        enc += (tmp-10)/20;
 
    enc += op->magic;
 
    /* For each attacktype a weapon has, one more encantment.  Start at 1 -
     * physical doesn't count against total.
     */
    if (op->type == WEAPON) {
        enc += bits_set(op->attacktype);
        if (op->slaying)
            enc += 2;     /* What it slays is probably more relevent */
    }
    /* Items the player can equip */
    if ((op->type == WEAPON)
    || (op->type == ARMOUR)
    || (op->type == HELMET)
    || (op->type == SHIELD)
    || (op->type == RING)
    || (op->type == BOOTS)
    || (op->type == GLOVES)
    || (op->type == AMULET)
    || (op->type == GIRDLE)
    || (op->type == BRACERS)
    || (op->type == CLOAK)) {
        enc += op->stats.food;     /* sustenance */
        enc += op->stats.hp;       /* hp regen */
        enc += op->stats.sp;       /* mana regen */
        enc += op->stats.grace;    /* grace regen */
        enc += op->stats.exp;      /* speed bonus */
    }
    enc += op->stats.luck;
 
    /* Do spell paths now */
    enc += bits_set(op->path_attuned);
    enc -= bits_set(op->path_repelled);
    enc -= 2*bits_set(op->path_denied);
 
    if (QUERY_FLAG(op, FLAG_LIFESAVE))
        enc += 5;
    if (QUERY_FLAG(op, FLAG_REFL_SPELL))
        enc += 3;
    if (QUERY_FLAG(op, FLAG_REFL_MISSILE))
        enc += 2;
    if (QUERY_FLAG(op, FLAG_STEALTH))
        enc += 1;
    if (QUERY_FLAG(op, FLAG_XRAYS))
        enc += 2;
    if (QUERY_FLAG(op, FLAG_SEE_IN_DARK))
        enc += 1;
    if (QUERY_FLAG(op, FLAG_MAKE_INVIS))
        enc += 1;
 
    return enc;
}
 
int calc_item_power(const object *op) {
    return get_power_from_ench(calc_item_enhancement(op));
}
 
const typedata *get_typedata(int itemtype) {
    int i;
 
    for (i = 0; i < item_types_size; i++)
        if (item_types[i].number == itemtype)
            return &item_types[i];
    return NULL;
}
 
const typedata *get_typedata_by_name(const char *name) {
    int i;
 
    for (i = 0; i < item_types_size; i++)
        if (!strcmp(item_types[i].name, name))
            return &item_types[i];
    for (i = 0; i < item_types_size; i++)
        if (!strcmp(item_types[i].name_pl, name)) {
            LOG(llevInfo, "get_typedata_by_name: I have been sent the plural %s, the singular form %s is preffered\n", name, item_types[i].name);
            return &item_types[i];
        }
    return NULL;
}
 
StringBuffer *describe_resistance(const object *op, int newline, int use_media_tags, StringBuffer *buf) {
    int tmpvar;
 
    if (buf == NULL)
        buf = stringbuffer_new();
 
    for (tmpvar = 0; tmpvar < NROFATTACKS; tmpvar++) {
        if (op->resist[tmpvar] && (op->type != FLESH || atnr_is_dragon_enabled(tmpvar) == 1)) {
            if (use_media_tags) {
                if (resist_color[tmpvar] != NULL) {
                    stringbuffer_append_printf(buf, "[color=%s]", resist_color[tmpvar]);
                }
                if (op->resist[tmpvar] == 100 || op->resist[tmpvar] == -100) {
                    stringbuffer_append_string(buf, "[ul]");
                }
            }
            if (!newline)
                stringbuffer_append_printf(buf, "(%s %+d)", resist_plus[tmpvar], op->resist[tmpvar]);
            else
                stringbuffer_append_printf(buf, "%s %d\n", resist_plus[tmpvar], op->resist[tmpvar]);
            if (use_media_tags) {
                if (op->resist[tmpvar] == 100 || op->resist[tmpvar] == -100) {
                    stringbuffer_append_string(buf, "[/ul]");
                }
                if (resist_color[tmpvar] != NULL) {
                    stringbuffer_append_string(buf, "[/color]");
                }
            }
        }
    }
 
    return buf;
}
 
void query_weight(const object *op, char *buf, size_t size) {
    int32_t i = NROF(op)*op->weight+op->carrying;
 
    if (op->weight < 0)
        snprintf(buf, size, "      ");
    else if (i%1000)
        snprintf(buf, size, "%6.1f", i/1000.0);
    else
        snprintf(buf, size, "%4d  ", i/1000);
}
 
static StringBuffer *ring_desc(const object *op, int use_media_tags, StringBuffer *buf) {
    int attr, val;
    size_t len;
 
    assert(op != NULL);
    assert(op->type == RING || op->type == AMULET || op->type == SKILL);
 
    if (buf == NULL)
        buf = stringbuffer_new();
    len = stringbuffer_length(buf);
 
    if (!QUERY_FLAG(op, FLAG_IDENTIFIED))
        return buf;
 
    for (attr = 0; attr < NUM_STATS; attr++) {
        if ((val = get_attr_value(&(op->stats), attr)) != 0) {
            stringbuffer_append_printf(buf, "(%s%+d)", short_stat_name[attr], val);
        }
    }
    if (op->stats.exp)
        stringbuffer_append_printf(buf, "(speed %+" FMT64 ")", op->stats.exp);
    if (op->stats.wc)
        stringbuffer_append_printf(buf, "(wc%+d)", op->stats.wc);
    if (op->stats.dam)
        stringbuffer_append_printf(buf, "(dam%+d)", op->stats.dam);
    if (op->stats.ac)
        stringbuffer_append_printf(buf, "(ac%+d)", op->stats.ac);
 
    describe_resistance(op, 0, use_media_tags, buf);
 
    if (op->stats.food != 0)
        stringbuffer_append_printf(buf, "(sustenance%+d)", op->stats.food);
    if (op->stats.grace)
        stringbuffer_append_printf(buf, "(grace%+d)", op->stats.grace);
    if (op->stats.sp && op->type != SKILL)
        stringbuffer_append_printf(buf, "(magic%+d)", op->stats.sp);
    if (op->stats.hp)
        stringbuffer_append_printf(buf, "(regeneration%+d)", op->stats.hp);
    if (op->stats.luck)
        stringbuffer_append_printf(buf, "(luck%+d)", op->stats.luck);
    if (QUERY_FLAG(op, FLAG_LIFESAVE))
        stringbuffer_append_printf(buf, "(lifesaving)");
    if (QUERY_FLAG(op, FLAG_REFL_SPELL))
        stringbuffer_append_printf(buf, "(reflect spells)");
    if (QUERY_FLAG(op, FLAG_REFL_MISSILE))
        stringbuffer_append_printf(buf, "(reflect missiles)");
    if (QUERY_FLAG(op, FLAG_STEALTH))
        stringbuffer_append_printf(buf, "(stealth)");
    if (op->glow_radius)
        stringbuffer_append_string(buf, "(glowing)");
 
    describe_spellpath_attenuation("Attuned", op->path_attuned, buf);
    describe_spellpath_attenuation("Repelled", op->path_repelled, buf);
    describe_spellpath_attenuation("Denied", op->path_denied, buf);
 
    /* item_power is done by the caller */
 /*   if (op->item_power)
        snprintf(buf+strlen(buf), size-strlen(buf), "(item_power %+d)", op->item_power);*/
    if (stringbuffer_length(buf) == len && op->type != SKILL)
        stringbuffer_append_string(buf, "of adornment");
 
    return buf;
}
 
void query_short_name(const object *op, char *buf, size_t size) {
    size_t len = 0;
 
    if (op->name == NULL) {
        snprintf(buf, size, "(null)");
        return;
    }
    if (!op->nrof && !op->weight && !op->title && !is_magical(op)) {
        strlcpy(buf, op->name, size); /* To speed things up (or make things slower?) */
        return;
    }
    buf[0] = '\0';
 
    if (op->nrof <= 1)
        safe_strcat(buf, op->name, &len, size);
    else
        safe_strcat(buf, op->name_pl, &len, size);
 
    if (op->title && QUERY_FLAG(op, FLAG_IDENTIFIED)) {
        safe_strcat(buf, " ", &len, size);
        safe_strcat(buf, op->title, &len, size);
    }
 
    switch (op->type) {
    case SPELLBOOK:
    case SCROLL:
    case WAND:
    case ROD:
    case POTION:
        if (QUERY_FLAG(op, FLAG_IDENTIFIED) || QUERY_FLAG(op, FLAG_BEEN_APPLIED)) {
            if (!op->title && (op->inv)) {
                safe_strcat(buf, " of ", &len, size);
                safe_strcat(buf, op->inv->name, &len, size);
            }
            if (op->type != SPELLBOOK) {
                snprintf(buf+len, size-len, " (lvl %d)", op->level);
                len += strlen(buf+len);
            }
        }
        break;
 
    case SKILL:
    case AMULET:
    case RING:
        if (!op->title) {
            /* If ring has a title, full description isn't so useful */
            char* desc;
 
            desc = stringbuffer_finish(ring_desc(op, 0, NULL));
            if (desc[0]) {
                safe_strcat(buf, " ", &len, size);
                safe_strcat(buf, desc, &len, size);
            }
            free(desc);
        }
        break;
 
    default:
        if (op->magic
        && (QUERY_FLAG(op, FLAG_BEEN_APPLIED) || is_identified(op))) {
            snprintf(buf+len, size-len, " %+d", op->magic);
            len += strlen(buf+len);
        }
    }
}
 
void query_name(const object *op, char *buf, size_t size) {
    size_t len = 0;
 
    buf[0] = '\0';
    /*
     * Since len is initialized to zero, but is not changed
     * up to this point, I see no reason to have buf+len and size-len;
     * buf and size should suffice, since we're just adding and
     * subtracting zero here, anyway.
     *
     * SilverNexus 2014-06-04
     */
    query_short_name(op, buf, size);
    len = strlen(buf);
 
    if (QUERY_FLAG(op, FLAG_INV_LOCKED))
        safe_strcat(buf, " *", &len, size);
    if (op->type == CONTAINER
    && ((op->env && op->env->container == op) || (!op->env && QUERY_FLAG(op, FLAG_APPLIED))))
        safe_strcat(buf, " (open)", &len, size);
 
    if (QUERY_FLAG(op, FLAG_KNOWN_CURSED)) {
        if (QUERY_FLAG(op, FLAG_DAMNED))
            safe_strcat(buf, " (damned)", &len, size);
        else if (QUERY_FLAG(op, FLAG_CURSED))
            safe_strcat(buf, " (cursed)", &len, size);
    }
    if (QUERY_FLAG(op, FLAG_BLESSED) && QUERY_FLAG(op, FLAG_KNOWN_BLESSED))
        safe_strcat(buf, " (blessed)", &len, size);
 
    /* Basically, if the object is known magical (detect magic spell on it),
     * and it isn't identified,  print out the fact that
     * it is magical.  Assume that the detect magical spell will only set
     * KNOWN_MAGICAL if the item actually is magical.
     *
     * Changed in V 0.91.4 - still print that the object is magical even
     * if it has been applied.  Equipping an item does not tell full
     * abilities, especially for artifact items.
     */
    if (QUERY_FLAG(op, FLAG_KNOWN_MAGICAL) && !QUERY_FLAG(op, FLAG_IDENTIFIED))
        safe_strcat(buf, " (magic)", &len, size);
 
    if (QUERY_FLAG(op, FLAG_APPLIED)) {
        switch (op->type) {
        case BOW:
        case WAND:
        case ROD:
            safe_strcat(buf, " (readied)", &len, size);
            break;
 
        case WEAPON:
            safe_strcat(buf, " (wielded)", &len, size);
            break;
 
        case ARMOUR:
        case HELMET:
        case SHIELD:
        case RING:
        case BOOTS:
        case GLOVES:
        case AMULET:
        case GIRDLE:
        case BRACERS:
        case CLOAK:
            safe_strcat(buf, " (worn)", &len, size);
            break;
 
        case CONTAINER:
            safe_strcat(buf, " (active)", &len, size);
            break;
 
        case SKILL:
        default:
            safe_strcat(buf, " (applied)", &len, size);
        }
    }
    // NO_SKILL_IDENT is set when identification fails or when the book is read. So the book is read only when it is
    // both identified and NO_SKILL_IDENT.
    if (QUERY_FLAG(op, FLAG_IDENTIFIED) && QUERY_FLAG(op, FLAG_NO_SKILL_IDENT) && op->type == BOOK)
        safe_strcat(buf, " (read)", &len, size);
    if (QUERY_FLAG(op, FLAG_UNPAID))
        safe_strcat(buf, " (unpaid)", &len, size);
}
 
void query_base_name(const object *op, int plural, char *buf, size_t size) {
    size_t len;
 
    if ((!plural && !op->name)
    || (plural && !op->name_pl)) {
        strncpy(buf, "(null)", size);
        return;
    }
 
    if (!op->nrof && !op->weight && !op->title && !is_magical(op)) {
        strncpy(buf, op->name, size); /* To speed things up (or make things slower?) */
        return;
    }
 
    buf[0] = '\0';
 
    strlcpy(buf, plural ? op->name_pl : op->name, size);
    len = strlen(buf);
 
    if (op->title && QUERY_FLAG(op, FLAG_IDENTIFIED)) {
        safe_strcat(buf, " ", &len, size);
        safe_strcat(buf, op->title, &len, size);
    }
 
    switch (op->type) {
    case SPELLBOOK:
    case SCROLL:
    case WAND:
    case ROD:
    case POTION:
        if (QUERY_FLAG(op, FLAG_IDENTIFIED) || QUERY_FLAG(op, FLAG_BEEN_APPLIED)) {
            if (!op->title && (op->inv)) {
                safe_strcat(buf, " of ", &len, size);
                // If, for some reason, a spell on a scroll were to stop existing as an arch,
                // we would get here. The scroll will hold an inventory object with no name.
                // So, to prevent a segfault, only print the spell name if it exists.
                if (op->inv->name)
                    safe_strcat(buf, op->inv->name, &len, size);
                // scroll of nothing seems like a good replacement for when the name does not exist.
                else
                    safe_strcat(buf, "nothing", &len, size);
            }
            if (op->type != SPELLBOOK) {
                snprintf(buf+len, size-len, " (lvl %d)", op->level);
                len += strlen(buf+len);
            }
        }
        break;
 
    case SKILL:
    case AMULET:
    case RING:
        if (!op->title) {
            /* If ring has a title, full description isn't so useful */
            char* s;
 
            s = stringbuffer_finish(ring_desc(op, 0, NULL));
            if (s[0]) {
                safe_strcat(buf, " ", &len, size);
                safe_strcat(buf, s, &len, size);
            }
            free(s);
        }
        break;
 
    default:
        if (op->magic
        && (QUERY_FLAG(op, FLAG_BEEN_APPLIED) || is_identified(op))) {
            snprintf(buf+strlen(buf), size-strlen(buf), " %+d", op->magic);
        }
    }
}
 
StringBuffer *describe_monster(const object *op, int use_media_tags, StringBuffer *buf) {
    assert(op != NULL);
    assert(QUERY_FLAG(op, FLAG_MONSTER) || op->type == PLAYER);
 
    if (buf == NULL)
        buf = stringbuffer_new();
 
    /* Note that the resolution this provides for players really isn't
     * very good.  Any player with a speed greater than .67 will
     * fall into the 'lightning fast movement' category.
     */
    if (FABS(op->speed) > MIN_ACTIVE_SPEED) {
        switch ((int)((FABS(op->speed))*15)) {
        case 0:
            stringbuffer_append_string(buf, "(very slow movement)");
            break;
 
        case 1:
            stringbuffer_append_string(buf, "(slow movement)");
            break;
 
        case 2:
            stringbuffer_append_string(buf, "(normal movement)");
            break;
 
        case 3:
        case 4:
            stringbuffer_append_string(buf, "(fast movement)");
            break;
 
        case 5:
        case 6:
            stringbuffer_append_string(buf, "(very fast movement)");
            break;
 
        case 7:
        case 8:
        case 9:
        case 10:
            stringbuffer_append_string(buf, "(extremely fast movement)");
            break;
 
        default:
            stringbuffer_append_string(buf, "(lightning fast movement)");
            break;
        }
    }
    if (QUERY_FLAG(op, FLAG_UNDEAD))
        stringbuffer_append_string(buf, "(undead)");
    if (QUERY_FLAG(op, FLAG_SEE_INVISIBLE))
        stringbuffer_append_string(buf, "(see invisible)");
    if (QUERY_FLAG(op, FLAG_USE_WEAPON))
        stringbuffer_append_string(buf, "(wield weapon)");
    if (QUERY_FLAG(op, FLAG_USE_BOW))
        stringbuffer_append_string(buf, "(archer)");
    if (QUERY_FLAG(op, FLAG_USE_ARMOUR))
        stringbuffer_append_string(buf, "(wear armour)");
    if (QUERY_FLAG(op, FLAG_USE_RING))
        stringbuffer_append_string(buf, "(wear ring)");
    if (QUERY_FLAG(op, FLAG_USE_SCROLL))
        stringbuffer_append_string(buf, "(read scroll)");
    if (QUERY_FLAG(op, FLAG_USE_RANGE))
        stringbuffer_append_string(buf, "(fires wand/rod/horn)");
    if (QUERY_FLAG(op, FLAG_CAN_USE_SKILL))
        stringbuffer_append_string(buf, "(skill user)");
    if (QUERY_FLAG(op, FLAG_CAST_SPELL))
        stringbuffer_append_string(buf, "(spellcaster)");
    if (QUERY_FLAG(op, FLAG_FRIENDLY))
        stringbuffer_append_string(buf, "(friendly)");
    if (QUERY_FLAG(op, FLAG_UNAGGRESSIVE))
        stringbuffer_append_string(buf, "(unaggressive)");
    if (QUERY_FLAG(op, FLAG_HITBACK))
        stringbuffer_append_string(buf, "(hitback)");
    if (QUERY_FLAG(op, FLAG_STEALTH))
        stringbuffer_append_string(buf, "(stealthy)");
    if (op->randomitems != NULL) {
        treasure *t;
        int first = 1;
 
        for (t = op->randomitems->items; t != NULL; t = t->next)
            if (t->item && (t->item->clone.type == SPELL)) {
                if (first) {
                    first = 0;
                    stringbuffer_append_string(buf, "(Spell abilities:)");
                }
                stringbuffer_append_printf(buf, "(%s)",  t->item->clone.name);
            }
    }
    if (op->type == PLAYER) {
        if (op->contr->digestion) {
            if (op->contr->digestion != 0)
                stringbuffer_append_printf(buf, "(sustenance%+d)", op->contr->digestion);
        }
        if (op->contr->gen_grace) {
            stringbuffer_append_printf(buf, "(grace%+d)", op->contr->gen_grace);
        }
        if (op->contr->gen_sp) {
            stringbuffer_append_printf(buf, "(magic%+d)", op->contr->gen_sp);
        }
        if (op->contr->gen_hp) {
            stringbuffer_append_printf(buf, "(regeneration%+d)", op->contr->gen_hp);
        }
        if (op->stats.luck) {
            stringbuffer_append_printf(buf, "(luck%+d)", op->stats.luck);
        }
    }
 
    /* describe attacktypes */
    if (is_dragon_pl(op)) {
        /* for dragon players display the attacktypes from clawing skill
         * Break apart the for loop - move the comparison checking down -
         * this makes it more readable.
         */
        object *tmp;
 
        tmp = object_find_by_type_and_name(op, SKILL, "clawing");
        if (tmp && tmp->attacktype != 0) {
            describe_attacktype("Claws", tmp->attacktype, buf);
        } else {
            describe_attacktype("Attacks", op->attacktype, buf);
        }
    } else {
        describe_attacktype("Attacks", op->attacktype, buf);
    }
    describe_spellpath_attenuation("Attuned", op->path_attuned &~ op->path_denied, buf);
    describe_spellpath_attenuation("Repelled", op->path_repelled &~ op->path_denied, buf );
    describe_spellpath_attenuation("Denied", op->path_denied, buf);
    describe_resistance(op, 0, use_media_tags, buf);
 
    return buf;
}
 
StringBuffer *describe_item(const object *op, const object *owner, int use_media_tags, StringBuffer *buf) {
    int identified, i;
 
    if (buf == NULL)
        buf = stringbuffer_new();
 
    if (QUERY_FLAG(op, FLAG_MONSTER) || op->type == PLAYER) {
        return describe_monster(op, use_media_tags, buf);
    }
 
    /* figure this out once, instead of making multiple calls to is_identified.
     * also makes the code easier to read.
     */
    if (is_identified(op)) {
        identified = 1;
    } else {
        stringbuffer_append_string(buf, "(unidentified)");
        identified = 0;
    }
    switch (op->type) {
    case BOW:
    case ARROW:
    case WAND:
    case ROD:
    case WEAPON:
    case ARMOUR:
    case HELMET:
    case SHIELD:
    case BOOTS:
    case GLOVES:
    case GIRDLE:
    case BRACERS:
    case CLOAK:
    case SKILL_TOOL:
        break;  /* We have more information to do below this switch */
 
    case LAMP:
        break; /* just so we get the "glowing" part. */
 
    case FOOD:
    case FLESH:
    case DRINK:
        if (identified || QUERY_FLAG(op, FLAG_BEEN_APPLIED)) {
            stringbuffer_append_printf(buf, "(food+%d)", op->stats.food);
 
            if (op->type == FLESH && op->last_eat > 0 && atnr_is_dragon_enabled(op->last_eat)) {
                stringbuffer_append_printf(buf, "(%s metabolism)", change_resist_msg[op->last_eat]);
            }
 
            if (!QUERY_FLAG(op, FLAG_CURSED)) {
                if (op->stats.hp > 0)
                    stringbuffer_append_string(buf, "(heals)");
                else if (op->stats.hp < 0)
                    stringbuffer_append_string(buf, "(damages)");
 
                if (op->stats.sp > 0)
                    stringbuffer_append_string(buf, "(spellpoint regen)");
                else if (op->stats.sp < 0)
                    stringbuffer_append_string(buf, "(spellpoint depletion)");
            } else {
                if (op->stats.hp)
                    stringbuffer_append_string(buf, "(damages)");
                if (op->stats.sp)
                    stringbuffer_append_string(buf, "(spellpoint depletion)");
            }
        }
        break;
 
    case SKILL:
    case RING:
    case AMULET:
        if (op->item_power) {
            stringbuffer_append_printf(buf, "(item_power %+d)", op->item_power);
        }
        if (op->title) {
            ring_desc(op, use_media_tags, buf);
        }
        return buf;
 
    default:
        return buf;
    }
 
    /* Down here, we more further describe equipment type items.
     * only describe them if they have been identified or the like.
     */
    if (identified || QUERY_FLAG(op, FLAG_BEEN_APPLIED)) {
        int attr, val;
 
        for (attr = 0; attr < NUM_STATS; attr++) {
            if ((val = get_attr_value(&(op->stats), attr)) != 0) {
                stringbuffer_append_printf(buf, "(%s%+d)", short_stat_name[attr], val);
            }
        }
        if (op->glow_radius)
            stringbuffer_append_string(buf, "(glowing)");
 
        switch (op->type) {
        case FLESH:
            break;
 
        default:
            if (op->stats.exp) {
                stringbuffer_append_printf(buf, "(speed %+" FMT64 ")", op->stats.exp);
            }
            break;
        }
        switch (op->type) {
        case BOW:
        case ARROW:
        case GIRDLE:
        case HELMET:
        case SHIELD:
        case BOOTS:
        case GLOVES:
        case WEAPON:
        case SKILL:
        case RING:
        case AMULET:
        case ARMOUR:
        case BRACERS:
        case FORCE:
        case CLOAK:
            if (op->stats.wc) {
                stringbuffer_append_printf(buf, "(wc%+d)", op->stats.wc);
            }
            if (op->stats.dam) {
                stringbuffer_append_printf(buf, "(dam%+d)", op->stats.dam);
            }
            if (op->stats.ac) {
                stringbuffer_append_printf(buf, "(ac%+d)", op->stats.ac);
            }
            if ((op->type == WEAPON || op->type == BOW) && op->level > 0) {
                stringbuffer_append_printf(buf, "(improved %d/%d)", op->last_eat, op->level);
            }
            break;
 
        default:
            break;
        }
        if (QUERY_FLAG(op, FLAG_XRAYS))
            stringbuffer_append_string(buf, "(xray-vision)");
        if (QUERY_FLAG(op, FLAG_SEE_IN_DARK))
            stringbuffer_append_string(buf, "(infravision)");
 
        /* levitate was what is was before, so we'll keep it */
        if (op->move_type&MOVE_FLY_LOW)
            stringbuffer_append_string(buf, "(levitate)");
 
        if (op->move_type&MOVE_FLY_HIGH)
            stringbuffer_append_string(buf, "(fly)");
 
        if (op->move_type&MOVE_SWIM)
            stringbuffer_append_string(buf, "(swim)");
 
        /* walking is presumed as 'normal', so doesn't need mentioning */
 
        if (op->item_power) {
            stringbuffer_append_printf(buf, "(item_power %+d)", op->item_power);
        }
    } /* End if identified or applied */
 
    /* This blocks only deals with fully identified object.
     * it is intentional that this is not an 'else' from a above -
     * in this way, information is added.
      */
    if (identified) {
        int more_info = 0;
 
        switch (op->type) {
        case ROD:  /* These use stats.sp for spell selection and stats.food */
                   /* and stats.hp for spell-point regeneration... */
        case ARROW:
        case WAND:
        case FOOD:
        case FLESH:
        case DRINK:
            more_info = 0;
            break;
 
        /* Bows use sp for firing rate. Per fire_bow(), the bow can be fired every 100/firing rate
         * character movements. It also makes sure it calculates the speed at no less than 1, to avoid floating point errors
         */
        case BOW:
            if (op->stats.sp) {
                stringbuffer_append_printf(buf, "(Firing delay %.2f)", 100./op->stats.sp);
            }
            more_info = 0;
            break;
 
            /* Armor type objects */
        case ARMOUR:
        case HELMET:
        case SHIELD:
        case BOOTS:
        case GLOVES:
        case GIRDLE:
        case BRACERS:
        case CLOAK:
            if (ARMOUR_SPEED(op)) {
                stringbuffer_append_printf(buf, "(Max speed %1.2f)", ARMOUR_SPEED(op)/10.0);
            }
            if (ARMOUR_SPELLS(op)) {
                stringbuffer_append_printf(buf, "(Spell regen penalty %d)", ARMOUR_SPELLS(op));
            }
            more_info = 1;
            break;
 
        case WEAPON:
            /* Calculate it the same way fix_object does so the results
             * make sense.
             */
            i = (WEAPON_SPEED(op)*2-op->magic)/2;
            if (i < 0)
                i = 0;
 
            stringbuffer_append_printf(buf, "(weapon speed %d)", i);
            /* If the reflecting flag is set, the weapon will bounce off walls when thrown. */
            if (QUERY_FLAG(op, FLAG_REFLECTING)) {
                stringbuffer_append_string(buf, "(ricochet)");
            }
            more_info = 1;
            break;
        }
        if (more_info) {
            if (op->stats.food) {
                if (op->stats.food != 0)
                    stringbuffer_append_printf(buf, "(sustenance%+d)", op->stats.food);
            }
            if (op->stats.grace) {
                stringbuffer_append_printf(buf, "(grace%+d)", op->stats.grace);
            }
            if (op->stats.sp) {
                stringbuffer_append_printf(buf, "(magic%+d)", op->stats.sp);
            }
            if (op->stats.hp) {
                stringbuffer_append_printf(buf, "(regeneration%+d)", op->stats.hp);
            }
        }
 
        if (op->stats.luck) {
            stringbuffer_append_printf(buf, "(luck%+d)", op->stats.luck);
        }
        if (QUERY_FLAG(op, FLAG_LIFESAVE))
            stringbuffer_append_string(buf, "(lifesaving)");
        if (QUERY_FLAG(op, FLAG_REFL_SPELL))
            stringbuffer_append_string(buf, "(reflect spells)");
        if (QUERY_FLAG(op, FLAG_REFL_MISSILE))
            stringbuffer_append_string(buf, "(reflect missiles)");
        if (QUERY_FLAG(op, FLAG_STEALTH))
            stringbuffer_append_string(buf, "(stealth)");
        if (op->slaying != NULL && op->type != FOOD) {
            stringbuffer_append_printf(buf, "(slay %s)", op->slaying);
        }
        describe_attacktype("Attacks", op->attacktype, buf);
        /* resistance on flesh is only visible for dragons.  If
         * non flesh, everyone can see its resistances
         */
        if (op->type != FLESH || (owner && is_dragon_pl(owner))) {
            describe_resistance(op, 0, 1, buf);
        }
        describe_spellpath_attenuation("Attuned", op->path_attuned &~ op->path_denied, buf);
        describe_spellpath_attenuation("Repelled", op->path_repelled &~ op->path_denied, buf);
        describe_spellpath_attenuation("Denied", op->path_denied, buf);
    }
 
    return buf;
}
 
int is_magical(const object *op) {
    int i;
 
    /* living creatures are considered non magical */
    if (QUERY_FLAG(op, FLAG_ALIVE))
        return 0;
 
    /* This is a test for it being an artifact, as artifacts have titles */
    if (op->title != NULL)
        return 1;
 
    /* Handle rings and amulets specially.  If they change any of these
     * values, it means they are magical.
     */
    if ((op->type == AMULET || op->type == RING)
    && (op->stats.ac || op->stats.food || op->stats.exp || op->stats.dam || op->stats.wc || op->stats.grace || op->stats.sp || op->stats.hp || op->stats.luck))
        return 1;
 
    /* Check for stealty, speed, flying, or just plain magic in the boots */
    /* Presume any boots that have a move_type are special. */
    if (op->type == BOOTS
    && ((QUERY_FLAG(op, FLAG_STEALTH) || op->move_type || op->stats.exp)))
        return 1;
 
    /* Take care of amulet/shield that reflects spells/missiles */
    if ((op->type == AMULET || op->type == SHIELD)
    && (QUERY_FLAG(op, FLAG_REFL_SPELL) || QUERY_FLAG(op, FLAG_REFL_MISSILE)))
        return 1;
 
    /* Take care of helmet of xrays */
    if (op->type == HELMET
    && QUERY_FLAG(op, FLAG_XRAYS))
        return 1;
 
    /* Potions & rods are always magical.  Wands/staves are also magical,
     * assuming they still have any charges left.
     */
    if (op->type == POTION || op->type == ROD || (op->type == WAND && op->stats.food))
        return 1;
 
    /* if something gives a protection, either positive or negative, its magical */
    /* This is really a pretty bad hack - as of now, ATNR_PHYSICAL is 0,
     * so this always works out fine.
     */
    for (i = ATNR_PHYSICAL+1; i < NROFATTACKS; i++)
        if (op->resist[i])
            return 1;
 
    /* Physical protection is expected on some item types, so they should
     * not be considered magical.
     */
    if (op->resist[ATNR_PHYSICAL]
    && op->type != HELMET
    && op->type != SHIELD
    && op->type != BOOTS
    && op->type != GLOVES
    && op->type != ARMOUR)
        return 1;
 
    /* power crystal, spellbooks, and scrolls are always magical.  */
    if (op->magic
    || op->type == POWER_CRYSTAL
    || op->type == SPELLBOOK
    || op->type == SCROLL
    || op->type == GIRDLE)
        return 1;
 
    /* Check to see if it increases/decreases any stats */
    for (i = 0; i < NUM_STATS; i++)
        if (get_attr_value(&(op->stats), i) != 0)
            return 1;
 
    /* If it doesn't fall into any of the above categories, must
     * be non magical.
     */
    return 0;
}
 
int is_identifiable_type(const object *op) {
    /* Special case -- skill tools don't have an associated identification
     * skill but still need IDing. TODO: we should probably have per-tool ID
     * skills, e.g. thievery for lockpicks and thaumaturgy for talismans, but
     * currently there's no good way to do this because the identifyskill is
     * tied to the itemtype rather than to the arch. */
    if (op->type == SKILL_TOOL) return true;
 
    /* Sometimes an itemtype has no associated typedata?! */
    const typedata *td = get_typedata(op->type);
    return td && td->identifyskill;
}
 
int is_identified(const object *op) {
    return !is_identifiable_type(op) || QUERY_FLAG(op, FLAG_IDENTIFIED);
}
 
void object_give_identified_properties(object *op) {
    // Make sure identified objects stack correctly
    CLEAR_FLAG(op, FLAG_KNOWN_MAGICAL);
    CLEAR_FLAG(op, FLAG_NO_SKILL_IDENT);
    CLEAR_FLAG(op, FLAG_BEEN_APPLIED);
 
    // The rest only apply to identifiable items. We don't want, e.g. shop
    // floors to show up as 'damned'.
    if (!is_identifiable_type(op))
        return;
 
    if (QUERY_FLAG(op, FLAG_CURSED) || QUERY_FLAG(op, FLAG_DAMNED))
        SET_FLAG(op, FLAG_KNOWN_CURSED);
 
    if (QUERY_FLAG(op, FLAG_BLESSED))
        SET_FLAG(op, FLAG_KNOWN_BLESSED);
 
    sstring key;
 
    key = object_get_value(op, "identified_face");
    if (key != NULL) {
        op->face = try_find_face(key, op->face);
        /* if the face is defined, clean the animation, because else
         * the face can be lost ; if an animation is defined, it'll be
         * processed later on */
        CLEAR_FLAG(op, FLAG_CLIENT_ANIM_RANDOM);
        CLEAR_FLAG(op, FLAG_CLIENT_ANIM_SYNC);
        op->anim_speed = 0;
        op->animation = 0;
        object_set_value(op, "identified_face", NULL, 0);
    }
 
    if (object_get_value(op, "identified_anim_random") != NULL) {
        SET_FLAG(op, FLAG_CLIENT_ANIM_RANDOM);
        object_set_value(op, "identified_anim_random", NULL, 0);
    }
 
    key = object_get_value(op, "identified_anim_speed");
    if (key != NULL) {
        op->anim_speed = atoi(key);
        op->last_anim = 1;
        object_set_value(op, "identified_anim_speed", NULL, 0);
    }
 
    key = object_get_value(op, "identified_animation");
    if (key != NULL) {
        Animations *anim = try_find_animation(key);
        if (anim) {
            op->animation = anim;
            if (!QUERY_FLAG(op, FLAG_IS_TURNABLE))
                SET_FLAG(op, FLAG_ANIMATE);
            animate_object(op, op->facing);
        }
        object_set_value(op, "identified_animation", NULL, 0);
    }
 
    key = object_get_value(op, "identified_name");
    if (key != NULL) {
        FREE_AND_COPY(op->name, key);
        object_set_value(op, "identified_name", NULL, 0);
    }
    key = object_get_value(op, "identified_name_pl");
    if (key != NULL) {
        FREE_AND_COPY(op->name_pl, key);
        object_set_value(op, "identified_name_pl", NULL, 0);
    }
}
 
object *identify(object *op) {
    object *pl, *op1;
 
    SET_FLAG(op, FLAG_IDENTIFIED);
    object_give_identified_properties(op);
 
    if (op->type == POTION) {
        if (op->inv && op->randomitems) {
            if (op->title)
                free_string(op->title);
            op->title = add_refcount(op->inv->name);
        } else if (op->arch) {
            free_string(op->name);
            op->name = add_refcount(op->arch->clone.name);
            free_string(op->name_pl);
            op->name_pl = add_refcount(op->arch->clone.name_pl);
        }
    }
 
    if (op->map) {
        /* If the object is on a map, make sure we update its face.
         * Also send name and such information to a player standing on it.
         */
        object *player = map_find_by_type(op->map, op->x, op->y, PLAYER);
 
        object_update(op, UP_OBJ_FACE);
        op1 = object_merge(op, GET_MAP_TOP(op->map, op->x, op->y));
        if (op1) op = op1;
 
        if (player)
            esrv_update_item(UPD_FACE | UPD_NAME | UPD_FLAGS, player, op);
 
    } else if (op->env) {
        /* If the object is in an inventory, merge it.
         */
        pl = object_get_player_container(op->env);
        op1 = object_merge(op, op->env->inv);
        if (op1) op = op1;
 
        if (pl)
            /* Item is directly in the player's inventory
             * A lot of the values can change from an update - might as well send
             * it all.
             */
            esrv_update_item(UPD_ALL, pl, op);
        else if (op->env->map &&
                (pl = map_find_by_type(op->env->map, op->env->x, op->env->y, PLAYER))
                && (pl->container == op->env)) {
            /* The item is in a container (on the ground) opened by a player, update */
            esrv_update_item(UPD_FACE | UPD_NAME | UPD_FLAGS, pl, op);
        }
    }
    /* There is a third option where we do nothing extra:
     * identifying a created item as it is created. */
    return op;
}
 
uint64_t price_base(const object *obj) {
    // When there are zero objects, there is really one.
    const int number = NROF(obj);
    const bool identified = is_identified(obj);
    uint64_t val = (uint64_t)obj->value * number;
 
    // Objects with price adjustments skip the rest of the calculations.
    const char *key = object_get_value(obj, "price_adjustment");
    if (key != NULL) {
        float ratio = atof(key);
        return val * ratio;
    }
 
    // Money and gems have fixed prices at shops.
    if (obj->type == MONEY || obj->type == GEM) {
        return val;
    }
 
    // Assume that good items, e.g. artifacts have that priced into their
    // value. Bad items may not.
    if (calc_item_enhancement(obj) < 0) {
        return 0;
    }
 
    // If unidentified, price item based on its archetype.
    if (!identified && obj->arch) {
        val = obj->arch->clone.value * number;
    }
 
    if (QUERY_FLAG(obj, FLAG_BLESSED)){
        val *= 1.15;
    } else if (QUERY_FLAG(obj, FLAG_CURSED)) {
        val *= 0.8;
    } else if (QUERY_FLAG(obj, FLAG_DAMNED)) {
        val *= 0.6;
    }
 
    // If an item is identified to have an enchantment above its archetype
    // enchantment, increase price exponentially.
    if (obj->arch != NULL && identified) {
        int diff = obj->magic - obj->arch->clone.magic;
        val *= pow(1.15, diff);
    }
 
    // FIXME: Is the 'baseline' 50 charges per wand?
    if (obj->type == WAND) {
        val *= obj->stats.food / 50.0;
    }
 
    /* we need to multiply these by 4.0 to keep buy costs roughly the same
     * (otherwise, you could buy a potion of charisma for around 400 pp.
     * Arguable, the costs in the archetypes should be updated to better
     * reflect values (potion charisma list for 1250 gold)
     */
    val *= 4; // FIXME
 
    return val;
}