#include "hack.h"

STATIC_DCL void FDECL(mkbox_cnts, (struct obj *));

STATIC_DCL unsigned FDECL(nextoid, (struct obj *, struct obj *));

STATIC_DCL void FDECL(maybe_adjust_light, (struct obj *, int));

STATIC_DCL void FDECL(obj_timer_checks, (struct obj *,

XCHAR_P, XCHAR_P, int));

STATIC_DCL void FDECL(container_weight, (struct obj *));

STATIC_DCL struct obj *FDECL(save_mtraits, (struct obj *, struct monst *));

STATIC_DCL void FDECL(objlist_sanity, (struct obj *, int, const char *));

STATIC_DCL void FDECL(mon_obj_sanity, (struct monst *, const char *));

STATIC_DCL const char *FDECL(where_name, (struct obj *));

STATIC_DCL void FDECL(insane_object, (struct obj *, const char *,

const char *, struct monst *));

STATIC_DCL void FDECL(check_contained, (struct obj *, const char *));

STATIC_DCL void FDECL(check_glob, (struct obj *, const char *));

STATIC_DCL void FDECL(sanity_check_worn, (struct obj *));

struct icp {

int iprob; /* probability of an item type */

char iclass; /* item class */

};

static const struct icp mkobjprobs[] = { { 10, WEAPON_CLASS },

{ 10, ARMOR_CLASS },

{ 20, FOOD_CLASS },

{ 8, TOOL_CLASS },

{ 8, GEM_CLASS },

{ 16, POTION_CLASS },

{ 16, SCROLL_CLASS },

{ 4, SPBOOK_CLASS },

{ 4, WAND_CLASS },

{ 3, RING_CLASS },

{ 1, AMULET_CLASS } };

static const struct icp boxiprobs[] = { { 18, GEM_CLASS },

{ 15, FOOD_CLASS },

{ 18, POTION_CLASS },

{ 18, SCROLL_CLASS },

{ 12, SPBOOK_CLASS },

{ 7, COIN_CLASS },

{ 6, WAND_CLASS },

{ 5, RING_CLASS },

{ 1, AMULET_CLASS } };

static const struct icp rogueprobs[] = { { 12, WEAPON_CLASS },

{ 12, ARMOR_CLASS },

{ 22, FOOD_CLASS },

{ 22, POTION_CLASS },

{ 22, SCROLL_CLASS },

{ 5, WAND_CLASS },

{ 5, RING_CLASS } };

static const struct icp hellprobs[] = { { 20, WEAPON_CLASS },

{ 20, ARMOR_CLASS },

{ 16, FOOD_CLASS },

{ 12, TOOL_CLASS },

{ 10, GEM_CLASS },

{ 1, POTION_CLASS },

{ 1, SCROLL_CLASS },

{ 8, WAND_CLASS },

{ 8, RING_CLASS },

{ 4, AMULET_CLASS } };

struct oextra *

newoextra()

{

struct oextra *oextra;

oextra = (struct oextra *) alloc(sizeof (struct oextra));

oextra->oname = 0;

oextra->omonst = 0;

oextra->omid = 0;

oextra->olong = 0;

oextra->omailcmd = 0;

return oextra;

}

dealloc_oextra(o)

struct obj *o;

{

struct oextra *x = o->oextra;

if (x) {

if (x->oname)

free((genericptr_t) x->oname);

if (x->omonst)

free_omonst(o); /* 'o' rather than 'x' */

if (x->omid)

free((genericptr_t) x->omid);

if (x->olong)

free((genericptr_t) x->olong);

if (x->omailcmd)

free((genericptr_t) x->omailcmd);

free((genericptr_t) x);

o->oextra = (struct oextra *) 0;

}

}

newomonst(otmp)

struct obj *otmp;

{

if (!otmp->oextra)

otmp->oextra = newoextra();

if (!OMONST(otmp)) {

struct monst *m = newmonst();

*m = zeromonst;

OMONST(otmp) = m;

}

}

free_omonst(otmp)

struct obj *otmp;

