#include "hack.h"

#define PAY_BUY 1

#define PAY_CANT 0 /* too poor */

#define PAY_SKIP (-1)

#define PAY_BROKE (-2)

enum billitem_status {

};

struct sortbill_item {

};

typedef struct sortbill_item Bill;

staticfn void makekops(coord *);

staticfn void getcad(struct monst *, const char *, coordxy, coordxy, boolean,

boolean, boolean);

staticfn void call_kops(struct monst *, boolean);

staticfn void kops_gone(boolean);

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

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

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

#define muteshk(shkp) (helpless(shkp) || (shkp)->data->msound <= MS_ANIMAL)

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

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

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

staticfn void append_honorific(char *);

staticfn long addupbill(struct monst *);

staticfn void pacify_shk(struct monst *, boolean);

staticfn struct bill_x *onbill(struct obj *, struct monst *, boolean);

staticfn struct monst *next_shkp(struct monst *, boolean);

staticfn long shop_debt(struct eshk *);

staticfn char *shk_owns(char *, struct obj *);

staticfn char *mon_owns(char *, struct obj *);

staticfn void clear_unpaid_obj(struct monst *, struct obj *);

staticfn void clear_unpaid(struct monst *, struct obj *);

staticfn void clear_no_charge_obj(struct monst *, struct obj *);

staticfn void clear_no_charge(struct monst *, struct obj *);

staticfn void clear_no_charge_pets(struct monst *);

staticfn long check_credit(long, struct monst *);

staticfn void pay(long, struct monst *);

staticfn long get_cost(struct obj *, struct monst *);

staticfn long set_cost(struct obj *, struct monst *);

staticfn const char *shk_embellish(struct obj *, long);

staticfn long cost_per_charge(struct monst *, struct obj *, boolean);

staticfn int QSORTCALLBACK sortbill_cmp(const genericptr, const genericptr)

NONNULLPTRS;

staticfn long cheapest_item(int, Bill *) NONNULLPTRS;

staticfn int make_itemized_bill(struct monst *shkp, Bill **ibill) NONNULLPTRS;

staticfn int menu_pick_pay_items(int, Bill *) NONNULLPTRS;

staticfn boolean pay_billed_items(struct monst *, int, Bill *, boolean,

boolean *) NONNULLPTRS;

staticfn void update_bill(int, int, Bill *, struct eshk *, struct bill_x *,

struct obj *) NONNULLPTRS;

staticfn int dopayobj(struct monst *, struct bill_x *, struct obj *, int,

boolean, boolean) NONNULLPTRS;

staticfn int buy_container(struct monst *, int, int, Bill *) NONNULLPTRS;

staticfn void reject_purchase(struct monst *, struct obj *, long) NONNULLPTRS;

staticfn boolean insufficient_funds(struct monst *, struct obj *, long)

NONNULLPTRS;

staticfn long stolen_container(struct obj *, struct monst *, long, boolean);

staticfn long corpsenm_price_adj(struct obj *);

staticfn long getprice(struct obj *, boolean);

staticfn void shk_names_obj(struct monst *, struct obj *, const char *, long,

const char *);

staticfn boolean inherits(struct monst *, int, int, boolean);

staticfn void set_repo_loc(struct monst *);

staticfn struct obj *bp_to_obj(struct bill_x *);

staticfn long get_pricing_units(struct obj *);

staticfn boolean angry_shk_exists(void);

staticfn void home_shk(struct monst *, boolean);

staticfn void rile_shk(struct monst *);

staticfn void rouse_shk(struct monst *, boolean);

staticfn boolean shk_impaired(struct monst *);

staticfn boolean repairable_damage(struct damage *, struct monst *);

staticfn struct damage *find_damage(struct monst *);

staticfn void discard_damage_struct(struct damage *);

staticfn void discard_damage_owned_by(struct monst *);

staticfn void shk_fixes_damage(struct monst *);

staticfn uint8 litter_getpos(uint8 *, coordxy, coordxy, struct monst *);

staticfn void litter_scatter(uint8 *, coordxy, coordxy, struct monst *);

staticfn void litter_newsyms(uint8 *, coordxy, coordxy);

staticfn int repair_damage(struct monst *, struct damage *, boolean);

staticfn void sub_one_frombill(struct obj *, struct monst *) NONNULLPTRS;

staticfn void add_one_tobill(struct obj *, boolean, struct monst *);

staticfn void dropped_container(struct obj *, struct monst *, boolean);

staticfn void add_to_billobjs(struct obj *);

staticfn void bill_box_content(struct obj *, boolean, boolean,

struct monst *);

staticfn boolean rob_shop(struct monst *);

staticfn void deserted_shop(char *);

staticfn boolean special_stock(struct obj *, struct monst *, boolean);

staticfn const char *cad(boolean);

static const char *const angrytexts[] = {

"quite upset", "ticked off", "furious"

};

money2mon(struct monst *mon, long amount)

{

struct obj *ygold = findgold(gi.invent);

if (amount <= 0) {

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

return 0L;

}

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

impossible("Paying without %s gold?", 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);

disp.botl = TRUE;

return amount;

}

