#include "hack.h"

#define PAY_SOME 2

#define PAY_BUY 1

#define PAY_CANT 0 /* too poor */

#define PAY_SKIP (-1)

#define PAY_BROKE (-2)

STATIC_DCL void FDECL(makekops, (coord *));

STATIC_DCL void FDECL(call_kops, (struct monst *, BOOLEAN_P));

STATIC_DCL void FDECL(kops_gone, (BOOLEAN_P));

#define NOTANGRY(mon) ((mon)->mpeaceful)

#define ANGRY(mon) (!NOTANGRY(mon))

#define IS_SHOP(x) (rooms[x].rtype >= SHOPBASE)

#define muteshk(shkp) \

((shkp)->msleeping || !(shkp)->mcanmove \

|| (shkp)->data->msound <= MS_ANIMAL)

extern const struct shclass shtypes[]; /* defined in shknam.c */

STATIC_VAR NEARDATA long int followmsg; /* last time of follow message */

STATIC_VAR const char and_its_contents[] = " and its contents";

STATIC_VAR const char the_contents_of[] = "the contents of ";

STATIC_DCL void FDECL(append_honorific, (char *));

STATIC_DCL long FDECL(addupbill, (struct monst *));

STATIC_DCL void FDECL(pacify_shk, (struct monst *));

STATIC_DCL struct bill_x *FDECL(onbill, (struct obj *, struct monst *,

BOOLEAN_P));

STATIC_DCL struct monst *FDECL(next_shkp, (struct monst *, BOOLEAN_P));

STATIC_DCL long FDECL(shop_debt, (struct eshk *));

STATIC_DCL char *FDECL(shk_owns, (char *, struct obj *));

STATIC_DCL char *FDECL(mon_owns, (char *, struct obj *));

STATIC_DCL void FDECL(clear_unpaid_obj, (struct monst *, struct obj *));

STATIC_DCL void FDECL(clear_unpaid, (struct monst *, struct obj *));

STATIC_DCL long FDECL(check_credit, (long, struct monst *));

STATIC_DCL void FDECL(pay, (long, struct monst *));

STATIC_DCL long FDECL(get_cost, (struct obj *, struct monst *));

STATIC_DCL long FDECL(set_cost, (struct obj *, struct monst *));

STATIC_DCL const char *FDECL(shk_embellish, (struct obj *, long));

STATIC_DCL long FDECL(cost_per_charge, (struct monst *, struct obj *,

BOOLEAN_P));

STATIC_DCL long FDECL(cheapest_item, (struct monst *));

STATIC_DCL int FDECL(dopayobj, (struct monst *, struct bill_x *,

struct obj **, int, BOOLEAN_P));

STATIC_DCL long FDECL(stolen_container, (struct obj *, struct monst *,

long, BOOLEAN_P));

STATIC_DCL long FDECL(getprice, (struct obj *, BOOLEAN_P));

STATIC_DCL void FDECL(shk_names_obj, (struct monst *, struct obj *,

const char *, long, const char *));

STATIC_DCL boolean FDECL(inherits, (struct monst *, int, int, BOOLEAN_P));

STATIC_DCL void FDECL(set_repo_loc, (struct monst *));

STATIC_DCL struct obj *FDECL(bp_to_obj, (struct bill_x *));

STATIC_DCL long FDECL(get_pricing_units, (struct obj *));

STATIC_DCL boolean NDECL(angry_shk_exists);

STATIC_DCL void FDECL(rile_shk, (struct monst *));

STATIC_DCL void FDECL(rouse_shk, (struct monst *, BOOLEAN_P));

STATIC_DCL void FDECL(remove_damage, (struct monst *, BOOLEAN_P));

STATIC_DCL void FDECL(sub_one_frombill, (struct obj *, struct monst *));

STATIC_DCL void FDECL(add_one_tobill, (struct obj *, BOOLEAN_P,

struct monst *));

STATIC_DCL void FDECL(dropped_container, (struct obj *, struct monst *,

BOOLEAN_P));

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

STATIC_DCL void FDECL(bill_box_content, (struct obj *, BOOLEAN_P, BOOLEAN_P,

struct monst *));

STATIC_DCL boolean FDECL(rob_shop, (struct monst *));

STATIC_DCL void FDECL(deserted_shop, (char *));

STATIC_DCL boolean FDECL(special_stock, (struct obj *, struct monst *,

BOOLEAN_P));