{

if (otmp->oextra) {

struct monst *m = OMONST(otmp);

if (m) {

if (m->mextra)

dealloc_mextra(m);

free((genericptr_t) m);

OMONST(otmp) = (struct monst *) 0;

}

}

}

newomid(otmp)

struct obj *otmp;

{

if (!otmp->oextra)

otmp->oextra = newoextra();

if (!OMID(otmp)) {

OMID(otmp) = (unsigned *) alloc(sizeof (unsigned));

(void) memset((genericptr_t) OMID(otmp), 0, sizeof (unsigned));

}

}

free_omid(otmp)

struct obj *otmp;

{

if (otmp->oextra && OMID(otmp)) {

free((genericptr_t) OMID(otmp));

OMID(otmp) = (unsigned *) 0;

}

}

newolong(otmp)

struct obj *otmp;

{

if (!otmp->oextra)

otmp->oextra = newoextra();

if (!OLONG(otmp)) {

OLONG(otmp) = (long *) alloc(sizeof (long));

(void) memset((genericptr_t) OLONG(otmp), 0, sizeof (long));

}

}

free_olong(otmp)

struct obj *otmp;

{

if (otmp->oextra && OLONG(otmp)) {

free((genericptr_t) OLONG(otmp));

OLONG(otmp) = (long *) 0;

}

}

new_omailcmd(otmp, response_cmd)

struct obj *otmp;

const char *response_cmd;

{

if (!otmp->oextra)

otmp->oextra = newoextra();

if (OMAILCMD(otmp))

free_omailcmd(otmp);

OMAILCMD(otmp) = dupstr(response_cmd);

}

free_omailcmd(otmp)

struct obj *otmp;

{

if (otmp->oextra && OMAILCMD(otmp)) {

free((genericptr_t) OMAILCMD(otmp));

OMAILCMD(otmp) = (char *) 0;

}

}

struct obj *

mkobj_at(let, x, y, artif)

char let;

int x, y;

boolean artif;

{

struct obj *otmp;

otmp = mkobj(let, artif);

place_object(otmp, x, y);

return otmp;

}

struct obj *

mksobj_at(otyp, x, y, init, artif)

int otyp, x, y;

boolean init, artif;

{

struct obj *otmp;

otmp = mksobj(otyp, init, artif);

place_object(otmp, x, y);

return otmp;

}

struct obj *

mksobj_migr_to_species(otyp, mflags2, init, artif)

int otyp;

unsigned mflags2;

boolean init, artif;

{

struct obj *otmp;

otmp = mksobj(otyp, init, artif);

if (otmp) {

add_to_migration(otmp);

otmp->owornmask = (long) MIGR_TO_SPECIES;

otmp->corpsenm = mflags2;

}

return otmp;

}

struct obj *

mkobj(oclass, artif)

char oclass;

boolean artif;

{

int tprob, i, prob = rnd(1000);

if (oclass == RANDOM_CLASS) {

const struct icp *iprobs = Is_rogue_level(&u.uz)

? (const struct icp *) rogueprobs

: Inhell ? (const struct icp *) hellprobs

: (const struct icp *) mkobjprobs;

for (tprob = rnd(100); (tprob -= iprobs->iprob) > 0; iprobs++)

;

oclass = iprobs->iclass;

}

i = bases[(int) oclass];

while ((prob -= objects[i].oc_prob) > 0)

i++;

if (objects[i].oc_class != oclass || !OBJ_NAME(objects[i]))

panic("probtype error, oclass=%d i=%d", (int) oclass, i);

return mksobj(i, TRUE, artif);

}

STATIC_OVL void

mkbox_cnts(box)

struct obj *box;

