/*
* Steal gold coins only. Leprechauns don't care for lesser coins.
*/
void stealgold(struct monst *mtmp)
{
struct obj *fgold = gold_at(level, u.ux, u.uy);
struct obj *ygold;
long tmp;
/* skip lesser coins on the floor */
while (fgold && fgold->otyp != GOLD_PIECE) fgold = fgold->nexthere;
/* Do you have real gold? */
ygold = findgold(invent);
if (fgold && ( !ygold || fgold->quan > ygold->quan || !rn2(5))) {
obj_extract_self(fgold);
add_to_minv(mtmp, fgold);
newsym(u.ux, u.uy);
pline("%s quickly snatches some gold from between your %s!",
Monnam(mtmp), makeplural(body_part(FOOT)));
if (!ygold || !rn2(5)) {
if (!tele_restrict(mtmp)) rloc(level, mtmp, FALSE);
monflee(mtmp, 0, FALSE, FALSE);
}
} else if (ygold) {
const int gold_price = objects[GOLD_PIECE].oc_cost;
tmp = (somegold(money_cnt(invent)) + gold_price - 1) / gold_price;
tmp = min(tmp, ygold->quan);
if (tmp < ygold->quan) ygold = splitobj(ygold, tmp);
freeinv(ygold);
add_to_minv(mtmp, ygold);
pline("Your purse feels lighter.");
if (!tele_restrict(mtmp)) rloc(level, mtmp, FALSE);
monflee(mtmp, 0, FALSE, FALSE);
iflags.botl = 1;
}
}
/* returns 1 if it won't attack. */
int
demon_talk(struct monst *mtmp)
{
long cash, demand, offer;
if (uwep && uwep->oartifact == ART_EXCALIBUR) {
pline("%s looks very angry.", Amonnam(mtmp));
msethostility(mtmp, TRUE, TRUE);
return 0;
}
/* Slight advantage given. */
if (is_dprince(mtmp->data) && mtmp->minvis) {
mtmp->minvis = mtmp->perminvis = 0;
if (!Blind)
pline("%s appears before you.", Amonnam(mtmp));
newsym(mtmp->mx, mtmp->my);
}
if (youmonst.data->mlet == S_DEMON) { /* Won't blackmail their own. */
pline("%s says, \"Good hunting, %s.\"", Amonnam(mtmp),
u.ufemale ? "Sister" : "Brother");
if (!tele_restrict(mtmp))
rloc(mtmp, TRUE);
return 1;
}
cash = money_cnt(invent);
/* don't bother with a custom RNG here, too much unpredictability is
involved */
demand = (cash * (rnd(80) + 20 * Athome)) /
(100 * (1 + (sgn(u.ualign.type) == sgn(mtmp->data->maligntyp))));
if (!demand) { /* you have no gold */
msethostility(mtmp, TRUE, TRUE);
return 0;
} else {
/* make sure that the demand is unmeetable if the monster has the
Amulet, preventing monster from being satisified and removed from
the game (along with said Amulet...) */
if (mon_has_amulet(mtmp))
demand = cash + (long)rn1(1000, 40);
pline("%s demands %ld %s for safe passage.", Amonnam(mtmp), demand,
currency(demand));
if ((offer = bribe(mtmp)) >= demand) {
pline("%s vanishes, laughing about cowardly %s.", Amonnam(mtmp),
makeplural(mortal_or_creature(youmonst.data, FALSE)));
} else if (offer > 0L && (long)rnd(40) > (demand - offer)) {
pline("%s scowls at you menacingly, then vanishes.", Amonnam(mtmp));
} else {
pline("%s gets angry...", Amonnam(mtmp));
msethostility(mtmp, TRUE, TRUE);
return 0;
}
}
mongone(mtmp);
return 1;
}
boolean
inside_gas_cloud(void *p1, void *p2)
{
struct region *reg;
struct monst *mtmp;
long dam;
reg = (struct region *)p1;
dam = (long)reg->arg;
if (p2 == NULL) { /* This means *YOU* Bozo! */
if (nonliving(youmonst.data) || u.uinvulnerable)
return FALSE;
/* If you will unblind next turn, extend the blindness so that you do
* not get a "You can see again!" message immediately before being
* blinded again. */
if (!Blind || Blinded == 1)
make_blinded(2L, FALSE);
if (Breathless)
return FALSE;
if (!Poison_resistance) {
pline("Something is burning your %s!", makeplural(body_part(LUNG)));
pline("You cough and spit blood!");
losehp(rnd(dam) + 5, killer_msg(DIED, "a gas cloud"));
return FALSE;
} else {
pline("You cough!");
return FALSE;
}
} else { /* A monster is inside the cloud */
mtmp = (struct monst *)p2;
/* Non living and non breathing monsters are not concerned */
if (!nonliving(mtmp->data) && !breathless(mtmp->data)) {
if (cansee(mtmp->mx, mtmp->my))
pline("%s coughs!", Monnam(mtmp));
setmangry(mtmp);
if (haseyes(mtmp->data) && mtmp->mcansee) {
mtmp->mblinded = 1;
mtmp->mcansee = 0;
}
if (resists_poison(mtmp))
return FALSE;
mtmp->mhp -= rnd(dam) + 5;
if (mtmp->mhp <= 0) {
if (heros_fault(reg))
killed(mtmp);
else
monkilled(mtmp, "gas cloud", AD_DRST);
if (DEADMONSTER(mtmp)) { /* not lifesaved */
return TRUE;
}
}
}
}
return FALSE; /* Monster is still alive */
}
void drop_uswapwep(void)
{
char str[BUFSZ];
struct obj *obj = uswapwep;
/* Avoid trashing makeplural's static buffer */
strcpy(str, makeplural(body_part(HAND)));
pline("Your %s from your %s!", aobjnam(obj, "slip"), str);
dropx(obj);
}
void weldmsg(struct obj *obj)
{
long savewornmask;
savewornmask = obj->owornmask;
pline("Your %s %s welded to your %s!",
xname(obj), otense(obj, "are"),
bimanual(obj) ? (const char *)makeplural(body_part(HAND))
: body_part(HAND));
obj->owornmask = savewornmask;
}
static void
dowatersnakes() /* Fountain of snakes! */
{
register int num = rn1(5,2);
struct monst *mtmp;
if (!(mons[PM_WATER_MOCCASIN].geno & (G_GENOD | G_EXTINCT))) {
if (!Blind)
pline("An endless stream of %s pours forth!",
Hallucination ? makeplural(rndmonnam()) : "snakes");
else
You("hear something hissing!");
while(num-- > 0)
if((mtmp = makemon(&mons[PM_WATER_MOCCASIN],u.ux,u.uy)) &&
t_at(mtmp->mx, mtmp->my))
(void) mintrap(mtmp);
} else
pline("The fountain bubbles furiously for a moment, then calms.");
}
int can_twoweapon(void)
{
struct obj *otmp;
#define NOT_WEAPON(obj) (!is_weptool(obj) && obj->oclass != WEAPON_CLASS)
if (!could_twoweap(youmonst.data)) {
if (Upolyd)
pline("You can't use two weapons in your current form.");
else
pline("%s aren't able to use two weapons at once.",
makeplural((flags.female && urole.name.f) ?
urole.name.f : urole.name.m));
} else if (!uwep || !uswapwep)
pline("Your %s%s%s empty.", uwep ? "left " : uswapwep ? "right " : "",
body_part(HAND), (!uwep && !uswapwep) ? "s are" : " is");
else if (NOT_WEAPON(uwep) || NOT_WEAPON(uswapwep)) {
otmp = NOT_WEAPON(uwep) ? uwep : uswapwep;
pline("%s %s.", Yname2(otmp),
is_plural(otmp) ? "aren't weapons" : "isn't a weapon");
} else if (bimanual(uwep) || bimanual(uswapwep)) {
otmp = bimanual(uwep) ? uwep : uswapwep;
pline("%s isn't one-handed.", Yname2(otmp));
} else if (uarms)
pline("You can't use two weapons while wearing a shield.");
else if (uswapwep->oartifact)
pline("%s %s being held second to another weapon!",
Yname2(uswapwep), otense(uswapwep, "resist"));
else if (!uarmg && !Stone_resistance && (uswapwep->otyp == CORPSE &&
touch_petrifies(&mons[uswapwep->corpsenm]))) {
char kbuf[BUFSZ];
pline("You wield the %s corpse with your bare %s.",
mons[uswapwep->corpsenm].mname, body_part(HAND));
sprintf(kbuf, "%s corpse", an(mons[uswapwep->corpsenm].mname));
instapetrify(kbuf);
} else if (Glib || uswapwep->cursed) {
if (!Glib)
uswapwep->bknown = TRUE;
drop_uswapwep();
} else
return TRUE;
return FALSE;
}
static void
mon_vision_summary(const struct monst *mtmp, char *outbuf)
{
unsigned msense_status = msensem(&youmonst, mtmp);
char *outbufp = outbuf;
char wbuf[BUFSZ];
outbuf[0] = '\0';
if (msense_status & MSENSE_VISION)
append_str_comma(outbuf, &outbufp, "normal vision");
if (msense_status & MSENSE_SEEINVIS)
append_str_comma(outbuf, &outbufp, "see invisible");
if (msense_status & MSENSE_INFRAVISION)
append_str_comma(outbuf, &outbufp, "infravision");
if (msense_status & MSENSE_TELEPATHY)
append_str_comma(outbuf, &outbufp, "telepathy");
if (msense_status & MSENSE_XRAY)
append_str_comma(outbuf, &outbufp, "astral vision");
if (msense_status & MSENSE_MONDETECT)
append_str_comma(outbuf, &outbufp, "monster detection");
if (msense_status & MSENSE_WARNOFMON) {
snprintf(wbuf, SIZE(wbuf), "warned of %s",
makeplural(mtmp->data->mname));
append_str_comma(outbuf, &outbufp,
Hallucination ? "paranoid delusion" : wbuf);
}
if (msense_status & MSENSE_COVETOUS)
append_str_comma(outbuf, &outbufp, "artifact sense");
if (msense_status & MSENSE_GOLDSMELL)
append_str_comma(outbuf, &outbufp, "smell of gold");
if (msense_status & MSENSE_SCENT)
append_str_comma(outbuf, &outbufp, "scent");
if (strcmp(outbuf, "normal vision") == 0)
outbuf[0] = '\0';
}
static void
convert_line (void)
{
char *c, *cc;
char xbuf[BUFSZ];
cc = out_line;
for (c = xcrypt(in_line, xbuf); *c; c++) {
*cc = 0;
switch(*c) {
case '\r':
case '\n':
*(++cc) = 0;
return;
case '%':
if (*(c+1)) {
convert_arg(*(++c));
switch (*(++c)) {
/* insert "a"/"an" prefix */
case 'A': strcat(cc, An(cvt_buf));
cc += strlen(cc);
continue; /* for */
case 'a': strcat(cc, an(cvt_buf));
cc += strlen(cc);
continue; /* for */
/* capitalize */
case 'C': cvt_buf[0] = highc(cvt_buf[0]);
break;
/* pluralize */
case 'P': cvt_buf[0] = highc(cvt_buf[0]);
case 'p': strcpy(cvt_buf, makeplural(cvt_buf));
break;
/* append possessive suffix */
case 'S': cvt_buf[0] = highc(cvt_buf[0]);
case 's': strcpy(cvt_buf, "TODO: s_suffix(cvt_buf)");
break;
/* strip any "the" prefix */
case 't': if (!strncmpi(cvt_buf, "the ", 4)) {
strcat(cc, &cvt_buf[4]);
cc += strlen(cc);
continue; /* for */
}
break;
default: --c; /* undo switch increment */
break;
}
strcat(cc, cvt_buf);
cc += strlen(cvt_buf);
break;
} /* else fall through */
default:
*cc++ = *c;
break;
}
}
if (cc >= out_line + sizeof out_line)
panic("convert_line: overflow");
*cc = 0;
return;
}
/* 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
static void mon_vision_summary(const struct monst *mtmp, char *outbuf)
{
int ways_seen = 0, normal = 0, xraydist;
boolean useemon = (boolean) canseemon(mtmp);
outbuf[0] = '\0';
xraydist = (u.xray_range<0) ? -1 : u.xray_range * u.xray_range;
/* normal vision */
if ((mtmp->wormno ? worm_known(mtmp) : cansee(mtmp->mx, mtmp->my)) &&
mon_visible(mtmp) && !mtmp->minvis) {
ways_seen++;
normal++;
}
/* see invisible */
if (useemon && mtmp->minvis)
ways_seen++;
/* infravision */
if ((!mtmp->minvis || See_invisible) && see_with_infrared(mtmp))
ways_seen++;
/* telepathy */
if (tp_sensemon(mtmp))
ways_seen++;
/* xray */
if (useemon && xraydist > 0 &&
distu(mtmp->mx, mtmp->my) <= xraydist)
ways_seen++;
if (Detect_monsters)
ways_seen++;
if (MATCH_WARN_OF_MON(mtmp))
ways_seen++;
if (ways_seen > 1 || !normal) {
if (normal) {
strcat(outbuf, "normal vision");
/* can't actually be 1 yet here */
if (ways_seen-- > 1) strcat(outbuf, ", ");
}
if (useemon && mtmp->minvis) {
strcat(outbuf, "see invisible");
if (ways_seen-- > 1) strcat(outbuf, ", ");
}
if ((!mtmp->minvis || See_invisible) &&
see_with_infrared(mtmp)) {
strcat(outbuf, "infravision");
if (ways_seen-- > 1) strcat(outbuf, ", ");
}
if (tp_sensemon(mtmp)) {
strcat(outbuf, "telepathy");
if (ways_seen-- > 1) strcat(outbuf, ", ");
}
if (useemon && xraydist > 0 &&
distu(mtmp->mx, mtmp->my) <= xraydist) {
/* Eyes of the Overworld */
strcat(outbuf, "astral vision");
if (ways_seen-- > 1) strcat(outbuf, ", ");
}
if (Detect_monsters) {
strcat(outbuf, "monster detection");
if (ways_seen-- > 1) strcat(outbuf, ", ");
}
if (MATCH_WARN_OF_MON(mtmp)) {
char wbuf[BUFSZ];
if (Hallucination)
strcat(outbuf, "paranoid delusion");
else {
sprintf(wbuf, "warned of %s",
makeplural(mtmp->data->mname));
strcat(outbuf, wbuf);
}
if (ways_seen-- > 1) strcat(outbuf, ", ");
}
}
}
int
dowrite(struct obj *pen, const struct nh_cmd_arg *arg)
{
struct obj *paper;
const char *namebuf, *nm, *bp;
struct obj *new_obj;
int basecost, actualcost;
int curseval;
const char *qbuf;
int first, last, i;
boolean by_descr = FALSE, by_name = FALSE;
const char *typeword;
if (nohands(youmonst.data)) {
pline(msgc_cancelled, "You need hands to be able to write!");
return 0;
} else if (slippery_fingers(&youmonst)) {
pline(msgc_cancelled1, "%s from your %s.", Tobjnam(pen, "slip"),
makeplural(body_part(FINGER)));
unwield_silently(pen);
dropx(pen);
return 1;
}
/* get paper to write on */
paper = getargobj(arg, write_on, "write on");
if (!paper)
return 0;
typeword = (paper->oclass == SPBOOK_CLASS) ? "spellbook" : "scroll";
if (Blind && !paper->dknown) {
pline(msgc_cancelled1,
"You don't know if that %s is blank or not!", typeword);
return 1;
}
paper->dknown = 1;
if (paper->otyp != SCR_BLANK_PAPER && paper->otyp != SPE_BLANK_PAPER) {
pline(msgc_cancelled1, "That %s is not blank!", typeword);
exercise(A_WIS, FALSE);
return 1;
}
/* what to write */
qbuf = msgprintf("What type of %s do you want to write?", typeword);
namebuf = getarglin(arg, qbuf);
namebuf = msgmungspaces(namebuf); /* remove any excess whitespace */
if (namebuf[0] == '\033' || !namebuf[0])
return 1;
nm = namebuf;
if (!strncmpi(nm, "scroll ", 7))
nm += 7;
else if (!strncmpi(nm, "spellbook ", 10))
nm += 10;
if (!strncmpi(nm, "of ", 3))
nm += 3;
if ((bp = strstri(nm, " armour")) != 0)
nm = msgcat_many(msgchop(nm, bp-nm), " armor", bp+7, NULL);
first = bases[(int)paper->oclass];
last = bases[(int)paper->oclass + 1] - 1;
for (i = first; i <= last; i++) {
/* extra shufflable descr not representing a real object */
if (!OBJ_NAME(objects[i]))
continue;
if (!strcmpi(OBJ_NAME(objects[i]), nm))
goto found;
if (!strcmpi(OBJ_DESCR(objects[i]), nm)) {
by_descr = TRUE;
goto found;
}
if (objects[i].oc_uname &&
!strcmpi(objects[i].oc_uname, nm)) {
by_name = TRUE;
goto found;
}
}
pline(msgc_cancelled1, "There is no such %s!", typeword);
return 1;
found:
if (i == SCR_BLANK_PAPER || i == SPE_BLANK_PAPER) {
pline(msgc_cancelled1, "You can't write that!");
pline(msgc_cancelled1, "It's obscene!");
return 1;
} else if (i == SPE_BOOK_OF_THE_DEAD) {
pline(msgc_cancelled1, "No mere dungeon adventurer could write that.");
return 1;
} else if ((by_descr || by_name) && paper->oclass == SPBOOK_CLASS &&
!objects[i].oc_name_known) {
/* can't write unknown spellbooks by description */
pline(msgc_cancelled1,
"Unfortunately you don't have enough information to go on.");
return 1;
}
/* KMH, conduct */
break_conduct(conduct_illiterate);
new_obj = mksobj(level, i, FALSE, FALSE, rng_main);
new_obj->bknown = (paper->bknown && pen->bknown);
/* shk imposes a flat rate per use, not based on actual charges used */
check_unpaid(pen);
/* see if there's enough ink */
basecost = cost(new_obj);
if (pen->spe < basecost / 2) {
pline(msgc_failcurse, "Your marker is too dry to write that!");
obfree(new_obj, NULL);
return 1;
}
/* we're really going to write now, so calculate cost
no custom RNG used: too much influence from player actions */
actualcost = rn1(basecost / 2, basecost / 2);
curseval = bcsign(pen) + bcsign(paper);
exercise(A_WIS, TRUE);
/* dry out marker */
if (pen->spe < actualcost) {
pen->spe = 0;
pline(msgc_itemloss, "Your marker dries out!");
/* scrolls disappear, spellbooks don't */
if (paper->oclass == SPBOOK_CLASS) {
pline(msgc_failcurse,
"The spellbook is left unfinished and your writing fades.");
update_inventory(); /* pen charges */
} else {
pline(msgc_failcurse, "The scroll is now useless and disappears!");
useup(paper);
}
obfree(new_obj, NULL);
return 1;
}
pen->spe -= actualcost;
/* can't write if we don't know it - unless we're lucky */
if (!(objects[new_obj->otyp].oc_name_known) &&
(rnl(Role_if(PM_WIZARD) ? 3 : 15))) {
pline(msgc_failrandom, "You %s to write that!",
by_descr ? "fail" : "don't know how");
/* scrolls disappear, spellbooks don't */
if (paper->oclass == SPBOOK_CLASS) {
pline_implied(msgc_failrandom,
"You write in your best handwriting: "
"\"My Diary\", but it quickly fades.");
update_inventory(); /* pen charges */
} else {
const char *written;
if (by_descr) {
written = OBJ_DESCR(objects[new_obj->otyp]);
written = eroded_text(written,
(6 + MAXULEV - youmonst.m_lev) / 6, 0);
} else
written = msgprintf("%s was here!", u.uplname);
pline_implied(msgc_failrandom,
"You write \"%s\" and the scroll disappears.",
written);
useup(paper);
}
obfree(new_obj, NULL);
return 1;
}
/* useup old scroll / spellbook */
useup(paper);
/* success */
if (new_obj->oclass == SPBOOK_CLASS) {
/* acknowledge the change in the object's description... */
pline(msgc_actionok, "The spellbook warps strangely, then turns %s.",
OBJ_DESCR(objects[new_obj->otyp]));
}
new_obj->blessed = (curseval > 0);
new_obj->cursed = (curseval < 0);
hold_another_object(new_obj, "Oops! %s out of your grasp!",
The(aobjnam(new_obj, "slip")), NULL);
return 1;
}
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));
}
}
/* (moved from apply.c) */
boolean wield_tool(struct obj *obj,
const char *verb) /* "rub",&c */
{
const char *what;
boolean more_than_1;
if (obj == uwep) return TRUE; /* nothing to do if already wielding it */
if (!verb) verb = "wield";
what = xname(obj);
more_than_1 = (obj->quan > 1L ||
strstri(what, "pair of ") != 0 ||
strstri(what, "s of ") != 0);
if (obj->owornmask & (W_ARMOR|W_RING|W_AMUL|W_TOOL)) {
char yourbuf[BUFSZ];
pline("You can't %s %s %s while wearing %s.",
verb, shk_your(yourbuf, obj), what,
more_than_1 ? "them" : "it");
return FALSE;
}
if (welded(uwep)) {
if (flags.verbose) {
const char *hand = body_part(HAND);
if (bimanual(uwep)) hand = makeplural(hand);
if (strstri(what, "pair of ") != 0) more_than_1 = FALSE;
pline(
"Since your weapon is welded to your %s, you cannot %s %s %s.",
hand, verb, more_than_1 ? "those" : "that", xname(obj));
} else {
pline("You can't do that.");
}
return FALSE;
}
if (cantwield(youmonst.data)) {
pline("You can't hold %s strongly enough.", more_than_1 ? "them" : "it");
return FALSE;
}
/* check shield */
if (uarms && bimanual(obj)) {
pline("You cannot %s a two-handed %s while wearing a shield.",
verb, (obj->oclass == WEAPON_CLASS) ? "weapon" : "tool");
return FALSE;
}
if (uquiver == obj) setuqwep(NULL);
if (uswapwep == obj) {
doswapweapon();
/* doswapweapon might fail */
if (uswapwep == obj) return FALSE;
} else {
pline("You now wield %s.", doname(obj));
setuwep(obj);
}
if (uwep != obj) return FALSE; /* rewielded old object after dying */
/* applying weapon or tool that gets wielded ends two-weapon combat */
if (u.twoweap)
untwoweapon();
if (obj->oclass != WEAPON_CLASS)
unweapon = TRUE;
return TRUE;
}
static int ready_weapon(struct obj *wep)
{
/* Separated function so swapping works easily */
int res = 0;
if (!wep) {
/* No weapon */
if (uwep) {
pline("You are empty %s.", body_part(HANDED));
setuwep(NULL);
res++;
} else
pline("You are already empty %s.", body_part(HANDED));
} else if (!uarmg && !Stone_resistance && wep->otyp == CORPSE
&& touch_petrifies(&mons[wep->corpsenm])) {
/* Prevent wielding cockatrice when not wearing gloves --KAA */
char kbuf[BUFSZ];
pline("You wield the %s corpse in your bare %s.",
mons[wep->corpsenm].mname, makeplural(body_part(HAND)));
sprintf(kbuf, "%s corpse", an(mons[wep->corpsenm].mname));
instapetrify(kbuf);
} else if (uarms && bimanual(wep))
pline("You cannot wield a two-handed %s while wearing a shield.",
is_sword(wep) ? "sword" :
wep->otyp == BATTLE_AXE ? "axe" : "weapon");
else if (wep->oartifact && !touch_artifact(wep, &youmonst)) {
res++; /* takes a turn even though it doesn't get wielded */
} else {
/* Weapon WILL be wielded after this point */
res++;
if (will_weld(wep)) {
const char *tmp = xname(wep), *thestr = "The ";
if (strncmp(tmp, thestr, 4) && !strncmp(The(tmp),thestr,4))
tmp = thestr;
else tmp = "";
pline("%s%s %s to your %s!", tmp, aobjnam(wep, "weld"),
(wep->quan == 1L) ? "itself" : "themselves", /* a3 */
bimanual(wep) ?
(const char *)makeplural(body_part(HAND))
: body_part(HAND));
wep->bknown = TRUE;
} else {
/* The message must be printed before setuwep (since
* you might die and be revived from changing weapons),
* and the message must be before the death message and
* Lifesaved rewielding. Yet we want the message to
* say "weapon in hand", thus this kludge.
*/
long dummy = wep->owornmask;
wep->owornmask |= W_WEP;
prinv(NULL, wep, 0L);
wep->owornmask = dummy;
}
setuwep(wep);
/* KMH -- Talking artifacts are finally implemented */
arti_speak(wep);
if (artifact_light(wep) && !wep->lamplit) {
begin_burn(wep, FALSE);
if (!Blind)
pline("%s to glow brilliantly!", Tobjnam(wep, "begin"));
}
if (wep->unpaid) {
struct monst *this_shkp;
if ((this_shkp = shop_keeper(level, inside_shop(level, u.ux, u.uy))) !=
NULL) {
pline("%s says \"You be careful with my %s!\"",
shkname(this_shkp),
xname(wep));
}
}
}
return res;
}
static void cast_cleric_spell(struct monst *mtmp, int dmg, int spellnum)
{
if (dmg == 0 && !is_undirected_spell(AD_CLRC, spellnum)) {
impossible("cast directed cleric spell (%d) with dmg=0?", spellnum);
return;
}
switch (spellnum) {
case CLC_GEYSER:
/* this is physical damage, not magical damage */
pline("A sudden geyser slams into you from nowhere!");
dmg = dice(8, 6);
if (Half_physical_damage) dmg = (dmg + 1) / 2;
break;
case CLC_FIRE_PILLAR:
pline("A pillar of fire strikes all around you!");
if (Fire_resistance) {
shieldeff(u.ux, u.uy);
dmg = 0;
} else
dmg = dice(8, 6);
if (Half_spell_damage) dmg = (dmg + 1) / 2;
burn_away_slime();
burnarmor(&youmonst);
destroy_item(SCROLL_CLASS, AD_FIRE);
destroy_item(POTION_CLASS, AD_FIRE);
destroy_item(SPBOOK_CLASS, AD_FIRE);
burn_floor_paper(u.ux, u.uy, TRUE, FALSE);
break;
case CLC_LIGHTNING:
{
boolean reflects;
pline("A bolt of lightning strikes down at you from above!");
reflects = ureflects("It bounces off your %s%s.", "");
if (reflects || Shock_resistance) {
shieldeff(u.ux, u.uy);
dmg = 0;
if (reflects)
break;
} else
dmg = dice(8, 6);
if (Half_spell_damage) dmg = (dmg + 1) / 2;
destroy_item(WAND_CLASS, AD_ELEC);
destroy_item(RING_CLASS, AD_ELEC);
break;
}
case CLC_CURSE_ITEMS:
pline("You feel as if you need some help.");
rndcurse();
dmg = 0;
break;
case CLC_INSECTS:
{
/* Try for insects, and if there are none
left, go for (sticks to) snakes. -3. */
const struct permonst *pm = mkclass(&u.uz, S_ANT,0);
struct monst *mtmp2 = NULL;
char let = (pm ? S_ANT : S_SNAKE);
boolean success;
int i;
coord bypos;
int quan;
quan = (mtmp->m_lev < 2) ? 1 : rnd((int)mtmp->m_lev / 2);
if (quan < 3) quan = 3;
success = pm ? TRUE : FALSE;
for (i = 0; i <= quan; i++) {
if (!enexto(&bypos, level, mtmp->mux, mtmp->muy, mtmp->data))
break;
if ((pm = mkclass(&u.uz, let,0)) != 0 &&
(mtmp2 = makemon(pm, level, bypos.x, bypos.y, NO_MM_FLAGS)) != 0) {
success = TRUE;
mtmp2->msleeping = mtmp2->mpeaceful = mtmp2->mtame = 0;
set_malign(mtmp2);
}
}
/* Not quite right:
* -- message doesn't always make sense for unseen caster (particularly
* the first message)
* -- message assumes plural monsters summoned (non-plural should be
* very rare, unlike in nasty())
* -- message assumes plural monsters seen
*/
if (!success)
pline("%s casts at a clump of sticks, but nothing happens.",
Monnam(mtmp));
else if (let == S_SNAKE)
pline("%s transforms a clump of sticks into snakes!",
Monnam(mtmp));
else if (Invisible && !perceives(mtmp->data) &&
(mtmp->mux != u.ux || mtmp->muy != u.uy))
pline("%s summons insects around a spot near you!",
Monnam(mtmp));
else if (Displaced && (mtmp->mux != u.ux || mtmp->muy != u.uy))
pline("%s summons insects around your displaced image!",
Monnam(mtmp));
else
pline("%s summons insects!", Monnam(mtmp));
dmg = 0;
break;
}
case CLC_BLIND_YOU:
/* note: resists_blnd() doesn't apply here */
if (!Blinded) {
int num_eyes = eyecount(youmonst.data);
pline("Scales cover your %s!",
(num_eyes == 1) ?
body_part(EYE) : makeplural(body_part(EYE)));
make_blinded(Half_spell_damage ? 100L : 200L, FALSE);
if (!Blind) pline("Your vision quickly clears.");
dmg = 0;
} else
impossible("no reason for monster to cast blindness spell?");
break;
case CLC_PARALYZE:
if (Antimagic || Free_action) {
shieldeff(u.ux, u.uy);
if (multi >= 0)
pline("You stiffen briefly.");
nomul(-1, "paralyzed by a monster");
} else {
if (multi >= 0)
pline("You are frozen in place!");
dmg = 4 + (int)mtmp->m_lev;
if (Half_spell_damage) dmg = (dmg + 1) / 2;
nomul(-dmg, "paralyzed by a monster");
}
dmg = 0;
break;
case CLC_CONFUSE_YOU:
if (Antimagic) {
shieldeff(u.ux, u.uy);
pline("You feel momentarily dizzy.");
} else {
boolean oldprop = !!Confusion;
dmg = (int)mtmp->m_lev;
if (Half_spell_damage) dmg = (dmg + 1) / 2;
make_confused(HConfusion + dmg, TRUE);
if (Hallucination)
pline("You feel %s!", oldprop ? "trippier" : "trippy");
else
pline("You feel %sconfused!", oldprop ? "more " : "");
}
dmg = 0;
break;
case CLC_CURE_SELF:
if (mtmp->mhp < mtmp->mhpmax) {
if (canseemon(mtmp))
pline("%s looks better.", Monnam(mtmp));
/* note: player healing does 6d4; this used to do 1d8 */
if ((mtmp->mhp += dice(3,6)) > mtmp->mhpmax)
mtmp->mhp = mtmp->mhpmax;
dmg = 0;
}
break;
case CLC_OPEN_WOUNDS:
if (Antimagic) {
shieldeff(u.ux, u.uy);
dmg = (dmg + 1) / 2;
}
if (dmg <= 5)
pline("Your skin itches badly for a moment.");
else if (dmg <= 10)
pline("Wounds appear on your body!");
else if (dmg <= 20)
pline("Severe wounds appear on your body!");
else
pline("Your body is covered with painful wounds!");
break;
default:
impossible("mcastu: invalid clerical spell (%d)", spellnum);
dmg = 0;
break;
}
if (dmg) mdamageu(mtmp, dmg);
}
void invault(void) {
struct monst *guard;
int trycount, vaultroom = (int)vault_occupied(u.urooms);
if (!vaultroom) {
u.uinvault = 0;
return;
}
vaultroom -= ROOMOFFSET;
guard = findgd();
if (++u.uinvault % 30 == 0 && !guard) { /* if time ok and no guard now. */
char buf[BUFSZ];
int x, y, dd, gx, gy;
int lx = 0, ly = 0;
/* first find the goal for the guard */
for (dd = 2; (dd < ROWNO || dd < COLNO); dd++) {
for (y = u.uy - dd; y <= u.uy + dd; ly = y, y++) {
if (y < 0 || y > ROWNO - 1)
continue;
for (x = u.ux - dd; x <= u.ux + dd; lx = x, x++) {
if (y != u.uy - dd && y != u.uy + dd && x != u.ux - dd)
x = u.ux + dd;
if (x < 1 || x > COLNO - 1)
continue;
if (levl[x][y].typ == CORR) {
if (x < u.ux)
lx = x + 1;
else if (x > u.ux)
lx = x - 1;
else
lx = x;
if (y < u.uy)
ly = y + 1;
else if (y > u.uy)
ly = y - 1;
else
ly = y;
if (levl[lx][ly].typ != STONE && levl[lx][ly].typ != CORR)
goto incr_radius;
goto fnd;
}
}
}
incr_radius: ;
}
impossible("Not a single corridor on this level??");
tele();
return;
fnd: gx = x;
gy = y;
/* next find a good place for a door in the wall */
x = u.ux;
y = u.uy;
if (levl[x][y].typ != ROOM) { /* player dug a door and is in it */
if (levl[x + 1][y].typ == ROOM)
x = x + 1;
else if (levl[x][y + 1].typ == ROOM)
y = y + 1;
else if (levl[x - 1][y].typ == ROOM)
x = x - 1;
else if (levl[x][y - 1].typ == ROOM)
y = y - 1;
else if (levl[x + 1][y + 1].typ == ROOM) {
x = x + 1;
y = y + 1;
} else if (levl[x - 1][y - 1].typ == ROOM) {
x = x - 1;
y = y - 1;
} else if (levl[x + 1][y - 1].typ == ROOM) {
x = x + 1;
y = y - 1;
} else if (levl[x - 1][y + 1].typ == ROOM) {
x = x - 1;
y = y + 1;
}
}
while (levl[x][y].typ == ROOM) {
int dx, dy;
dx = (gx > x) ? 1 : (gx < x) ? -1 : 0;
dy = (gy > y) ? 1 : (gy < y) ? -1 : 0;
if (abs(gx - x) >= abs(gy - y))
x += dx;
else
y += dy;
}
if (x == u.ux && y == u.uy) {
if (levl[x + 1][y].typ == HWALL || levl[x + 1][y].typ == DOOR)
x = x + 1;
else if (levl[x - 1][y].typ == HWALL || levl[x - 1][y].typ == DOOR)
x = x - 1;
else if (levl[x][y + 1].typ == VWALL || levl[x][y + 1].typ == DOOR)
y = y + 1;
else if (levl[x][y - 1].typ == VWALL || levl[x][y - 1].typ == DOOR)
y = y - 1;
else
return;
}
/* make something interesting happen */
if (!(guard = makemon(&mons[PM_GUARD], x, y, NO_MM_FLAGS)))
return;
guard->isgd = 1;
guard->mpeaceful = 1;
set_malign(guard);
EGD(guard)->gddone = 0;
EGD(guard)->ogx = x;
EGD(guard)->ogy = y;
assign_level(&(EGD(guard)->gdlevel), &u.uz);
EGD(guard)->vroom = vaultroom;
EGD(guard)->warncnt = 0;
reset_faint(); /* if fainted - wake up */
if (canspotmon(guard)) {
char name[BUFSZ];
g_monnam(name, BUFSZ, guard);
pline("Suddenly one of the Vault's %s enters!", makeplural(name));
} else {
pline("Someone else has entered the Vault.");
}
newsym(guard->mx, guard->my);
if (youmonst.m_ap_type == M_AP_OBJECT || u.uundetected) {
if (youmonst.m_ap_type == M_AP_OBJECT && youmonst.mappearance != GOLD_PIECE)
verbalize("Hey! Who left that %s in here?", mimic_obj_name(&youmonst));
/* You're mimicking some object or you're hidden. */
pline("Puzzled, %s turns around and leaves.", mhe(guard));
mongone(guard);
return;
}
if (Strangled|| is_silent(youmonst.data) || multi < 0) {
/* [we ought to record whether this this message has already
been given in order to vary it upon repeat visits, but
discarding the monster and its egd data renders that hard] */
verbalize("I'll be back when you're ready to speak to me!");
mongone(guard);
return;
}
stop_occupation(); /* if occupied, stop it *now* */
trycount = 5;
do {
getlin("\"Hello stranger, who are you?\" -", buf);
(void)mungspaces(buf);
} while (!letter(buf[0]) && --trycount > 0);
if (u.ualign.type == A_LAWFUL &&
/* ignore trailing text, in case player includes character's rank */
strncmpi(buf, plname, (int)strlen(plname)) != 0) {
adjalign(-1); /* Liar! */
}
if (!strcmpi(buf, "Croesus") || !strcmpi(buf, "Kroisos") || !strcmpi(buf, "Creosote")) {
if (!mvitals[PM_CROESUS].died) {
verbalize("Oh, yes, of course. Sorry to have disturbed you.");
mongone(guard);
} else {
setmangry(guard);
verbalize("Back from the dead, are you? I'll remedy that!");
/* don't want guard to waste next turn wielding a weapon */
if (!MON_WEP(guard)) {
guard->weapon_check = NEED_HTH_WEAPON;
(void)mon_wield_item(guard);
}
}
return;
}
verbalize("I don't know you.");
if (!u.ugold && !hidden_gold())
verbalize("Please follow me.");
else {
if (!u.ugold)
verbalize("You have hidden gold.");
verbalize("Most likely all your gold was stolen from this vault.");
verbalize("Please drop that gold and follow me.");
}
EGD(guard)->gdx = gx;
EGD(guard)->gdy = gy;
EGD(guard)->fcbeg = 0;
EGD(guard)->fakecorr[0].fx = x;
EGD(guard)->fakecorr[0].fy = y;
if (IS_WALL(levl[x][y].typ))
EGD(guard)->fakecorr[0].ftyp = levl[x][y].typ;
else { /* the initial guard location is a dug door */
int vlt = EGD(guard)->vroom;
signed char lowx = rooms[vlt].lx, hix = rooms[vlt].hx;
signed char lowy = rooms[vlt].ly, hiy = rooms[vlt].hy;
if (x == lowx - 1 && y == lowy - 1)
EGD(guard)->fakecorr[0].ftyp = TLCORNER;
else if (x == hix + 1 && y == lowy - 1)
EGD(guard)->fakecorr[0].ftyp = TRCORNER;
else if (x == lowx - 1 && y == hiy + 1)
EGD(guard)->fakecorr[0].ftyp = BLCORNER;
else if (x == hix + 1 && y == hiy + 1)
EGD(guard)->fakecorr[0].ftyp = BRCORNER;
else if (y == lowy - 1 || y == hiy + 1)
EGD(guard)->fakecorr[0].ftyp = HWALL;
else if (x == lowx - 1 || x == hix + 1)
EGD(guard)->fakecorr[0].ftyp = VWALL;
}
levl[x][y].typ = DOOR;
levl[x][y].flags = D_NODOOR;
unblock_point(x, y); /* doesn't block light */
EGD(guard)->fcend = 1;
EGD(guard)->warncnt = 1;
}
}
/* look for gold, on the floor or in monsters' possession */
int gold_detect(struct obj *sobj, boolean *scr_known)
{
struct obj *obj;
struct monst *mtmp;
int uw = u.uinwater;
struct obj *temp;
boolean stale;
*scr_known = stale = clear_stale_map(COIN_CLASS, sobj->blessed ? GOLD : 0);
/* look for gold carried by monsters (might be in a container) */
for (mtmp = level->monlist; mtmp; mtmp = mtmp->nmon) {
if (DEADMONSTER(mtmp)) continue; /* probably not needed in this case but... */
if (findgold(mtmp->minvent) || monsndx(mtmp->data) == PM_GOLD_GOLEM) {
*scr_known = TRUE;
goto outgoldmap; /* skip further searching */
} else for (obj = mtmp->minvent; obj; obj = obj->nobj)
if (sobj->blessed && o_material(obj, GOLD)) {
*scr_known = TRUE;
goto outgoldmap;
} else if (o_in(obj, COIN_CLASS)) {
*scr_known = TRUE;
goto outgoldmap; /* skip further searching */
}
}
/* look for gold objects */
for (obj = level->objlist; obj; obj = obj->nobj) {
if (sobj->blessed && o_material(obj, GOLD)) {
*scr_known = TRUE;
if (obj->ox != u.ux || obj->oy != u.uy) goto outgoldmap;
} else if (o_in(obj, COIN_CLASS)) {
*scr_known = TRUE;
if (obj->ox != u.ux || obj->oy != u.uy) goto outgoldmap;
}
}
if (!*scr_known) {
/* no gold found on floor or monster's inventory.
adjust message if you have gold in your inventory */
char buf[BUFSZ];
if (youmonst.data == &mons[PM_GOLD_GOLEM]) {
sprintf(buf, "You feel like a million %s!", currency(2L));
} else if (hidden_gold() || money_cnt(invent))
strcpy(buf, "You feel worried about your future financial situation.");
else
strcpy(buf, "You feel materially poor.");
strange_feeling(sobj, buf);
return 1;
}
/* only under me - no separate display required */
if (stale) doredraw();
pline("You notice some gold between your %s.", makeplural(body_part(FOOT)));
return 0;
outgoldmap:
cls();
u.uinwater = 0;
/* Discover gold locations. */
for (obj = level->objlist; obj; obj = obj->nobj) {
if (sobj->blessed && (temp = o_material(obj, GOLD))) {
if (temp != obj) {
temp->ox = obj->ox;
temp->oy = obj->oy;
}
map_object(temp,1);
} else if ((temp = o_in(obj, COIN_CLASS))) {
if (temp != obj) {
temp->ox = obj->ox;
temp->oy = obj->oy;
}
map_object(temp,1);
}
}
for (mtmp = level->monlist; mtmp; mtmp = mtmp->nmon) {
if (DEADMONSTER(mtmp)) continue; /* probably overkill here */
if (findgold(mtmp->minvent) || monsndx(mtmp->data) == PM_GOLD_GOLEM) {
struct obj gold;
gold.otyp = GOLD_PIECE;
gold.ox = mtmp->mx;
gold.oy = mtmp->my;
map_object(&gold,1);
} else for (obj = mtmp->minvent; obj; obj = obj->nobj)
if (sobj->blessed && (temp = o_material(obj, GOLD))) {
temp->ox = mtmp->mx;
temp->oy = mtmp->my;
map_object(temp,1);
break;
} else if ((temp = o_in(obj, COIN_CLASS))) {
temp->ox = mtmp->mx;
temp->oy = mtmp->my;
map_object(temp,1);
break;
}
}
newsym(u.ux,u.uy);
pline("You feel very greedy, and sense gold!");
exercise(A_WIS, TRUE);
win_pause_output(P_MAP);
doredraw();
u.uinwater = uw;
if (Underwater) under_water(2);
if (u.uburied) under_ground(2);
return 0;
}
/* Start riding, with the given monster */
boolean
mount_steed(struct monst * mtmp, /* The animal */
boolean force)
{ /* Quietly force this animal */
struct obj *otmp;
const struct permonst *ptr;
/* Sanity checks */
if (u.usteed) {
pline("You are already riding %s.", mon_nam(u.usteed));
return FALSE;
}
/* Is the player in the right form? */
if (Hallucination && !force) {
pline("Maybe you should find a designated driver.");
return FALSE;
}
/* While riding Wounded_legs refers to the steed's, not the hero's legs.
That opens up a potential abuse where the player can mount a steed, then
dismount immediately to heal leg damage, because leg damage is always
healed upon dismount (Wounded_legs context switch). By preventing a hero
with Wounded_legs from mounting a steed, the potential for abuse is
minimized, if not eliminated altogether. */
if (Wounded_legs) {
pline("Your %s are in no shape for riding.",
makeplural(body_part(LEG)));
if (force && wizard && yn("Heal your legs?") == 'y')
LWounded_legs = RWounded_legs = 0;
else
return FALSE;
}
if (Upolyd &&
(!humanoid(youmonst.data) || verysmall(youmonst.data) ||
bigmonst(youmonst.data) || slithy(youmonst.data))) {
pline("You won't fit on a saddle.");
return FALSE;
}
if (!force && (near_capacity() > SLT_ENCUMBER)) {
pline("You can't do that while carrying so much stuff.");
return FALSE;
}
/* Can the player reach and see the monster? */
if (!mtmp ||
(!force &&
((Blind && !Blind_telepat) || mtmp->mundetected ||
mtmp->m_ap_type == M_AP_FURNITURE ||
mtmp->m_ap_type == M_AP_OBJECT))) {
pline("I see nobody there.");
return FALSE;
}
struct test_move_cache cache;
init_test_move_cache(&cache);
if (Engulfed || u.ustuck || u.utrap || Punished ||
!test_move(u.ux, u.uy, mtmp->mx - u.ux, mtmp->my - u.uy, 0,
TEST_MOVE, &cache)) {
if (Punished || !(Engulfed || u.ustuck || u.utrap))
pline("You are unable to swing your %s over.", body_part(LEG));
else
pline("You are stuck here for now.");
return FALSE;
}
/* Is this a valid monster? */
otmp = which_armor(mtmp, os_saddle);
if (!otmp) {
pline("%s is not saddled.", Monnam(mtmp));
return FALSE;
}
ptr = mtmp->data;
if (touch_petrifies(ptr) && !Stone_resistance) {
pline("You touch %s.", mon_nam(mtmp));
instapetrify(killer_msg(STONING,
msgcat("attempting to ride ", an(mtmp->data->mname))));
}
if (!mtmp->mtame || mtmp->isminion) {
pline("I think %s would mind.", mon_nam(mtmp));
return FALSE;
}
if (mtmp->mtrapped) {
struct trap *t = t_at(level, mtmp->mx, mtmp->my);
pline("You can't mount %s while %s's trapped in %s.", mon_nam(mtmp),
mhe(mtmp), t ? an(trapexplain[t->ttyp - 1]) : "ice");
return FALSE;
}
if (!force && !Role_if(PM_KNIGHT) && !(--mtmp->mtame)) {
/* no longer tame */
newsym(mtmp->mx, mtmp->my);
pline("%s resists%s!", Monnam(mtmp),
mtmp->mleashed ? " and its leash comes off" : "");
if (mtmp->mleashed)
m_unleash(mtmp, FALSE);
return FALSE;
}
if (!force && Underwater && !is_swimmer(ptr)) {
pline("You can't ride that creature while under water.");
return FALSE;
}
if (!can_saddle(mtmp) || !can_ride(mtmp)) {
pline("You can't ride such a creature.");
return 0;
}
/* Is the player impaired? */
if (!force && !is_floater(ptr) && !is_flyer(ptr) && Levitation &&
!Lev_at_will) {
pline("You cannot reach %s.", mon_nam(mtmp));
return FALSE;
}
if (!force && uarm && is_metallic(uarm) && greatest_erosion(uarm)) {
pline("Your %s armor is too stiff to be able to mount %s.",
uarm->oeroded ? "rusty" : "corroded", mon_nam(mtmp));
return FALSE;
}
if (!force &&
(Confusion || Fumbling || Glib || Wounded_legs || otmp->cursed ||
((u.ulevel + mtmp->mtame < rnd(MAXULEV / 2 + 5)) &&
(!Role_if(PM_KNIGHT))))) {
if (Levitation) {
pline("%s slips away from you.", Monnam(mtmp));
return FALSE;
}
pline("You slip while trying to get on %s.", mon_nam(mtmp));
const char *buf = msgcat(
"slipped while mounting ",
/* "a saddled mumak" or "a saddled pony called Dobbin" */
x_monnam(mtmp, ARTICLE_A, NULL,
SUPPRESS_IT | SUPPRESS_INVISIBLE |
SUPPRESS_HALLUCINATION, TRUE));
losehp(rn1(5, 10), buf);
return FALSE;
}
/* Success */
maybewakesteed(mtmp);
if (!force) {
if (Levitation && !is_floater(ptr) && !is_flyer(ptr))
/* Must have Lev_at_will at this point */
pline("%s magically floats up!", Monnam(mtmp));
pline("You mount %s.", mon_nam(mtmp));
}
/* setuwep handles polearms differently when you're mounted */
if (uwep && is_pole(uwep))
u.bashmsg = TRUE;
u.usteed = mtmp;
remove_monster(level, mtmp->mx, mtmp->my);
teleds(mtmp->mx, mtmp->my, TRUE);
return TRUE;
}
void
ustatusline(void)
{
const char *info = "";
if (Sick) {
info = msgcat(info, ", dying from");
if (u.usick_type & SICK_VOMITABLE)
info = msgcat(info, " food poisoning");
if (u.usick_type & SICK_NONVOMITABLE) {
if (u.usick_type & SICK_VOMITABLE)
info = msgcat(info, " and");
info = msgcat(info, " illness");
}
}
if (Stoned)
info = msgcat(info, ", solidifying");
if (Slimed)
info = msgcat(info, ", becoming slimy");
if (Strangled)
info = msgcat(info, ", being strangled");
if (Vomiting)
info = msgcat(info, ", nauseated"); /* !"nauseous" */
if (Confusion)
info = msgcat(info, ", confused");
if (Blind) {
info = msgcat(info, ", blind");
if (u.ucreamed) {
if ((long)u.ucreamed < Blinded || Blindfolded ||
!haseyes(youmonst.data))
info = msgcat(info, ", cover");
info = msgcat(info, "ed by sticky goop");
} /* note: "goop" == "glop"; variation is intentional */
}
if (Stunned)
info = msgcat(info, ", stunned");
if (!u.usteed && Wounded_legs) {
const char *what = body_part(LEG);
if (LWounded_legs && RWounded_legs)
what = makeplural(what);
info = msgcat_many(info, ", injured ", what, NULL);
}
if (Glib)
info = msgcat_many(info, ", slippery ",
makeplural(body_part(HAND)), NULL);
if (u.utrap)
info = msgcat(info, ", trapped");
if (Fast)
info = msgcat(info, Very_fast ? ", very fast" : ", fast");
if (u.uundetected)
info = msgcat(info, ", concealed");
if (Invis)
info = msgcat(info, ", invisible");
if (u.ustuck) {
if (sticks(youmonst.data))
info = msgcat(info, ", holding ");
else
info = msgcat(info, ", held by ");
info = msgcat(info, mon_nam(u.ustuck));
}
pline("Status of %s (%s%s): Level %d HP %d(%d) Def %d%s.", u.uplname,
(u.ualign.record >= 20) ? "piously " :
(u.ualign.record > 13) ? "devoutly " :
(u.ualign.record > 8) ? "fervently " :
(u.ualign.record > 3) ? "stridently " :
(u.ualign.record == 3) ? "" :
(u.ualign.record >= 1) ? "haltingly " :
(u.ualign.record == 0) ? "nominally " : "insufficiently ",
align_str(u.ualign.type), Upolyd ? mons[u.umonnum].mlevel : u.ulevel,
Upolyd ? u.mh : u.uhp, Upolyd ? u.mhmax : u.uhpmax,
10 - get_player_ac(), info);
}
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;
}
static const char *
convert_line(const char *in_line)
{
/* xcrypt needs us to allocate a buffer for it */
char decrypted_line[strlen(in_line)+1];
xcrypt(in_line, decrypted_line);
const char *rv = "";
char *c;
/* Tokenize the decrypted line; we stop at \r, \n, or \0, and do
special handling of "%" characters.
The algorithm used here is quadratic (when linear is possible), but
given that the lines are only 80 characters long, I feel that a clear
algorithm is superior to a low computational complexity algorithm. */
for (c = xcrypt(in_line, decrypted_line);; c++) {
switch (*c) {
case '\r':
case '\n':
case '\0':
return rv;
case '%':
if (c[1]) {
const char *conversion = convert_arg(*(++c));
switch (*(++c)) {
/* insert "a"/"an" prefix */
case 'A':
rv = msgcat(rv, An(conversion));
break;
case 'a':
rv = msgcat(rv, an(conversion));
break;
/* capitalize */
case 'C':
rv = msgcat(rv, msgupcasefirst(conversion));
break;
/* pluralize */
case 'P':
/* Note: makeplural doesn't work on arbitrarily capitalized
strings */
rv = msgcat(rv, msgupcasefirst(makeplural(conversion)));
break;
case 'p':
rv = msgcat(rv, makeplural(conversion));
break;
/* append possessive suffix */
case 'S':
conversion = msgupcasefirst(conversion);
/* fall through */
case 's':
rv = msgcat(rv, s_suffix(conversion));
break;
/* strip any "the" prefix */
case 't':
if (!strncmpi(conversion, "the ", 4))
rv = msgcat(rv, conversion + 4);
else
rv = msgcat(rv, conversion);
break;
default:
--c; /* undo switch increment */
rv = msgcat(rv, conversion);
break;
}
break;
}
/* else fall through */
default:
rv = msgkitten(rv, *c);
break;
}
}
}