STATIC_DCL const char *FDECL(cad, (BOOLEAN_P));

static const char *angrytexts[] = { "quite upset", "ticked off", "furious" };

money2mon(mon, amount)

struct monst *mon;

long amount;

{

struct obj *ygold = findgold(invent, TRUE);

if (amount <= 0) {

impossible("%s payment in money2mon!", amount ? "negative" : "zero");

return 0L;

}

if (!ygold || ygold->quan < amount) {

impossible("Paying without %s money?", ygold ? "enough" : "");

return 0L;

}

if (ygold->quan > amount)

ygold = splitobj(ygold, amount);

else if (ygold->owornmask)

remove_worn_item(ygold, FALSE); /* quiver */

freeinv(ygold);

add_to_minv(mon, ygold);

context.botl = 1;

return amount;

}

money2u(mon, amount)

struct monst *mon;

long amount;

{

struct obj *mongold = findgold(mon->minvent, TRUE);

if (amount <= 0) {

impossible("%s payment in money2u!", amount ? "negative" : "zero");

return;

}

if (!mongold || mongold->quan < amount) {

impossible("%s paying without %s money?", a_monnam(mon),

mongold ? "enough" : "");

return;

}

if (mongold->quan > amount)

mongold = splitobj(mongold, amount);

obj_extract_self(mongold);

if (!merge_choice(invent, mongold) && inv_cnt(FALSE) >= 52) {

You("have no room for the money!");

dropy(mongold);

} else {

addinv(mongold);

context.botl = 1;

}

}

STATIC_OVL struct monst *

next_shkp(shkp, withbill)

register struct monst *shkp;

register boolean withbill;

{

for (; shkp; shkp = shkp->nmon) {

if (DEADMONSTER(shkp))

continue;

if (shkp->isshk && (ESHK(shkp)->billct || !withbill))

break;

}

if (shkp) {

if (NOTANGRY(shkp)) {

if (ESHK(shkp)->surcharge)

pacify_shk(shkp);

} else {

if (!ESHK(shkp)->surcharge)

rile_shk(shkp);

}

}

return shkp;

}

shkgone(mtmp)

struct monst *mtmp;

{

struct eshk *eshk = ESHK(mtmp);

struct mkroom *sroom = &rooms[eshk->shoproom - ROOMOFFSET];

struct obj *otmp;

char *p;

int sx, sy;

/* [BUG: some of this should be done on the shop level */

/* even when the shk dies on a different level.] */

if (on_level(&eshk->shoplevel, &u.uz)) {

remove_damage(mtmp, TRUE);

sroom->resident = (struct monst *) 0;

if (!search_special(ANY_SHOP))

level.flags.has_shop = 0;

/* items on shop floor revert to ordinary objects */

for (sx = sroom->lx; sx <= sroom->hx; sx++)

for (sy = sroom->ly; sy <= sroom->hy; sy++)

for (otmp = level.objects[sx][sy]; otmp;

otmp = otmp->nexthere)

otmp->no_charge = 0;

/* Make sure bill is set only when the

if ((p = index(u.ushops, eshk->shoproom)) != 0) {

setpaid(mtmp);

eshk->bill_p = (struct bill_x *) 0;

/* remove eshk->shoproom from u.ushops */

do {

*p = *(p + 1);

} while (*++p);

}

}

}

set_residency(shkp, zero_out)

register struct monst *shkp;

register boolean zero_out;

{

if (on_level(&(ESHK(shkp)->shoplevel), &u.uz))

rooms[ESHK(shkp)->shoproom - ROOMOFFSET].resident =

(zero_out) ? (struct monst *) 0 : shkp;

}

replshk(mtmp, mtmp2)

register struct monst *mtmp, *mtmp2;

{

rooms[ESHK(mtmp2)->shoproom - ROOMOFFSET].resident = mtmp2;

if (inhishop(mtmp) && *u.ushops == ESHK(mtmp)->shoproom) {

ESHK(mtmp2)->bill_p = &(ESHK(mtmp2)->bill[0]);

}

}

restshk(shkp, ghostly)

struct monst *shkp;

boolean ghostly;