{

register int n;

register struct obj *otmp;

box->cobj = (struct obj *) 0;

switch (box->otyp) {

case ICE_BOX:

n = 20;

break;

case CHEST:

n = box->olocked ? 7 : 5;

break;

case LARGE_BOX:

n = box->olocked ? 5 : 3;

break;

case SACK:

case OILSKIN_SACK:

/* initial inventory: sack starts out empty */

if (moves <= 1 && !in_mklev) {

n = 0;

break;

}

/*FALLTHRU*/

case BAG_OF_HOLDING:

n = 1;

break;

default:

n = 0;

break;

}

for (n = rn2(n + 1); n > 0; n--) {

if (box->otyp == ICE_BOX) {

if (!(otmp = mksobj(CORPSE, TRUE, TRUE)))

continue;

/* Note: setting age to 0 is correct. Age has a different

otmp->age = 0L;

if (otmp->timed) {

(void) stop_timer(ROT_CORPSE, obj_to_any(otmp));

(void) stop_timer(REVIVE_MON, obj_to_any(otmp));

}

} else {

register int tprob;

const struct icp *iprobs = boxiprobs;

for (tprob = rnd(100); (tprob -= iprobs->iprob) > 0; iprobs++)

;

if (!(otmp = mkobj(iprobs->iclass, TRUE)))

continue;

/* handle a couple of special cases */

if (otmp->oclass == COIN_CLASS) {

/* 2.5 x level's usual amount; weight adjusted below */

otmp->quan = (long) (rnd(level_difficulty() + 2) * rnd(75));

otmp->owt = weight(otmp);

} else

while (otmp->otyp == ROCK) {

otmp->otyp = rnd_class(DILITHIUM_CRYSTAL, LOADSTONE);

if (otmp->quan > 2L)

otmp->quan = 1L;

otmp->owt = weight(otmp);

}

if (box->otyp == BAG_OF_HOLDING) {

if (Is_mbag(otmp)) {

otmp->otyp = SACK;

otmp->spe = 0;

otmp->owt = weight(otmp);

} else

while (otmp->otyp == WAN_CANCELLATION)

otmp->otyp = rnd_class(WAN_LIGHT, WAN_LIGHTNING);

}

}

(void) add_to_container(box, otmp);

}

}

rndmonnum()

{

register struct permonst *ptr;

register int i;

unsigned short excludeflags;

/* Plan A: get a level-appropriate common monster */

ptr = rndmonst();

if (ptr)

return monsndx(ptr);

/* Plan B: get any common monster */

excludeflags = G_UNIQ | G_NOGEN | (Inhell ? G_NOHELL : G_HELL);

do {

i = rn1(SPECIAL_PM - LOW_PM, LOW_PM);

ptr = &mons[i];

} while ((ptr->geno & excludeflags) != 0);

return i;

}

copy_oextra(obj2, obj1)

struct obj *obj2, *obj1;

{

if (!obj2 || !obj1 || !obj1->oextra)

return;

if (!obj2->oextra)

obj2->oextra = newoextra();

if (has_oname(obj1))

oname(obj2, ONAME(obj1));

if (has_omonst(obj1)) {

if (!OMONST(obj2))

newomonst(obj2);

(void) memcpy((genericptr_t) OMONST(obj2),

(genericptr_t) OMONST(obj1), sizeof (struct monst));

OMONST(obj2)->mextra = (struct mextra *) 0;

OMONST(obj2)->nmon = (struct monst *) 0;

#if 0

OMONST(obj2)->m_id = context.ident++;

if (OMONST(obj2)->m_id) /* ident overflowed */

OMONST(obj2)->m_id = context.ident++;

if (OMONST(obj1)->mextra)

copy_mextra(OMONST(obj2), OMONST(obj1));

}

if (has_omid(obj1)) {

if (!OMID(obj2))

newomid(obj2);

(void) memcpy((genericptr_t) OMID(obj2), (genericptr_t) OMID(obj1),

sizeof (unsigned));

}

if (has_olong(obj1)) {

if (!OLONG(obj2))

newolong(obj2);

(void) memcpy((genericptr_t) OLONG(obj2), (genericptr_t) OLONG(obj1),

sizeof (long));

}

if (has_omailcmd(obj1)) {

new_omailcmd(obj2, OMAILCMD(obj1));

}

}

struct obj *

splitobj(obj, num)

struct obj *obj;

long num;

