ab8b63434d
Use const. Add __noreturn__ attributes. Add a __format__ attribute. Add __unused__ attributes. Use symbolic constants for open() and lseek(). Declare types of all function parameters; convert some function definitions to ISO C form. Ensure standard file descriptors are open on startup. Check for errors writing output of makedefs. Avoid duplicate definitions of variables.
1112 lines
24 KiB
C
1112 lines
24 KiB
C
/* $NetBSD: hack.shk.c,v 1.5 2001/03/25 20:44:02 jsm Exp $ */
|
|
|
|
/*
|
|
* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985.
|
|
*/
|
|
|
|
#include <sys/cdefs.h>
|
|
#ifndef lint
|
|
__RCSID("$NetBSD: hack.shk.c,v 1.5 2001/03/25 20:44:02 jsm Exp $");
|
|
#endif /* not lint */
|
|
|
|
#include <stdlib.h>
|
|
#include "hack.h"
|
|
#include "extern.h"
|
|
|
|
#ifndef QUEST
|
|
static void setpaid __P((void));
|
|
static void addupbill __P((void));
|
|
static void findshk __P((int));
|
|
static struct bill_x *onbill __P((struct obj *));
|
|
static void pay __P((long, struct monst *));
|
|
static int dopayobj __P((struct bill_x *));
|
|
static int getprice __P((struct obj *));
|
|
static int realhunger __P((void));
|
|
#endif
|
|
|
|
#ifdef QUEST
|
|
int shlevel = 0;
|
|
struct monst *shopkeeper = 0;
|
|
struct obj *billobjs = 0;
|
|
void
|
|
obfree(obj, merge)
|
|
struct obj *obj, *merge;
|
|
{
|
|
free((char *) obj);
|
|
}
|
|
int
|
|
inshop() {
|
|
return (0);
|
|
}
|
|
void
|
|
shopdig(n)
|
|
int n;
|
|
{
|
|
}
|
|
void
|
|
addtobill(obj)
|
|
struct obj *obj;
|
|
{
|
|
}
|
|
void
|
|
subfrombill(obj)
|
|
struct obj *obj;
|
|
{
|
|
}
|
|
void
|
|
splitbill(o1, o2)
|
|
struct obj *o1, *o2;
|
|
{
|
|
}
|
|
int
|
|
dopay() {
|
|
return (0);
|
|
}
|
|
void
|
|
paybill()
|
|
{
|
|
}
|
|
int
|
|
doinvbill(n)
|
|
int n;
|
|
{
|
|
return (0);
|
|
}
|
|
void
|
|
shkdead(m)
|
|
struct monst *m;
|
|
{
|
|
}
|
|
int
|
|
shkcatch(obj)
|
|
struct obj *obj;
|
|
{
|
|
return (0);
|
|
}
|
|
int
|
|
shk_move(m)
|
|
struct monst *m;
|
|
{
|
|
return (0);
|
|
}
|
|
void
|
|
replshk(mtmp, mtmp2)
|
|
struct monst *mtmp, *mtmp2;
|
|
{
|
|
}
|
|
char *shkname(m)
|
|
struct monst *m;
|
|
{
|
|
return ("");
|
|
}
|
|
|
|
#else /* QUEST */
|
|
#include "hack.mfndpos.h"
|
|
#include "def.mkroom.h"
|
|
#include "def.eshk.h"
|
|
|
|
#define ESHK(mon) ((struct eshk *)(&(mon->mextra[0])))
|
|
#define NOTANGRY(mon) mon->mpeaceful
|
|
#define ANGRY(mon) !NOTANGRY(mon)
|
|
|
|
/*
|
|
* Descriptor of current shopkeeper. Note that the bill need not be
|
|
* per-shopkeeper, since it is valid only when in a shop.
|
|
*/
|
|
static struct monst *shopkeeper = 0;
|
|
static struct bill_x *bill;
|
|
static int shlevel = 0; /* level of this shopkeeper */
|
|
struct obj *billobjs; /* objects on bill with bp->useup */
|
|
/* only accessed here and by save & restore */
|
|
static long int total; /* filled by addupbill() */
|
|
static long int followmsg; /* last time of follow message */
|
|
|
|
/*
|
|
invariants: obj->unpaid iff onbill(obj) [unless bp->useup]
|
|
obj->quan <= bp->bquan
|
|
*/
|
|
|
|
|
|
const char shtypes[] = { /* 8 shoptypes: 7 specialized, 1 mixed */
|
|
RING_SYM, WAND_SYM, WEAPON_SYM, FOOD_SYM, SCROLL_SYM,
|
|
POTION_SYM, ARMOR_SYM, 0
|
|
};
|
|
|
|
static const char *const shopnam[] = {
|
|
"engagement ring", "walking cane", "antique weapon",
|
|
"delicatessen", "second hand book", "liquor",
|
|
"used armor", "assorted antiques"
|
|
};
|
|
|
|
char *
|
|
shkname(mtmp) /* called in do_name.c */
|
|
struct monst *mtmp;
|
|
{
|
|
return (ESHK(mtmp)->shknam);
|
|
}
|
|
|
|
void
|
|
shkdead(mtmp) /* called in mon.c */
|
|
struct monst *mtmp;
|
|
{
|
|
struct eshk *eshk = ESHK(mtmp);
|
|
|
|
if (eshk->shoplevel == dlevel)
|
|
rooms[eshk->shoproom].rtype = 0;
|
|
if (mtmp == shopkeeper) {
|
|
setpaid();
|
|
shopkeeper = 0;
|
|
bill = (struct bill_x *) - 1000; /* dump core when
|
|
* referenced */
|
|
}
|
|
}
|
|
|
|
void
|
|
replshk(mtmp, mtmp2)
|
|
struct monst *mtmp, *mtmp2;
|
|
{
|
|
if (mtmp == shopkeeper) {
|
|
shopkeeper = mtmp2;
|
|
bill = &(ESHK(shopkeeper)->bill[0]);
|
|
}
|
|
}
|
|
|
|
static void
|
|
setpaid()
|
|
{ /* caller has checked that shopkeeper exists */
|
|
/* either we paid or left the shop or he just died */
|
|
struct obj *obj;
|
|
struct monst *mtmp;
|
|
for (obj = invent; obj; obj = obj->nobj)
|
|
obj->unpaid = 0;
|
|
for (obj = fobj; obj; obj = obj->nobj)
|
|
obj->unpaid = 0;
|
|
for (obj = fcobj; obj; obj = obj->nobj)
|
|
obj->unpaid = 0;
|
|
for (mtmp = fmon; mtmp; mtmp = mtmp->nmon)
|
|
for (obj = mtmp->minvent; obj; obj = obj->nobj)
|
|
obj->unpaid = 0;
|
|
for (mtmp = fallen_down; mtmp; mtmp = mtmp->nmon)
|
|
for (obj = mtmp->minvent; obj; obj = obj->nobj)
|
|
obj->unpaid = 0;
|
|
while ((obj = billobjs) != NULL) {
|
|
billobjs = obj->nobj;
|
|
free((char *) obj);
|
|
}
|
|
ESHK(shopkeeper)->billct = 0;
|
|
}
|
|
|
|
static void
|
|
addupbill()
|
|
{ /* delivers result in total */
|
|
/* caller has checked that shopkeeper exists */
|
|
int ct = ESHK(shopkeeper)->billct;
|
|
struct bill_x *bp = bill;
|
|
total = 0;
|
|
while (ct--) {
|
|
total += bp->price * bp->bquan;
|
|
bp++;
|
|
}
|
|
}
|
|
|
|
int
|
|
inshop()
|
|
{
|
|
int roomno = inroom(u.ux, u.uy);
|
|
|
|
/* Did we just leave a shop? */
|
|
if (u.uinshop &&
|
|
(u.uinshop != roomno + 1 || shlevel != dlevel || !shopkeeper)) {
|
|
if (shopkeeper) {
|
|
if (ESHK(shopkeeper)->billct) {
|
|
if (inroom(shopkeeper->mx, shopkeeper->my)
|
|
== u.uinshop - 1) /* ab@unido */
|
|
pline("Somehow you escaped the shop without paying!");
|
|
addupbill();
|
|
pline("You stole for a total worth of %ld zorkmids.",
|
|
total);
|
|
ESHK(shopkeeper)->robbed += total;
|
|
setpaid();
|
|
if ((rooms[ESHK(shopkeeper)->shoproom].rtype == GENERAL)
|
|
== (rn2(3) == 0))
|
|
ESHK(shopkeeper)->following = 1;
|
|
}
|
|
shopkeeper = 0;
|
|
shlevel = 0;
|
|
}
|
|
u.uinshop = 0;
|
|
}
|
|
/* Did we just enter a zoo of some kind? */
|
|
if (roomno >= 0) {
|
|
int rt = rooms[roomno].rtype;
|
|
struct monst *mtmp;
|
|
if (rt == ZOO) {
|
|
pline("Welcome to David's treasure zoo!");
|
|
} else if (rt == SWAMP) {
|
|
pline("It looks rather muddy down here.");
|
|
} else if (rt == MORGUE) {
|
|
if (midnight())
|
|
pline("Go away! Go away!");
|
|
else
|
|
pline("You get an uncanny feeling ...");
|
|
} else
|
|
rt = 0;
|
|
if (rt != 0) {
|
|
rooms[roomno].rtype = 0;
|
|
for (mtmp = fmon; mtmp; mtmp = mtmp->nmon)
|
|
if (rt != ZOO || !rn2(3))
|
|
mtmp->msleep = 0;
|
|
}
|
|
}
|
|
/* Did we just enter a shop? */
|
|
if (roomno >= 0 && rooms[roomno].rtype >= 8) {
|
|
if (shlevel != dlevel || !shopkeeper
|
|
|| ESHK(shopkeeper)->shoproom != roomno)
|
|
findshk(roomno);
|
|
if (!shopkeeper) {
|
|
rooms[roomno].rtype = 0;
|
|
u.uinshop = 0;
|
|
} else if (!u.uinshop) {
|
|
if (!ESHK(shopkeeper)->visitct ||
|
|
strncmp(ESHK(shopkeeper)->customer, plname, PL_NSIZ)) {
|
|
|
|
/* He seems to be new here */
|
|
ESHK(shopkeeper)->visitct = 0;
|
|
ESHK(shopkeeper)->following = 0;
|
|
(void) strncpy(ESHK(shopkeeper)->customer, plname, PL_NSIZ);
|
|
NOTANGRY(shopkeeper) = 1;
|
|
}
|
|
if (!ESHK(shopkeeper)->following) {
|
|
boolean box, pick;
|
|
|
|
pline("Hello %s! Welcome%s to %s's %s shop!",
|
|
plname,
|
|
ESHK(shopkeeper)->visitct++ ? " again" : "",
|
|
shkname(shopkeeper),
|
|
shopnam[rooms[ESHK(shopkeeper)->shoproom].rtype - 8]);
|
|
box = carrying(ICE_BOX);
|
|
pick = carrying(PICK_AXE);
|
|
if (box || pick) {
|
|
if (dochug(shopkeeper)) {
|
|
u.uinshop = 0; /* he died moving */
|
|
return (0);
|
|
}
|
|
pline("Will you please leave your %s outside?",
|
|
(box && pick) ? "box and pick-axe" :
|
|
box ? "box" : "pick-axe");
|
|
}
|
|
}
|
|
u.uinshop = roomno + 1;
|
|
}
|
|
}
|
|
return (u.uinshop);
|
|
}
|
|
|
|
static void
|
|
findshk(roomno)
|
|
int roomno;
|
|
{
|
|
struct monst *mtmp;
|
|
for (mtmp = fmon; mtmp; mtmp = mtmp->nmon)
|
|
if (mtmp->isshk && ESHK(mtmp)->shoproom == roomno
|
|
&& ESHK(mtmp)->shoplevel == dlevel) {
|
|
shopkeeper = mtmp;
|
|
bill = &(ESHK(shopkeeper)->bill[0]);
|
|
shlevel = dlevel;
|
|
if (ANGRY(shopkeeper) &&
|
|
strncmp(ESHK(shopkeeper)->customer, plname, PL_NSIZ))
|
|
NOTANGRY(shopkeeper) = 1;
|
|
/*
|
|
* billobjs = 0; -- this is wrong if we save in a
|
|
* shop
|
|
*/
|
|
/*
|
|
* (and it is harmless to have too many things in
|
|
* billobjs)
|
|
*/
|
|
return;
|
|
}
|
|
shopkeeper = 0;
|
|
shlevel = 0;
|
|
bill = (struct bill_x *) - 1000; /* dump core when referenced */
|
|
}
|
|
|
|
static struct bill_x *
|
|
onbill(obj)
|
|
struct obj *obj;
|
|
{
|
|
struct bill_x *bp;
|
|
if (!shopkeeper)
|
|
return (0);
|
|
for (bp = bill; bp < &bill[ESHK(shopkeeper)->billct]; bp++)
|
|
if (bp->bo_id == obj->o_id) {
|
|
if (!obj->unpaid)
|
|
pline("onbill: paid obj on bill?");
|
|
return (bp);
|
|
}
|
|
if (obj->unpaid)
|
|
pline("onbill: unpaid obj not on bill?");
|
|
return (0);
|
|
}
|
|
|
|
/* called with two args on merge */
|
|
void
|
|
obfree(obj, merge)
|
|
struct obj *obj, *merge;
|
|
{
|
|
struct bill_x *bp = onbill(obj);
|
|
struct bill_x *bpm;
|
|
if (bp) {
|
|
if (!merge) {
|
|
bp->useup = 1;
|
|
obj->unpaid = 0; /* only for doinvbill */
|
|
obj->nobj = billobjs;
|
|
billobjs = obj;
|
|
return;
|
|
}
|
|
bpm = onbill(merge);
|
|
if (!bpm) {
|
|
/* this used to be a rename */
|
|
impossible("obfree: not on bill??");
|
|
return;
|
|
} else {
|
|
/* this was a merger */
|
|
bpm->bquan += bp->bquan;
|
|
ESHK(shopkeeper)->billct--;
|
|
*bp = bill[ESHK(shopkeeper)->billct];
|
|
}
|
|
}
|
|
free((char *) obj);
|
|
}
|
|
|
|
static void
|
|
pay(tmp, shkp)
|
|
long tmp;
|
|
struct monst *shkp;
|
|
{
|
|
long robbed = ESHK(shkp)->robbed;
|
|
|
|
u.ugold -= tmp;
|
|
shkp->mgold += tmp;
|
|
flags.botl = 1;
|
|
if (robbed) {
|
|
robbed -= tmp;
|
|
if (robbed < 0)
|
|
robbed = 0;
|
|
ESHK(shkp)->robbed = robbed;
|
|
}
|
|
}
|
|
|
|
int
|
|
dopay()
|
|
{
|
|
long ltmp;
|
|
struct bill_x *bp;
|
|
struct monst *shkp;
|
|
int pass, tmp;
|
|
|
|
multi = 0;
|
|
(void) inshop();
|
|
for (shkp = fmon; shkp; shkp = shkp->nmon)
|
|
if (shkp->isshk && dist(shkp->mx, shkp->my) < 3)
|
|
break;
|
|
if (!shkp && u.uinshop &&
|
|
inroom(shopkeeper->mx, shopkeeper->my) == ESHK(shopkeeper)->shoproom)
|
|
shkp = shopkeeper;
|
|
|
|
if (!shkp) {
|
|
pline("There is nobody here to receive your payment.");
|
|
return (0);
|
|
}
|
|
ltmp = ESHK(shkp)->robbed;
|
|
if (shkp != shopkeeper && NOTANGRY(shkp)) {
|
|
if (!ltmp) {
|
|
pline("You do not owe %s anything.", monnam(shkp));
|
|
} else if (!u.ugold) {
|
|
pline("You have no money.");
|
|
} else {
|
|
long ugold = u.ugold;
|
|
|
|
if (u.ugold > ltmp) {
|
|
pline("You give %s the %ld gold pieces he asked for.",
|
|
monnam(shkp), ltmp);
|
|
pay(ltmp, shkp);
|
|
} else {
|
|
pline("You give %s all your gold.", monnam(shkp));
|
|
pay(u.ugold, shkp);
|
|
}
|
|
if (ugold < ltmp / 2) {
|
|
pline("Unfortunately, he doesn't look satisfied.");
|
|
} else {
|
|
ESHK(shkp)->robbed = 0;
|
|
ESHK(shkp)->following = 0;
|
|
if (ESHK(shkp)->shoplevel != dlevel) {
|
|
/*
|
|
* For convenience's sake, let him
|
|
* disappear
|
|
*/
|
|
shkp->minvent = 0; /* %% */
|
|
shkp->mgold = 0;
|
|
mondead(shkp);
|
|
}
|
|
}
|
|
}
|
|
return (1);
|
|
}
|
|
if (!ESHK(shkp)->billct) {
|
|
pline("You do not owe %s anything.", monnam(shkp));
|
|
if (!u.ugold) {
|
|
pline("Moreover, you have no money.");
|
|
return (1);
|
|
}
|
|
if (ESHK(shkp)->robbed) {
|
|
#define min(a,b) ((a<b)?a:b)
|
|
pline("But since his shop has been robbed recently,");
|
|
pline("you %srepay %s's expenses.",
|
|
(u.ugold < ESHK(shkp)->robbed) ? "partially " : "",
|
|
monnam(shkp));
|
|
pay(min(u.ugold, ESHK(shkp)->robbed), shkp);
|
|
ESHK(shkp)->robbed = 0;
|
|
return (1);
|
|
}
|
|
if (ANGRY(shkp)) {
|
|
pline("But in order to appease %s,",
|
|
amonnam(shkp, "angry"));
|
|
if (u.ugold >= 1000) {
|
|
ltmp = 1000;
|
|
pline(" you give him 1000 gold pieces.");
|
|
} else {
|
|
ltmp = u.ugold;
|
|
pline(" you give him all your money.");
|
|
}
|
|
pay(ltmp, shkp);
|
|
if (strncmp(ESHK(shkp)->customer, plname, PL_NSIZ)
|
|
|| rn2(3)) {
|
|
pline("%s calms down.", Monnam(shkp));
|
|
NOTANGRY(shkp) = 1;
|
|
} else
|
|
pline("%s is as angry as ever.",
|
|
Monnam(shkp));
|
|
}
|
|
return (1);
|
|
}
|
|
if (shkp != shopkeeper) {
|
|
impossible("dopay: not to shopkeeper?");
|
|
if (shopkeeper)
|
|
setpaid();
|
|
return (0);
|
|
}
|
|
for (pass = 0; pass <= 1; pass++) {
|
|
tmp = 0;
|
|
while (tmp < ESHK(shopkeeper)->billct) {
|
|
bp = &bill[tmp];
|
|
if (!pass && !bp->useup) {
|
|
tmp++;
|
|
continue;
|
|
}
|
|
if (!dopayobj(bp))
|
|
return (1);
|
|
bill[tmp] = bill[--ESHK(shopkeeper)->billct];
|
|
}
|
|
}
|
|
pline("Thank you for shopping in %s's %s store!",
|
|
shkname(shopkeeper),
|
|
shopnam[rooms[ESHK(shopkeeper)->shoproom].rtype - 8]);
|
|
NOTANGRY(shopkeeper) = 1;
|
|
return (1);
|
|
}
|
|
|
|
/* return 1 if paid successfully */
|
|
/* 0 if not enough money */
|
|
/* -1 if object could not be found (but was paid) */
|
|
static int
|
|
dopayobj(bp)
|
|
struct bill_x *bp;
|
|
{
|
|
struct obj *obj;
|
|
long ltmp;
|
|
|
|
/* find the object on one of the lists */
|
|
obj = bp_to_obj(bp);
|
|
|
|
if (!obj) {
|
|
impossible("Shopkeeper administration out of order.");
|
|
setpaid(); /* be nice to the player */
|
|
return (0);
|
|
}
|
|
if (!obj->unpaid && !bp->useup) {
|
|
impossible("Paid object on bill??");
|
|
return (1);
|
|
}
|
|
obj->unpaid = 0;
|
|
ltmp = bp->price * bp->bquan;
|
|
if (ANGRY(shopkeeper))
|
|
ltmp += ltmp / 3;
|
|
if (u.ugold < ltmp) {
|
|
pline("You don't have gold enough to pay %s.",
|
|
doname(obj));
|
|
obj->unpaid = 1;
|
|
return (0);
|
|
}
|
|
pay(ltmp, shopkeeper);
|
|
pline("You bought %s for %ld gold piece%s.",
|
|
doname(obj), ltmp, plur(ltmp));
|
|
if (bp->useup) {
|
|
struct obj *otmp = billobjs;
|
|
if (obj == billobjs)
|
|
billobjs = obj->nobj;
|
|
else {
|
|
while (otmp && otmp->nobj != obj)
|
|
otmp = otmp->nobj;
|
|
if (otmp)
|
|
otmp->nobj = obj->nobj;
|
|
else
|
|
pline("Error in shopkeeper administration.");
|
|
}
|
|
free((char *) obj);
|
|
}
|
|
return (1);
|
|
}
|
|
|
|
/* routine called after dying (or quitting) with nonempty bill */
|
|
void
|
|
paybill()
|
|
{
|
|
if (shlevel == dlevel && shopkeeper && ESHK(shopkeeper)->billct) {
|
|
addupbill();
|
|
if (total > u.ugold) {
|
|
shopkeeper->mgold += u.ugold;
|
|
u.ugold = 0;
|
|
pline("%s comes and takes all your possessions.",
|
|
Monnam(shopkeeper));
|
|
} else {
|
|
u.ugold -= total;
|
|
shopkeeper->mgold += total;
|
|
pline("%s comes and takes the %ld zorkmids you owed him.",
|
|
Monnam(shopkeeper), total);
|
|
}
|
|
setpaid(); /* in case we create bones */
|
|
}
|
|
}
|
|
|
|
/* find obj on one of the lists */
|
|
struct obj *
|
|
bp_to_obj(bp)
|
|
struct bill_x *bp;
|
|
{
|
|
struct obj *obj;
|
|
struct monst *mtmp;
|
|
unsigned id = bp->bo_id;
|
|
|
|
if (bp->useup)
|
|
obj = o_on(id, billobjs);
|
|
else if (!(obj = o_on(id, invent)) &&
|
|
!(obj = o_on(id, fobj)) &&
|
|
!(obj = o_on(id, fcobj))) {
|
|
for (mtmp = fmon; mtmp; mtmp = mtmp->nmon)
|
|
if ((obj = o_on(id, mtmp->minvent)) != NULL)
|
|
break;
|
|
for (mtmp = fallen_down; mtmp; mtmp = mtmp->nmon)
|
|
if ((obj = o_on(id, mtmp->minvent)) != NULL)
|
|
break;
|
|
}
|
|
return (obj);
|
|
}
|
|
|
|
/* called in hack.c when we pickup an object */
|
|
void
|
|
addtobill(obj)
|
|
struct obj *obj;
|
|
{
|
|
struct bill_x *bp;
|
|
if (!inshop() ||
|
|
(u.ux == ESHK(shopkeeper)->shk.x && u.uy == ESHK(shopkeeper)->shk.y) ||
|
|
(u.ux == ESHK(shopkeeper)->shd.x && u.uy == ESHK(shopkeeper)->shd.y) ||
|
|
onbill(obj) /* perhaps we threw it away earlier */
|
|
)
|
|
return;
|
|
if (ESHK(shopkeeper)->billct == BILLSZ) {
|
|
pline("You got that for free!");
|
|
return;
|
|
}
|
|
bp = &bill[ESHK(shopkeeper)->billct];
|
|
bp->bo_id = obj->o_id;
|
|
bp->bquan = obj->quan;
|
|
bp->useup = 0;
|
|
bp->price = getprice(obj);
|
|
ESHK(shopkeeper)->billct++;
|
|
obj->unpaid = 1;
|
|
}
|
|
|
|
void
|
|
splitbill(obj, otmp)
|
|
struct obj *obj, *otmp;
|
|
{
|
|
/* otmp has been split off from obj */
|
|
struct bill_x *bp;
|
|
int tmp;
|
|
bp = onbill(obj);
|
|
if (!bp) {
|
|
impossible("splitbill: not on bill?");
|
|
return;
|
|
}
|
|
if (bp->bquan < otmp->quan) {
|
|
impossible("Negative quantity on bill??");
|
|
}
|
|
if (bp->bquan == otmp->quan) {
|
|
impossible("Zero quantity on bill??");
|
|
}
|
|
bp->bquan -= otmp->quan;
|
|
|
|
/* addtobill(otmp); */
|
|
if (ESHK(shopkeeper)->billct == BILLSZ)
|
|
otmp->unpaid = 0;
|
|
else {
|
|
tmp = bp->price;
|
|
bp = &bill[ESHK(shopkeeper)->billct];
|
|
bp->bo_id = otmp->o_id;
|
|
bp->bquan = otmp->quan;
|
|
bp->useup = 0;
|
|
bp->price = tmp;
|
|
ESHK(shopkeeper)->billct++;
|
|
}
|
|
}
|
|
|
|
void
|
|
subfrombill(obj)
|
|
struct obj *obj;
|
|
{
|
|
long ltmp;
|
|
int tmp;
|
|
struct obj *otmp;
|
|
struct bill_x *bp;
|
|
if (!inshop() || (u.ux == ESHK(shopkeeper)->shk.x && u.uy == ESHK(shopkeeper)->shk.y) ||
|
|
(u.ux == ESHK(shopkeeper)->shd.x && u.uy == ESHK(shopkeeper)->shd.y))
|
|
return;
|
|
if ((bp = onbill(obj)) != 0) {
|
|
obj->unpaid = 0;
|
|
if (bp->bquan > obj->quan) {
|
|
otmp = newobj(0);
|
|
*otmp = *obj;
|
|
bp->bo_id = otmp->o_id = flags.ident++;
|
|
otmp->quan = (bp->bquan -= obj->quan);
|
|
otmp->owt = 0; /* superfluous */
|
|
otmp->onamelth = 0;
|
|
bp->useup = 1;
|
|
otmp->nobj = billobjs;
|
|
billobjs = otmp;
|
|
return;
|
|
}
|
|
ESHK(shopkeeper)->billct--;
|
|
*bp = bill[ESHK(shopkeeper)->billct];
|
|
return;
|
|
}
|
|
if (obj->unpaid) {
|
|
pline("%s didn't notice.", Monnam(shopkeeper));
|
|
obj->unpaid = 0;
|
|
return; /* %% */
|
|
}
|
|
/* he dropped something of his own - probably wants to sell it */
|
|
if (shopkeeper->msleep || shopkeeper->mfroz ||
|
|
inroom(shopkeeper->mx, shopkeeper->my) != ESHK(shopkeeper)->shoproom)
|
|
return;
|
|
if (ESHK(shopkeeper)->billct == BILLSZ ||
|
|
((tmp = shtypes[rooms[ESHK(shopkeeper)->shoproom].rtype - 8]) && tmp != obj->olet)
|
|
|| strchr("_0", obj->olet)) {
|
|
pline("%s seems not interested.", Monnam(shopkeeper));
|
|
return;
|
|
}
|
|
ltmp = getprice(obj) * obj->quan;
|
|
if (ANGRY(shopkeeper)) {
|
|
ltmp /= 3;
|
|
NOTANGRY(shopkeeper) = 1;
|
|
} else
|
|
ltmp /= 2;
|
|
if (ESHK(shopkeeper)->robbed) {
|
|
if ((ESHK(shopkeeper)->robbed -= ltmp) < 0)
|
|
ESHK(shopkeeper)->robbed = 0;
|
|
pline("Thank you for your contribution to restock this recently plundered shop.");
|
|
return;
|
|
}
|
|
if (ltmp > shopkeeper->mgold)
|
|
ltmp = shopkeeper->mgold;
|
|
pay(-ltmp, shopkeeper);
|
|
if (!ltmp)
|
|
pline("%s gladly accepts %s but cannot pay you at present.",
|
|
Monnam(shopkeeper), doname(obj));
|
|
else
|
|
pline("You sold %s and got %ld gold piece%s.", doname(obj), ltmp,
|
|
plur(ltmp));
|
|
}
|
|
|
|
int
|
|
doinvbill(mode)
|
|
int mode; /* 0: deliver count 1: paged */
|
|
{
|
|
struct bill_x *bp;
|
|
struct obj *obj;
|
|
long totused, thisused;
|
|
char buf[BUFSZ];
|
|
|
|
if (mode == 0) {
|
|
int cnt = 0;
|
|
|
|
if (shopkeeper)
|
|
for (bp = bill; bp - bill < ESHK(shopkeeper)->billct; bp++)
|
|
if (bp->useup ||
|
|
((obj = bp_to_obj(bp)) && obj->quan < bp->bquan))
|
|
cnt++;
|
|
return (cnt);
|
|
}
|
|
if (!shopkeeper) {
|
|
impossible("doinvbill: no shopkeeper?");
|
|
return (0);
|
|
}
|
|
set_pager(0);
|
|
if (page_line("Unpaid articles already used up:") || page_line(""))
|
|
goto quit;
|
|
|
|
totused = 0;
|
|
for (bp = bill; bp - bill < ESHK(shopkeeper)->billct; bp++) {
|
|
obj = bp_to_obj(bp);
|
|
if (!obj) {
|
|
impossible("Bad shopkeeper administration.");
|
|
goto quit;
|
|
}
|
|
if (bp->useup || bp->bquan > obj->quan) {
|
|
int cnt, oquan, uquan;
|
|
|
|
oquan = obj->quan;
|
|
uquan = (bp->useup ? bp->bquan : bp->bquan - oquan);
|
|
thisused = bp->price * uquan;
|
|
totused += thisused;
|
|
obj->quan = uquan; /* cheat doname */
|
|
(void) sprintf(buf, "x - %s", doname(obj));
|
|
obj->quan = oquan; /* restore value */
|
|
for (cnt = 0; buf[cnt]; cnt++);
|
|
while (cnt < 50)
|
|
buf[cnt++] = ' ';
|
|
(void) sprintf(&buf[cnt], " %5ld zorkmids", thisused);
|
|
if (page_line(buf))
|
|
goto quit;
|
|
}
|
|
}
|
|
(void) sprintf(buf, "Total:%50ld zorkmids", totused);
|
|
if (page_line("") || page_line(buf))
|
|
goto quit;
|
|
set_pager(1);
|
|
return (0);
|
|
quit:
|
|
set_pager(2);
|
|
return (0);
|
|
}
|
|
|
|
static int
|
|
getprice(obj)
|
|
struct obj *obj;
|
|
{
|
|
int tmp, ac;
|
|
|
|
switch (obj->olet) {
|
|
case AMULET_SYM:
|
|
tmp = 10 * rnd(500);
|
|
break;
|
|
case TOOL_SYM:
|
|
tmp = 10 * rnd((obj->otyp == EXPENSIVE_CAMERA) ? 150 : 30);
|
|
break;
|
|
case RING_SYM:
|
|
tmp = 10 * rnd(100);
|
|
break;
|
|
case WAND_SYM:
|
|
tmp = 10 * rnd(100);
|
|
break;
|
|
case SCROLL_SYM:
|
|
tmp = 10 * rnd(50);
|
|
#ifdef MAIL
|
|
if (obj->otyp == SCR_MAIL)
|
|
tmp = rnd(5);
|
|
#endif /* MAIL */
|
|
break;
|
|
case POTION_SYM:
|
|
tmp = 10 * rnd(50);
|
|
break;
|
|
case FOOD_SYM:
|
|
tmp = 10 * rnd(5 + (2000 / realhunger()));
|
|
break;
|
|
case GEM_SYM:
|
|
tmp = 10 * rnd(20);
|
|
break;
|
|
case ARMOR_SYM:
|
|
ac = ARM_BONUS(obj);
|
|
if (ac <= -10) /* probably impossible */
|
|
ac = -9;
|
|
tmp = 100 + ac * ac * rnd(10 + ac);
|
|
break;
|
|
case WEAPON_SYM:
|
|
if (obj->otyp < BOOMERANG)
|
|
tmp = 5 * rnd(10);
|
|
else if (obj->otyp == LONG_SWORD ||
|
|
obj->otyp == TWO_HANDED_SWORD)
|
|
tmp = 10 * rnd(150);
|
|
else
|
|
tmp = 10 * rnd(75);
|
|
break;
|
|
case CHAIN_SYM:
|
|
pline("Strange ..., carrying a chain?");
|
|
case BALL_SYM:
|
|
tmp = 10;
|
|
break;
|
|
default:
|
|
tmp = 10000;
|
|
}
|
|
return (tmp);
|
|
}
|
|
|
|
static int
|
|
realhunger()
|
|
{ /* not completely foolproof */
|
|
int tmp = u.uhunger;
|
|
struct obj *otmp = invent;
|
|
while (otmp) {
|
|
if (otmp->olet == FOOD_SYM && !otmp->unpaid)
|
|
tmp += objects[otmp->otyp].nutrition;
|
|
otmp = otmp->nobj;
|
|
}
|
|
return ((tmp <= 0) ? 1 : tmp);
|
|
}
|
|
|
|
int
|
|
shkcatch(obj)
|
|
struct obj *obj;
|
|
{
|
|
struct monst *shkp = shopkeeper;
|
|
|
|
if (u.uinshop && shkp && !shkp->mfroz && !shkp->msleep &&
|
|
u.dx && u.dy &&
|
|
inroom(u.ux + u.dx, u.uy + u.dy) + 1 == u.uinshop &&
|
|
shkp->mx == ESHK(shkp)->shk.x && shkp->my == ESHK(shkp)->shk.y &&
|
|
u.ux == ESHK(shkp)->shd.x && u.uy == ESHK(shkp)->shd.y) {
|
|
pline("%s nimbly catches the %s.", Monnam(shkp), xname(obj));
|
|
obj->nobj = shkp->minvent;
|
|
shkp->minvent = obj;
|
|
return (1);
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* shk_move: return 1: he moved 0: he didnt -1: let m_move do it
|
|
*/
|
|
int
|
|
shk_move(shkp)
|
|
struct monst *shkp;
|
|
{
|
|
struct monst *mtmp;
|
|
const struct permonst *mdat = shkp->data;
|
|
xchar gx, gy, omx, omy, nx, ny, nix, niy;
|
|
schar appr, i;
|
|
int udist;
|
|
int z;
|
|
schar shkroom, chi, chcnt, cnt;
|
|
boolean uondoor = 0, satdoor, avoid = 0, badinv;
|
|
coord poss[9];
|
|
int info[9];
|
|
struct obj *ib = 0;
|
|
|
|
omx = shkp->mx;
|
|
omy = shkp->my;
|
|
|
|
if ((udist = dist(omx, omy)) < 3) {
|
|
if (ANGRY(shkp)) {
|
|
(void) hitu(shkp, d(mdat->damn, mdat->damd) + 1);
|
|
return (0);
|
|
}
|
|
if (ESHK(shkp)->following) {
|
|
if (strncmp(ESHK(shkp)->customer, plname, PL_NSIZ)) {
|
|
pline("Hello %s! I was looking for %s.",
|
|
plname, ESHK(shkp)->customer);
|
|
ESHK(shkp)->following = 0;
|
|
return (0);
|
|
}
|
|
if (!ESHK(shkp)->robbed) { /* impossible? */
|
|
ESHK(shkp)->following = 0;
|
|
return (0);
|
|
}
|
|
if (moves > followmsg + 4) {
|
|
pline("Hello %s! Didn't you forget to pay?",
|
|
plname);
|
|
followmsg = moves;
|
|
}
|
|
if (udist < 2)
|
|
return (0);
|
|
}
|
|
}
|
|
shkroom = inroom(omx, omy);
|
|
appr = 1;
|
|
gx = ESHK(shkp)->shk.x;
|
|
gy = ESHK(shkp)->shk.y;
|
|
satdoor = (gx == omx && gy == omy);
|
|
if (ESHK(shkp)->following || ((z = holetime()) >= 0 && z * z <= udist)) {
|
|
gx = u.ux;
|
|
gy = u.uy;
|
|
if (shkroom < 0 || shkroom != inroom(u.ux, u.uy))
|
|
if (udist > 4)
|
|
return (-1); /* leave it to m_move */
|
|
} else if (ANGRY(shkp)) {
|
|
long saveBlind = Blind;
|
|
Blind = 0;
|
|
if (shkp->mcansee && !Invis && cansee(omx, omy)) {
|
|
gx = u.ux;
|
|
gy = u.uy;
|
|
}
|
|
Blind = saveBlind;
|
|
avoid = FALSE;
|
|
} else {
|
|
#define GDIST(x,y) ((x-gx)*(x-gx)+(y-gy)*(y-gy))
|
|
if (Invis)
|
|
avoid = FALSE;
|
|
else {
|
|
uondoor = (u.ux == ESHK(shkp)->shd.x &&
|
|
u.uy == ESHK(shkp)->shd.y);
|
|
if (uondoor) {
|
|
if (ESHK(shkp)->billct)
|
|
pline("Hello %s! Will you please pay before leaving?",
|
|
plname);
|
|
badinv = (carrying(PICK_AXE) || carrying(ICE_BOX));
|
|
if (satdoor && badinv)
|
|
return (0);
|
|
avoid = !badinv;
|
|
} else {
|
|
avoid = (u.uinshop && dist(gx, gy) > 8);
|
|
badinv = FALSE;
|
|
}
|
|
|
|
if (((!ESHK(shkp)->robbed && !ESHK(shkp)->billct) || avoid)
|
|
&& GDIST(omx, omy) < 3) {
|
|
if (!badinv && !online(omx, omy))
|
|
return (0);
|
|
if (satdoor)
|
|
appr = gx = gy = 0;
|
|
}
|
|
}
|
|
}
|
|
if (omx == gx && omy == gy)
|
|
return (0);
|
|
if (shkp->mconf) {
|
|
avoid = FALSE;
|
|
appr = 0;
|
|
}
|
|
nix = omx;
|
|
niy = omy;
|
|
cnt = mfndpos(shkp, poss, info, ALLOW_SSM);
|
|
if (avoid && uondoor) { /* perhaps we cannot avoid him */
|
|
for (i = 0; i < cnt; i++)
|
|
if (!(info[i] & NOTONL))
|
|
goto notonl_ok;
|
|
avoid = FALSE;
|
|
notonl_ok:
|
|
;
|
|
}
|
|
chi = -1;
|
|
chcnt = 0;
|
|
for (i = 0; i < cnt; i++) {
|
|
nx = poss[i].x;
|
|
ny = poss[i].y;
|
|
if (levl[nx][ny].typ == ROOM
|
|
|| shkroom != ESHK(shkp)->shoproom
|
|
|| ESHK(shkp)->following) {
|
|
#ifdef STUPID
|
|
/* cater for stupid compilers */
|
|
int zz;
|
|
#endif /* STUPID */
|
|
if (uondoor && (ib = sobj_at(ICE_BOX, nx, ny))) {
|
|
nix = nx;
|
|
niy = ny;
|
|
chi = i;
|
|
break;
|
|
}
|
|
if (avoid && (info[i] & NOTONL))
|
|
continue;
|
|
if ((!appr && !rn2(++chcnt)) ||
|
|
#ifdef STUPID
|
|
(appr && (zz = GDIST(nix, niy)) && zz > GDIST(nx, ny))
|
|
#else
|
|
(appr && GDIST(nx, ny) < GDIST(nix, niy))
|
|
#endif /* STUPID */
|
|
) {
|
|
nix = nx;
|
|
niy = ny;
|
|
chi = i;
|
|
}
|
|
}
|
|
}
|
|
if (nix != omx || niy != omy) {
|
|
if (info[chi] & ALLOW_M) {
|
|
mtmp = m_at(nix, niy);
|
|
if (hitmm(shkp, mtmp) == 1 && rn2(3) &&
|
|
hitmm(mtmp, shkp) == 2)
|
|
return (2);
|
|
return (0);
|
|
} else if (info[chi] & ALLOW_U) {
|
|
(void) hitu(shkp, d(mdat->damn, mdat->damd) + 1);
|
|
return (0);
|
|
}
|
|
shkp->mx = nix;
|
|
shkp->my = niy;
|
|
pmon(shkp);
|
|
if (ib) {
|
|
freeobj(ib);
|
|
mpickobj(shkp, ib);
|
|
}
|
|
return (1);
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
/* He is digging in the shop. */
|
|
void
|
|
shopdig(fall)
|
|
int fall;
|
|
{
|
|
if (!fall) {
|
|
if (u.utraptype == TT_PIT)
|
|
pline("\"Be careful, sir, or you might fall through the floor.\"");
|
|
else
|
|
pline("\"Please, do not damage the floor here.\"");
|
|
} else if (dist(shopkeeper->mx, shopkeeper->my) < 3) {
|
|
struct obj *obj, *obj2;
|
|
|
|
pline("%s grabs your backpack!", shkname(shopkeeper));
|
|
for (obj = invent; obj; obj = obj2) {
|
|
obj2 = obj->nobj;
|
|
if (obj->owornmask)
|
|
continue;
|
|
freeinv(obj);
|
|
obj->nobj = shopkeeper->minvent;
|
|
shopkeeper->minvent = obj;
|
|
if (obj->unpaid)
|
|
subfrombill(obj);
|
|
}
|
|
}
|
|
}
|
|
#endif /* QUEST */
|
|
|
|
int
|
|
online(int x, int y)
|
|
{
|
|
return (x == u.ux || y == u.uy ||
|
|
(x - u.ux) * (x - u.ux) == (y - u.uy) * (y - u.uy));
|
|
}
|
|
|
|
/* Does this monster follow me downstairs? */
|
|
int
|
|
follower(mtmp)
|
|
struct monst *mtmp;
|
|
{
|
|
return (mtmp->mtame || strchr("1TVWZi&, ", mtmp->data->mlet)
|
|
#ifndef QUEST
|
|
|| (mtmp->isshk && ESHK(mtmp)->following)
|
|
#endif /* QUEST */
|
|
);
|
|
}
|