{

if (u.uz.dlevel) {

struct eshk *eshkp = ESHK(shkp);

if (eshkp->bill_p != (struct bill_x *) -1000)

eshkp->bill_p = &eshkp->bill[0];

/* shoplevel can change as dungeons move around */

/* savebones guarantees that non-homed shk's will be gone */

if (ghostly) {

assign_level(&eshkp->shoplevel, &u.uz);

if (ANGRY(shkp) && strncmpi(eshkp->customer, plname, PL_NSIZ))

pacify_shk(shkp);

}

}

}

STATIC_OVL void

clear_unpaid_obj(shkp, otmp)

struct monst *shkp;

struct obj *otmp;

{

if (Has_contents(otmp))

clear_unpaid(shkp, otmp->cobj);

if (onbill(otmp, shkp, TRUE))

otmp->unpaid = 0;

}

STATIC_OVL void

clear_unpaid(shkp, list)

struct monst *shkp;

struct obj *list;

{

while (list) {

clear_unpaid_obj(shkp, list);

list = list->nobj;

}

}

setpaid(shkp)

register struct monst *shkp;

{

register struct obj *obj;

register struct monst *mtmp;

clear_unpaid(shkp, invent);

clear_unpaid(shkp, fobj);

clear_unpaid(shkp, level.buriedobjlist);

if (thrownobj)

clear_unpaid_obj(shkp, thrownobj);

if (kickedobj)

clear_unpaid_obj(shkp, kickedobj);

for (mtmp = fmon; mtmp; mtmp = mtmp->nmon)

clear_unpaid(shkp, mtmp->minvent);

for (mtmp = migrating_mons; mtmp; mtmp = mtmp->nmon)

clear_unpaid(shkp, mtmp->minvent);

while ((obj = billobjs) != 0) {

obj_extract_self(obj);

dealloc_obj(obj);

}

if (shkp) {

ESHK(shkp)->billct = 0;

ESHK(shkp)->credit = 0L;

ESHK(shkp)->debit = 0L;

ESHK(shkp)->loan = 0L;

}

}

addupbill(shkp)

register struct monst *shkp;

{

register int ct = ESHK(shkp)->billct;

register struct bill_x *bp = ESHK(shkp)->bill_p;

register long total = 0L;

while (ct--) {

total += bp->price * bp->bquan;

bp++;

}

return total;

}

STATIC_OVL void

call_kops(shkp, nearshop)

register struct monst *shkp;

register boolean nearshop;

{

/* Keystone Kops srt@ucla */

register boolean nokops;

if (!shkp)

return;

if (!Deaf)

pline("An alarm sounds!");

nokops = ((mvitals[PM_KEYSTONE_KOP].mvflags & G_GONE)

&& (mvitals[PM_KOP_SERGEANT].mvflags & G_GONE)

&& (mvitals[PM_KOP_LIEUTENANT].mvflags & G_GONE)

&& (mvitals[PM_KOP_KAPTAIN].mvflags & G_GONE));

if (Is_blackmarket(&u.uz)) {

nokops = ((mvitals[PM_SOLDIER].mvflags & G_GONE) &&

(mvitals[PM_SERGEANT].mvflags & G_GONE) &&

(mvitals[PM_LIEUTENANT].mvflags & G_GONE) &&

(mvitals[PM_CAPTAIN].mvflags & G_GONE));

}

if (!angry_guards(!!Deaf) && nokops) {

if (flags.verbose && !Deaf)

pline("But no one seems to respond to it.");

return;

}

if (nokops)

return;

{

coord mm;

if (nearshop && !Is_blackmarket(&u.uz)) {

/* Create swarm around you, if you merely "stepped out" */

if (flags.verbose)

pline_The("Keystone Kops appear!");

mm.x = u.ux;

mm.y = u.uy;

makekops(&mm);

return;

}

if (flags.verbose && !Is_blackmarket(&u.uz))

pline_The("Keystone Kops are after you!");

/* Create swarm near down staircase (hinders return to level) */

if (Is_blackmarket(&u.uz)) {

struct trap *trap = ftrap;

while (trap) {

if (trap->ttyp == MAGIC_PORTAL) {

mm.x = trap->tx;

mm.y = trap->ty;

}

trap = trap->ntrap;

}

} else {

mm.x = xdnstair;

mm.y = ydnstair;

}

makekops(&mm);

/* Create swarm near shopkeeper (hinders return to shop) */

mm.x = shkp->mx;

mm.y = shkp->my;

makekops(&mm);

}

}

blkmar_guards(mtmp)