{

struct obj *otmp;

if (obj->cobj || num <= 0L || obj->quan <= num)

panic("splitobj"); /* can't split containers */

otmp = newobj();

*otmp = *obj; /* copies whole structure */

otmp->oextra = (struct oextra *) 0;

otmp->o_id = nextoid(obj, otmp);

otmp->timed = 0; /* not timed, yet */

otmp->lamplit = 0; /* ditto */

otmp->owornmask = 0L; /* new object isn't worn */

obj->quan -= num;

obj->owt = weight(obj);

otmp->quan = num;

otmp->owt = weight(otmp); /* -= obj->owt ? */

context.objsplit.parent_oid = obj->o_id;

context.objsplit.child_oid = otmp->o_id;

obj->nobj = otmp;

/* Only set nexthere when on the floor, nexthere is also used */

/* as a back pointer to the container object when contained. */

if (obj->where == OBJ_FLOOR)

obj->nexthere = otmp;

copy_oextra(otmp, obj);

if (has_omid(otmp))

free_omid(otmp); /* only one association with m_id*/

if (obj->unpaid)

splitbill(obj, otmp);

if (obj->timed)

obj_split_timers(obj, otmp);

if (obj_sheds_light(obj))

obj_split_light_source(obj, otmp);

return otmp;

}

nextoid(oldobj, newobj)

struct obj *oldobj, *newobj;

{

int olddif, newdif, trylimit = 256; /* limit of 4 suffices at present */

unsigned oid = context.ident - 1; /* loop increment will reverse -1 */

olddif = oid_price_adjustment(oldobj, oldobj->o_id);

do {

++oid;

if (!oid) /* avoid using 0 (in case value wrapped) */

++oid;

newdif = oid_price_adjustment(newobj, oid);

} while (newdif != olddif && --trylimit >= 0);

context.ident = oid + 1; /* ready for next new object */

return oid;

}

struct obj *

unsplitobj(obj)

struct obj *obj;

{

unsigned target_oid = 0;

struct obj *oparent = 0, *ochild = 0, *list = 0;

/*

switch (obj->where) {

case OBJ_FREE:

case OBJ_FLOOR:

case OBJ_ONBILL:

case OBJ_MIGRATING:

case OBJ_BURIED:

default:

return (struct obj *) 0;

case OBJ_INVENT:

list = invent;

break;

case OBJ_MINVENT:

list = obj->ocarry->minvent;

break;

case OBJ_CONTAINED:

list = obj->ocontainer->cobj;

break;

}

/* first try the expected case; obj is split from another stack */

if (obj->o_id == context.objsplit.child_oid) {

/* parent probably precedes child and will require list traversal */

ochild = obj;

target_oid = context.objsplit.parent_oid;

if (obj->nobj && obj->nobj->o_id == target_oid)

oparent = obj->nobj;

} else if (obj->o_id == context.objsplit.parent_oid) {

/* alternate scenario: another stack was split from obj;

oparent = obj;

target_oid = context.objsplit.child_oid;

if (obj->nobj && obj->nobj->o_id == target_oid)

ochild = obj->nobj;

}

/* if we have only half the split, scan obj's list to find other half */

if (ochild && !oparent) {

/* expected case */

for (obj = list; obj; obj = obj->nobj)

if (obj->o_id == target_oid) {

oparent = obj;

break;

}

} else if (oparent && !ochild) {

/* alternate scenario */

for (obj = list; obj; obj = obj->nobj)

if (obj->o_id == target_oid) {

ochild = obj;

break;

}

}

/* if we have both parent and child, try to merge them;

return (oparent && ochild && merged(&oparent, &ochild)) ? oparent : 0;

}

clear_splitobjs()

{

context.objsplit.parent_oid = context.objsplit.child_oid = 0;

}

replace_object(obj, otmp)

struct obj *obj;

struct obj *otmp;

{

otmp->where = obj->where;

switch (obj->where) {

case OBJ_FREE:

/* do nothing */

break;

case OBJ_INVENT:

otmp->nobj = obj->nobj;

obj->nobj = otmp;

extract_nobj(obj, &invent);

break;

case OBJ_CONTAINED:

otmp->nobj = obj->nobj;

otmp->ocontainer = obj->ocontainer;

obj->nobj = otmp;

extract_nobj(obj, &obj->ocontainer->cobj);

break;

case OBJ_MINVENT:

otmp->nobj = obj->nobj;

otmp->ocarry = obj->ocarry;

obj->nobj = otmp;

extract_nobj(obj, &obj->ocarry->minvent);

break;

case OBJ_FLOOR:

otmp->nobj = obj->nobj;

otmp->nexthere = obj->nexthere;

otmp->ox = obj->ox;

otmp->oy = obj->oy;

obj->nobj = otmp;

obj->nexthere = otmp;

extract_nobj(obj, &fobj);

extract_nexthere(obj, &level.objects[obj->ox][obj->oy]);

break;

default:

panic("replace_object: obj position");

break;

}

}

