/*
* packweight: Get the total weight of the hero's pack
*/
packweight()
{
struct linked_list *pc;
int weight = 0;
for (pc = pack; pc != NULL; pc = next(pc)) {
struct object *obj = OBJPTR(pc);
weight += itemweight(obj) * obj->o_count;
}
if (weight < 0) /* caused by artifacts or blessed items */
weight = 0;
return (weight);
}
/*
* packweight:
* Get the total weight of the hero's pack
*/
int
packweight(void)
{
reg struct object *obj;
reg struct linked_list *pc;
reg int weight;
weight = 0;
for(pc = pack ; pc != NULL ; pc = next(pc)) {
obj = OBJPTR(pc);
weight += itemweight(obj) * obj->o_count;
}
if(ISWEARING(R_CARRYING))
weight -= (ring_value(R_CARRYING) * weight) / 4;
if(weight < 0) /* in case of artifacts and stuff */
weight = 0;
return(weight);
}
/*
* packweight:
* Get the total weight of the hero's pack
*/
int packweight()
{
struct object *obj;
struct linked_list *pc;
int weight, i;
weight = 0;
for (pc = pack; pc != NULL; pc = next(pc)) {
obj = OBJPTR(pc);
weight += itemweight(obj) * obj->o_count;
}
if (weight < 0) /* in case of amulet */
weight = 0;
for (i = LEFT; i <= RIGHT; i += 1) {
obj = cur_ring[i];
if (obj != NULL) {
if (obj->o_type == R_HEAVY && o_off(obj, ISBLESS))
weight += weight / 4;
}
}
return weight;
}
int
wield_ok(struct thing *wieldee, struct object *obj, int print_message)
{
int ret_val = TRUE;
int class_type = wieldee->t_ctype;
if (obj->o_type != WEAPON)
{
ret_val = FALSE;
return(ret_val);
}
else
switch (class_type)
{
case C_MAGICIAN: /* need one hand free */
case C_ILLUSION:
if (obj->o_flags & ISTWOH)
ret_val = FALSE;
break;
case C_THIEF: /* need portable weapon */
case C_ASSASIN:
case C_NINJA:
if (obj->o_flags & ISTWOH)
ret_val = FALSE;
break;
case C_CLERIC: /* No sharp weapons */
if (obj->o_flags & ISSHARP)
ret_val = FALSE;
break;
case C_DRUID: /* No non-silver metal weapons */
if (obj->o_flags & ISMETAL && !(obj->o_flags & ISSILVER))
ret_val = FALSE;
break;
case C_PALADIN: /* must wield sharp stuff */
if ((obj->o_flags & ISSHARP) == FALSE)
ret_val = FALSE;
break;
case C_FIGHTER: /* wield anything */
case C_RANGER:
case C_MONSTER:
break;
default: /* Unknown class */
debug("Unknown class %d.", class_type);
break;
}
if (itemweight(obj) > 18 * pstats.s_str)
{
if (wieldee == &player && print_message == TRUE)
msg("That is too heavy for you to swing effectively!");
ret_val = FALSE;
return(ret_val);
}
if (ret_val == FALSE && print_message == MESSAGE)
switch (class_type)
{
case C_MAGICIAN:
case C_ILLUSION:
msg("You'll find it hard to cast spells while wielding that!");
break;
case C_THIEF:
case C_ASSASIN:
case C_NINJA:
msg("Don't expect to backstab anyone while wielding that!");
break;
case C_CLERIC:
case C_DRUID:
case C_PALADIN:
msg("Your god strongly disapproves of your wielding that!");
break;
case C_FIGHTER:
case C_RANGER:
case C_MONSTER:
break;
}
return(ret_val);
}
void
new_monster(struct linked_list *item, int type, coord *cp, int max_monster)
{
struct thing *tp;
struct monster *mp;
char *ip, *hitp;
int i, min_intel, max_intel;
int num_dice, num_sides = 8, num_extra = 0;
int eff_charisma = pstats.s_charisma;
int eff_intel = pstats.s_intel;
attach(mlist, item);
tp = THINGPTR(item);
tp->t_index = type;
tp->t_wasshot = FALSE;
tp->t_type = monsters[type].m_appear;
tp->t_ctype = C_MONSTER;
tp->t_no_move = 0;
tp->t_doorgoal = -1;
tp->t_pos = *cp;
tp->t_oldpos = *cp;
tp->t_oldch = CCHAR( 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.s_hpt;
num_dice = atoi(hitp);
if ((hitp = strchr(hitp, 'd')) != NULL)
{
num_sides = atoi(++hitp);
if ((hitp = strchr(hitp, '+')) != NULL)
num_extra = atoi(++hitp);
}
if (max_monster == MAXSTATS)
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_lvl = mp->m_stats.s_lvl;
tp->t_stats.s_arm = mp->m_stats.s_arm;
tp->t_stats.s_dmg = mp->m_stats.s_dmg;
tp->t_stats.s_exp = mp->m_stats.s_exp + mp->m_add_exp * tp->t_stats.s_hpt;
tp->t_stats.s_str = mp->m_stats.s_str;
if (max_level > 30)
{
tp->t_stats.s_hpt += roll(4, (max_level - 60) * 2);
tp->t_stats.s_lvl += roll(4, (max_level - 60) / 8);
tp->t_stats.s_arm -= roll(2, (max_level - 60) / 8);
tp->t_stats.s_str += roll(2, (max_level - 60) / 12);
tp->t_stats.s_exp += roll(4, (max_level - 60) * 2) * mp->m_add_exp;
}
/*
* 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(4);
tp->t_stats.s_dext = 8 + rnd(4);
tp->t_stats.s_const = 8 + rnd(4);
tp->t_stats.s_charisma = 8 + rnd(4);
if (max_level > 45)
tp->t_stats.s_dext += roll(2, (max_level - 50) / 8);
/* Set the initial flags */
for (i = 0; i < 16; i++)
tp->t_flags[i] = 0;
for (i = 0; i < 16; i++)
turn_on(*tp, mp->m_flags[i]);
/* suprising monsters don't always surprise you */
if (!max_monster && on(*tp, CANSURPRISE) && rnd(100) < 20)
turn_off(*tp, CANSURPRISE);
/* If this monster is unique, genocide it */
if (on(*tp, ISUNIQUE))
mp->m_normal = FALSE;
/* gods automatically get special abilities */
if (on(*tp, ISGOD))
{
turn_on(*tp, CANFRIGHTEN);
turn_on(*tp, CANCAST);
turn_on(*tp, CANFLY);
turn_on(*tp, CANBARGAIN);
turn_on(*tp, ISLARGE);
turn_on(*tp, CANTELEPORT);
turn_on(*tp, CANSPEAK);
turn_on(*tp, CANDARKEN);
turn_on(*tp, CANSEE);
turn_on(*tp, CANLIGHT);
turn_on(*tp, BMAGICHIT);
}
tp->t_turn = TRUE;
tp->t_pack = NULL;
/* 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);
}
tp->t_stats.s_power = (rnd(tp->t_stats.s_lvl / 5) + 1) * tp->t_stats.s_intel;
tp->maxstats = tp->t_stats; /* structure assignment */
/* If the monster can shoot, it may have a weapon */
if (on(*tp, CANSHOOT) && (max_monster || rnd(9) < 6))
{
struct linked_list *thrower_item, *missile_item;
struct object *thrower, *a_missile;
thrower_item = new_item(sizeof *thrower);
thrower = OBJPTR(thrower_item);
carried_weapon(tp, thrower);
missile_item = new_item(sizeof *a_missile);
a_missile = OBJPTR(missile_item);
carried_weapon(tp, a_missile);
/* The monster may use a crossbow, sling, footbow, or an arrow */
/* Take racial preferences into account */
if ((strcmp(mp->m_name, "elf") == 0) ||
(strcmp(mp->m_name, "noldor elf") == 0))
{
thrower->o_which = BOW;
if (rnd(5) == 0)
a_missile->o_which = SILVERARROW;
else
a_missile->o_which = ARROW;
}
else if ((strcmp(mp->m_name, "dwarf") == 0) ||
(strcmp(mp->m_name, "kazad dwarf") == 0))
{
thrower->o_which = CROSSBOW;
a_missile->o_which = BOLT;
}
else if (on(*tp, ISSMALL))
{
switch (rnd(3))
{
case 0:
thrower->o_which = SLING;
a_missile->o_which = BULLET;
break;
default:
thrower->o_which = SLING;
a_missile->o_which = ROCK;
}
}
else if (on(*tp, ISLARGE))
{
switch (rnd(4))
{
case 0:
thrower->o_which = CROSSBOW;
a_missile->o_which = BOLT;
break;
case 1:
thrower->o_which = FOOTBOW;
a_missile->o_which = FBBOLT;
break;
default:
thrower->o_which = BOW;
if (rnd(5) == 0)
a_missile->o_which = FLAMEARROW;
else
a_missile->o_which = ARROW;
break;
}
}
else
{
switch (rnd(6))
{
case 1:
thrower->o_which = SLING;
a_missile->o_which = ROCK;
break;
case 2:
thrower->o_which = CROSSBOW;
a_missile->o_which = BOLT;
break;
case 3:
thrower->o_which = FOOTBOW;
a_missile->o_which = FBBOLT;
break;
case 4:
thrower->o_which = BOW;
a_missile->o_which = ARROW;
break;
default:
thrower->o_which = SLING;
a_missile->o_which = BULLET;
break;
}
}
init_weapon(thrower, thrower->o_which);
init_weapon(a_missile, a_missile->o_which);
attach(tp->t_pack, thrower_item);
attach(tp->t_pack, missile_item);
}
/* monsters that wield weapons */
if (on(*tp, CANWIELD))
{
if (max_monster || rnd(3))
{
struct linked_list *wield_item;
struct object *wielded;
wield_item = new_item(sizeof *wielded);
wielded = OBJPTR(wield_item);
carried_weapon(tp, wielded);
i = rnd(CLAYMORE - CLUB) + rnd(2 * tp->t_stats.s_lvl);
i = min(i, CLAYMORE);
wielded->o_which = i;
init_weapon(wielded, wielded->o_which);
/* Is it too heavy? */
if (itemweight(wielded) > 8 * tp->t_stats.s_str)
discard(wield_item);
else
attach(tp->t_pack, wield_item);
}
}
if (is_wearing(R_AGGR))
chase_it(cp, &player);
else
{
turn_off(*tp, ISRUN);
if (on(*tp, ISFLEE) && (rnd(4) == 0))
turn_off(*tp, ISFLEE);
if (rnd(luck) == 0)
switch (player.t_ctype)
{
case C_MAGICIAN:
case C_ILLUSION:
eff_intel = 2 * pstats.s_intel;
break;
case C_DRUID:
eff_intel = 2 * pstats.s_intel;
case C_RANGER:
eff_charisma = 2 * pstats.s_charisma;
break;
case C_ASSASIN:
case C_THIEF:
case C_NINJA:
eff_charisma = pstats.s_charisma / 2;
break;
}
/* LOWFRIENDLY monsters might be friendly */
i = roll(1,100);
if (i == 0 || (on(*tp, LOWFRIENDLY) && i < eff_charisma) ||
(on(*tp, MEDFRIENDLY) && i < 3 * eff_charisma) ||
(on(*tp, HIGHFRIENDLY) && i < 5 * eff_charisma))
{
turn_on(*tp, ISFRIENDLY);
turn_off(*tp, ISMEAN);
}
i = roll(1,100);
if (i == 0 || (on(*tp, LOWCAST) && i < eff_intel) ||
(on(*tp, MEDCAST) && i < 3 * eff_intel) ||
(on(*tp, HIGHCAST) && i < 5 * eff_intel))
{
turn_on(*tp, CANCAST);
}
if (on(*tp, ISDISGUISE))
{
char mch = 0;
if (tp->t_pack != NULL)
mch = (OBJPTR(tp->t_pack))->o_type;
else
switch (rnd(level > arts[0].ar_level ? 10 : 9))
{
case 0: mch = GOLD; break;
case 1: mch = POTION; break;
case 2: mch = SCROLL; break;
case 3: mch = FOOD; break;
case 4: mch = WEAPON; break;
case 5: mch = ARMOR; break;
case 6: mch = RING; break;
case 7: mch = STICK; break;
case 8: mch = monsters[randmonster(NOWANDER, NOGRAB)].m_appear;
break;
case 9: mch = ARTIFACT; break;
}
tp->t_disguise = mch;
}
}
}
int
add_pack(struct linked_list *item, int print_message)
{
struct object *obj, *op;
int from_floor;
if (item == NULL)
{
from_floor = TRUE;
if ((item = find_obj(hero.y, hero.x)) == NULL)
{
msg("Nothing to pick up.");
return(FALSE);
}
}
else
from_floor = FALSE;
if (from_floor)
{
item = get_stack(item);
if (!item)
return(FALSE);
}
obj = OBJPTR(item);
/* If it is gold, just add its value to rogue's purse and get rid of */
if (obj->o_type == GOLD)
{
struct linked_list *mitem;
struct thing *tp;
if (print_message)
{
if (!terse)
addmsg("You found ");
msg("%d gold pieces.", obj->o_count);
}
/*
* First make sure no greedy monster is after this gold. If
* so, make the monster run after the rogue instead.
*/
for (mitem = mlist; mitem != NULL; mitem = next(mitem))
{
tp = THINGPTR(mitem);
if (tp->t_horde==obj)
{
tp->t_ischasing = TRUE;
tp->t_chasee = &player;
tp->t_horde = NULL;
}
}
/*
* This will cause problems if people are able to drop and
* pick up gold, or when GOLDSTEAL monsters are killed.
*/
/* Thieves get EXP for gold they pick up */
if (player.t_ctype == C_THIEF)
{
pstats.s_exp += obj->o_count / 4;
check_level();
}
purse += obj->o_count;
if (from_floor)
rem_obj(item, TRUE); /* Remove object from the level */
return (TRUE);
}
/* see if he can carry any more weight */
if (itemweight(obj) + pstats.s_pack > pstats.s_carry)
{
msg("Too much for you to carry.");
if (print_message)
{
msg("%s onto %s", terse ? "Moved" : "You moved",
inv_name(obj, LOWERCASE));
}
return(FALSE);
}
/*
* Link it into the pack. If the item can be grouped, try to find its
* neighbors and bump the count. A special case is food, which can't
* be grouped, but an exact match allows the count to get
* incremented.
*/
if ((op = apply_to_bag(pack, obj->o_type, bff_group, NULL, obj)) != NULL)
{
op->o_count += obj->o_count; /* add it to the rest */
if (from_floor)
rem_obj(item, FALSE);
pack_report(op, print_message, "You now have ");
return(TRUE);
}
/* Check for and deal with scare monster scrolls */
if (obj->o_type == SCROLL && obj->o_which == S_SCARE)
if (obj->o_flags & ISCURSED)
{
msg("The scroll turns to dust as you pick it up.");
rem_obj(item, TRUE);
return(TRUE);
}
/* Check if there is room */
if (count_bag(pack, obj->o_type, NULL) == max_print())
{
msg("You have no room for more %s.", name_type(obj->o_type));
if (print_message)
{
obj = OBJPTR(item);
msg("%s onto %s.", terse ? "Moved" : "You moved",
inv_name(obj, LOWERCASE));
}
return(FALSE);
}
/*
* finally, add the new item to the bag, and free up the linked list
* on top of it.
*/
if (from_floor)
rem_obj(item, FALSE);
push_bag(&pack, obj);
pack_report(obj, print_message, "You now have ");
ur_free(item);
return(TRUE); /* signal success */
}
/*
* add_pack:
* Pick up an object and add it to the pack. If the argument
* is non-null use it as the linked_list pointer instead of
* getting it off the ground.
*/
bool add_pack(struct linked_list *item,bool silent)
{
struct linked_list *ip, *lp;
struct object *obj, *op;
bool from_floor;
char delchar;
if (player.t_room == NULL)
delchar = PASSAGE;
else
delchar = FLOOR;
if (item == NULL) {
from_floor = TRUE;
if ((item = find_obj(hero.y, hero.x)) == NULL) {
mpos = 0;
msg("That object must have been an illusion.");
mvaddch(hero.y, hero.x, delchar);
return FALSE;
}
/*
* Check for scare monster scrolls
*/
obj = OBJPTR(item);
if (obj->o_type == SCROLL && obj->o_which == S_SCARE) {
if (o_on(obj,ISFOUND)) {
msg("The scroll turns to dust as you pick it up.");
detach(lvl_obj, item);
discard(item);
mvaddch(hero.y, hero.x, delchar);
return FALSE;
}
}
}
else
from_floor = FALSE;
obj = OBJPTR(item);
/*
* See if this guy can carry any more weight
*/
if (itemweight(obj) + him->s_pack > him->s_carry) {
msg("You can't carry that %s.", obj->o_typname);
return FALSE;
}
/*
* Check if there is room
*/
if (packvol + obj->o_vol > V_PACK) {
msg("That %s won't fit in your pack.", obj->o_typname);
return FALSE;
}
if (from_floor) {
detach(lvl_obj, item);
mvaddch(hero.y, hero.x, delchar);
}
item->l_prev = NULL;
item->l_next = NULL;
setoflg(obj, ISFOUND);
/*
* start looking thru pack to find the start of items
* with the same type.
*/
lp = pack;
for (ip = pack; ip != NULL; ip = next(ip)) {
op = OBJPTR(ip);
/*
* If we find a matching type then quit.
*/
if (op->o_type == obj->o_type)
break;
if (next(ip) != NULL)
lp = next(lp); /* update "previous" entry */
}
/*
* If the pack was empty, just stick the item in it.
*/
if (pack == NULL) {
pack = item;
item->l_prev = NULL;
}
/*
* If we looked thru the pack, but could not find an
* item of the same type, then stick it at the end,
* unless it was food, then put it in front.
*/
else if (ip == NULL) {
if (obj->o_type == FOOD) { /* insert food at front */
item->l_next = pack;
pack->l_prev = item;
pack = item;
item->l_prev = NULL;
}
else { /* insert other stuff at back */
lp->l_next = item;
item->l_prev = lp;
}
}
/*
* Here, we found at least one item of the same type.
* Look thru these items to see if there is one of the
* same group. If so, increment the count and throw the
* new item away. If not, stick it at the end of the
* items with the same type. Also keep all similar
* objects near each other, like all identify scrolls, etc.
*/
else {
struct linked_list **save;
while (ip != NULL && op->o_type == obj->o_type) {
if (op->o_group == obj->o_group) {
if (op->o_flags == obj->o_flags) {
op->o_count++;
discard(item);
item = ip;
goto picked_up;
}
else {
goto around;
}
}
if (op->o_which == obj->o_which) {
if (obj->o_type == FOOD)
ip = next(ip);
break;
}
around:
ip = next(ip);
if (ip != NULL) {
op = OBJPTR(ip);
lp = next(lp);
}
}
/*
* If inserting into last of group at end of pack,
* just tack on the end.
*/
if (ip == NULL) {
lp->l_next = item;
item->l_prev = lp;
}
/*
* Insert into the last of a group of objects
* not at the end of the pack.
*/
else {
save = &((ip->l_prev)->l_next);
item->l_next = ip;
item->l_prev = ip->l_prev;
ip->l_prev = item;
*save = item;
}
}
picked_up:
obj = OBJPTR(item);
if (!silent)
msg("%s (%c)",inv_name(obj,FALSE),pack_char(obj));
if (obj->o_type == AMULET)
amulet = TRUE;
updpack(); /* new pack weight & volume */
return TRUE;
}