money2u(struct monst *mon, long amount)

{

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

if (amount <= 0) {

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

return;

}

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

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

mongold ? "enough" : "");

return;

}

if (mongold->quan > amount)

mongold = splitobj(mongold, amount);

obj_extract_self(mongold);

if (!merge_choice(gi.invent, mongold)

&& inv_cnt(FALSE) >= invlet_basic) {

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

dropy(mongold);

} else {

addinv(mongold);

disp.botl = TRUE;

}

}

staticfn struct monst *

next_shkp(struct monst *shkp, boolean withbill)

{

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

if (DEADMONSTER(shkp))

continue;

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

break;

}

if (shkp) {

if (ANGRY(shkp)) {

if (!ESHK(shkp)->surcharge)

rile_shk(shkp);

}

}

return shkp;

}

shkgone(struct monst *mtmp)

{

struct eshk *eshk = ESHK(mtmp);

struct mkroom *sroom = &svr.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)) {

discard_damage_owned_by(mtmp);

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

if (!search_special(ANY_SHOP))

svl.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 = svl.level.objects[sx][sy]; otmp;

otmp = otmp->nexthere)

otmp->no_charge = 0;

/* Make sure bill is set only when the

if ((p = strchr(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(struct monst *shkp, boolean zero_out)

{

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

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

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

}

replshk(struct monst *mtmp, struct monst *mtmp2)

{

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

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

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

}

}

restshk(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, svp.plname, PL_NSIZ))

pacify_shk(shkp, TRUE);

}

}

}

staticfn void

clear_unpaid_obj(struct monst *shkp, struct obj *otmp)

{

if (Has_contents(otmp))

clear_unpaid(shkp, otmp->cobj);

if (onbill(otmp, shkp, TRUE))

otmp->unpaid = 0;

}

staticfn void

clear_unpaid(struct monst *shkp, struct obj *list)

{

while (list) {

clear_unpaid_obj(shkp, list);

list = list->nobj;

}

}

staticfn void

clear_no_charge_obj(

struct monst *shkp, /* if null, clear regardless of shop */

struct obj *otmp)

{

if (Has_contents(otmp))

clear_no_charge(shkp, otmp->cobj);

if (otmp->no_charge) {

struct monst *rm_shkp;

int rno;

coordxy x, y;

/*

if (!shkp

|| (otmp->where != OBJ_FLOOR

&& otmp->where != OBJ_CONTAINED

&& otmp->where != OBJ_BURIED)

|| !get_obj_location(otmp, &x, &y, OBJ_CONTAINED | OBJ_BURIED)

|| !isok(x, y)

|| (rno = levl[x][y].roomno) < ROOMOFFSET

|| !IS_SHOP(rno - ROOMOFFSET)

|| (rm_shkp = svr.rooms[rno - ROOMOFFSET].resident) == 0

|| rm_shkp == shkp)

otmp->no_charge = 0;

}

}

staticfn void

clear_no_charge(struct monst *shkp, struct obj *list)

{

while (list) {

/* handle first element of list and any contents it may have */

clear_no_charge_obj(shkp, list);

/* move on to next element of list */

list = list->nobj;

}

}

staticfn void

clear_no_charge_pets(struct monst *shkp)

{

struct monst *mtmp;

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

if (mtmp->mtame && mtmp->minvent)

clear_no_charge(shkp, mtmp->minvent);

}

setpaid(struct monst *shkp)

