Import XRogue 8.0 from the Roguelike Restoration Project (r1490)
This commit is contained in:
John "Elwin" Edwards
parent
6af92da76a
commit
034d8d6484
51 changed files with 37250 additions and 0 deletions
865
xrogue/monsters.c
Normal file
865
xrogue/monsters.c
Normal file
|
|
@ -0,0 +1,865 @@
|
|||
/*
|
||||
monsters.c - File with various monster functions in it
|
||||
|
||||
XRogue: Expeditions into the Dungeons of Doom
|
||||
Copyright (C) 1991 Robert Pietkivitch
|
||||
All rights reserved.
|
||||
|
||||
Based on "Advanced Rogue"
|
||||
Copyright (C) 1984, 1985 Michael Morgan, Ken Dalka and AT&T
|
||||
All rights reserved.
|
||||
|
||||
Based on "Rogue: Exploring the Dungeons of Doom"
|
||||
Copyright (C) 1980, 1981 Michael Toy, Ken Arnold and Glenn Wichman
|
||||
All rights reserved.
|
||||
|
||||
See the file LICENSE.TXT for full copyright and licensing information.
|
||||
*/
|
||||
|
||||
#include <curses.h>
|
||||
#include <ctype.h>
|
||||
#include <string.h>
|
||||
#include "rogue.h"
|
||||
|
||||
/*
|
||||
* Check_residue takes care of any effect of the monster
|
||||
*/
|
||||
|
||||
check_residue(tp)
|
||||
register struct thing *tp;
|
||||
{
|
||||
/*
|
||||
* Take care of special abilities
|
||||
*/
|
||||
if (on(*tp, DIDHOLD) && (--hold_count == 0)) {
|
||||
turn_off(player, ISHELD);
|
||||
turn_off(*tp, DIDHOLD);
|
||||
}
|
||||
|
||||
/* If frightened of this monster, stop */
|
||||
if (on(player, ISFLEE) &&
|
||||
player.t_dest == &tp->t_pos) turn_off(player, ISFLEE);
|
||||
|
||||
/* If monster was suffocating player, stop it */
|
||||
if (on(*tp, DIDSUFFOCATE)) {
|
||||
extinguish(suffocate);
|
||||
turn_off(*tp, DIDSUFFOCATE);
|
||||
}
|
||||
|
||||
/* If something with fire, may darken */
|
||||
if (on(*tp, HASFIRE)) {
|
||||
register struct room *rp=roomin(&tp->t_pos);
|
||||
register struct linked_list *fire_item;
|
||||
|
||||
if (rp) {
|
||||
for (fire_item = rp->r_fires; fire_item != NULL;
|
||||
fire_item = next(fire_item)) {
|
||||
if (THINGPTR(fire_item) == tp) {
|
||||
detach(rp->r_fires, fire_item);
|
||||
destroy_item(fire_item);
|
||||
if (rp->r_fires == NULL) {
|
||||
rp->r_flags &= ~HASFIRE;
|
||||
if (cansee(tp->t_pos.y, tp->t_pos.x)) light(&hero);
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Creat_mons creates the specified monster -- any if 0
|
||||
*/
|
||||
|
||||
bool
|
||||
creat_mons(person, monster, report)
|
||||
struct thing *person; /* Where to create next to */
|
||||
short monster;
|
||||
bool report;
|
||||
{
|
||||
struct linked_list *nitem;
|
||||
register struct thing *tp;
|
||||
struct room *rp;
|
||||
coord *mp;
|
||||
|
||||
if (levtype == POSTLEV)
|
||||
return(FALSE);
|
||||
if ((mp = fallpos(&(person->t_pos), FALSE, 2)) != NULL) {
|
||||
nitem = new_item(sizeof (struct thing));
|
||||
new_monster(nitem,
|
||||
monster == 0 ? randmonster(FALSE, FALSE)
|
||||
: monster,
|
||||
mp,
|
||||
TRUE);
|
||||
tp = THINGPTR(nitem);
|
||||
runto(tp, &hero);
|
||||
carry_obj(tp, monsters[tp->t_index].m_carry/2); /* only half chance */
|
||||
|
||||
/* since it just got here, it is disoriented */
|
||||
tp->t_no_move = 2 * movement(tp);
|
||||
|
||||
if (on(*tp, HASFIRE)) {
|
||||
rp = roomin(&tp->t_pos);
|
||||
if (rp) {
|
||||
register struct linked_list *fire_item;
|
||||
|
||||
/* Put the new fellow in the room list */
|
||||
fire_item = creat_item();
|
||||
ldata(fire_item) = (char *) tp;
|
||||
attach(rp->r_fires, fire_item);
|
||||
|
||||
rp->r_flags |= HASFIRE;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* If we can see this monster, set oldch to ' ' to make light()
|
||||
* think the creature used to be invisible (ie. not seen here)
|
||||
*/
|
||||
if (cansee(tp->t_pos.y, tp->t_pos.x)) tp->t_oldch = ' ';
|
||||
return(TRUE);
|
||||
}
|
||||
if (report) msg("You hear a faint cry of anguish in the distance.. ");
|
||||
return(FALSE);
|
||||
}
|
||||
|
||||
/*
|
||||
* Genmonsters:
|
||||
* Generate at least 'least' monsters for this single room level.
|
||||
* 'Treas' indicates whether this is a "treasure" level.
|
||||
*/
|
||||
|
||||
void
|
||||
genmonsters(least, treas)
|
||||
register int least;
|
||||
bool treas;
|
||||
{
|
||||
reg int i;
|
||||
reg struct room *rp = &rooms[0];
|
||||
reg struct linked_list *item;
|
||||
reg struct thing *mp;
|
||||
coord tp;
|
||||
|
||||
for (i = 0; i < (max(50, level) + least); i++) {
|
||||
if (!treas && rnd(100) < 65) /* put in some little buggers */
|
||||
continue;
|
||||
|
||||
/*
|
||||
* Put the monster in
|
||||
*/
|
||||
item = new_item(sizeof *mp);
|
||||
mp = THINGPTR(item);
|
||||
do {
|
||||
rnd_pos(rp, &tp);
|
||||
} until(mvwinch(stdscr, tp.y, tp.x) == FLOOR);
|
||||
|
||||
new_monster(item, randmonster(FALSE, FALSE), &tp, FALSE);
|
||||
/*
|
||||
* See if we want to give it a treasure to carry around.
|
||||
*/
|
||||
carry_obj(mp, monsters[mp->t_index].m_carry);
|
||||
|
||||
/* Calculate a movement rate */
|
||||
mp->t_no_move = movement(mp);
|
||||
|
||||
/* Is it going to give us some light? */
|
||||
if (on(*mp, HASFIRE)) {
|
||||
register struct linked_list *fire_item;
|
||||
|
||||
fire_item = creat_item();
|
||||
ldata(fire_item) = (char *) mp;
|
||||
attach(rp->r_fires, fire_item);
|
||||
rp->r_flags |= HASFIRE;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* id_monst returns the index of the monster given its letter
|
||||
*/
|
||||
|
||||
short
|
||||
id_monst(monster)
|
||||
register char monster;
|
||||
{
|
||||
register short result;
|
||||
|
||||
if (levtype == OUTSIDE) {
|
||||
result = NLEVMONS*vlevel + (NUMMONST-NUMDINOS-1);
|
||||
if (result > NUMMONST) result = NUMMONST;
|
||||
}
|
||||
else {
|
||||
result = NLEVMONS*vlevel;
|
||||
if (result > NUMMONST-NUMDINOS) result = NUMMONST-NUMDINOS;
|
||||
}
|
||||
|
||||
if (levtype == OUTSIDE) {
|
||||
for(; result>(NUMMONST-NUMDINOS-1); result--)
|
||||
if (monsters[result].m_appear == monster) return(result);
|
||||
for (result=(NLEVMONS*vlevel)+1; result <= NUMMONST-NUMDINOS; result++)
|
||||
if (monsters[result].m_appear == monster) return(result);
|
||||
}
|
||||
else {
|
||||
for(; result>0; result--)
|
||||
if (monsters[result].m_appear == monster) return(result);
|
||||
for (result=(NLEVMONS*vlevel)+1; result <= NUMMONST; result++)
|
||||
if (monsters[result].m_appear == monster) return(result);
|
||||
}
|
||||
return(0);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* new_monster:
|
||||
* Pick a new monster and add it to the list
|
||||
*/
|
||||
|
||||
new_monster(item, type, cp, max_monster)
|
||||
struct linked_list *item;
|
||||
short type;
|
||||
coord *cp;
|
||||
bool max_monster;
|
||||
{
|
||||
register struct thing *tp;
|
||||
register struct monster *mp;
|
||||
register char *ip, *hitp;
|
||||
register int i, min_intel, max_intel;
|
||||
register int num_dice, num_sides=8, num_extra=0;
|
||||
|
||||
attach(mlist, item);
|
||||
tp = THINGPTR(item);
|
||||
tp->t_pack = NULL;
|
||||
tp->t_index = type;
|
||||
tp->t_wasshot = FALSE;
|
||||
tp->t_type = monsters[type].m_appear;
|
||||
tp->t_ctype = C_MONSTER;
|
||||
tp->t_action = A_NIL;
|
||||
tp->t_doorgoal.x = tp->t_doorgoal.y = -1;
|
||||
tp->t_quiet = 0;
|
||||
tp->t_dest = NULL;
|
||||
tp->t_name = NULL;
|
||||
tp->t_pos = tp->t_oldpos = *cp;
|
||||
tp->t_oldch = mvwinch(cw, cp->y, cp->x);
|
||||
mvwaddch(mw, cp->y, cp->x, tp->t_type);
|
||||
mp = &monsters[tp->t_index];
|
||||
|
||||
/* Figure out monster's hit points */
|
||||
hitp = mp->m_stats.ms_hpt;
|
||||
num_dice = atoi(hitp);
|
||||
if ((hitp = strchr(hitp, 'd')) != NULL) {
|
||||
num_sides = atoi(++hitp);
|
||||
if ((hitp = strchr(hitp, '+')) != NULL)
|
||||
num_extra = atoi(++hitp);
|
||||
}
|
||||
|
||||
tp->t_stats.s_lvladj = 0;
|
||||
tp->t_stats.s_lvl = mp->m_stats.ms_lvl;
|
||||
tp->t_stats.s_arm = mp->m_stats.ms_arm;
|
||||
strcpy(tp->t_stats.s_dmg,mp->m_stats.ms_dmg);
|
||||
tp->t_stats.s_str = mp->m_stats.ms_str;
|
||||
tp->t_stats.s_dext = mp->m_stats.ms_dex;
|
||||
tp->t_movement = mp->m_stats.ms_move;
|
||||
if (vlevel > HARDER) { /* the deeper, the meaner we get */
|
||||
tp->t_stats.s_lvl += (vlevel - HARDER);
|
||||
num_dice += (vlevel - HARDER)/2;
|
||||
tp->t_stats.s_arm -= (vlevel - HARDER) / 4;
|
||||
}
|
||||
if (max_monster)
|
||||
tp->t_stats.s_hpt = num_dice * num_sides + num_extra;
|
||||
else
|
||||
tp->t_stats.s_hpt = roll(num_dice, num_sides) + num_extra;
|
||||
tp->t_stats.s_exp = mp->m_stats.ms_exp + mp->m_add_exp*tp->t_stats.s_hpt;
|
||||
|
||||
/*
|
||||
* just initailize others values to something reasonable for now
|
||||
* maybe someday will *really* put these in monster table
|
||||
*/
|
||||
tp->t_stats.s_wisdom = 8 + rnd(7);
|
||||
tp->t_stats.s_const = 8 + rnd(7);
|
||||
tp->t_stats.s_charisma = 8 + rnd(7);
|
||||
|
||||
/* Set the initial flags */
|
||||
for (i=0; i<16; i++) tp->t_flags[i] = 0;
|
||||
for (i=0; i<MAXFLAGS; i++)
|
||||
turn_on(*tp, mp->m_flags[i]);
|
||||
|
||||
/*
|
||||
* these are the base chances that a creatures will do something
|
||||
* assuming it can. These are(or can be) modified at runtime
|
||||
* based on what the creature experiences
|
||||
*/
|
||||
tp->t_breathe = 70; /* base chance of breathing */
|
||||
tp->t_artifact = 90; /* base chance of using artifact */
|
||||
tp->t_summon = 50; /* base chance of summoning */
|
||||
tp->t_cast = 70; /* base chance of casting a spell */
|
||||
tp->t_wand = on(*tp, ISUNIQUE) ? 35 : 50; /* base chance of using wands */
|
||||
|
||||
/* suprising monsters don't always surprise you */
|
||||
if (!max_monster && on(*tp, CANSURPRISE) &&
|
||||
off(*tp, ISUNIQUE) && rnd(100) < 25)
|
||||
turn_off(*tp, CANSURPRISE);
|
||||
|
||||
/* If this monster is unique, gen it */
|
||||
if (on(*tp, ISUNIQUE)) mp->m_normal = FALSE;
|
||||
|
||||
/*
|
||||
* If it is the quartermaster, then compute his level and exp pts
|
||||
* based on the level. This will make it fair when thieves try to
|
||||
* steal and give them reasonable experience if they succeed.
|
||||
* Then fill his pack with his wares.
|
||||
*/
|
||||
if (on(*tp, CANSELL)) {
|
||||
tp->t_stats.s_exp = vlevel * 100;
|
||||
tp->t_stats.s_lvl = vlevel/2 + 1;
|
||||
make_sell_pack(tp);
|
||||
}
|
||||
|
||||
/* Normally scared monsters have a chance to not be scared */
|
||||
if (on(*tp, ISFLEE) && (rnd(4) == 0)) turn_off(*tp, ISFLEE);
|
||||
|
||||
/* Figure intelligence */
|
||||
min_intel = atoi(mp->m_intel);
|
||||
if ((ip = (char *) strchr(mp->m_intel, '-')) == NULL)
|
||||
tp->t_stats.s_intel = min_intel;
|
||||
else {
|
||||
max_intel = atoi(++ip);
|
||||
if (max_monster)
|
||||
tp->t_stats.s_intel = max_intel;
|
||||
else
|
||||
tp->t_stats.s_intel = min_intel + rnd(max_intel - min_intel);
|
||||
}
|
||||
if (vlevel > HARDER)
|
||||
tp->t_stats.s_intel += ((vlevel - HARDER)/2);
|
||||
tp->maxstats = tp->t_stats;
|
||||
|
||||
/* If the monster can shoot, it may have a weapon */
|
||||
if (on(*tp, CANSHOOT) && ((rnd(100) < (20 + vlevel)) || max_monster)) {
|
||||
struct linked_list *item1;
|
||||
register struct object *cur, *cur1;
|
||||
|
||||
item = new_item(sizeof *cur);
|
||||
item1 = new_item(sizeof *cur1);
|
||||
cur = OBJPTR(item);
|
||||
cur1 = OBJPTR(item1);
|
||||
cur->o_hplus = (rnd(4) < 3) ? 0
|
||||
: (rnd(3) + 1) * ((rnd(3) < 2) ? 1 : -1);
|
||||
cur->o_dplus = (rnd(4) < 3) ? 0
|
||||
: (rnd(3) + 1) * ((rnd(3) < 2) ? 1 : -1);
|
||||
cur1->o_hplus = (rnd(4) < 3) ? 0
|
||||
: (rnd(3) + 1) * ((rnd(3) < 2) ? 1 : -1);
|
||||
cur1->o_dplus = (rnd(4) < 3) ? 0
|
||||
: (rnd(3) + 1) * ((rnd(3) < 2) ? 1 : -1);
|
||||
strcpy(cur->o_damage,"0d0");
|
||||
strcpy(cur->o_hurldmg,"0d0");
|
||||
strcpy(cur1->o_damage,"0d0");
|
||||
strcpy(cur1->o_hurldmg,"0d0");
|
||||
cur->o_ac = cur1->o_ac = 11;
|
||||
cur->o_count = cur1->o_count = 1;
|
||||
cur->o_group = cur1->o_group = 0;
|
||||
cur->contents = cur1->contents = NULL;
|
||||
if ((cur->o_hplus <= 0) && (cur->o_dplus <= 0)) cur->o_flags = ISCURSED;
|
||||
if ((cur1->o_hplus <= 0) && (cur1->o_dplus <= 0))
|
||||
cur1->o_flags = ISCURSED;
|
||||
cur->o_flags = cur1->o_flags = 0;
|
||||
cur->o_type = cur1->o_type = WEAPON;
|
||||
cur->o_mark[0] = cur1->o_mark[0] = '\0';
|
||||
|
||||
/* The monster may use a crossbow, sling, or an arrow */
|
||||
i = rnd(100);
|
||||
if (i < 35) {
|
||||
cur->o_which = CROSSBOW;
|
||||
cur1->o_which = BOLT;
|
||||
init_weapon(cur, CROSSBOW);
|
||||
init_weapon(cur1, BOLT);
|
||||
}
|
||||
else if (i < 70) {
|
||||
cur->o_which = BOW;
|
||||
cur1->o_which = ARROW;
|
||||
init_weapon(cur, BOW);
|
||||
init_weapon(cur1, ARROW);
|
||||
}
|
||||
else {
|
||||
cur->o_which = SLING;
|
||||
cur1->o_which = ROCK;
|
||||
init_weapon(cur, SLING);
|
||||
init_weapon(cur1, ROCK);
|
||||
}
|
||||
|
||||
attach(tp->t_pack, item);
|
||||
attach(tp->t_pack, item1);
|
||||
}
|
||||
|
||||
|
||||
/* Calculate the initial movement rate */
|
||||
updpack(TRUE, tp);
|
||||
tp->t_no_move = movement(tp);
|
||||
|
||||
if (ISWEARING(R_AGGR))
|
||||
runto(tp, &hero);
|
||||
|
||||
if (on(*tp, ISDISGUISE))
|
||||
{
|
||||
char mch = 0;
|
||||
|
||||
if (tp->t_pack != NULL)
|
||||
mch = (OBJPTR(tp->t_pack))->o_type;
|
||||
else
|
||||
switch (rnd(10)) {
|
||||
case 0: mch = GOLD;
|
||||
when 1: mch = POTION;
|
||||
when 2: mch = SCROLL;
|
||||
when 3: mch = FOOD;
|
||||
when 4: mch = WEAPON;
|
||||
when 5: mch = ARMOR;
|
||||
when 6: mch = RING;
|
||||
when 7: mch = STICK;
|
||||
when 8: mch = monsters[randmonster(FALSE, FALSE)].m_appear;
|
||||
when 9: mch = MM;
|
||||
}
|
||||
tp->t_disguise = mch;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* randmonster:
|
||||
* Pick a monster to show up. The lower the level,
|
||||
* the meaner the monster.
|
||||
*/
|
||||
|
||||
short
|
||||
randmonster(wander, no_unique)
|
||||
register bool wander, no_unique;
|
||||
{
|
||||
register int d, cur_level, range, i;
|
||||
|
||||
/*
|
||||
* Do we want a merchant? Merchant is always in place 'NUMMONST'
|
||||
*/
|
||||
if (wander && monsters[NUMMONST].m_wander && rnd(100) < pstats.s_charisma/3)
|
||||
return NUMMONST;
|
||||
|
||||
cur_level = vlevel;
|
||||
range = (4*NLEVMONS)+1; /* range is 0 thru 12 */
|
||||
i = 0;
|
||||
do
|
||||
{
|
||||
if (i++ > NUMMONST-1) { /* in case all have be genocided */
|
||||
i = 0;
|
||||
if (--cur_level <= 0)
|
||||
fatal("rogue: Could not find a monster to make! ");
|
||||
}
|
||||
if (levtype == OUTSIDE) { /* create DINOSUARS */
|
||||
d = (cur_level - rnd(range/2)) + (NUMMONST-NUMDINOS-1);
|
||||
if (d < NUMMONST-NUMDINOS)
|
||||
d = (NUMMONST-NUMDINOS) + rnd(range/2);
|
||||
if (d > NUMMONST-1)
|
||||
d = (NUMMONST-NUMDINOS) + rnd(NUMDINOS);
|
||||
}
|
||||
else { /* Create NORMALs and UNIQs here */
|
||||
d = (NLEVMONS*(cur_level-1) + rnd(range) - (range-NLEVMONS-1));
|
||||
if (d < 1) d = rnd(6)+1;
|
||||
|
||||
if (d > NUMMONST-NUMDINOS-1) { /* Entire range NORMs + UNIQs */
|
||||
if (no_unique) /* Choose from last 12 NORMAL monsters */
|
||||
d = (NUMMONST-NUMDINOS-NUMUNIQUE-1) - rnd(NUMUNIQUE/5);
|
||||
else /* Choose from entire UNIQ monsters + range */
|
||||
d = (NUMMONST-NUMDINOS-1) - rnd(NUMUNIQUE+range);
|
||||
}
|
||||
/* Half-way into the UNIQs now */
|
||||
else if (d > (NUMMONST-NUMDINOS-(NUMUNIQUE/2)-1)) {
|
||||
if (no_unique) /* Choose from last 15 NORMAL monsters */
|
||||
d = (NUMMONST-NUMDINOS-NUMUNIQUE-1) - rnd(NUMUNIQUE/4);
|
||||
else /* Choose from entire UNIQ monsters + range */
|
||||
d = (NUMMONST-NUMDINOS-1) - rnd(NUMUNIQUE+range);
|
||||
}
|
||||
/* End NORMALs and begin relic bearing UNIQs */
|
||||
else if (d > (NUMMONST-NUMDINOS-NUMUNIQUE-1)) {
|
||||
if (no_unique) /* Choose from last 20 NORMAL monsters */
|
||||
d = (NUMMONST-NUMDINOS-NUMUNIQUE-1) - rnd(NUMUNIQUE/3);
|
||||
else /* Choose from first 20 UNIQ monsters */
|
||||
d = (NUMMONST-NUMDINOS-NUMUNIQUE-1) + rnd(NUMUNIQUE/3);
|
||||
}
|
||||
}
|
||||
}
|
||||
while (wander ? !monsters[d].m_wander || !monsters[d].m_normal
|
||||
: !monsters[d].m_normal);
|
||||
return d;
|
||||
}
|
||||
|
||||
/* Sell displays a menu of goods from which the player may choose
|
||||
* to purchase something.
|
||||
*/
|
||||
|
||||
sell(tp)
|
||||
register struct thing *tp;
|
||||
{
|
||||
register struct linked_list *item, *seller;
|
||||
register struct linked_list *sellpack;
|
||||
register struct object *obj;
|
||||
register long worth, min_worth;
|
||||
char buffer[LINELEN];
|
||||
|
||||
/*
|
||||
* Get a linked_list pointer to the seller. We need this in case
|
||||
* he disappears so we can set him ISDEAD.
|
||||
*/
|
||||
seller = find_mons(tp->t_pos.y, tp->t_pos.x);
|
||||
|
||||
sellpack = tp->t_pack;
|
||||
if (sellpack == NULL) {
|
||||
msg("%s looks puzzled and departs.", prname(monster_name(tp), TRUE));
|
||||
|
||||
/* Get rid of the monster */
|
||||
killed(seller, FALSE, FALSE, FALSE);
|
||||
return;
|
||||
}
|
||||
|
||||
/* See how much the minimum pack item is worth */
|
||||
min_worth = 100000;
|
||||
for (item = sellpack; item != NULL; item = next(item)) {
|
||||
obj = OBJPTR(item);
|
||||
obj->o_flags |= ISPOST; /* Force a long description of the item */
|
||||
worth = get_worth(obj);
|
||||
if (worth < min_worth) min_worth = worth;
|
||||
}
|
||||
|
||||
/* See if player can afford an item */
|
||||
if (min_worth > purse) {
|
||||
msg("%s eyes your small purse and departs.",
|
||||
prname(monster_name(tp), TRUE));
|
||||
|
||||
/* Get rid of the monster */
|
||||
killed(seller, FALSE, FALSE, FALSE);
|
||||
return;
|
||||
}
|
||||
|
||||
/* Announce our intentions */
|
||||
msg("%s opens his pack. --More--", prname(monster_name(tp), TRUE));
|
||||
wait_for(' ');
|
||||
|
||||
/* Try to sell something */
|
||||
sprintf(buffer, "You got %ld gold pieces. Buy", purse);
|
||||
item = get_item(sellpack, buffer, ALL, TRUE, TRUE);
|
||||
|
||||
/* Get rid of the monster */
|
||||
if (item != NULL) detach(tp->t_pack, item); /* Take it out of the pack */
|
||||
killed(seller, FALSE, FALSE, FALSE);
|
||||
|
||||
if (item == NULL) return;
|
||||
|
||||
/* Can he afford the selected item? */
|
||||
obj = OBJPTR(item);
|
||||
|
||||
worth = get_worth(obj);
|
||||
if (worth > purse) {
|
||||
msg("You cannot afford it.");
|
||||
o_discard(item);
|
||||
return;
|
||||
}
|
||||
|
||||
/* Charge him through the nose */
|
||||
purse -= worth;
|
||||
|
||||
/* If a stick or ring, let player know the type */
|
||||
switch (obj->o_type) {
|
||||
case RING: r_know[obj->o_which] = TRUE;
|
||||
when POTION: p_know[obj->o_which] = TRUE;
|
||||
when SCROLL: s_know[obj->o_which] = TRUE;
|
||||
when STICK: ws_know[obj->o_which] = TRUE;
|
||||
when MM: m_know[obj->o_which] = TRUE;
|
||||
|
||||
}
|
||||
|
||||
/* identify it */
|
||||
whatis (item);
|
||||
|
||||
/* Remove the POST flag that we used for get_item() */
|
||||
obj->o_flags &= ~ISPOST;
|
||||
|
||||
if (add_pack(item, FALSE) == FALSE) {
|
||||
obj->o_pos = hero;
|
||||
fall(item, TRUE);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* what to do when the hero steps next to a monster
|
||||
*/
|
||||
|
||||
struct linked_list *
|
||||
wake_monster(y, x)
|
||||
int y, x;
|
||||
{
|
||||
register struct thing *tp;
|
||||
register struct linked_list *it;
|
||||
register struct room *trp;
|
||||
register char *mname;
|
||||
bool nasty; /* Will the monster "attack"? */
|
||||
|
||||
if ((it = find_mons(y, x)) == NULL) {
|
||||
msg("Wake: can't find monster in show (%d, %d)", y, x);
|
||||
return (NULL);
|
||||
}
|
||||
tp = THINGPTR(it);
|
||||
if (on(*tp, ISSTONE)) /* if stoned, don't do anything */
|
||||
return it;
|
||||
|
||||
/*
|
||||
* For now, if we are a friendly monster, we won't do any of
|
||||
* our special effects.
|
||||
*/
|
||||
if (on(*tp, ISFRIENDLY)) return it;
|
||||
|
||||
trp = roomin(&tp->t_pos); /* Current room for monster */
|
||||
|
||||
/*
|
||||
* Let greedy ones in a room guard gold
|
||||
* (except in a maze where lots of creatures would all go for the
|
||||
* same piece of gold)
|
||||
*/
|
||||
if (on(*tp, ISGREED) && off(*tp, ISRUN) && levtype != MAZELEV &&
|
||||
trp != NULL && lvl_obj != NULL) {
|
||||
register struct linked_list *item;
|
||||
register struct object *cur;
|
||||
|
||||
for (item = lvl_obj; item != NULL; item = next(item)) {
|
||||
cur = OBJPTR(item);
|
||||
if ((cur->o_type == GOLD) && (roomin(&cur->o_pos) == trp)) {
|
||||
/* Run to the gold */
|
||||
runto(tp, &cur->o_pos);
|
||||
|
||||
/* Make it worth protecting */
|
||||
cur->o_count += GOLDCALC + GOLDCALC;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Every time he sees mean monster, it might start chasing him
|
||||
*/
|
||||
if (on(*tp, ISMEAN) &&
|
||||
off(*tp, ISHELD) &&
|
||||
off(*tp, ISRUN) &&
|
||||
rnd(100) > 35 &&
|
||||
(!is_stealth(&player) || (on(*tp, ISUNIQUE) && rnd(100) > 35)) &&
|
||||
(off(player, ISINVIS) || on(*tp, CANSEE)) ||
|
||||
(trp != NULL && (trp->r_flags & ISTREAS))) {
|
||||
runto(tp, &hero);
|
||||
}
|
||||
|
||||
/*
|
||||
* Get the name; we don't want to do it until here because we need to
|
||||
* know whether the monster is still sleeping or not.
|
||||
*/
|
||||
mname = monster_name(tp);
|
||||
|
||||
/* See if the monster will bother the player */
|
||||
nasty = (on(*tp, ISRUN) && cansee(tp->t_pos.y, tp->t_pos.x));
|
||||
|
||||
/*
|
||||
* if the creature is awake and can see the player and the
|
||||
* player has the dreaded "eye of vecna" then see if the
|
||||
* creature is turned to stone
|
||||
*/
|
||||
if (cur_relic[EYE_VECNA] && nasty && off(*tp, NOSTONE) &&
|
||||
(off(player, ISINVIS) || on(*tp, CANSEE))) {
|
||||
turn_on(*tp, NOSTONE); /* only have to save once */
|
||||
if (!save(VS_PETRIFICATION, tp, -2)) {
|
||||
turn_on(*tp, ISSTONE);
|
||||
turn_off(*tp, ISRUN);
|
||||
turn_off(*tp, ISINVIS);
|
||||
turn_off(*tp, CANSURPRISE);
|
||||
turn_off(*tp, ISDISGUISE);
|
||||
msg("%s is turned to stone!", prname(mname, TRUE));
|
||||
return it;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Handle monsters that can gaze and do things while running
|
||||
* Player must be able to see the monster and the monster must
|
||||
* not be asleep
|
||||
*/
|
||||
if (nasty && !invisible(tp)) {
|
||||
/*
|
||||
* Confusion
|
||||
*/
|
||||
if (on(*tp, CANHUH) &&
|
||||
(off(*tp, ISINVIS) || on(player, CANSEE)) &&
|
||||
(off(*tp, CANSURPRISE) || ISWEARING(R_ALERT))) {
|
||||
if (!save(VS_MAGIC, &player, 0)) {
|
||||
if (off(player, ISCLEAR)) {
|
||||
if (find_slot(unconfuse))
|
||||
lengthen(unconfuse, HUHDURATION);
|
||||
else {
|
||||
fuse(unconfuse, (VOID *)NULL, HUHDURATION, AFTER);
|
||||
msg("%s's gaze has confused you.",prname(mname, TRUE));
|
||||
turn_on(player, ISHUH);
|
||||
}
|
||||
}
|
||||
else msg("You feel dizzy for a moment, but it quickly passes.");
|
||||
}
|
||||
else if (rnd(100) < 67)
|
||||
turn_off(*tp, CANHUH); /* Once you save, maybe that's it */
|
||||
}
|
||||
|
||||
/* Sleep */
|
||||
if(on(*tp, CANSNORE) &&
|
||||
player.t_action != A_FREEZE &&
|
||||
!save(VS_PARALYZATION, &player, 0)) {
|
||||
if (ISWEARING(R_ALERT))
|
||||
msg("You feel drowsy for a moment.. ");
|
||||
else {
|
||||
msg("%s's gaze puts you to sleep! ", prname(mname, TRUE));
|
||||
player.t_no_move += movement(&player) * SLEEPTIME;
|
||||
player.t_action = A_FREEZE;
|
||||
if (rnd(100) < 50) turn_off(*tp, CANSNORE);
|
||||
}
|
||||
}
|
||||
|
||||
/* Fear */
|
||||
if (on(*tp, CANFRIGHTEN) && !on(player, ISFLEE)) {
|
||||
turn_off(*tp, CANFRIGHTEN);
|
||||
if (!ISWEARING(R_HEROISM) &&
|
||||
!save(VS_WAND, &player, -(tp->t_stats.s_lvl/10))) {
|
||||
turn_on(player, ISFLEE);
|
||||
player.t_dest = &tp->t_pos;
|
||||
msg("The sight of %s terrifies you!", prname(mname, FALSE));
|
||||
}
|
||||
}
|
||||
|
||||
/* blinding creatures */
|
||||
if(on(*tp, CANBLIND) && !find_slot(sight)) {
|
||||
turn_off(*tp, CANBLIND);
|
||||
if (!save(VS_WAND, &player, 0)) {
|
||||
msg("The gaze of %s blinds you! ", prname(mname, FALSE));
|
||||
turn_on(player, ISBLIND);
|
||||
fuse(sight, (VOID *)NULL, rnd(30)+20, AFTER);
|
||||
light(&hero);
|
||||
}
|
||||
}
|
||||
|
||||
/* the sight of the ghost can age you! */
|
||||
if (on(*tp, CANAGE)) {
|
||||
turn_off (*tp, CANAGE);
|
||||
if (!save(VS_MAGIC, &player, 0)) {
|
||||
msg ("The sight of %s ages you!", prname(mname, FALSE));
|
||||
pstats.s_const--;
|
||||
/* max_stats.s_const--; */
|
||||
if (pstats.s_const < 1) {
|
||||
pstats.s_hpt = -1;
|
||||
death (D_CONSTITUTION);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Turning to stone */
|
||||
if (on(*tp, LOOKSTONE)) {
|
||||
turn_off(*tp, LOOKSTONE);
|
||||
|
||||
if (on(player, CANINWALL))
|
||||
msg("The gaze of %s has no effect.", prname(mname, FALSE));
|
||||
else {
|
||||
if (!save(VS_PETRIFICATION, &player, 0) && rnd(100) < 5) {
|
||||
pstats.s_hpt = -1;
|
||||
msg("The gaze of %s petrifies you!", prname(mname, FALSE));
|
||||
msg("You are turned to stone!!! --More--");
|
||||
wait_for(' ');
|
||||
death(D_PETRIFY);
|
||||
}
|
||||
else {
|
||||
msg("The gaze of %s stiffens your limbs.",
|
||||
prname(mname, FALSE));
|
||||
player.t_no_move += movement(&player) * STONETIME;
|
||||
player.t_action = A_FREEZE;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return it;
|
||||
}
|
||||
/*
|
||||
* wanderer:
|
||||
* A wandering monster has awakened and is headed for the player
|
||||
*/
|
||||
|
||||
wanderer()
|
||||
{
|
||||
register int i;
|
||||
register struct room *hr = roomin(&hero);
|
||||
register struct linked_list *item;
|
||||
register struct thing *tp;
|
||||
register long *attr; /* Points to monsters' attributes */
|
||||
int carry; /* Chance of wanderer carrying anything */
|
||||
short rmonst; /* Our random wanderer */
|
||||
bool canteleport = FALSE, /* Can the monster teleport? */
|
||||
seehim; /* Is monster within sight? */
|
||||
coord cp;
|
||||
|
||||
rmonst = randmonster(TRUE, FALSE); /* Choose a random wanderer */
|
||||
attr = &monsters[rmonst].m_flags[0]; /* Start of attributes */
|
||||
for (i=0; i<MAXFLAGS; i++)
|
||||
if (*attr++ == CANTELEPORT) {
|
||||
canteleport = TRUE;
|
||||
break;
|
||||
}
|
||||
|
||||
/* Find a place for it -- avoid the player's room if can't teleport */
|
||||
do {
|
||||
do {
|
||||
i = rnd_room();
|
||||
} until (canteleport || hr != &rooms[i] || levtype == MAZELEV ||
|
||||
levtype == OUTSIDE);
|
||||
|
||||
/* Make sure the monster does not teleport on top of the player */
|
||||
do {
|
||||
rnd_pos(&rooms[i], &cp);
|
||||
} while (hr == &rooms[i] && ce(cp, hero));
|
||||
} until (step_ok(cp.y, cp.x, NOMONST, (struct thing *)NULL));
|
||||
|
||||
/* Create a new wandering monster */
|
||||
item = new_item(sizeof *tp);
|
||||
new_monster(item, rmonst, &cp, FALSE);
|
||||
tp = THINGPTR(item);
|
||||
runto(tp, &hero);
|
||||
tp->t_pos = cp; /* Assign the position to the monster */
|
||||
seehim = cansee(tp->t_pos.y, tp->t_pos.x);
|
||||
if (on(*tp, HASFIRE)) {
|
||||
register struct room *rp;
|
||||
|
||||
rp = roomin(&tp->t_pos);
|
||||
if (rp) {
|
||||
register struct linked_list *fire_item;
|
||||
|
||||
fire_item = creat_item();
|
||||
ldata(fire_item) = (char *) tp;
|
||||
attach(rp->r_fires, fire_item);
|
||||
|
||||
rp->r_flags |= HASFIRE;
|
||||
if (seehim && next(rp->r_fires) == NULL)
|
||||
light(&hero);
|
||||
}
|
||||
}
|
||||
|
||||
/* See if we give the monster anything */
|
||||
carry = monsters[tp->t_index].m_carry;
|
||||
if (off(*tp, ISUNIQUE)) carry /= 2; /* Non-unique has only a half chance */
|
||||
carry_obj(tp, carry);
|
||||
|
||||
/* Calculate its movement rate */
|
||||
tp->t_no_move = movement(tp);
|
||||
|
||||
/* Alert the player if a monster just teleported in */
|
||||
if (hr == &rooms[i] && canteleport && seehim && !invisible(tp)) {
|
||||
msg("A %s just teleported in", monster_name(tp));
|
||||
light(&hero);
|
||||
running = FALSE;
|
||||
}
|
||||
|
||||
if (wizard)
|
||||
msg("Started a wandering %s", monster_name(tp));
|
||||
}
|
||||
|
||||
Loading…
Add table
Add a link
Reference in a new issue