register struct monst *mtmp;

{

register struct monst *mt;

boolean mesg_given = FALSE; /* Only give message if assistants peaceful */

static boolean rlock = FALSE; /* Prevent recursive calls (via wakeup) */

if (rlock) return;

rlock = TRUE;

/* allow black marketeer to leave his shop */

hot_pursuit(mtmp);

/* wake up assistants */

for (mt = fmon; mt; mt = mt->nmon) {

if (DEADMONSTER(mt)) continue;

/* non-tame named monsters are presumably

else if (mt->mpeaceful &&

((!mt->mtame && has_mname(mt) &&

mt->mpeaceful && mt != mtmp) ||

mt->data == &mons[PM_ARMS_DEALER])) {

if (!mesg_given) {

pline("%s calls for help!", noit_Monnam(mtmp));

mesg_given = TRUE;

bars_around_portal(FALSE);

call_kops(mtmp, FALSE);

}

wakeup(mt, FALSE);

setmangry(mt, FALSE);

}

}

rlock = FALSE;

}

bars_around_portal(removebars)

boolean removebars;

{

int x, y, dx, dy;

boolean sawit = FALSE;

struct trap *trap = ftrap;

while (trap) {

if (trap->ttyp == MAGIC_PORTAL) break;

trap = trap->ntrap;

}

if (!trap) return;

if (trap->tx == u.ux && trap->ty == u.uy) return;

for (dx = -1; dx <= 1; dx++)

for (dy = -1; dy <= 1; dy++) {

if (!dx && !dy) continue;

x = trap->tx + dx;

y = trap->ty + dy;

if (removebars) {

if (levl[x][y].typ == IRONBARS) {

dissolve_bars(x,y);

if (cansee(x,y))

sawit = TRUE;

}

} else {

if (!IS_ROCK(levl[x][y].typ) && levl[x][y].typ != IRONBARS) {

levl[x][y].typ = IRONBARS;

newsym(x, y);

if (cansee(x,y))

sawit = TRUE;

}

}

}

if (sawit) {

if (removebars)

pline("The iron bars rise back into the ceiling.");

else

pline("Iron bars drop from the ceiling around the magic portal!");

}

}

inside_shop(x, y)

register xchar x, y;

{

register char rno;

rno = levl[x][y].roomno;

if ((rno < ROOMOFFSET) || levl[x][y].edge || !IS_SHOP(rno - ROOMOFFSET))

rno = NO_ROOM;

return rno;

}

u_left_shop(leavestring, newlev)

char *leavestring;

boolean newlev;

{

struct monst *shkp;

struct eshk *eshkp;

/*

if (!*leavestring && (!levl[u.ux][u.uy].edge || levl[u.ux0][u.uy0].edge))

return;

shkp = shop_keeper(*u.ushops0);

if (!shkp || !inhishop(shkp))

return; /* shk died, teleported, changed levels... */

eshkp = ESHK(shkp);

if (!eshkp->billct && !eshkp->debit) /* bill is settled */

return;

if (!*leavestring && !muteshk(shkp)) {

/*

if (!Deaf && !muteshk(shkp))

verbalize(NOTANGRY(shkp) ? "%s! Please pay before leaving."

: "%s! Don't you leave without paying!",

plname);

else

pline("%s %s that you need to pay before leaving%s",

Shknam(shkp),

NOTANGRY(shkp) ? "points out" : "makes it clear",

NOTANGRY(shkp) ? "." : "!");

return;

}

if (rob_shop(shkp)) {

if (Is_blackmarket(&u.uz))

blkmar_guards(shkp);

else

call_kops(shkp, (!newlev && levl[u.ux0][u.uy0].edge));

}

}

remote_burglary(x, y)

xchar x, y;

{

struct monst *shkp;

struct eshk *eshkp;

shkp = shop_keeper(*in_rooms(x, y, SHOPBASE));

if (!shkp || !inhishop(shkp))

return; /* shk died, teleported, changed levels... */

eshkp = ESHK(shkp);

if (!eshkp->billct && !eshkp->debit) /* bill is settled */

return;

if (rob_shop(shkp)) {

if (Is_blackmarket(&u.uz))

blkmar_guards(shkp);

else

/*[might want to set 2nd arg based on distance from shop doorway]*/

call_kops(shkp, FALSE);

}

}

STATIC_OVL boolean

rob_shop(shkp)

struct monst *shkp;

{

struct eshk *eshkp;

long total;

eshkp = ESHK(shkp);

rouse_shk(shkp, TRUE);

total = (addupbill(shkp) + eshkp->debit);

if (eshkp->credit >= total) {

Your("credit of %ld %s is used to cover your shopping bill.",

eshkp->credit, currency(eshkp->credit));

total = 0L; /* credit gets cleared by setpaid() */

} else {

You("escaped the shop without paying!");

total -= eshkp->credit;

}

setpaid(shkp);

if (!total)

return FALSE;

/* by this point, we know an actual robbery has taken place */

eshkp->robbed += total;

You("stole %ld %s worth of merchandise.", total, currency(total));

if (!Role_if(PM_ROGUE)) /* stealing is unlawful */

adjalign(-sgn(u.ualign.type));

hot_pursuit(shkp);

return TRUE;

}

STATIC_OVL void

deserted_shop(enterstring)

/*const*/ char *enterstring;

{

struct monst *mtmp;

struct mkroom *r = &rooms[(int) *enterstring - ROOMOFFSET];

int x, y, m = 0, n = 0;

for (x = r->lx; x <= r->hx; ++x)

for (y = r->ly; y <= r->hy; ++y) {

if (x == u.ux && y == u.uy)

continue;

if ((mtmp = m_at(x, y)) != 0) {

++n;

if (sensemon(mtmp) || ((M_AP_TYPE(mtmp) == M_AP_NOTHING

|| M_AP_TYPE(mtmp) == M_AP_MONSTER)

&& canseemon(mtmp)))

++m;

}

}

if (Blind && !(Blind_telepat || Detect_monsters))

++n; /* force feedback to be less specific */

pline("This shop %s %s.", (m < n) ? "seems to be" : "is",

!n ? "deserted" : "untended");

}

u_entered_shop(enterstring)

char *enterstring;

{

register int rt;

register struct monst *shkp;

register struct eshk *eshkp;

static char empty_shops[5];

if (!*enterstring)

return;

if (!(shkp = shop_keeper(*enterstring))) {

if (!index(empty_shops, *enterstring)

&& in_rooms(u.ux, u.uy, SHOPBASE)

!= in_rooms(u.ux0, u.uy0, SHOPBASE))

deserted_shop(enterstring);

Strcpy(empty_shops, u.ushops);

u.ushops[0] = '\0';

return;

}

eshkp = ESHK(shkp);

if (!inhishop(shkp)) {

/* dump core when referenced */

eshkp->bill_p = (struct bill_x *) -1000;

if (!index(empty_shops, *enterstring))

deserted_shop(enterstring);

Strcpy(empty_shops, u.ushops);

u.ushops[0] = '\0';

return;

}

eshkp->bill_p = &(eshkp->bill[0]);

if ((!eshkp->visitct || *eshkp->customer)

&& strncmpi(eshkp->customer, plname, PL_NSIZ)) {

/* You seem to be new here */

eshkp->visitct = 0;

eshkp->following = 0;

(void) strncpy(eshkp->customer, plname, PL_NSIZ);

pacify_shk(shkp);

}

if (muteshk(shkp) || eshkp->following)

return; /* no dialog */

if (Invis) {

pline("%s senses your presence.", shkname(shkp));

if (!Deaf && !muteshk(shkp) && !Is_blackmarket(&u.uz))

verbalize("Invisible customers are not welcome!");

else

pline("%s stands firm as if %s knows you are there.",

Shknam(shkp), noit_mhe(shkp));

return;

}

/* Visible striped prison shirt */

if ((uarmu && (uarmu->otyp == STRIPED_SHIRT)) && !uarm && !uarmc) {

eshkp->pbanned = TRUE;

}

rt = rooms[*enterstring - ROOMOFFSET].rtype;

if (ANGRY(shkp)) {

if (!Deaf && !muteshk(shkp))

verbalize("So, %s, you dare return to %s %s?!", plname,

s_suffix(shkname(shkp)), shtypes[rt - SHOPBASE].name);

else

pline("%s seems %s over your return to %s %s!",

Shknam(shkp), angrytexts[rn2(SIZE(angrytexts))],

noit_mhis(shkp), shtypes[rt - SHOPBASE].name);

} else if (eshkp->robbed) {

if (!Deaf)

pline("%s mutters imprecations against shoplifters.",

Shknam(shkp));

else

pline("%s is combing through %s inventory list.",

Shknam(shkp), noit_mhis(shkp));

} else {

if (!Deaf && !muteshk(shkp) && !eshkp->pbanned)

verbalize("%s, %s! Welcome%s to %s %s!", Hello(shkp), plname,

eshkp->visitct++ ? " again" : "",

s_suffix(shkname(shkp)), shtypes[rt - SHOPBASE].name);

else

You("enter %s %s%s!",

s_suffix(shkname(shkp)),

shtypes[rt - SHOPBASE].name,

eshkp->visitct++ ? " again" : "");

}

/* can't do anything about blocking if teleported in */

if (!inside_shop(u.ux, u.uy) && !Is_blackmarket(&u.uz)) {

boolean should_block;

int cnt;

const char *tool;

struct obj *pick = carrying(PICK_AXE),

*mattock = carrying(DWARVISH_MATTOCK);

if (pick || mattock) {

cnt = 1; /* so far */

if (pick && mattock) { /* carrying both types */

tool = "digging tool";

cnt = 2; /* `more than 1' is all that matters */

} else if (pick) {

tool = "pick-axe";

/* hack: `pick' already points somewhere into inventory */

while ((pick = pick->nobj) != 0)

if (pick->otyp == PICK_AXE)

++cnt;

} else { /* assert(mattock != 0) */

tool = "mattock";

while ((mattock = mattock->nobj) != 0)

if (mattock->otyp == DWARVISH_MATTOCK)

++cnt;

/* [ALI] Shopkeeper identifies mattock(s) */

if (!Blind)

makeknown(DWARVISH_MATTOCK);

}

if (!Deaf && !muteshk(shkp))

verbalize(NOTANGRY(shkp)

? "Will you please leave your %s%s outside?"

: "Leave the %s%s outside.",

tool, plur(cnt));

else

pline("%s %s to let you in with your %s%s.",

Shknam(shkp),

NOTANGRY(shkp) ? "is hesitant" : "refuses",

tool, plur(cnt));

should_block = TRUE;

} else if (eshkp->pbanned && !ANGRY(shkp)) {

verbalize("I don't sell to your kind here.");

should_block = TRUE;

} else if (u.usteed) {

if (!Deaf && !muteshk(shkp))

verbalize(NOTANGRY(shkp) ? "Will you please leave %s outside?"

: "Leave %s outside.",

y_monnam(u.usteed));

else

pline("%s %s to let you in while you're riding %s.",

Shknam(shkp),

NOTANGRY(shkp) ? "doesn't want" : "refuses",

y_monnam(u.usteed));

should_block = TRUE;

} else {

should_block =

(Fast && (sobj_at(PICK_AXE, u.ux, u.uy)

|| sobj_at(DWARVISH_MATTOCK, u.ux, u.uy)));

}

if (should_block)

(void) dochug(shkp); /* shk gets extra move */

}

return;

}

pick_pick(obj)

struct obj *obj;

{

struct monst *shkp;

if (obj->unpaid || !is_pick(obj))

return;

shkp = shop_keeper(*u.ushops);

if (shkp && inhishop(shkp)) {

static NEARDATA long pickmovetime = 0L;

/* if you bring a sack of N picks into a shop to sell,

if (moves != pickmovetime) {

if (!Deaf && !muteshk(shkp))

verbalize("You sneaky %s! Get out of here with that pick!",

cad(FALSE));

else

pline("%s %s your pick!",

Shknam(shkp),

haseyes(shkp->data) ? "glares at"

: "is dismayed because of");

}

pickmovetime = moves;

}

}

same_price(obj1, obj2)

struct obj *obj1, *obj2;

{

register struct monst *shkp1, *shkp2;

struct bill_x *bp1 = 0, *bp2 = 0;

boolean are_mergable = FALSE;

/* look up the first object by finding shk whose bill it's on */

for (shkp1 = next_shkp(fmon, TRUE); shkp1;

shkp1 = next_shkp(shkp1->nmon, TRUE))

if ((bp1 = onbill(obj1, shkp1, TRUE)) != 0)

break;

/* second object is probably owned by same shk; if not, look harder */

if (shkp1 && (bp2 = onbill(obj2, shkp1, TRUE)) != 0) {

shkp2 = shkp1;

} else {

for (shkp2 = next_shkp(fmon, TRUE); shkp2;

shkp2 = next_shkp(shkp2->nmon, TRUE))

if ((bp2 = onbill(obj2, shkp2, TRUE)) != 0)

break;

}

if (!bp1 || !bp2)

impossible("same_price: object wasn't on any bill!");

else

are_mergable = (shkp1 == shkp2 && bp1->price == bp2->price);

return are_mergable;

}

shop_debt(eshkp)

struct eshk *eshkp;

{

struct bill_x *bp;

int ct;

long debt = eshkp->debit;

for (bp = eshkp->bill_p, ct = eshkp->billct; ct > 0; bp++, ct--)

debt += bp->price * bp->bquan;

return debt;

}

shopper_financial_report()

{

struct monst *shkp, *this_shkp = shop_keeper(inside_shop(u.ux, u.uy));

struct eshk *eshkp;

long amt;

int pass;

eshkp = this_shkp ? ESHK(this_shkp) : 0;

if (eshkp && !(eshkp->credit || shop_debt(eshkp))) {

You("have no credit or debt in here.");

this_shkp = 0; /* skip first pass */

}

/* pass 0: report for the shop we're currently in, if any;

for (pass = this_shkp ? 0 : 1; pass <= 1; pass++)

for (shkp = next_shkp(fmon, FALSE); shkp;

shkp = next_shkp(shkp->nmon, FALSE)) {

if ((shkp != this_shkp) ^ pass)

continue;

eshkp = ESHK(shkp);

if ((amt = eshkp->credit) != 0)

You("have %ld %s credit at %s %s.", amt, currency(amt),

s_suffix(shkname(shkp)),

shtypes[eshkp->shoptype - SHOPBASE].name);

else if (shkp == this_shkp)

You("have no credit in here.");

if ((amt = shop_debt(eshkp)) != 0)

You("owe %s %ld %s.", shkname(shkp), amt, currency(amt));

else if (shkp == this_shkp)

You("don't owe any money here.");

}

}

inhishop(mtmp)

register struct monst *mtmp;

{

struct eshk *eshkp = ESHK(mtmp);

return (index(in_rooms(mtmp->mx, mtmp->my, SHOPBASE), eshkp->shoproom)

&& on_level(&eshkp->shoplevel, &u.uz));

}

struct monst *

shop_keeper(rmno)

char rmno;

{

struct monst *shkp;

shkp = (rmno >= ROOMOFFSET) ? rooms[rmno - ROOMOFFSET].resident : 0;

if (shkp) {

if (has_eshk(shkp)) {

if (NOTANGRY(shkp)) {

if (ESHK(shkp)->surcharge)

pacify_shk(shkp);

} else {

if (!ESHK(shkp)->surcharge)

rile_shk(shkp);

}

} else {

/* would have segfaulted on ESHK dereference previously */

impossible("%s? (rmno=%d, rtype=%d, mnum=%d, \"%s\")",

shkp->isshk ? "shopkeeper career change"

: "shop resident not shopkeeper",

(int) rmno,

(int) rooms[rmno - ROOMOFFSET].rtype,

shkp->mnum,

/* [real shopkeeper name is kept in ESHK, not MNAME] */

has_mname(shkp) ? MNAME(shkp) : "anonymous");

/* not sure if this is appropriate, because it does nothing to

return (struct monst *) 0;

}

}

return shkp;

}

tended_shop(sroom)

struct mkroom *sroom;

{

struct monst *mtmp = sroom->resident;

return !mtmp ? FALSE : (boolean) inhishop(mtmp);

}

STATIC_OVL struct bill_x *

onbill(obj, shkp, silent)

struct obj *obj;

struct monst *shkp;

boolean silent;

{

if (shkp) {

register struct bill_x *bp = ESHK(shkp)->bill_p;

register int ct = ESHK(shkp)->billct;

while (--ct >= 0)

if (bp->bo_id == obj->o_id) {

if (!obj->unpaid)

pline("onbill: paid obj on bill?");

return bp;

} else

bp++;

}

if (obj->unpaid && !silent)

pline("onbill: unpaid obj not on bill?");

return (struct bill_x *) 0;

}

is_unpaid(obj)

struct obj *obj;

{

return (boolean) (obj->unpaid

|| (Has_contents(obj) && count_unpaid(obj->cobj)));

}

delete_contents(obj)