{

struct obj *obj;

struct monst *mtmp;

clear_unpaid(shkp, gi.invent);

clear_unpaid(shkp, fobj);

if (svl.level.buriedobjlist)

clear_unpaid(shkp, svl.level.buriedobjlist);

if (gt.thrownobj)

clear_unpaid_obj(shkp, gt.thrownobj);

if (gk.kickedobj)

clear_unpaid_obj(shkp, gk.kickedobj);

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

if (mtmp->minvent)

clear_unpaid(shkp, mtmp->minvent);

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

if (mtmp->minvent)

clear_unpaid(shkp, mtmp->minvent);

/* clear obj->no_charge for all obj in shkp's shop */

clear_no_charge(shkp, fobj);

clear_no_charge(shkp, svl.level.buriedobjlist);

while ((obj = gb.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(struct monst *shkp)

{

int ct = ESHK(shkp)->billct;

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

long total = 0L;

while (ct--) {

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

bp++;

}

return total;

}

staticfn void

call_kops(struct monst *shkp, boolean nearshop)

{

/* Keystone Kops srt@ucla */

boolean nokops;

if (!shkp)

return;

Soundeffect(se_alarm, 80);

if (!Deaf)

pline("An alarm sounds!");

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

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

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

&& (svm.mvitals[PM_KOP_KAPTAIN].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;

coordxy sx = 0, sy = 0;

choose_stairs(&sx, &sy, TRUE);

if (nearshop) {

/* 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)

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

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

if (isok(sx, sy)) {

mm.x = sx;

mm.y = sy;

makekops(&mm);

}

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

mm.x = shkp->mx;

mm.y = shkp->my;

makekops(&mm);

}

}

inside_shop(coordxy x, coordxy y)

{

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(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(*leavestring ? *leavestring : *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)) {

/*

boolean not_upset = !eshkp->surcharge;

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

SetVoice(shkp, 0, 80, 0);

verbalize(not_upset ? "%s! Please pay before leaving."

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

svp.plname);

} else {

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

Shknam(shkp),

not_upset ? "points out" : "makes it clear",

not_upset ? "." : "!");

}

return;

}

if (rob_shop(shkp)) {

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

}

}

credit_report(struct monst *shkp, int idx, boolean silent)

{

struct eshk *eshkp = ESHK(shkp);

static long credit_snap[2][3] = {{0L, 0L, 0L}, {0L, 0L, 0L}};

if (!idx) {

credit_snap[BEFORE][0] = credit_snap[NOW][0] = 0L;

credit_snap[BEFORE][1] = credit_snap[NOW][1] = 0L;

credit_snap[BEFORE][2] = credit_snap[NOW][2] = 0L;

} else {

idx = 1;

}

credit_snap[idx][0] = eshkp->credit;

credit_snap[idx][1] = eshkp->debit;

credit_snap[idx][2] = eshkp->loan;

if (idx && !silent) {

long amt = 0L;

const char *msg = "debt has increased";

if (credit_snap[NOW][0] < credit_snap[BEFORE][0]) {

amt = credit_snap[BEFORE][0] - credit_snap[NOW][0];

msg = "credit has been reduced";

} else if (credit_snap[NOW][1] > credit_snap[BEFORE][1]) {

amt = credit_snap[NOW][1] - credit_snap[BEFORE][1];

} else if (credit_snap[NOW][2] > credit_snap[BEFORE][2]) {

amt = credit_snap[NOW][2] - credit_snap[BEFORE][2];

}

if (amt)

Your("%s by %ld %s.", msg, amt, currency(amt));

}

}

remote_burglary(coordxy x, coordxy 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)) {

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

call_kops(shkp, FALSE);

}

}

staticfn boolean

rob_shop(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));

livelog_printf(LL_ACHIEVE, "stole %ld %s worth of merchandise from %s %s",

total, currency(total), s_suffix(shkname(shkp)),

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

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

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

hot_pursuit(shkp);

return TRUE;

}

staticfn void

deserted_shop(/*const*/ char *enterstring)

{

struct monst *mtmp;

struct mkroom *r = &svr.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 (u_at(x, y))

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(char *enterstring)

{

static char empty_shops[5];

struct monst *shkp;

struct eshk *eshkp;

int rt;

if (!*enterstring)

return;

shkp = shop_keeper(*enterstring);

if (!shkp) {

if (!strchr(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 (!strchr(empty_shops, *enterstring))

deserted_shop(enterstring);

Strcpy(empty_shops, u.ushops);

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

return;

}

record_achievement(ACH_SHOP);

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

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

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

/* You seem to be new here */

eshkp->visitct = 0;

eshkp->following = 0;

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

pacify_shk(shkp, TRUE);

}

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

return; /* no dialog */

if (Invis) {

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

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

SetVoice(shkp, 0, 80, 0);

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

} else {

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

Shknam(shkp), noit_mhe(shkp));

}

return;

}

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

if (ANGRY(shkp)) {

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

SetVoice(shkp, 0, 80, 0);

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

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

} else {

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

Shknam(shkp), ROLL_FROM(angrytexts),

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

}

} else if (eshkp->surcharge) {

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

SetVoice(shkp, 0, 80, 0);

verbalize("Back again, %s? I've got my %s on you.",

svp.plname, mbodypart(shkp, EYE));

} else {

pline_The("atmosphere at %s %s seems unwelcoming.",

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

}

} else if (eshkp->robbed) {

if (!Deaf) {

Soundeffect(se_mutter_imprecations, 50);

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)) {

set_voice(shkp, 0, 80, 0);

verbalize("%s, %s! Welcome%s to %s %s!", Hello(shkp), svp.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)) {

boolean should_block, not_upset = !eshkp->surcharge;

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)) {

SetVoice(shkp, 0, 80, 0);

verbalize(not_upset

? "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),

not_upset ? "is hesitant" : "refuses",

tool, plur(cnt));

}

should_block = TRUE;

} else if (u.usteed) {

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

SetVoice(shkp, 0, 80, 0);

verbalize(not_upset ? "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),

not_upset ? "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(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 (svm.moves != pickmovetime) {

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

SetVoice(shkp, 0, 80, 0);

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 = svm.moves;

}

}

same_price(struct obj *obj1, struct obj *obj2)

{

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(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(void)

{

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 gold here.");

}

}

inhishop(struct monst *shkp)

{

char *shkrooms;

struct eshk *eshkp = ESHK(shkp);

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

return FALSE;

shkrooms = in_rooms(shkp->mx, shkp->my, SHOPBASE);

return (strchr(shkrooms, eshkp->shoproom) != 0);

}

struct monst *

shop_keeper(char rmno)

{

struct monst *shkp;

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

if (shkp) {

if (has_eshk(shkp)) {

if (ANGRY(shkp)) {