struct obj *

unknwn_contnr_contents(obj)

struct obj *obj;

{

struct obj *result = 0, *parent;

while (obj->where == OBJ_CONTAINED) {

parent = obj->ocontainer;

if (!parent->cknown)

result = parent;

obj = parent;

}

return result;

}

bill_dummy_object(otmp)

register struct obj *otmp;

{

register struct obj *dummy;

long cost = 0L;

if (otmp->unpaid) {

cost = unpaid_cost(otmp, FALSE);

subfrombill(otmp, shop_keeper(*u.ushops));

}

dummy = newobj();

*dummy = *otmp;

dummy->oextra = (struct oextra *) 0;

dummy->where = OBJ_FREE;

dummy->o_id = context.ident++;

if (!dummy->o_id)

dummy->o_id = context.ident++; /* ident overflowed */

dummy->timed = 0;

copy_oextra(dummy, otmp);

if (has_omid(dummy))

free_omid(dummy); /* only one association with m_id*/

if (Is_candle(dummy))

dummy->lamplit = 0;

dummy->owornmask = 0L; /* dummy object is not worn */

addtobill(dummy, FALSE, TRUE, TRUE);

if (cost)

alter_cost(dummy, -cost);

/* no_charge is only valid for some locations */

otmp->no_charge =

(otmp->where == OBJ_FLOOR || otmp->where == OBJ_CONTAINED) ? 1 : 0;

otmp->unpaid = 0;

return;

}

static const char *const alteration_verbs[] = {

"cancel", "drain", "uncharge", "unbless", "uncurse", "disenchant",

"degrade", "dilute", "erase", "burn", "neutralize", "destroy", "splatter",

"bite", "open", "break the lock on", "rust", "rot", "tarnish"

};

costly_alteration(obj, alter_type)

struct obj *obj;

int alter_type;

{

xchar ox, oy;

char objroom;

boolean learn_bknown;

const char *those, *them;

struct monst *shkp = 0;

if (alter_type < 0 || alter_type >= SIZE(alteration_verbs)) {

impossible("invalid alteration type (%d)", alter_type);

alter_type = 0;

}

ox = oy = 0; /* lint suppression */

objroom = '\0'; /* ditto */

if (carried(obj) || obj->where == OBJ_FREE) {

/* OBJ_FREE catches obj_no_longer_held()'s transformation

if (!obj->unpaid)

return;

} else {

/* this get_obj_location shouldn't fail, but if it does,

if (!get_obj_location(obj, &ox, &oy, CONTAINED_TOO))

ox = u.ux, oy = u.uy;

if (!costly_spot(ox, oy))

return;

objroom = *in_rooms(ox, oy, SHOPBASE);

/* if no shop cares about it, we're done */

if (!billable(&shkp, obj, objroom, FALSE))

return;

}

if (obj->quan == 1L)

those = "that", them = "it";

else

those = "those", them = "them";

/* when shopkeeper describes the object as being uncursed or unblessed

learn_bknown = (alter_type == COST_UNCURS || alter_type == COST_UNBLSS);

switch (obj->where) {

case OBJ_FREE: /* obj_no_longer_held() */

case OBJ_INVENT:

if (learn_bknown)

set_bknown(obj, 1);

verbalize("You %s %s %s, you pay for %s!",

alteration_verbs[alter_type], those, simpleonames(obj),

them);

bill_dummy_object(obj);

break;

case OBJ_FLOOR:

if (learn_bknown)

obj->bknown = 1; /* ok to bypass set_bknown() here */

if (costly_spot(u.ux, u.uy) && objroom == *u.ushops) {

verbalize("You %s %s, you pay for %s!",

alteration_verbs[alter_type], those, them);

bill_dummy_object(obj);

} else {

(void) stolen_value(obj, ox, oy, FALSE, FALSE);

}

break;

}

}

