/*
* playhand:
* Do up one hand of the game
*/
int
playhand(bool mycrib)
{
int deckpos;
werase(Compwin);
wrefresh(Compwin);
werase(Tablewin);
wrefresh(Tablewin);
knownum = 0;
deckpos = deal(mycrib);
sorthand(chand, FULLHAND);
sorthand(phand, FULLHAND);
makeknown(chand, FULLHAND);
prhand(phand, FULLHAND, Playwin, FALSE);
discard(mycrib);
if (cut(mycrib, deckpos))
return TRUE;
if (peg(mycrib))
return TRUE;
werase(Tablewin);
wrefresh(Tablewin);
if (score(mycrib))
return TRUE;
return FALSE;
}
/*
* cut:
* Cut the deck and set turnover. Actually, we only ASK the
* player what card to turn. We do a random one, anyway.
*/
int
cut(bool mycrib, int pos)
{
int i;
bool win;
win = FALSE;
if (mycrib) {
if (!rflag) { /* random cut */
char *foo;
/* This is silly, but we should parse user input,
* even if we're not actually going to use it.
*/
do {
msg(quiet ? "Cut the deck? " :
"How many cards down do you wish to cut the deck? ");
foo = get_line();
if (*foo != '\0' && ((i = atoi(foo)) < 4 || i > 36))
msg("Invalid cut");
else
*foo = '\0';
} while (*foo != '\0');
}
i = arc4random_uniform(CARDS - pos);
turnover = deck[i + pos];
addmsg(quiet ? "You cut " : "You cut the ");
msgcard(turnover, FALSE);
endmsg();
prcrib(mycrib, FALSE);
if (turnover.rank == JACK) {
msg("I get two for his heels");
win = chkscr(&cscore, 2);
}
} else {
i = arc4random_uniform(CARDS - pos) + pos;
turnover = deck[i];
addmsg(quiet ? "I cut " : "I cut the ");
msgcard(turnover, FALSE);
endmsg();
prcrib(mycrib, FALSE);
if (turnover.rank == JACK) {
msg("You get two for his heels");
win = chkscr(&pscore, 2);
}
}
makeknown(&turnover, 1);
return (win);
}
static void m_dowear_type(struct monst *mon, long flag, boolean creation,
boolean racialexception)
{
struct obj *old, *best, *obj;
int m_delay = 0;
int unseen = !canseemon(mon);
char nambuf[BUFSZ];
if (mon->mfrozen) return; /* probably putting previous item on */
/* Get a copy of monster's name before altering its visibility */
strcpy(nambuf, See_invisible ? Monnam(mon) : mon_nam(mon));
old = which_armor(mon, flag);
if (old && old->cursed) return;
if (old && flag == W_AMUL) return; /* no such thing as better amulets */
best = old;
for (obj = mon->minvent; obj; obj = obj->nobj) {
switch(flag) {
case W_AMUL:
if (obj->oclass != AMULET_CLASS ||
(obj->otyp != AMULET_OF_LIFE_SAVING &&
obj->otyp != AMULET_OF_REFLECTION))
continue;
best = obj;
goto outer_break; /* no such thing as better amulets */
case W_ARMU:
if (!is_shirt(obj)) continue;
break;
case W_ARMC:
if (!is_cloak(obj)) continue;
break;
case W_ARMH:
if (!is_helmet(obj)) continue;
/* (flimsy exception matches polyself handling) */
if (has_horns(mon->data) && !is_flimsy(obj)) continue;
break;
case W_ARMS:
if (!is_shield(obj)) continue;
break;
case W_ARMG:
if (!is_gloves(obj)) continue;
break;
case W_ARMF:
if (!is_boots(obj)) continue;
break;
case W_ARM:
if (!is_suit(obj)) continue;
if (racialexception && (racial_exception(mon, obj) < 1)) continue;
break;
}
if (obj->owornmask) continue;
/* I'd like to define a VISIBLE_ARM_BONUS which doesn't assume the
* monster knows obj->spe, but if I did that, a monster would keep
* switching forever between two -2 caps since when it took off one
* it would forget spe and once again think the object is better
* than what it already has.
*/
if (best && (ARM_BONUS(best) + extra_pref(mon,best) >= ARM_BONUS(obj) + extra_pref(mon,obj)))
continue;
best = obj;
}
outer_break:
if (!best || best == old) return;
/* if wearing a cloak, account for the time spent removing
and re-wearing it when putting on a suit or shirt */
if ((flag == W_ARM || flag == W_ARMU) && (mon->misc_worn_check & W_ARMC))
m_delay += 2;
/* when upgrading a piece of armor, account for time spent
taking off current one */
if (old)
m_delay += objects[old->otyp].oc_delay;
if (old) /* do this first to avoid "(being worn)" */
old->owornmask = 0L;
if (!creation) {
if (canseemon(mon)) {
char buf[BUFSZ];
if (old)
sprintf(buf, " removes %s and", distant_name(old, doname));
else
buf[0] = '\0';
pline("%s%s puts on %s.", Monnam(mon),
buf, distant_name(best,doname));
} /* can see it */
m_delay += objects[best->otyp].oc_delay;
mon->mfrozen = m_delay;
if (mon->mfrozen) mon->mcanmove = 0;
}
if (old)
update_mon_intrinsics(mon, old, FALSE, creation);
mon->misc_worn_check |= flag;
best->owornmask |= flag;
update_mon_intrinsics(mon, best, TRUE, creation);
/* if couldn't see it but now can, or vice versa, */
if (!creation && (unseen ^ !canseemon(mon))) {
if (mon->minvis && !See_invisible) {
pline("Suddenly you cannot see %s.", nambuf);
makeknown(best->otyp);
} /* else if (!mon->minvis) pline("%s suddenly appears!", Amonnam(mon)); */
}
}
void mon_adjust_speed(struct monst *mon,
int adjust, /* positive => increase speed, negative => decrease */
struct obj *obj) /* item to make known if effect can be seen */
{
struct obj *otmp;
boolean give_msg = !in_mklev, petrify = FALSE;
unsigned int oldspeed = mon->mspeed;
switch (adjust) {
case 2:
mon->permspeed = MFAST;
give_msg = FALSE; /* special case monster creation */
break;
case 1:
if (mon->permspeed == MSLOW) mon->permspeed = 0;
else mon->permspeed = MFAST;
break;
case 0: /* just check for worn speed boots */
break;
case -1:
if (mon->permspeed == MFAST) mon->permspeed = 0;
else mon->permspeed = MSLOW;
break;
case -2:
mon->permspeed = MSLOW;
give_msg = FALSE; /* (not currently used) */
break;
case -3: /* petrification */
/* take away intrinsic speed but don't reduce normal speed */
if (mon->permspeed == MFAST) mon->permspeed = 0;
petrify = TRUE;
break;
}
for (otmp = mon->minvent; otmp; otmp = otmp->nobj)
if (otmp->owornmask && objects[otmp->otyp].oc_oprop == FAST)
break;
if (otmp) /* speed boots */
mon->mspeed = MFAST;
else
mon->mspeed = mon->permspeed;
if (give_msg && (mon->mspeed != oldspeed || petrify) && canseemon(mon)) {
/* fast to slow (skipping intermediate state) or vice versa */
const char *howmuch = (mon->mspeed + oldspeed == MFAST + MSLOW) ?
"much " : "";
if (petrify) {
/* mimic the player's petrification countdown; "slowing down"
even if fast movement rate retained via worn speed boots */
if (flags.verbose) pline("%s is slowing down.", Monnam(mon));
} else if (adjust > 0 || mon->mspeed == MFAST)
pline("%s is suddenly moving %sfaster.", Monnam(mon), howmuch);
else
pline("%s seems to be moving %sslower.", Monnam(mon), howmuch);
/* might discover an object if we see the speed change happen, but
avoid making possibly forgotten book known when casting its spell */
if (obj != 0 && obj->dknown &&
objects[obj->otyp].oc_class != SPBOOK_CLASS)
makeknown(obj->otyp);
}
}
/* return 1 if action took 1 (or more) moves, 0 if error or aborted */
int doengrave(struct obj *otmp)
{
boolean dengr = FALSE; /* TRUE if we wipe out the current engraving */
boolean doblind = FALSE;/* TRUE if engraving blinds the player */
boolean doknown = FALSE;/* TRUE if we identify the stylus */
boolean eow = FALSE; /* TRUE if we are overwriting oep */
boolean jello = FALSE; /* TRUE if we are engraving in slime */
boolean ptext = TRUE; /* TRUE if we must prompt for engrave text */
boolean teleengr =FALSE;/* TRUE if we move the old engraving */
boolean zapwand = FALSE;/* TRUE if we remove a wand charge */
xchar type = DUST; /* Type of engraving made */
char buf[BUFSZ]; /* Buffer for final/poly engraving text */
char ebuf[BUFSZ]; /* Buffer for initial engraving text */
char qbuf[QBUFSZ]; /* Buffer for query text */
char post_engr_text[BUFSZ]; /* Text displayed after engraving prompt */
const char *everb; /* Present tense of engraving type */
const char *eloc; /* Where the engraving is (ie dust/floor/...) */
char *sp; /* Place holder for space count of engr text */
int len; /* # of nonspace chars of new engraving text */
int maxelen; /* Max allowable length of engraving text */
struct engr *oep = engr_at(level, u.ux,u.uy);
/* The current engraving */
char *writer;
multi = 0; /* moves consumed */
nomovemsg = NULL; /* occupation end message */
buf[0] = (char)0;
ebuf[0] = (char)0;
post_engr_text[0] = (char)0;
maxelen = BUFSZ - 1;
if (is_demon(youmonst.data) || youmonst.data->mlet == S_VAMPIRE)
type = ENGR_BLOOD;
/* Can the adventurer engrave at all? */
if (u.uswallow) {
if (is_animal(u.ustuck->data)) {
pline("What would you write? \"Jonah was here\"?");
return 0;
} else if (is_whirly(u.ustuck->data)) {
pline("You can't reach the %s.", surface(u.ux,u.uy));
return 0;
} else
jello = TRUE;
} else if (is_lava(level, u.ux, u.uy)) {
pline("You can't write on the lava!");
return 0;
} else if (Underwater) {
pline("You can't write underwater!");
return 0;
} else if (is_pool(level, u.ux,u.uy) || IS_FOUNTAIN(level->locations[u.ux][u.uy].typ)) {
pline("You can't write on the water!");
return 0;
}
if (Is_airlevel(&u.uz) || Is_waterlevel(&u.uz)/* in bubble */) {
pline("You can't write in thin air!");
return 0;
}
if (cantwield(youmonst.data)) {
pline("You can't even hold anything!");
return 0;
}
if (check_capacity(NULL)) return 0;
/* One may write with finger, or weapon, or wand, or..., or...
* Edited by GAN 10/20/86 so as not to change weapon wielded.
*/
if (otmp && !validate_object(otmp, styluses, "write with"))
return 0;
else if (!otmp)
otmp = getobj(styluses, "write with");
if (!otmp) return 0; /* otmp == zeroobj if fingers */
if (otmp == &zeroobj) writer = makeplural(body_part(FINGER));
else writer = xname(otmp);
/* There's no reason you should be able to write with a wand
* while both your hands are tied up.
*/
if (!freehand() && otmp != uwep && !otmp->owornmask) {
pline("You have no free %s to write with!", body_part(HAND));
return 0;
}
if (jello) {
pline("You tickle %s with your %s.", mon_nam(u.ustuck), writer);
pline("Your message dissolves...");
return 0;
}
if (otmp->oclass != WAND_CLASS && !can_reach_floor()) {
pline("You can't reach the %s!", surface(u.ux,u.uy));
return 0;
}
if (IS_ALTAR(level->locations[u.ux][u.uy].typ)) {
pline("You make a motion towards the altar with your %s.", writer);
altar_wrath(u.ux, u.uy);
return 0;
}
if (IS_GRAVE(level->locations[u.ux][u.uy].typ)) {
if (otmp == &zeroobj) { /* using only finger */
pline("You would only make a small smudge on the %s.",
surface(u.ux, u.uy));
return 0;
} else if (!level->locations[u.ux][u.uy].disturbed) {
pline("You disturb the undead!");
level->locations[u.ux][u.uy].disturbed = 1;
makemon(&mons[PM_GHOUL], level, u.ux, u.uy, NO_MM_FLAGS);
exercise(A_WIS, FALSE);
return 1;
}
}
/* SPFX for items */
switch (otmp->oclass) {
default:
case AMULET_CLASS:
case CHAIN_CLASS:
case POTION_CLASS:
case COIN_CLASS:
break;
case RING_CLASS:
/* "diamond" rings and others should work */
case GEM_CLASS:
/* diamonds & other hard gems should work */
if (objects[otmp->otyp].oc_tough) {
type = ENGRAVE;
break;
}
break;
case ARMOR_CLASS:
if (is_boots(otmp)) {
type = DUST;
break;
}
/* fall through */
/* Objects too large to engrave with */
case BALL_CLASS:
case ROCK_CLASS:
pline("You can't engrave with such a large object!");
ptext = FALSE;
break;
/* Objects too silly to engrave with */
case FOOD_CLASS:
case SCROLL_CLASS:
case SPBOOK_CLASS:
pline("Your %s would get %s.", xname(otmp),
is_ice(level, u.ux, u.uy) ? "all frosty" : "too dirty");
ptext = FALSE;
break;
case RANDOM_CLASS: /* This should mean fingers */
break;
/* The charge is removed from the wand before prompting for
* the engraving text, because all kinds of setup decisions
* and pre-engraving messages are based upon knowing what type
* of engraving the wand is going to do. Also, the player
* will have potentially seen "You wrest .." message, and
* therefore will know they are using a charge.
*/
case WAND_CLASS:
if (zappable(otmp)) {
check_unpaid(otmp);
zapwand = TRUE;
if (Levitation) ptext = FALSE;
switch (otmp->otyp) {
/* DUST wands */
default:
break;
/* NODIR wands */
case WAN_LIGHT:
case WAN_SECRET_DOOR_DETECTION:
case WAN_CREATE_MONSTER:
case WAN_WISHING:
case WAN_ENLIGHTENMENT:
zapnodir(otmp);
break;
/* IMMEDIATE wands */
/* If wand is "IMMEDIATE", remember to affect the
* previous engraving even if turning to dust.
*/
case WAN_STRIKING:
strcpy(post_engr_text,
"The wand unsuccessfully fights your attempt to write!"
);
break;
case WAN_SLOW_MONSTER:
if (!Blind) {
sprintf(post_engr_text,
"The bugs on the %s slow down!",
surface(u.ux, u.uy));
}
break;
case WAN_SPEED_MONSTER:
if (!Blind) {
sprintf(post_engr_text,
"The bugs on the %s speed up!",
surface(u.ux, u.uy));
}
break;
case WAN_POLYMORPH:
if (oep) {
if (!Blind) {
type = (xchar)0; /* random */
random_engraving(buf);
}
dengr = TRUE;
}
break;
case WAN_NOTHING:
case WAN_UNDEAD_TURNING:
case WAN_OPENING:
case WAN_LOCKING:
case WAN_PROBING:
break;
/* RAY wands */
case WAN_MAGIC_MISSILE:
ptext = TRUE;
if (!Blind) {
sprintf(post_engr_text,
"The %s is riddled by bullet holes!",
surface(u.ux, u.uy));
}
break;
/* can't tell sleep from death - Eric Backus */
case WAN_SLEEP:
case WAN_DEATH:
if (!Blind) {
sprintf(post_engr_text,
"The bugs on the %s stop moving!",
surface(u.ux, u.uy));
}
break;
case WAN_COLD:
if (!Blind)
strcpy(post_engr_text,
"A few ice cubes drop from the wand.");
if (!oep || (oep->engr_type != BURN))
break;
case WAN_CANCELLATION:
case WAN_MAKE_INVISIBLE:
if (oep && oep->engr_type != HEADSTONE) {
if (!Blind)
pline("The engraving on the %s vanishes!",
surface(u.ux,u.uy));
dengr = TRUE;
}
break;
case WAN_TELEPORTATION:
if (oep && oep->engr_type != HEADSTONE) {
if (!Blind)
pline("The engraving on the %s vanishes!",
surface(u.ux,u.uy));
teleengr = TRUE;
}
break;
/* type = ENGRAVE wands */
case WAN_DIGGING:
ptext = TRUE;
type = ENGRAVE;
if (!objects[otmp->otyp].oc_name_known) {
if (flags.verbose)
pline("This %s is a wand of digging!",
xname(otmp));
doknown = TRUE;
}
if (!Blind)
strcpy(post_engr_text,
IS_GRAVE(level->locations[u.ux][u.uy].typ) ?
"Chips fly out from the headstone." :
is_ice(level, u.ux, u.uy) ?
"Ice chips fly up from the ice surface!" :
"Gravel flies up from the floor.");
else
strcpy(post_engr_text, "You hear drilling!");
break;
/* type = BURN wands */
case WAN_FIRE:
ptext = TRUE;
type = BURN;
if (!objects[otmp->otyp].oc_name_known) {
if (flags.verbose)
pline("This %s is a wand of fire!", xname(otmp));
doknown = TRUE;
}
strcpy(post_engr_text,
Blind ? "You feel the wand heat up." :
"Flames fly from the wand.");
break;
case WAN_LIGHTNING:
ptext = TRUE;
type = BURN;
if (!objects[otmp->otyp].oc_name_known) {
if (flags.verbose)
pline("This %s is a wand of lightning!",
xname(otmp));
doknown = TRUE;
}
if (!Blind) {
strcpy(post_engr_text,
"Lightning arcs from the wand.");
doblind = TRUE;
} else
strcpy(post_engr_text, "You hear crackling!");
break;
/* type = MARK wands */
/* type = ENGR_BLOOD wands */
}
} else /* end if zappable */
if (!can_reach_floor()) {
pline("You can't reach the %s!", surface(u.ux,u.uy));
/* If it's a wrestable wand, the player wasted a
turn trying. */
if (wrestable(otmp))
return 1;
else
return 0;
}
break;
case WEAPON_CLASS:
if (is_blade(otmp)) {
if ((int)otmp->spe > -3)
type = ENGRAVE;
else
pline("Your %s too dull for engraving.", aobjnam(otmp,"are"));
}
break;
case TOOL_CLASS:
if (otmp == ublindf) {
pline(
"That is a bit difficult to engrave with, don't you think?");
return 0;
}
switch (otmp->otyp) {
case MAGIC_MARKER:
if (otmp->spe <= 0)
pline("Your marker has dried out.");
else
type = MARK;
break;
case TOWEL:
/* Can't really engrave with a towel */
ptext = FALSE;
if (oep)
if ((oep->engr_type == DUST ) ||
(oep->engr_type == ENGR_BLOOD) ||
(oep->engr_type == MARK )) {
if (!Blind)
pline("You wipe out the message here.");
else
pline("Your %s %s %s.", xname(otmp),
otense(otmp, "get"),
is_ice(level, u.ux, u.uy) ?
"frosty" : "dusty");
dengr = TRUE;
} else
pline("Your %s can't wipe out this engraving.",
xname(otmp));
else
pline("Your %s %s %s.", xname(otmp), otense(otmp, "get"),
is_ice(level, u.ux, u.uy) ? "frosty" : "dusty");
break;
default:
break;
}
break;
case VENOM_CLASS:
if (wizard) {
pline("Writing a poison pen letter??");
break;
}
case ILLOBJ_CLASS:
impossible("You're engraving with an illegal object!");
break;
}
if (IS_GRAVE(level->locations[u.ux][u.uy].typ)) {
if (type == ENGRAVE || type == 0)
type = HEADSTONE;
else {
/* ensures the "cannot wipe out" case */
type = DUST;
dengr = FALSE;
teleengr = FALSE;
buf[0] = (char)0;
}
}
/* End of implement setup */
/* Identify stylus */
if (doknown) {
makeknown(otmp->otyp);
more_experienced(0,10);
}
if (teleengr) {
rloc_engr(oep);
oep = NULL;
}
if (dengr) {
del_engr(oep, level);
oep = NULL;
}
/* Something has changed the engraving here */
if (*buf) {
make_engr_at(level, u.ux, u.uy, buf, moves, type);
pline("The engraving now reads: \"%s\".", buf);
ptext = FALSE;
}
if (zapwand && (otmp->spe < 0)) {
pline("%s %sturns to dust.",
The(xname(otmp)), Blind ? "" : "glows violently, then ");
if (!IS_GRAVE(level->locations[u.ux][u.uy].typ))
pline("You are not going to get anywhere trying to write in the %s with your dust.",
is_ice(level, u.ux, u.uy) ? "frost" : "dust");
useup(otmp);
ptext = FALSE;
}
if (!ptext) { /* Early exit for some implements. */
if (otmp->oclass == WAND_CLASS && !can_reach_floor())
pline("You can't reach the %s!", surface(u.ux,u.uy));
return 1;
}
/* Special effects should have deleted the current engraving (if
* possible) by now.
*/
if (oep) {
char c = 'n';
/* Give player the choice to add to engraving. */
if (type == HEADSTONE) {
/* no choice, only append */
c = 'y';
} else if ( (type == oep->engr_type) && (!Blind ||
(oep->engr_type == BURN) || (oep->engr_type == ENGRAVE)) ) {
c = yn_function("Do you want to add to the current engraving?",
ynqchars, 'y');
if (c == 'q') {
pline("Never mind.");
return 0;
}
}
if (c == 'n' || Blind) {
if ( (oep->engr_type == DUST) || (oep->engr_type == ENGR_BLOOD) ||
(oep->engr_type == MARK) ) {
if (!Blind) {
pline("You wipe out the message that was %s here.",
((oep->engr_type == DUST) ? "written in the dust" :
((oep->engr_type == ENGR_BLOOD) ? "scrawled in blood" :
"written")));
del_engr(oep, level);
oep = NULL;
} else
/* Don't delete engr until after we *know* we're engraving */
eow = TRUE;
} else
if ( (type == DUST) || (type == MARK) || (type == ENGR_BLOOD) ) {
pline(
"You cannot wipe out the message that is %s the %s here.",
oep->engr_type == BURN ?
(is_ice(level, u.ux, u.uy) ? "melted into" : "burned into") :
"engraved in", surface(u.ux,u.uy));
return 1;
} else
if ( (type != oep->engr_type) || (c == 'n') ) {
if (!Blind || can_reach_floor())
pline("You will overwrite the current message.");
eow = TRUE;
}
}
}
eloc = surface(u.ux,u.uy);
switch(type){
default:
everb = (oep && !eow ? "add to the weird writing on" :
"write strangely on");
break;
case DUST:
everb = (oep && !eow ? "add to the writing in" :
"write in");
eloc = is_ice(level, u.ux, u.uy) ? "frost" : "dust";
break;
case HEADSTONE:
everb = (oep && !eow ? "add to the epitaph on" :
"engrave on");
break;
case ENGRAVE:
everb = (oep && !eow ? "add to the engraving in" :
"engrave in");
break;
case BURN:
everb = (oep && !eow ?
( is_ice(level, u.ux,u.uy) ? "add to the text melted into" :
"add to the text burned into") :
( is_ice(level, u.ux,u.uy) ? "melt into" : "burn into"));
break;
case MARK:
everb = (oep && !eow ? "add to the graffiti on" :
"scribble on");
break;
case ENGR_BLOOD:
everb = (oep && !eow ? "add to the scrawl on" :
"scrawl on");
break;
}
/* Tell adventurer what is going on */
if (otmp != &zeroobj)
pline("You %s the %s with %s.", everb, eloc, doname(otmp));
else
pline("You %s the %s with your %s.", everb, eloc,
makeplural(body_part(FINGER)));
/* Prompt for engraving! */
sprintf(qbuf,"What do you want to %s the %s here?", everb, eloc);
getlin(qbuf, ebuf);
/* Count the actual # of chars engraved not including spaces */
len = strlen(ebuf);
for (sp = ebuf; *sp; sp++) if (isspace(*sp)) len -= 1;
if (len == 0 || strchr(ebuf, '\033')) {
if (zapwand) {
if (!Blind)
pline("%s, then %s.",
Tobjnam(otmp, "glow"), otense(otmp, "fade"));
return 1;
} else {
pline("Never mind.");
if (otmp && otmp->oclass == WAND_CLASS && wrestable(otmp))
return 1; /* disallow zero turn wrest */
else
return 0;
}
}
/* A single `x' is the traditional signature of an illiterate person */
if (len != 1 || (!strchr(ebuf, 'x') && !strchr(ebuf, 'X')))
u.uconduct.literate++;
/* Mix up engraving if surface or state of mind is unsound.
Note: this won't add or remove any spaces. */
for (sp = ebuf; *sp; sp++) {
if (isspace(*sp)) continue;
if (((type == DUST || type == ENGR_BLOOD) && !rn2(25)) ||
(Blind && !rn2(11)) || (Confusion && !rn2(7)) ||
(Stunned && !rn2(4)) || (Hallucination && !rn2(2)))
*sp = ' ' + rnd(96 - 2); /* ASCII '!' thru '~'
(excludes ' ' and DEL) */
}
/* Previous engraving is overwritten */
if (eow) {
del_engr(oep, level);
oep = NULL;
}
/* Figure out how long it took to engrave, and if player has
* engraved too much.
*/
switch(type){
default:
multi = -(len/10);
if (multi) nomovemsg = "You finish your weird engraving.";
break;
case DUST:
multi = -(len/10);
if (multi) nomovemsg = "You finish writing in the dust.";
break;
case HEADSTONE:
case ENGRAVE:
multi = -(len/10);
if ((otmp->oclass == WEAPON_CLASS) &&
((otmp->otyp != ATHAME) || otmp->cursed)) {
multi = -len;
maxelen = ((otmp->spe + 3) * 2) + 1;
/* -2 = 3, -1 = 5, 0 = 7, +1 = 9, +2 = 11
* Note: this does not allow a +0 anything (except
* an athame) to engrave "Elbereth" all at once.
* However, you could now engrave "Elb", then
* "ere", then "th".
*/
pline("Your %s dull.", aobjnam(otmp, "get"));
if (otmp->unpaid) {
struct monst *shkp = shop_keeper(level, *u.ushops);
if (shkp) {
pline("You damage it, you pay for it!");
bill_dummy_object(otmp);
}
}
if (len > maxelen) {
multi = -maxelen;
otmp->spe = -3;
} else if (len > 1)
otmp->spe -= len >> 1;
else otmp->spe -= 1; /* Prevent infinite engraving */
} else
int
study_book(struct obj *spellbook, const struct nh_cmd_arg *arg)
{
int booktype = spellbook->otyp;
boolean confused = (Confusion != 0);
boolean too_hard = FALSE;
if (u.uoccupation_progress[tos_book] && !confused &&
spellbook == u.utracked[tos_book] &&
/* handle the sequence: start reading, get interrupted, have book
become erased somehow, resume reading it */
booktype != SPE_BLANK_PAPER) {
if (turnstate.continue_message)
pline("You continue your efforts to memorize the spell.");
} else {
/* Restarting reading the book */
/* KMH -- Simplified this code */
if (booktype == SPE_BLANK_PAPER) {
pline("This spellbook is all blank.");
makeknown(booktype);
return 1;
}
switch (objects[booktype].oc_level) {
case 1:
case 2:
u.uoccupation_progress[tos_book] = -objects[booktype].oc_delay;
break;
case 3:
case 4:
u.uoccupation_progress[tos_book] =
-(objects[booktype].oc_level - 1) * objects[booktype].oc_delay;
break;
case 5:
case 6:
u.uoccupation_progress[tos_book] =
-objects[booktype].oc_level * objects[booktype].oc_delay;
break;
case 7:
u.uoccupation_progress[tos_book] = -8 * objects[booktype].oc_delay;
break;
default:
impossible("Unknown spellbook level %d, book %d;",
objects[booktype].oc_level, booktype);
return 0;
}
/* Books are often wiser than their readers (Rus.) */
spellbook->in_use = TRUE;
if (!spellbook->blessed && spellbook->otyp != SPE_BOOK_OF_THE_DEAD) {
if (spellbook->cursed) {
too_hard = TRUE;
} else {
/* uncursed - chance to fail */
int read_ability =
ACURR(A_INT) + 4 + u.ulevel / 2 -
2 * objects[booktype].oc_level +
((ublindf && ublindf->otyp == LENSES) ? 2 : 0);
/* only wizards know if a spell is too difficult */
if (Role_if(PM_WIZARD) && read_ability < 20 && !confused) {
const char *qbuf;
qbuf = msgprintf("This spellbook is %sdifficult to "
"comprehend. Continue?",
(read_ability < 12 ? "very " : ""));
if (yn(qbuf) != 'y') {
spellbook->in_use = FALSE;
return 1;
}
}
/* it's up to random luck now */
if (rnd(20) > read_ability) {
too_hard = TRUE;
}
}
}
if (too_hard) {
boolean gone = cursed_book(spellbook);
helpless(-u.uoccupation_progress[tos_book], hr_paralyzed,
"frozen by a spellbook", NULL);
u.uoccupation_progress[tos_book] = 0;
if (gone || !rn2(3)) {
if (!gone)
pline("The spellbook crumbles to dust!");
if (!objects[spellbook->otyp].oc_name_known &&
!objects[spellbook->otyp].oc_uname)
docall(spellbook);
useup(spellbook);
} else
spellbook->in_use = FALSE;
return 1;
} else if (confused) {
if (!confused_book(spellbook)) {
spellbook->in_use = FALSE;
}
helpless(-u.uoccupation_progress[tos_book], hr_busy,
"absorbed in a spellbook",
"You're finally able to put the book down.");
u.uoccupation_progress[tos_book] = 0;
u.utracked[tos_book] = 0;
return 1;
}
spellbook->in_use = FALSE;
pline("You begin to %s the runes.",
spellbook->otyp == SPE_BOOK_OF_THE_DEAD ? "recite" : "memorize");
}
u.utracked[tos_book] = spellbook;
one_occupation_turn(learn, "studying", occ_book);
return 1;
}
/* Handles one turn of book reading. Returns 1 if unfinished, 0 if finshed. */
static int
learn(void)
{
int i;
short booktype;
boolean costly = TRUE;
boolean already_known = FALSE;
int first_unknown = MAXSPELL;
int known_spells = 0;
const char *splname;
/* JDS: lenses give 50% faster reading; 33% smaller read time */
if (u.uoccupation_progress[tos_book] &&
ublindf && ublindf->otyp == LENSES && rn2(2))
u.uoccupation_progress[tos_book]++;
if (Confusion) { /* became confused while learning */
confused_book(u.utracked[tos_book]);
u.utracked[tos_book] = 0; /* no longer studying */
helpless(-u.uoccupation_progress[tos_book], hr_busy,
"absorbed in a spellbook",
"You're finally able to put the book down.");
u.uoccupation_progress[tos_book] = 0;
return 0;
}
booktype = u.utracked[tos_book]->otyp;
if (booktype == SPE_BOOK_OF_THE_DEAD) {
deadbook(u.utracked[tos_book], FALSE);
u.utracked[tos_book] = 0;
u.uoccupation_progress[tos_book] = 0;
return 0;
}
/* The book might get cursed while we're reading it. In this case,
immediately stop reading it, cancel progress, and apply a few turns of
helplessness. (3.4.3 applies negative spellbook effects but lets you
memorize the spell anyway; this makes no sense. It destroys the spellbook
on the "contact poison" result, which makes even less sense.) */
if (u.utracked[tos_book]->cursed) {
pline("This book isn't making sense any more.");
helpless(rn1(5,5), hr_busy,
"making sense of a spellbook",
"You give up trying to make sense of the spellbook.");
u.uoccupation_progress[tos_book] = 0;
u.utracked[tos_book] = 0;
return 0;
}
if (++u.uoccupation_progress[tos_book] < 0)
return 1; /* still busy */
if (ACURR(A_WIS) < 12)
exercise(A_WIS, TRUE); /* you're studying. */
splname = msgprintf(objects[booktype].oc_name_known ?
"\"%s\"" : "the \"%s\" spell",
OBJ_NAME(objects[booktype]));
for (i = 0; i < MAXSPELL; i++) {
if (spellid(i) == booktype) {
already_known = TRUE;
if (u.utracked[tos_book]->spestudied > MAX_SPELL_STUDY) {
pline("This spellbook is too faint to be read any more.");
u.utracked[tos_book]->otyp = booktype = SPE_BLANK_PAPER;
} else if (spellknow(i) <= 1000) {
pline("Your knowledge of %s is keener.", splname);
incrnknow(i);
u.utracked[tos_book]->spestudied++;
if (ACURR(A_WIS) < 12)
exercise(A_WIS, TRUE); /* extra study */
} else { /* 1000 < spellknow(i) <= MAX_SPELL_STUDY */
pline("You know %s quite well already.", splname);
if (yn("Do you want to read the book anyway?") == 'y') {
pline("You refresh your knowledge of %s.", splname);
incrnknow(i);
u.utracked[tos_book]->spestudied++;
} else
costly = FALSE;
}
/* make book become known even when spell is already known, in case
amnesia made you forget the book */
makeknown((int)booktype);
break;
} else if (spellid(i) == NO_SPELL &&
(i < first_unknown ||
i == spellno_from_let(objects[booktype].oc_defletter)))
first_unknown = i;
else
known_spells++;
}
if (first_unknown == MAXSPELL && !already_known)
panic("Too many spells memorized!");
if (!already_known) {
spl_book[first_unknown].sp_id = booktype;
spl_book[first_unknown].sp_lev = objects[booktype].oc_level;
incrnknow(first_unknown);
u.utracked[tos_book]->spestudied++;
pline(known_spells > 0 ? "You add %s to your repertoire." :
"You learn %s.", splname);
makeknown((int)booktype);
}
if (costly)
check_unpaid(u.utracked[tos_book]);
u.utracked[tos_book] = 0;
return 0;
}
/* special effects for The Book of the Dead */
void
deadbook(struct obj *book2, boolean invoked)
{
struct monst *mtmp, *mtmp2;
coord mm;
if (!invoked)
pline("You turn the pages of the Book of the Dead...");
makeknown(SPE_BOOK_OF_THE_DEAD);
/* KMH -- Need ->known to avoid "_a_ Book of the Dead" */
book2->known = 1;
if (invocation_pos(&u.uz, u.ux, u.uy) && !On_stairs(u.ux, u.uy)) {
struct obj *otmp;
boolean arti1_primed = FALSE, arti2_primed = FALSE, arti_cursed = FALSE;
if (invoked) {
if (Blind)
You_hear("a crisp flicker...");
else
pline("The Book of the Dead opens of its own accord...");
}
if (book2->cursed) {
if (invoked) {
if (Hallucination)
You_hear("gratuitous bleeping.");
else
You_hear("a mumbled curse.");
} else
pline("The runes appear scrambled. You can't read them!");
return;
}
if (!Uhave_bell || !Uhave_menorah) {
pline("A chill runs down your %s.", body_part(SPINE));
if (!Uhave_bell) {
if (Hallucination)
pline("You feel like a tuning fork!");
else
You_hear("a faint chime...");
}
if (!Uhave_menorah) {
if (Hallucination) {
pline("Nosferatu giggles.");
} else if (mvitals[PM_DOPPELGANGER].mvflags & G_GENOD) {
/* suggestion by b_jonas: can't talk about doppelgangers
if they don't exist */
if (Uhave_bell)
pline("Nothing seems to happen.");
/* otherwise no message, we already printed one. */
} else {
pline("Vlad's doppelganger is amused.");
}
}
return;
}
for (otmp = invent; otmp; otmp = otmp->nobj) {
if (otmp->otyp == CANDELABRUM_OF_INVOCATION && otmp->spe == 7 &&
otmp->lamplit) {
if (!otmp->cursed)
arti1_primed = TRUE;
else
arti_cursed = TRUE;
}
if (otmp->otyp == BELL_OF_OPENING && (moves - otmp->age) < 5L) {
/* you rang it recently */
if (!otmp->cursed)
arti2_primed = TRUE;
else
arti_cursed = TRUE;
}
}
if (arti_cursed) {
pline("The invocation fails!");
if (Hallucination)
pline("At least one of your heirlooms is in a tizzy!");
else
pline("At least one of your artifacts is cursed...");
} else if (arti1_primed && arti2_primed) {
unsigned soon = (unsigned)dice(2, 6); /* time til next intervene */
/* successful invocation */
mkinvokearea();
u.uevent.invoked = 1;
historic_event(FALSE, TRUE, "performed the invocation.");
/* in case you haven't killed the Wizard yet, behave as if you just
did */
u.uevent.udemigod = 1; /* wizdead() */
if (!u.udg_cnt || u.udg_cnt > soon)
u.udg_cnt = soon;
} else { /* at least one artifact not prepared properly */
pline("You have a feeling that something is amiss...");
goto raise_dead;
}
return;
}
/* when not an invocation situation */
if (invoked) {
pline("Nothing happens.");
return;
}
if (book2->cursed) {
raise_dead:
if (Hallucination)
You_hear("Michael Jackson dancing!");
else
pline("You raised the dead!");
/* first maybe place a dangerous adversary; don't bother with
MM_CREATEMONSTER, that's mostly used to ensure that consistent
species of monsters generate */
if (!rn2(3) &&
((mtmp = makemon(&mons[PM_MASTER_LICH], level, u.ux, u.uy,
NO_MINVENT)) != 0 ||
(mtmp = makemon(&mons[PM_NALFESHNEE], level, u.ux, u.uy,
NO_MINVENT)) != 0)) {
msethostility(mtmp, TRUE, TRUE);
}
/* next handle the effect on things you're carrying */
unturn_dead(&youmonst);
/* last place some monsters around you */
mm.x = u.ux;
mm.y = u.uy;
mkundead(level, &mm, TRUE, NO_MINVENT);
} else if (book2->blessed) {
for (mtmp = level->monlist; mtmp; mtmp = mtmp2) {
mtmp2 = mtmp->nmon; /* tamedog() changes chain */
if (DEADMONSTER(mtmp))
continue;
if (is_undead(mtmp->data) && cansee(mtmp->mx, mtmp->my)) {
msethostility(mtmp, FALSE, FALSE); /* TODO: reset alignment? */
if (sgn(mtmp->data->maligntyp) == sgn(u.ualign.type)
&& distu(mtmp->mx, mtmp->my) < 4)
if (mtmp->mtame) {
if (mtmp->mtame < 20)
mtmp->mtame++;
} else
tamedog(mtmp, NULL);
else
monflee(mtmp, 0, FALSE, TRUE);
}
}
} else {
switch (rn2(3)) {
case 0:
pline("Your ancestors are annoyed with you!");
break;
case 1:
pline("The headstones in the cemetery begin to move!");
break;
default:
pline("Oh my! Your name appears in the book!");
}
}
return;
}
int chwepon(struct obj *otmp, int amount)
{
const char *color = hcolor((amount < 0) ? "black" : "blue");
const char *xtime;
int otyp = STRANGE_OBJECT;
if (!uwep || (uwep->oclass != WEAPON_CLASS && !is_weptool(uwep))) {
char buf[BUFSZ];
sprintf(buf, "Your %s %s.", makeplural(body_part(HAND)),
(amount >= 0) ? "twitch" : "itch");
strange_feeling(otmp, buf);
exercise(A_DEX, (boolean) (amount >= 0));
return 0;
}
if (otmp && otmp->oclass == SCROLL_CLASS) otyp = otmp->otyp;
if (uwep->otyp == WORM_TOOTH && amount >= 0) {
uwep->otyp = CRYSKNIFE;
uwep->oerodeproof = 0;
pline("Your weapon seems sharper now.");
uwep->cursed = 0;
if (otyp != STRANGE_OBJECT) makeknown(otyp);
return 1;
}
if (uwep->otyp == CRYSKNIFE && amount < 0) {
uwep->otyp = WORM_TOOTH;
uwep->oerodeproof = 0;
pline("Your weapon seems duller now.");
if (otyp != STRANGE_OBJECT && otmp->bknown) makeknown(otyp);
return 1;
}
if (amount < 0 && uwep->oartifact && restrict_name(uwep, ONAME(uwep))) {
if (!Blind)
pline("Your %s %s.", aobjnam(uwep, "faintly glow"), color);
return 1;
}
/* there is a (soft) upper and lower limit to uwep->spe */
if (((uwep->spe > 5 && amount >= 0) || (uwep->spe < -5 && amount < 0))
&& rn2(3)) {
if (!Blind)
pline("Your %s %s for a while and then %s.",
aobjnam(uwep, "violently glow"), color,
otense(uwep, "evaporate"));
else
pline("Your %s.", aobjnam(uwep, "evaporate"));
useupall(uwep); /* let all of them disappear */
return 1;
}
if (!Blind) {
xtime = (amount*amount == 1) ? "moment" : "while";
pline("Your %s %s for a %s.",
aobjnam(uwep, amount == 0 ? "violently glow" : "glow"),
color, xtime);
if (otyp != STRANGE_OBJECT && uwep->known &&
(amount > 0 || (amount < 0 && otmp->bknown)))
makeknown(otyp);
}
uwep->spe += amount;
if (amount > 0) uwep->cursed = 0;
/*
* Enchantment, which normally improves a weapon, has an
* addition adverse reaction on Magicbane whose effects are
* spe dependent. Give an obscure clue here.
*/
if (uwep->oartifact == ART_MAGICBANE && uwep->spe >= 0) {
pline("Your right %s %sches!",
body_part(HAND),
(((amount > 1) && (uwep->spe > 1)) ? "flin" : "it"));
}
/* an elven magic clue, cookie@keebler */
/* elven weapons vibrate warningly when enchanted beyond a limit */
if ((uwep->spe > 5)
&& (is_elven_weapon(uwep) || uwep->oartifact || !rn2(7)))
pline("Your %s unexpectedly.",
aobjnam(uwep, "suddenly vibrate"));
return 1;
}
int
doread() {
register struct obj *scroll;
register boolean confused = (Confusion != 0);
known = FALSE;
scroll = getobj(readable, "read"); /* "#-" added by GAN 10/22/86 */
if(!scroll) return(0);
/* below added to allow reading of fortune cookies */
if(scroll->otyp == FORTUNE_COOKIE) {
if(flags.verbose)
You("break up the cookie and throw away the pieces.");
outrumor(bcsign(scroll), TRUE);
useup(scroll);
return(1);
} else
if(scroll->olet != SCROLL_SYM
#ifdef SPELLS
&& scroll->olet != SPBOOK_SYM
#endif
) {
pline("That is a silly thing to read.");
return(0);
}
if(Blind) {
#ifdef SPELLS
if (scroll->olet == SPBOOK_SYM) {
pline("Being blind, you cannot read the mystic runes.");
return(0);
} else
#endif
if (!scroll->dknown) {
pline("Being blind, you cannot read the formula on the scroll.");
return(0);
}
}
#ifndef NO_SIGNAL
scroll->in_use = TRUE; /* now being read */
#endif
#ifdef SPELLS
if(scroll->olet == SPBOOK_SYM) {
if(confused) {
You("cannot grasp the meaning of this tome.");
useup(scroll);
return(0);
} else
return(study_book(scroll));
}
#endif
if(scroll->otyp != SCR_BLANK_PAPER) {
if(Blind)
pline("As you pronounce the formula on it, the scroll disappears.");
else
pline("As you read the scroll, it disappears.");
if(confused) {
if (Hallucination)
pline("Being so trippy, you screw up...");
else
pline("Being confused, you mispronounce the magic words...");
}
}
if(!seffects(scroll)) {
if(!objects[scroll->otyp].oc_name_known) {
if(known && !confused) {
makeknown(scroll->otyp);
more_experienced(0,10);
} else if(!objects[scroll->otyp].oc_uname)
docall(scroll);
}
if(!(scroll->otyp == SCR_BLANK_PAPER) || confused)
useup(scroll);
#ifndef NO_SIGNAL
else scroll->in_use = FALSE;
#endif
}
return(1);
}
/* The player is trying to extract something from his/her instrument. */
static int
do_improvisation(struct obj *instr, const struct nh_cmd_arg *arg)
{
int do_spec = !Confusion;
if (!do_spec)
pline(msgc_yafm, "What you produce is quite far from music...");
else
pline(msgc_occstart, "You start playing %s.", the(xname(instr)));
switch (instr->otyp) {
case MAGIC_FLUTE: /* Make monster fall asleep */
if (do_spec && instr->spe > 0) {
consume_obj_charge(instr, TRUE);
pline(msgc_actionok, "You produce soft music.");
put_monsters_to_sleep(youmonst.m_lev * 5);
exercise(A_DEX, TRUE);
break;
} /* else FALLTHRU */
case WOODEN_FLUTE: /* May charm snakes */
do_spec &= (rn2(ACURR(A_DEX)) + youmonst.m_lev > 25);
pline(do_spec ? msgc_actionok : msgc_failrandom, "%s.",
Tobjnam(instr, do_spec ? "trill" : "toot"));
if (do_spec)
charm_snakes(youmonst.m_lev * 3);
exercise(A_DEX, TRUE);
break;
case FROST_HORN: /* Idem wand of cold */
case FIRE_HORN: /* Idem wand of fire */
if (do_spec && instr->spe > 0) {
schar dx, dy, dz;
consume_obj_charge(instr, TRUE);
if (!getargdir(arg, NULL, &dx, &dy, &dz)) {
pline(msgc_yafm, "%s.", Tobjnam(instr, "vibrate"));
break;
} else {
buzz((instr->otyp == FROST_HORN) ? AD_COLD - 1 : AD_FIRE - 1,
rn1(6, 6), youmonst.mx, youmonst.my, dx, dy, 0);
}
makeknown(instr->otyp);
break;
} /* else FALLTHRU */
case TOOLED_HORN: /* Awaken or scare monsters */
pline(msgc_actionok, "You produce a frightful, grave sound.");
awaken_monsters(&youmonst, youmonst.m_lev * 30);
exercise(A_WIS, FALSE);
break;
case BUGLE: /* Awaken & attract soldiers */
pline(msgc_actionok, "You extract a loud noise from %s.",
the(xname(instr)));
awaken_soldiers(&youmonst);
exercise(A_WIS, FALSE);
break;
case MAGIC_HARP: /* Charm monsters */
if (do_spec && instr->spe > 0) {
consume_obj_charge(instr, TRUE);
pline(msgc_actionok, "%s very attractive music.",
Tobjnam(instr, "produce"));
charm_monsters((youmonst.m_lev - 1) / 3 + 1);
exercise(A_DEX, TRUE);
break;
} /* else FALLTHRU */
case WOODEN_HARP: /* May calm Nymph */
do_spec &= (rn2(ACURR(A_DEX)) + youmonst.m_lev > 25);
pline(do_spec ? msgc_actionok : msgc_failrandom,
"%s %s.", The(xname(instr)),
do_spec ? "produces a lilting melody" : "twangs");
if (do_spec)
calm_nymphs(youmonst.m_lev * 3);
exercise(A_DEX, TRUE);
break;
case DRUM_OF_EARTHQUAKE: /* create several pits */
if (do_spec && instr->spe > 0) {
consume_obj_charge(instr, TRUE);
pline(msgc_occstart, "You produce a heavy, thunderous rolling!");
pline_implied(msgc_occstart,
"The entire dungeon is shaking around you!");
do_earthquake((youmonst.m_lev - 1) / 3 + 1);
/* shake up monsters in a much larger radius... */
awaken_monsters(&youmonst, ROWNO * COLNO);
makeknown(DRUM_OF_EARTHQUAKE);
break;
} /* else FALLTHRU */
case LEATHER_DRUM: /* Awaken monsters */
pline(msgc_actionok, "You beat a deafening row!");
awaken_monsters(&youmonst, youmonst.m_lev * 40);
exercise(A_WIS, FALSE);
break;
default:
impossible("What a weird instrument (%d)!", instr->otyp);
break;
}
return 2; /* That takes time */
}
void
m_throw(struct monst *mon, int x, int y, int dx, int dy, int range,
struct obj *obj, boolean verbose)
{
struct monst *mtmp;
struct obj *singleobj;
struct tmp_sym *tsym = 0;
int hitu, blindinc = 0;
bhitpos.x = x;
bhitpos.y = y;
if (obj->quan == 1L) {
/*
* Remove object from minvent. This cannot be done later on;
* what if the player dies before then, leaving the monster
* with 0 daggers? (This caused the infamous 2^32-1 orcish
* dagger bug).
*
* VENOM is not in minvent - it should already be OBJ_FREE.
* The extract below does nothing.
*/
/* not possibly_unwield, which checks the object's */
/* location, not its existence */
if (MON_WEP(mon) == obj) {
setmnotwielded(mon, obj);
MON_NOWEP(mon);
}
obj_extract_self(obj);
singleobj = obj;
obj = NULL;
} else {
singleobj = splitobj(obj, 1L);
obj_extract_self(singleobj);
}
singleobj->owornmask = 0; /* threw one of multiple weapons in hand? */
singleobj->olev = level; /* object is on the same level as monster */
if ((singleobj->cursed || singleobj->greased) && (dx || dy) && !rn2(7)) {
if (canseemon(mon) && flags.verbose) {
if (is_ammo(singleobj))
pline("%s misfires!", Monnam(mon));
else
pline("%s as %s throws it!", Tobjnam(singleobj, "slip"),
mon_nam(mon));
}
dx = rn2(3) - 1;
dy = rn2(3) - 1;
/* check validity of new direction */
if (!dx && !dy) {
drop_throw(singleobj, 0, bhitpos.x, bhitpos.y);
return;
}
}
/* pre-check for doors, walls and boundaries. Also need to pre-check for
bars regardless of direction; the random chance for small objects
hitting bars is skipped when reaching them at point blank range */
if (!isok(bhitpos.x + dx, bhitpos.y + dy)
|| IS_ROCK(level->locations[bhitpos.x + dx][bhitpos.y + dy].typ)
|| closed_door(level, bhitpos.x + dx, bhitpos.y + dy)
|| (level->locations[bhitpos.x + dx][bhitpos.y + dy].typ == IRONBARS &&
hits_bars(&singleobj, bhitpos.x, bhitpos.y, 0, 0))) {
drop_throw(singleobj, 0, bhitpos.x, bhitpos.y);
return;
}
/* Note: drop_throw may destroy singleobj. Since obj must be destroyed
early to avoid the dagger bug, anyone who modifies this code should be
careful not to use either one after it's been freed. */
tsym = tmpsym_initobj(singleobj);
while (range-- > 0) { /* Actually the loop is always exited by break */
bhitpos.x += dx;
bhitpos.y += dy;
if ((mtmp = m_at(level, bhitpos.x, bhitpos.y)) != 0) {
if (ohitmon(mtmp, singleobj, range, verbose))
break;
} else if (bhitpos.x == u.ux && bhitpos.y == u.uy) {
action_interrupted();
if (singleobj->oclass == GEM_CLASS &&
singleobj->otyp <= LAST_GEM + 9
/* 9 glass colors */
&& is_unicorn(youmonst.data) && !u_helpless(hm_all)) {
if (singleobj->otyp > LAST_GEM) {
pline("You catch the %s.", xname(singleobj));
pline("You are not interested in %s junk.",
s_suffix(mon_nam(mon)));
makeknown(singleobj->otyp);
dropy(singleobj);
} else {
pline("You accept %s gift in the spirit in which it was "
"intended.", s_suffix(mon_nam(mon)));
hold_another_object(singleobj, "You catch, but drop, %s.",
xname(singleobj), "You catch:");
}
break;
}
if (singleobj->oclass == POTION_CLASS) {
if (!Blind)
singleobj->dknown = 1;
potionhit(&youmonst, singleobj, FALSE);
break;
}
switch (singleobj->otyp) {
int dam, hitv;
case EGG:
if (!touch_petrifies(&mons[singleobj->corpsenm])) {
impossible("monster throwing egg type %d",
singleobj->corpsenm);
hitu = 0;
break;
}
/* fall through */
case CREAM_PIE:
case BLINDING_VENOM:
hitu = thitu(8, 0, singleobj, NULL);
break;
default:
dam = dmgval(singleobj, &youmonst);
hitv = 3 - distmin(u.ux, u.uy, mon->mx, mon->my);
if (hitv < -4)
hitv = -4;
if (is_elf(mon->data) &&
objects[singleobj->otyp].oc_skill == P_BOW) {
hitv++;
if (MON_WEP(mon) && MON_WEP(mon)->otyp == ELVEN_BOW)
hitv++;
if (singleobj->otyp == ELVEN_ARROW)
dam++;
}
if (bigmonst(youmonst.data))
hitv++;
hitv += 8 + singleobj->spe;
if (dam < 1)
dam = 1;
if (objects[singleobj->otyp].oc_class == WEAPON_CLASS ||
objects[singleobj->otyp].oc_class == VENOM_CLASS) {
hitv += objects[singleobj->otyp].oc_hitbon;
}
hitu = thitu(hitv, dam, singleobj, NULL);
}
if (hitu && singleobj->opoisoned && is_poisonable(singleobj)) {
poisoned(xname(singleobj), A_STR,
killer_msg_obj(POISONING, singleobj), -10);
}
if (hitu &&
can_blnd(NULL, &youmonst,
(uchar) (singleobj->otyp ==
BLINDING_VENOM ? AT_SPIT : AT_WEAP),
singleobj)) {
blindinc = rnd(25);
if (singleobj->otyp == CREAM_PIE) {
if (!Blind)
pline("Yecch! You've been creamed.");
else
pline("There's something sticky all over your %s.",
body_part(FACE));
} else if (singleobj->otyp == BLINDING_VENOM) {
int num_eyes = eyecount(youmonst.data);
/* venom in the eyes */
if (!Blind)
pline("The venom blinds you.");
else
pline("Your %s sting%s.",
(num_eyes ==
1) ? body_part(EYE) : makeplural(body_part(EYE)),
(num_eyes == 1) ? "s" : "");
}
}
if (hitu && singleobj->otyp == VAMPIRE_BLOOD) {
if (!Drain_resistance) {
losexp("vampire blood", FALSE);
}
}
if (hitu && singleobj->otyp == EGG) {
if (touched_monster(singleobj->corpsenm))
Stoned = 5;
}
action_interrupted();
if (hitu || !range) {
drop_throw(singleobj, hitu, u.ux, u.uy);
break;
}
} else if (!range /* reached end of path */
/* missile hits edge of screen */
|| !isok(bhitpos.x + dx, bhitpos.y + dy)
/* missile hits the wall */
|| IS_ROCK(level->
locations[bhitpos.x + dx][bhitpos.y + dy].typ)
/* missile hit closed door */
|| closed_door(level, bhitpos.x + dx, bhitpos.y + dy)
/* missile might hit iron bars */
|| (level->locations[bhitpos.x + dx][bhitpos.y + dy].typ ==
IRONBARS &&
hits_bars(&singleobj, bhitpos.x, bhitpos.y, !rn2(5), 0))
/* Thrown objects "sink" */
|| IS_SINK(level->locations[bhitpos.x][bhitpos.y].typ)) {
if (singleobj) /* hits_bars might have destroyed it */
drop_throw(singleobj, 0, bhitpos.x, bhitpos.y);
break;
}
tmpsym_at(tsym, bhitpos.x, bhitpos.y);
win_delay_output();
}
tmpsym_at(tsym, bhitpos.x, bhitpos.y);
win_delay_output();
tmpsym_end(tsym);
if (blindinc) {
u.ucreamed += blindinc;
make_blinded(Blinded + (long)blindinc, FALSE);
if (!Blind)
pline("Your vision quickly clears.");
else if (flags.verbose)
pline("Use the command #wipe to clean your %s.", body_part(FACE));
}
}
int
peg(bool mycrib)
{
static CARD ch[CINHAND], ph[CINHAND];
int i, j, k;
int l;
int cnum, pnum, sum;
bool myturn, mego, ugo, last, played;
CARD crd;
played = FALSE;
cnum = pnum = CINHAND;
for (i = 0; i < CINHAND; i++) { /* make copies of hands */
ch[i] = chand[i];
ph[i] = phand[i];
}
Tcnt = 0; /* index to table of cards played */
sum = 0; /* sum of cards played */
mego = ugo = FALSE;
myturn = !mycrib;
for (;;) {
last = TRUE; /* enable last flag */
prhand(ph, pnum, Playwin, FALSE);
prhand(ch, cnum, Compwin, TRUE);
prtable(sum);
if (myturn) {
if (!anymove(ch, cnum, sum)) { /* if no card to play */
if (!mego && cnum) { /* go for comp? */
msg("GO");
mego = TRUE;
}
/* can player move? */
if (anymove(ph, pnum, sum))
myturn = !myturn;
else { /* give him his point */
msg(quiet ? "You get one" :
"You get one point");
do_wait();
if (chkscr(&pscore, 1))
return TRUE;
sum = 0;
mego = ugo = FALSE;
Tcnt = 0;
}
} else {
played = TRUE;
j = -1;
k = 0;
/* maximize score */
for (i = 0; i < cnum; i++) {
l = pegscore(ch[i], Table, Tcnt, sum);
if (l > k) {
k = l;
j = i;
}
}
if (j < 0) /* if nothing scores */
j = cchose(ch, cnum, sum);
crd = ch[j];
cremove(crd, ch, cnum--);
sum += VAL(crd.rank);
Table[Tcnt++] = crd;
if (k > 0) {
addmsg(quiet ? "I get %d playing " :
"I get %d points playing ", k);
msgcard(crd, FALSE);
endmsg();
prhand(ph, pnum, Playwin, FALSE);
prhand(ch, cnum, Compwin, TRUE);
prtable(sum);
if (chkscr(&cscore, k))
return TRUE;
}
myturn = !myturn;
}
} else {
if (!anymove(ph, pnum, sum)) { /* can player move? */
if (!ugo && pnum) { /* go for player */
msg("You have a GO");
ugo = TRUE;
}
/* can computer play? */
if (anymove(ch, cnum, sum))
myturn = !myturn;
else {
msg(quiet ? "I get one" :
"I get one point");
do_wait();
prhand(ph, pnum, Playwin, FALSE);
prhand(ch, cnum, Compwin, TRUE);
prtable(sum);
if (chkscr(&cscore, 1))
return TRUE;
sum = 0;
mego = ugo = FALSE;
Tcnt = 0;
}
} else { /* player plays */
played = FALSE;
if (pnum == 1) {
crd = ph[0];
msg("You play your last card");
} else
for (;;) {
prhand(ph,
pnum, Playwin, FALSE);
crd = ph[infrom(ph,
pnum, "Your play: ")];
if (sum + VAL(crd.rank) <= 31)
break;
else
msg("Total > 31 -- try again");
}
makeknown(&crd, 1);
cremove(crd, ph, pnum--);
i = pegscore(crd, Table, Tcnt, sum);
sum += VAL(crd.rank);
Table[Tcnt++] = crd;
if (i > 0) {
msg(quiet ? "You got %d" :
"You got %d points", i);
if (pnum == 0)
do_wait();
prhand(ph, pnum, Playwin, FALSE);
prhand(ch, cnum, Compwin, TRUE);
prtable(sum);
if (chkscr(&pscore, i))
return TRUE;
}
myturn = !myturn;
}
}
if (sum >= 31) {
if (!myturn)
do_wait();
sum = 0;
mego = ugo = FALSE;
Tcnt = 0;
last = FALSE; /* disable last flag */
}
if (!pnum && !cnum)
break; /* both done */
}
prhand(ph, pnum, Playwin, FALSE);
prhand(ch, cnum, Compwin, TRUE);
prtable(sum);
if (last) {
if (played) {
msg(quiet ? "I get one for last" :
"I get one point for last");
do_wait();
if (chkscr(&cscore, 1))
return TRUE;
} else {
msg(quiet ? "You get one for last" :
"You get one point for last");
do_wait();
if (chkscr(&pscore, 1))
return TRUE;
}
}
return (FALSE);
}
