/* * 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; }