static const char dknowns[] = { WAND_CLASS, RING_CLASS, POTION_CLASS,

SCROLL_CLASS, GEM_CLASS, SPBOOK_CLASS,

WEAPON_CLASS, TOOL_CLASS, 0 };

struct obj *

mksobj(otyp, init, artif)

int otyp;

boolean init;

boolean artif;

{

int mndx, tryct;

struct obj *otmp;

char let = objects[otyp].oc_class;

otmp = newobj();

*otmp = zeroobj;

otmp->age = monstermoves;

otmp->o_id = context.ident++;

if (!otmp->o_id)

otmp->o_id = context.ident++; /* ident overflowed */

otmp->quan = 1L;

otmp->oclass = let;

otmp->otyp = otyp;

otmp->where = OBJ_FREE;

otmp->dknown = index(dknowns, let) ? 0 : 1;

if ((otmp->otyp >= ELVEN_SHIELD && otmp->otyp <= ORCISH_SHIELD)

|| otmp->otyp == SHIELD_OF_REFLECTION

|| objects[otmp->otyp].oc_merge)

otmp->dknown = 0;

if (!objects[otmp->otyp].oc_uses_known)

otmp->known = 1;

otmp->lknown = 0;

otmp->cknown = 0;

otmp->corpsenm = NON_PM;

if (init) {

switch (let) {

case WEAPON_CLASS:

otmp->quan = is_multigen(otmp) ? (long) rn1(6, 6) : 1L;

if (!rn2(11)) {

otmp->spe = rne(3);

otmp->blessed = rn2(2);

} else if (!rn2(10)) {

curse(otmp);

otmp->spe = -rne(3);

} else

blessorcurse(otmp, 10);

if (is_poisonable(otmp) && !rn2(100))

otmp->opoisoned = 1;

if (artif && !rn2(20))

otmp = mk_artifact(otmp, (aligntyp) A_NONE);

break;

case FOOD_CLASS:

otmp->oeaten = 0;

switch (otmp->otyp) {

case CORPSE:

/* possibly overridden by mkcorpstat() */

tryct = 50;

do

otmp->corpsenm = undead_to_corpse(rndmonnum());

while ((mvitals[otmp->corpsenm].mvflags & G_NOCORPSE)

&& (--tryct > 0));

if (tryct == 0) {

/* perhaps rndmonnum() only wants to make G_NOCORPSE

otmp->corpsenm = PM_HUMAN;

}

/* timer set below */

break;

case EGG:

otmp->corpsenm = NON_PM; /* generic egg */

if (!rn2(3))

for (tryct = 200; tryct > 0; --tryct) {

mndx = can_be_hatched(rndmonnum());

if (mndx != NON_PM && !dead_species(mndx, TRUE)) {

otmp->corpsenm = mndx; /* typed egg */

break;

}

}

/* timer set below */

break;

case TIN:

otmp->corpsenm = NON_PM; /* empty (so far) */

if (!rn2(6))

set_tin_variety(otmp, SPINACH_TIN);

else

for (tryct = 200; tryct > 0; --tryct) {

mndx = undead_to_corpse(rndmonnum());

if (mons[mndx].cnutrit

&& !(mvitals[mndx].mvflags & G_NOCORPSE)) {

otmp->corpsenm = mndx;

set_tin_variety(otmp, RANDOM_TIN);

break;

}

}

blessorcurse(otmp, 10);

break;

case SLIME_MOLD:

otmp->spe = context.current_fruit;

flags.made_fruit = TRUE;

break;

case KELP_FROND:

otmp->quan = (long) rnd(2);

break;

}

if (Is_pudding(otmp)) {

otmp->quan = 1L; /* for emphasis; glob quantity is always 1 */

otmp->globby = 1;

otmp->known = otmp->dknown = 1;

otmp->corpsenm = PM_GRAY_OOZE

+ (otmp->otyp - GLOB_OF_GRAY_OOZE);

} else {

if (otmp->otyp != CORPSE && otmp->otyp != MEAT_RING

&& otmp->otyp != KELP_FROND && !rn2(6)) {

otmp->quan = 2L;

}

}

break;

case GEM_CLASS:

otmp->corpsenm = 0; /* LOADSTONE hack */

if (otmp->otyp == LOADSTONE)

curse(otmp);

else if (otmp->otyp == ROCK)

otmp->quan = (long) rn1(6, 6);

else if (otmp->otyp != LUCKSTONE && !rn2(6))

otmp->quan = 2L;

else

otmp->quan = 1L;

break;

case TOOL_CLASS:

switch (otmp->otyp) {

case TALLOW_CANDLE:

case WAX_CANDLE:

otmp->spe = 1;

otmp->age = 20L * /* 400 or 200 */

(long) objects[otmp->otyp].oc_cost;

otmp->lamplit = 0;

otmp->quan = 1L + (long) (rn2(2) ? rn2(7) : 0);

blessorcurse(otmp, 5);

break;

case BRASS_LANTERN:

case OIL_LAMP:

otmp->spe = 1;

otmp->age = (long) rn1(500, 1000);

otmp->lamplit = 0;

blessorcurse(otmp, 5);

break;

case MAGIC_LAMP:

otmp->spe = 1;

otmp->lamplit = 0;

blessorcurse(otmp, 2);

break;

case CHEST:

case LARGE_BOX:

otmp->olocked = !!(rn2(5));

otmp->otrapped = !(rn2(10));

/*FALLTHRU*/

case ICE_BOX:

case SACK:

case OILSKIN_SACK:

case BAG_OF_HOLDING:

mkbox_cnts(otmp);

break;

case EXPENSIVE_CAMERA:

case TINNING_KIT:

case MAGIC_MARKER:

otmp->spe = rn1(70, 30);

break;

case CAN_OF_GREASE:

otmp->spe = rnd(25);

blessorcurse(otmp, 10);

break;

case CRYSTAL_BALL:

otmp->spe = rnd(5);

blessorcurse(otmp, 2);

break;

case HORN_OF_PLENTY:

case BAG_OF_TRICKS:

otmp->spe = rnd(20);

break;

case FIGURINE:

tryct = 0;

do

otmp->corpsenm = rndmonnum();

while (is_human(&mons[otmp->corpsenm]) && tryct++ < 30);

blessorcurse(otmp, 4);

break;

case BELL_OF_OPENING:

otmp->spe = 3;

break;

case MAGIC_FLUTE:

case MAGIC_HARP:

case FROST_HORN:

case FIRE_HORN:

case DRUM_OF_EARTHQUAKE:

otmp->spe = rn1(5, 4);

break;

}

break;

case AMULET_CLASS:

if (otmp->otyp == AMULET_OF_YENDOR)

context.made_amulet = TRUE;

if (rn2(10) && (otmp->otyp == AMULET_OF_STRANGULATION

|| otmp->otyp == AMULET_OF_CHANGE

|| otmp->otyp == AMULET_OF_RESTFUL_SLEEP)) {

curse(otmp);

} else

blessorcurse(otmp, 10);

break;

case VENOM_CLASS:

case CHAIN_CLASS:

case BALL_CLASS:

break;

case POTION_CLASS: /* note: potions get some additional init below */

case SCROLL_CLASS:

#ifdef MAIL

if (otmp->otyp != SCR_MAIL)

blessorcurse(otmp, 4);

break;

case SPBOOK_CLASS:

otmp->spestudied = 0;

blessorcurse(otmp, 17);

break;

case ARMOR_CLASS:

if (rn2(10)

&& (otmp->otyp == FUMBLE_BOOTS

|| otmp->otyp == LEVITATION_BOOTS

|| otmp->otyp == HELM_OF_OPPOSITE_ALIGNMENT

|| otmp->otyp == GAUNTLETS_OF_FUMBLING || !rn2(11))) {

curse(otmp);