games-request@tekred.TEK.COM (11/05/87)
Submitted by: "James E. Wilson" <wilson@ji.berkeley.edu>
Comp.sources.games: Volume 2, Issue 75
Archive-name: umoria/Part10
#! /bin/sh
# This is a shell archive. Remove anything before this line, then unpack
# it by saving it into a file and typing "sh file". To overwrite existing
# files, type "sh file -c". You can also feed this as standard input via
# unshar, or by typing "sh <file", e.g.. If this archive is complete, you
# will see the following message at the end:
# "End of archive 10 (of 16)."
# Contents: Moria_hours misc1.c scrolls.c
# Wrapped by billr@tekred on Wed Nov 4 09:59:58 1987
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f Moria_hours -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"Moria_hours\"
else
echo shar: Extracting \"Moria_hours\" \(352 characters\)
sed "s/^X//" >Moria_hours <<'END_OF_Moria_hours'
X Moria operating hours are:
X | AM | PM |
X 1 111 111
X 2123456789012123456789012
XSUN:XXXXXXXXXXXXXXXXXXXXXXXX
XMON:XXXXXXXX.........XXXXXXX
XTUE:XXXXXXXX.........XXXXXXX
XWED:XXXXXXXX.........XXXXXXX
XTHU:XXXXXXXX.........XXXXXXX
XFRI:XXXXXXXX.........XXXXXXX
XSAT:XXXXXXXXXXXXXXXXXXXXXXXX
X (X==Open; .==Closed)
END_OF_Moria_hours
if test 352 -ne `wc -c <Moria_hours`; then
echo shar: \"Moria_hours\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f misc1.c -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"misc1.c\"
else
echo shar: Extracting \"misc1.c\" \(39748 characters\)
sed "s/^X//" >misc1.c <<'END_OF_misc1.c'
X#include <time.h>
X#include <math.h>
X#include <stdio.h>
X#ifdef USG
X#include <string.h>
X#else
X#include <strings.h>
X#endif
X#include <sys/types.h>
X
X#include "config.h"
X#include "constants.h"
X#include "types.h"
X/* SUN4 has a variable called class in the include file <math.h>
X avoid a conflict by not defining my class in the file externs.h */
X#define DONT_DEFINE_CLASS
X#include "externs.h"
X
Xlong time();
Xstruct tm *localtime();
Xdouble sqrt();
Xdouble cos();
Xdouble fabs();
X#if defined(ultrix) || defined(sun) || defined(USG)
Xint getuid();
Xint geteuid();
Xint getgid();
Xint getegid();
X#else
Xuid_t getuid();
Xuid_t geteuid();
Xuid_t getgid();
Xuid_t getegid();
X#endif
X
X#ifdef USG
Xvoid srand();
X#else
Xlong random();
Xchar *initstate();
Xchar *setstate();
X#endif
X
X#ifdef ultrix
Xvoid srandom();
X#endif
X
X/* gets a new random seed for the random number generator */
Xinit_seeds()
X{
X long clock;
X int euid;
X
X /* in case game is setuid root */
X if ((euid = geteuid()) == 0)
X euid = (int)time((long *)0);
X
X clock = time((long *)0);
X clock = clock * getpid() * euid;
X#ifdef USG
X /* can't do this, sigh */
X#else
X (void) initstate((unsigned int)clock, randes_state, STATE_SIZE);
X#endif
X randes_seed = (unsigned int)clock;
X
X clock = time((long *)0);
X clock = clock * getpid() * euid;
X#ifdef USG
X /* can't do this */
X#else
X (void) initstate((unsigned int)clock, town_state, STATE_SIZE);
X#endif
X town_seed = (unsigned int)clock;
X
X clock = time((long *)0);
X clock = clock * getpid() * euid * getuid();
X#ifdef USG
X /* can't do this, do fake it */
X srand((unsigned int)clock);
X#else
X (void) initstate((unsigned int)clock, norm_state, STATE_SIZE);
X#endif
X}
X
X
X/* change to different random number generator state */
X/*ARGSUSED*/
Xset_seed(state, seed)
Xchar *state;
Xint seed;
X{
X#ifdef USG
X srand((unsigned)seed);
X#else
X (void) setstate(state);
X /* want reproducible state here, so call srandom */
X srandom(seed);
X#endif
X}
X
X
X/* restore the normal random generator state */
Xreset_seed()
X{
X#ifdef USG
X /* can't do this, so just call srand() with the current time */
X srand((unsigned int)(time ((long *)0)));
X#else
X (void) setstate(norm_state);
X#endif
X}
X
X
X/* Returns the day number; 0==Sunday...6==Saturday -RAK- */
Xint day_num()
X{
X long clock;
X struct tm *time_struct;
X
X clock = time((long *)0);
X time_struct = localtime(&clock);
X return (time_struct->tm_wday);
X}
X
X
X/* Returns the hour number; 0==midnight...23==11 PM -RAK- */
Xint hour_num()
X{
X long clock;
X struct tm *time_struct;
X
X clock = time((long *)0);
X time_struct = localtime(&clock);
X return (time_struct->tm_hour);
X}
X
X
X/* Check the day-time strings to see if open -RAK- */
Xint check_time()
X{
X switch ((int)days[day_num()][(hour_num()+4)]) {
X case '.': return(FALSE); /* Closed */
X case 'X': return(TRUE); /* Normal hours */
X default: return(FALSE); /* Other, assumed closed */
X }
X}
X
X
X/* Generates a random integer x where 1<==X<==MAXVAL -RAK- */
Xint randint(maxval)
Xint maxval;
X{
X long randval;
X
X#ifdef USG
X randval = rand(); /* only returns numbers from 0 to 2**15-1 */
X#else
X randval = random() >> 16;
X#endif
X return ((randval % maxval) + 1);
X}
X
X/* For i := 1 to y do sum := sum + randint(x) */
Xint rand_rep(num, die)
Xint num;
Xint die;
X{
X int sum = 0;
X int i;
X
X for (i = 0; i < num; i++)
X sum += randint(die);
X return(sum);
X}
X
X/* Generates a random integer number of NORMAL distribution -RAK-*/
Xint randnor(mean, stand)
Xint mean;
Xint stand;
X{
X return ((int)((sqrt(-2.0*log(randint((int)9999999)/10000000.0))*
X cos(6.283*(randint((int)9999999)/10000000.0))*stand) + mean));
X}
X
X
X/* Returns position of first set bit -RAK- */
X/* and clears that bit */
Xint bit_pos(test)
Xunsigned int *test;
X{
X int i;
X int mask = 0x1;
X
X for (i = 0; i < sizeof(int)*8; i++) {
X if (*test & mask) {
X *test &= ~mask;
X return(i);
X }
X mask <<= 1;
X }
X
X /* no one bits found */
X return(-1);
X}
X
X/* Checks a co-ordinate for in bounds status -RAK- */
Xint in_bounds(y, x)
Xint y, x;
X{
X if ((y > 0) && (y < cur_height-1) && (x > 0) && (x < cur_width-1))
X return(TRUE);
X else
X return(FALSE);
X}
X
X
X/* Distance between two points -RAK- */
Xint distance(y1, x1, y2, x2)
Xint y1, x1, y2, x2;
X{
X int dy, dx;
X
X dy = abs(y1 - y2);
X dx = abs(x1 - x2);
X
X return( (2 * (dy + dx) - (dy > dx ? dx : dy)) / 2);
X}
X
X/* Checks points north, south, east, and west for a type -RAK- */
Xint next_to4(y, x, elem_a, elem_b, elem_c)
Xint y, x;
Xint elem_a, elem_b, elem_c;
X{
X int i;
X
X i = 0;
X if (y > 0)
X if ((cave[y-1][x].fval == elem_a) || (cave[y-1][x].fval == elem_b) ||
X (cave[y-1][x].fval == elem_c))
X i++;
X if (y < cur_height-1)
X if ((cave[y+1][x].fval == elem_a) || (cave[y+1][x].fval == elem_b) ||
X (cave[y+1][x].fval == elem_c))
X i++;
X if (x > 0)
X if ((cave[y][x-1].fval == elem_a) || (cave[y][x-1].fval == elem_b) ||
X (cave[y][x-1].fval == elem_c))
X i++;
X if (x < cur_width-1)
X if ((cave[y][x+1].fval == elem_a) || (cave[y][x+1].fval == elem_b) ||
X (cave[y][x+1].fval == elem_c))
X i++;
X return(i);
X}
X
X
X/* Checks all adjacent spots for elements -RAK- */
Xint next_to8(y, x, elem_a, elem_b, elem_c)
Xint y, x;
Xint elem_a, elem_b, elem_c;
X{
X int i, j, k;
X
X i = 0;
X for (j = (y - 1); j <= (y + 1); j++)
X for (k = (x - 1); k <= (x + 1); k++)
X if (in_bounds(j, k))
X if ((cave[j][k].fval == elem_a) || (cave[j][k].fval == elem_b) ||
X (cave[j][k].fval == elem_c))
X i++;
X return(i);
X}
X
X
X/* Link all free space in treasure list together */
Xtlink()
X{
X int i;
X
X for (i = 0; i < MAX_TALLOC; i++)
X {
X t_list[i] = blank_treasure;
X t_list[i].p1 = i - 1;
X }
X tcptr = MAX_TALLOC - 1;
X}
X
X
X/* Link all free space in monster list together */
Xmlink()
X{
X int i;
X
X for (i = 0; i < MAX_MALLOC; i++)
X {
X m_list[i] = blank_monster;
X m_list[i].nptr = i - 1;
X }
X m_list[1].nptr = 0;
X muptr = 0;
X mfptr = MAX_MALLOC - 1;
X}
X
X
X/* Initializes M_LEVEL array for use with PLACE_MONSTER -RAK- */
Xinit_m_level()
X{
X int i, j, k;
X
X i = 0;
X j = 0;
X k = MAX_CREATURES - WIN_MON_TOT;
X while (j <= MAX_MONS_LEVEL) {
X m_level[j] = 0;
X while ((i < k) && (c_list[i].level == j))
X {
X m_level[j]++;
X i++;
X }
X j++;
X }
X for (i = 2; i <= MAX_MONS_LEVEL; i++)
X m_level[i] += m_level[i-1];
X}
X
X
X/* Initializes T_LEVEL array for use with PLACE_OBJECT -RAK- */
Xinit_t_level()
X{
X int i, j;
X
X i = 0;
X j = 0;
X while ((j < MAX_OBJ_LEVEL) && (i < MAX_OBJECTS))
X {
X while ((i < MAX_OBJECTS) && (object_list[i].level == j))
X {
X t_level[j]++;
X i++;
X }
X j++;
X }
X for (i = 1; i < MAX_OBJ_LEVEL; i++)
X t_level[i] += t_level[i-1];
X}
X
X
X/* Adjust prices of objects -RAK- */
Xprice_adjust()
X{
X int i;
X
X for (i = 0; i < MAX_OBJECTS; i++)
X object_list[i].cost = object_list[i].cost*COST_ADJ + 0.99;
X for (i = 0; i < INVEN_INIT_MAX; i++)
X inventory_init[i].cost = inventory_init[i].cost*COST_ADJ + 0.99;
X}
X
X
X/* Converts input string into a dice roll -RAK- */
X/* Normal input string will look like "2d6", "3d8"... etc. */
Xint damroll(dice)
Xchar *dice;
X{
X int num, sides;
X
X num = 0;
X sides = 0;
X (void) sscanf(dice, "%d d %d", &num, &sides);
X return(rand_rep(num, sides));
X}
X
X
X/* Returns true if no obstructions between two given points -RAK-*/
Xint los(y1, x1, y2, x2)
Xint y1, x1, y2, x2;
X{
X int ty, tx, stepy, stepx, p1, p2;
X double slp, tmp;
X int flag;
X
X ty = (y1 - y2);
X tx = (x1 - x2);
X flag = TRUE;
X if ((ty != 0) || (tx != 0))
X {
X if (ty < 0)
X stepy = -1;
X else
X stepy = 1;
X if (tx < 0)
X stepx = -1;
X else
X stepx = 1;
X if (ty == 0)
X {
X do
X {
X x2 += stepx;
X flag = cave[y2][x2].fopen;
X }
X while((x1 != x2) && (flag));
X }
X else if (tx == 0)
X {
X do
X {
X y2 += stepy;
X flag = cave[y2][x2].fopen;
X }
X while((y1 != y2) && (flag));
X }
X else if (abs(ty) > abs(tx))
X {
X slp = fabs((double)tx / (double)ty) * stepx;
X tmp = x2;
X do
X {
X y2 += stepy;
X tmp += slp;
X /* round to nearest integer */
X p1 = (int)floor(tmp - 0.1 + 0.5);
X p2 = (int)floor(tmp + 0.1 + 0.5);
X if ((!cave[y2][p1].fopen) && (!cave[y2][p2].fopen))
X flag = FALSE;
X }
X while((y1 != y2) && (flag));
X }
X else
X {
X slp = fabs((double)ty / (double)tx) * stepy;
X tmp = y2;
X do
X {
X x2 += stepx;
X tmp += slp;
X /* round to nearest integer */
X p1 = (int)floor(tmp - 0.1 + 0.5);
X p2 = (int)floor(tmp + 0.1 + 0.5);
X if ((!cave[p1][x2].fopen) && (!cave[p2][x2].fopen))
X flag = FALSE;
X }
X while((x1 != x2) && (flag));
X }
X }
X return(flag);
X}
X
X
X/* Returns symbol for given row, column -RAK- */
Xloc_symbol(y, x, sym)
Xint y, x;
Xchar *sym;
X{
X cave_type *cave_ptr;
X monster_type *mon_ptr;
X
X cave_ptr = &cave[y][x];
X if ((cave_ptr->cptr == 1) && (!find_flag))
X *sym = '@';
X else if (py.flags.blind > 0)
X *sym = ' ';
X else
X {
X if (cave_ptr->cptr > 1)
X {
X mon_ptr = &m_list[cave_ptr->cptr];
X if ((mon_ptr->ml) &&
X (((c_list[mon_ptr->mptr].cmove & 0x00010000) == 0) ||
X (py.flags.see_inv)))
X *sym = c_list[mon_ptr->mptr].cchar;
X else if (cave_ptr->tptr != 0)
X *sym = t_list[cave_ptr->tptr].tchar;
X else if (cave_ptr->fval < 10)
X *sym = '.';
X else
X *sym = '#';
X }
X else if (cave_ptr->tptr != 0)
X *sym = t_list[cave_ptr->tptr].tchar;
X else if (cave_ptr->fval < 10)
X *sym = '.';
X else
X *sym = '#';
X }
X}
X
X
X/* Tests a spot for light or field mark status -RAK- */
Xint test_light(y, x)
Xint y, x;
X{
X cave_type *cave_ptr;
X
X cave_ptr = &cave[y][x];
X if ((cave_ptr->pl) || (cave_ptr->fm) || (cave_ptr->tl))
X return(TRUE);
X else
X return(FALSE);
X}
X
X
X/* Prints the map of the dungeon -RAK- */
Xprt_map()
X{
X int i, j, k, l, m;
X int ypos, isp;
X /* this eliminates lint warning: xpos may be used before set */
X int xpos = 0;
X vtype floor_str;
X char tmp_char[2];
X int flag;
X cave_type *cave_ptr;
X
X k = 0; /* Used for erasing dirty lines */
X l = 13; /* Erasure starts in this column */
X for (i = panel_row_min; i <= panel_row_max; i++) /* Top to bottom */
X {
X k++; /* Increment dirty line ctr */
X if (used_line[k]) /* If line is dirty... */
X {
X erase_line(k, l); /* erase it. */
X used_line[k] = FALSE; /* Now it's a clean line */
X }
X floor_str[0] = '\0'; /* Floor_str is string to be printed*/
X ypos = i; /* Save row */
X flag = FALSE; /* False until floor_str != "" */
X isp = 0; /* Number of blanks encountered */
X for (j = panel_col_min; j <= panel_col_max; j++) /* Left to right */
X {
X cave_ptr = &cave[i][j]; /* Get character for location */
X if (test_light(i, j))
X loc_symbol(i, j, tmp_char);
X else if ((cave_ptr->cptr == 1) && (!find_flag))
X tmp_char[0] = '@';
X else if (cave_ptr->cptr > 1)
X if (m_list[cave_ptr->cptr].ml)
X loc_symbol(i, j, tmp_char);
X else
X tmp_char[0] = ' ';
X else
X tmp_char[0] = ' ';
X if (tmp_char[0] == ' ') /* If blank... */
X {
X if (flag) /* If floor_str != "" */
X {
X isp++; /* Increment blank ctr */
X if (isp > 3) /* Too many blanks, print*/
X { /* floor_str and reset */
X print(floor_str, ypos, xpos);
X flag = FALSE;
X isp = 0;
X }
X }
X }
X else
X {
X if (flag) /* Floor_str != "" */
X {
X if (isp > 0) /* Add on the blanks */
X {
X for (m = 0; m < isp; m++)
X (void) strcat(floor_str, " ");
X isp = 0;
X } /* Add on the character */
X tmp_char[1] = '\0';
X (void) strcat(floor_str, tmp_char);
X }
X else
X { /* Floor_str == "" */
X xpos = j; /* Save column for printing */
X flag = TRUE; /* Set flag to true */
X floor_str[0] = tmp_char[0]; /* Floor_str != "" */
X floor_str[1] = '\0';
X }
X }
X }
X if (flag) /* Print remainder, if any */
X print(floor_str, ypos, xpos);
X }
X}
X
X
X/* Compact monsters -RAK- */
Xcompact_monsters()
X{
X int i, j, k, cur_dis;
X int delete_1, delete_any;
X monster_type *mon_ptr;
X
X cur_dis = 66;
X delete_any = FALSE;
X do
X {
X i = muptr;
X j = 0;
X while (i > 0)
X {
X delete_1 = FALSE;
X k = m_list[i].nptr;
X mon_ptr = &m_list[i];
X if (cur_dis > mon_ptr->cdis)
X if (randint(3) == 1)
X {
X if (j == 0)
X muptr = k;
X else
X m_list[j].nptr = k;
X cave[mon_ptr->fy][mon_ptr->fx].cptr = 0;
X m_list[i] = blank_monster;
X m_list[i].nptr = mfptr;
X mfptr = i;
X delete_1 = TRUE;
X delete_any = TRUE;
X }
X if (!delete_1)
X j = i;
X i = k;
X }
X if (!delete_any)
X cur_dis -= 6;
X }
X while (!delete_any);
X if (cur_dis < 66)
X prt_map();
X}
X
X
X/* Returns a pointer to next free space -RAK- */
Xpopm(x)
Xint *x;
X{
X if (mfptr <= 1)
X compact_monsters();
X *x = mfptr;
X mfptr = m_list[*x].nptr;
X}
X
X
X/* Pushs a record back onto free space list -RAK- */
Xpushm(x)
Xint x;
X{
X m_list[x] = blank_monster;
X m_list[x].nptr = mfptr;
X mfptr = x;
X}
X
X
X/* Gives Max hit points -RAK- */
Xint max_hp(hp_str)
Xchar *hp_str;
X{
X int num, die;
X
X (void) sscanf(hp_str, "%d d %d", &num, &die);
X return(num*die);
X}
X
X
X/* Places a monster at given location -RAK- */
Xplace_monster(y, x, z, slp)
Xint y, x, z;
Xint slp;
X{
X int cur_pos;
X monster_type *mon_ptr;
X
X popm(&cur_pos);
X mon_ptr = &m_list[cur_pos];
X mon_ptr->fy = y;
X mon_ptr->fx = x;
X mon_ptr->mptr = z;
X mon_ptr->nptr = muptr;
X muptr = cur_pos;
X if (c_list[z].cdefense & 0x4000)
X mon_ptr->hp = max_hp(c_list[z].hd);
X else
X mon_ptr->hp = damroll(c_list[z].hd);
X mon_ptr->cspeed = c_list[z].speed + py.flags.speed;
X mon_ptr->stunned = 0;
X mon_ptr->cdis = distance(char_row, char_col,y,x);
X cave[y][x].cptr = cur_pos;
X if (slp)
X {
X if (c_list[z].sleep == 0)
X mon_ptr->csleep = 0;
X else
X mon_ptr->csleep = (c_list[z].sleep/5.0) + randint(c_list[z].sleep);
X }
X else
X mon_ptr->csleep = 0;
X}
X
X
X/* Places a monster at given location -RAK- */
Xplace_win_monster()
X{
X int cur_pos;
X int y, x;
X monster_type *mon_ptr;
X
X if (!total_winner)
X {
X popm(&cur_pos);
X mon_ptr = &m_list[cur_pos];
X do
X {
X y = randint(cur_height-2);
X x = randint(cur_width-2);
X }
X while (((cave[y][x].fval != 1) && (cave[y][x].fval != 2) &&
X (cave[y][x].fval != 4)) ||
X (cave[y][x].cptr != 0) ||
X (cave[y][x].tptr != 0) ||
X (distance(y,x,char_row, char_col) <= MAX_SIGHT));
X mon_ptr->fy = y;
X mon_ptr->fx = x;
X mon_ptr->mptr = randint(WIN_MON_TOT) - 1 + m_level[MAX_MONS_LEVEL] +
X m_level[0];
X mon_ptr->nptr = muptr;
X muptr = cur_pos;
X if (c_list[mon_ptr->mptr].cdefense & 0x4000)
X mon_ptr->hp = max_hp(c_list[mon_ptr->mptr].hd);
X else
X mon_ptr->hp = damroll(c_list[mon_ptr->mptr].hd);
X mon_ptr->cspeed = c_list[mon_ptr->mptr].speed + py.flags.speed;
X mon_ptr->stunned = 0;
X mon_ptr->cdis = distance(char_row, char_col,y,x);
X cave[y][x].cptr = cur_pos;
X mon_ptr->csleep = 0;
X }
X}
X
X/* Allocates a random monster -RAK- */
Xalloc_monster(alloc_set, num, dis, slp)
Xint (*alloc_set)();
Xint num, dis;
Xint slp;
X{
X int y, x, i, j, k;
X
X for (i = 0; i < num; i++)
X {
X do
X {
X y = randint(cur_height-2);
X x = randint(cur_width-2);
X }
X while ((!(*alloc_set)(cave[y][x].fval)) ||
X (cave[y][x].cptr != 0) ||
X (!cave[y][x].fopen) ||
X (distance(y,x,char_row, char_col) <= dis));
X if (dun_level == 0)
X j = randint(m_level[0]) - 1;
X else if (dun_level >= MAX_MONS_LEVEL)
X j = randint(m_level[MAX_MONS_LEVEL]) - 1 + m_level[0];
X else if (randint(MON_NASTY) == 1)
X {
X j = dun_level + abs(randnor(0, 4)) + 1;
X if (j > MAX_MONS_LEVEL)
X j = MAX_MONS_LEVEL;
X k = m_level[j] - m_level[j-1];
X j = randint(k) - 1 + m_level[j-1];
X }
X else
X j = randint(m_level[dun_level]) - 1 + m_level[0];
X place_monster(y, x, j, slp);
X }
X}
X
X
X/* Places creature adjacent to given location -RAK- */
Xint summon_monster(y, x, slp)
Xint *y, *x;
Xint slp;
X{
X int i, j, k, l, m;
X cave_type *cave_ptr;
X int summon;
X
X i = 0;
X m = dun_level + MON_SUMMON_ADJ;
X summon = FALSE;
X if (m > MAX_MONS_LEVEL)
X l = MAX_MONS_LEVEL;
X else
X l = m;
X if (dun_level == 0)
X l = randint(m_level[0]) - 1;
X else
X l = randint(m_level[l]) - 1 + m_level[0];
X do
X {
X j = *y - 2 + randint(3);
X k = *x - 2 + randint(3);
X if (in_bounds(j, k))
X {
X cave_ptr = &cave[j][k];
X if ((cave_ptr->fval == 1) || (cave_ptr->fval == 2) ||
X (cave_ptr->fval == 4) || (cave_ptr->fval == 5))
X if (cave_ptr->cptr == 0)
X if (cave_ptr->fopen)
X {
X place_monster(j, k, l, slp);
X summon = TRUE;
X i = 9;
X *y = j;
X *x = k;
X }
X }
X i++;
X }
X while (i <= 9);
X return(summon);
X}
X
X
X/* Places undead adjacent to given location -RAK- */
Xint summon_undead(y, x)
Xint *y, *x;
X{
X int i, j, k, l, m, ctr;
X int summon;
X cave_type *cave_ptr;
X
X i = 0;
X summon = FALSE;
X l = m_level[MAX_MONS_LEVEL] + m_level[0];
X do
X {
X m = randint(l) - 1;
X ctr = 0;
X do
X {
X if (c_list[m].cdefense & 0x0008)
X {
X ctr = 20;
X l = 0;
X }
X else
X {
X m++;
X if (m > l)
X ctr = 20;
X else
X ctr++;
X }
X }
X while (ctr <= 19);
X }
X while(l != 0);
X do
X {
X j = *y - 2 + randint(3);
X k = *x - 2 + randint(3);
X if (in_bounds(j, k))
X {
X cave_ptr = &cave[j][k];
X if ((cave_ptr->fval == 1) || (cave_ptr->fval == 2) ||
X (cave_ptr->fval == 4) || (cave_ptr->fval == 5))
X if ((cave_ptr->cptr == 0) && (cave_ptr->fopen))
X {
X place_monster(j, k, m, FALSE);
X summon = TRUE;
X i = 9;
X *y = j;
X *x = k;
X }
X }
X i++;
X }
X while(i <= 9);
X return(summon);
X}
X
X
X/* If too many objects on floor level, delete some of them-RAK- */
Xcompact_objects()
X{
X int i, j, ctr, cur_dis;
X int flag;
X cave_type *cave_ptr;
X treasure_type *t_ptr;
X
X ctr = 0;
X cur_dis = 66;
X do
X {
X for (i = 0; i < cur_height; i++)
X for (j = 0; j < cur_width; j++)
X {
X cave_ptr = &cave[i][j];
X if (cave_ptr->tptr != 0)
X if (distance(i, j, char_row, char_col) > cur_dis)
X {
X flag = FALSE;
X t_ptr = &t_list[cave_ptr->tptr];
X switch(t_ptr->tval)
X {
X case 102:
X if ((t_ptr->subval == 1) || (t_ptr->subval == 6) ||
X (t_ptr->subval == 9))
X flag = TRUE;
X else if (randint(4) == 1)
X flag = TRUE;
X break;
X case 103:
X flag = TRUE;
X break;
X case 104: case 105:
X if (randint(4) == 1) flag = TRUE;
X break;
X case 107: case 108:
X break;
X default:
X if (randint(8) == 1) flag = TRUE;
X }
X if (flag)
X {
X cave_ptr->fopen = TRUE;
X t_list[cave_ptr->tptr] = blank_treasure;
X t_list[cave_ptr->tptr].p1 = tcptr;
X tcptr = cave_ptr->tptr;
X cave_ptr->tptr = 0;
X ctr++;
X }
X }
X if (ctr == 0) cur_dis -= 6;
X }
X }
X while (ctr <= 0);
X if (cur_dis < 66) prt_map();
X}
X
X
X
X/* Gives pointer to next free space -RAK- */
Xpopt(x)
Xint *x;
X{
X if (tcptr < 1)
X compact_objects();
X *x = tcptr;
X tcptr = t_list[*x].p1;
X}
X
X
X/* Pushs a record back onto free space list -RAK- */
Xpusht(x)
Xint x;
X{
X t_list[x] = blank_treasure;
X t_list[x].p1 = tcptr;
X tcptr = x;
X}
X
X
X/* Order the treasure list by level -RAK- */
Xsort_objects()
X{
X int i, j, k, gap;
X treasure_type tmp;
X
X gap = MAX_OBJECTS / 2;
X while (gap > 0)
X {
X for (i = gap; i < MAX_OBJECTS; i++)
X {
X j = i - gap;
X while (j >= 0)
X {
X k = j + gap;
X if (object_list[j].level > object_list[k].level)
X {
X tmp = object_list[j];
X object_list[j] = object_list[k];
X object_list[k] = tmp;
X }
X else
X j = -1;
X j -= gap;
X }
X }
X gap /= 2;
X }
X}
X
X
X/* Boolean : is object enchanted -RAK- */
Xint magik(chance)
Xint chance;
X{
X if (randint(100) <= chance)
X return(TRUE);
X else
X return(FALSE);
X}
X
X
X/* Enchant a bonus based on degree desired -RAK- */
Xint m_bonus(base, max_std, level)
Xint base, max_std, level;
X{
X int x, stand_dev;
X
X stand_dev = (OBJ_STD_ADJ*level) + OBJ_STD_MIN;
X if (stand_dev > max_std)
X stand_dev = max_std;
X x = (abs(randnor(0, stand_dev))/10.0) + base;
X if (x < base)
X return(base);
X else
X return(x);
X}
X
X
X/* Chance of treasure having magic abilities -RAK- */
X/* Chance increases with each dungeon level */
Xmagic_treasure(x, level)
Xint x, level;
X{
X int chance, special, cursed, i;
X treasure_type *t_ptr;
X
X chance = OBJ_BASE_MAGIC + level;
X if (chance > OBJ_BASE_MAX)
X chance = OBJ_BASE_MAX;
X special = (chance/OBJ_DIV_SPECIAL);
X cursed = (chance/OBJ_DIV_CURSED);
X t_ptr = &t_list[x];
X/* I vehemently disagree with this!! */
X/* t_ptr->level = level; */
X /* Depending on treasure type, it can have certain magical properties*/
X switch (t_ptr->tval)
X {
X case 34: case 35: case 36: /* Armor and shields*/
X if (magik(chance))
X {
X t_ptr->toac = m_bonus(1, 30, level);
X if (magik(special))
X switch(randint(9))
X {
X case 1:
X t_ptr->flags |= 0x02380000;
X (void) strcat(t_ptr->name, " (R)");
X t_ptr->toac += 5;
X t_ptr->cost += 2500;
X break;
X case 2: /* Resist Acid */
X t_ptr->flags |= 0x00100000;
X (void) strcat(t_ptr->name, " (RA)");
X t_ptr->cost += 1000;
X break;
X case 3: case 4: /* Resist Fire */
X t_ptr->flags |= 0x00080000;
X (void) strcat(t_ptr->name, " (RF)");
X t_ptr->cost += 600;
X break;
X case 5: case 6: /* Resist Cold */
X t_ptr->flags |= 0x00200000;
X (void) strcat(t_ptr->name, " (RC)");
X t_ptr->cost += 600;
X break;
X case 7: case 8: case 9: /* Resist Lightning*/
X t_ptr->flags |= 0x02000000;
X (void) strcat(t_ptr->name, " (RL)");
X t_ptr->cost += 500;
X break;
X }
X }
X else if (magik(cursed))
X {
X t_ptr->toac = -m_bonus(1, 40, level);
X t_ptr->cost = 0;
X t_ptr->flags |= 0x80000000;
X }
X break;
X
X case 21: case 22: case 23: /* Weapons */
X if (magik(chance))
X {
X t_ptr->tohit = m_bonus(0, 40, level);
X t_ptr->todam = m_bonus(0, 40, level);
X if (magik(special))
X switch(randint(16))
X {
X case 1: /* Holy Avenger */
X t_ptr->flags |= 0x01418001;
X t_ptr->tohit += 5;
X t_ptr->todam += 5;
X t_ptr->toac = randint(4);
X t_ptr->p1 = randint(4) - 1;
X (void) strcat(t_ptr->name, " (HA)");
X t_ptr->cost += t_ptr->p1*500;
X t_ptr->cost += 10000;
X break;
X case 2: /* Defender */
X t_ptr->flags |= 0x07B80900;
X t_ptr->tohit += 3;
X t_ptr->todam += 3;
X t_ptr->toac = 5 + randint(5);
X (void) strcat(t_ptr->name, " [%P4] (DF)");
X t_ptr->p1 = randint(3);
X t_ptr->cost += t_ptr->p1*500;
X t_ptr->cost += 7500;
X break;
X case 3: case 4: /* Slay Monster */
X t_ptr->flags |= 0x01004000;
X t_ptr->tohit += 3;
X t_ptr->todam += 3;
X (void) strcat(t_ptr->name, " (SM)");
X t_ptr->cost += 5000;
X break;
X case 5: case 6: /* Slay Dragon */
X t_ptr->flags |= 0x00002000;
X t_ptr->tohit += 3;
X t_ptr->todam += 3;
X (void) strcat(t_ptr->name, " (SD)");
X t_ptr->cost += 4000;
X break;
X case 7: case 8: /* Slay Evil */
X t_ptr->flags |= 0x00008000;
X t_ptr->tohit += 3;
X t_ptr->todam += 3;
X (void) strcat(t_ptr->name, " (SE)");
X t_ptr->cost += 4000;
X break;
X case 9: case 10: /* Slay Undead */
X t_ptr->flags |= 0x00010000;
X t_ptr->tohit += 2;
X t_ptr->todam += 2;
X (void) strcat(t_ptr->name, " (SU)");
X t_ptr->cost += 3000;
X break;
X case 11: case 12: case 13: /* Flame Tongue */
X t_ptr->flags |= 0x00040000;
X t_ptr->tohit++;
X t_ptr->todam += 3;
X (void) strcat(t_ptr->name, " (FT)");
X t_ptr->cost += 2000;
X break;
X case 14: case 15: case 16: /* Frost Brand */
X t_ptr->flags |= 0x00020000;
X t_ptr->tohit++;
X t_ptr->todam++;
X (void) strcat(t_ptr->name, " (FB)");
X t_ptr->cost += 1200;
X break;
X }
X }
X else if (magik(cursed))
X {
X t_ptr->tohit = -m_bonus(1, 55, level);
X t_ptr->todam = -m_bonus(1, 55, level);
X t_ptr->flags |= 0x80000000;
X t_ptr->cost = 0;
X }
X break;
X
X case 20: /* Bows, crossbows, and slings */
X if (magik(chance))
X t_ptr->tohit = m_bonus(1, 30, level);
X else if (magik(cursed))
X {
X t_ptr->tohit = -m_bonus(1, 50, level);
X t_ptr->flags |= 0x80000000;
X t_ptr->cost = 0;
X }
X break;
X
X case 25: /* Digging tools */
X if (magik(chance))
X switch(randint(3))
X {
X case 1: case 2:
X t_ptr->p1 = m_bonus(2, 25, level);
X t_ptr->cost += t_ptr->p1*100;
X break;
X case 3:
X t_ptr->p1 = -m_bonus(1, 30, level);
X t_ptr->cost = 0;
X t_ptr->flags |= 0x80000000;
X }
X break;
X
X case 31: /* Gloves and Gauntlets */
X if (magik(chance))
X {
X t_ptr->toac = m_bonus(1, 20, level);
X if (magik(special))
X switch(randint(2))
X {
X case 1:
X t_ptr->flags |= 0x00800000;
X (void) strcat(t_ptr->name, " of Free Action");
X t_ptr->cost += 1000;
X break;
X case 2:
X t_ptr->tohit = 1 + randint(3);
X t_ptr->todam = 1 + randint(3);
X (void) strcat(t_ptr->name, " of Slaying");
X t_ptr->cost += (t_ptr->tohit+t_ptr->todam)*250;
X break;
X }
X }
X else if (magik(cursed))
X {
X if (magik(special))
X switch(randint(2))
X {
X case 1:
X t_ptr->flags |= 0x80000002;
X (void) strcat(t_ptr->name, " of Clumsiness");
X t_ptr->p1 = 1;
X break;
X case 2:
X t_ptr->flags |= 0x80000001;
X (void) strcat(t_ptr->name, " of Weakness");
X t_ptr->p1 = 1;
X break;
X }
X t_ptr->toac = -m_bonus(1, 40, level);
X t_ptr->p1 = -m_bonus(1, 10, level);
X t_ptr->flags |= 0x80000000;
X t_ptr->cost = 0;
X }
X break;
X
X case 30: /* Boots */
X if (magik(chance))
X {
X t_ptr->toac = m_bonus(1, 20, level);
X if (magik(special))
X switch(randint(12))
X {
X case 1:
X t_ptr->flags |= 0x00001000;
X (void) strcat(t_ptr->name, " of Speed");
X t_ptr->p1 = 1;
X t_ptr->cost += 5000;
X break;
X case 2: case 3: case 4: case 5:
X t_ptr->flags |= 0x00000100;
X (void) strcat(t_ptr->name, " of Stealth");
X t_ptr->cost += 500;
X break;
X default:
X t_ptr->flags |= 0x04000000;
X (void) strcat(t_ptr->name, " of Slow descent");
X t_ptr->cost += 250;
X break;
X }
X }
X else if (magik(cursed))
X {
X switch(randint(3))
X {
X case 1:
X t_ptr->flags |= 0x80001000;
X (void) strcat(t_ptr->name, " of Slowness");
X t_ptr->p1 = -1;
X break;
X case 2:
X t_ptr->flags |= 0x80000200;
X (void) strcat(t_ptr->name, " of Noise");
X break;
X case 3:
X t_ptr->flags |= 0x80000000;
X (void) strcat(t_ptr->name, " of Great Mass");
X t_ptr->weight *= 5;
X break;
X }
X t_ptr->cost = 0;
X t_ptr->ac = -m_bonus(2, 45, level);
X }
X break;
X
X case 33: /* Helms */
X if (magik(chance))
X {
X t_ptr->toac = m_bonus(1, 20, level);
X if (magik(special))
X switch(t_ptr->subval)
X {
X case 1: case 2: case 3: case 4: case 5:
X switch(randint(3))
X {
X case 1:
X t_ptr->p1 = randint(2);
X t_ptr->flags |= 0x00000008;
X (void) strcat(t_ptr->name, " of Intelligence");
X t_ptr->cost += t_ptr->p1*500;
X break;
X case 2:
X t_ptr->p1 = randint(2);
X t_ptr->flags |= 0x00000010;
X (void) strcat(t_ptr->name, " of Wisdom");
X t_ptr->cost += t_ptr->p1*500;
X break;
X case 3:
X t_ptr->p1 = 1 + randint(4);
X t_ptr->flags |= 0x40000000;
X (void) strcat(t_ptr->name, " of Infra-Vision");
X t_ptr->cost += t_ptr->p1*250;
X break;
X }
X break;
X case 6: case 7: case 8:
X switch(randint(6))
X {
X case 1:
X t_ptr->p1 = randint(3);
X t_ptr->flags |= 0x00800007;
X (void) strcat(t_ptr->name, " of Might");
X t_ptr->cost += 1000 + t_ptr->p1*500;
X break;
X case 2:
X t_ptr->p1 = randint(3);
X t_ptr->flags |= 0x00000030;
X (void) strcat(t_ptr->name, " of Lordliness");
X t_ptr->cost += 1000 + t_ptr->p1*500;
X break;
X case 3:
X t_ptr->p1 = randint(3);
X t_ptr->flags |= 0x01380008;
X (void) strcat(t_ptr->name, " of the Magi");
X t_ptr->cost += 3000 + t_ptr->p1*500;
X break;
X case 4:
X t_ptr->p1 = randint(3);
X t_ptr->flags |= 0x00000020;
X (void) strcat(t_ptr->name, " of Beauty");
X t_ptr->cost += 750;
X break;
X case 5:
X t_ptr->p1 = 1 + randint(4);
X t_ptr->flags |= 0x01000040;
X (void) strcat(t_ptr->name, " of Seeing");
X t_ptr->cost += 1000 + t_ptr->p1*100;
X break;
X case 6:
X t_ptr->flags |= 0x00000800;
X (void) strcat(t_ptr->name, " of Regeneration");
X t_ptr->cost += 1500;
X break;
X }
X break;
X }
X else if (magik(cursed))
X {
X t_ptr->toac = -m_bonus(1, 45, level);
X t_ptr->flags |= 0x80000000;
X t_ptr->cost = 0;
X if (magik(special))
X switch(randint(7))
X {
X case 1:
X t_ptr->p1 = -1;
X t_ptr->flags |= 0x00000008;
X (void) strcat(t_ptr->name, " of Stupidity");
X break;
X case 2:
X t_ptr->p1 = -1;
X t_ptr->flags |= 0x00000010;
X (void) strcat(t_ptr->name, " of Dullness");
X break;
X case 3:
X t_ptr->flags |= 0x08000000;
X (void) strcat(t_ptr->name, " of Blindness");
X break;
X case 4:
X t_ptr->flags |= 0x10000000;
X (void) strcat(t_ptr->name, " of Timidness");
X break;
X case 5:
X t_ptr->p1 = -1;
X t_ptr->flags |= 0x00000001;
X (void) strcat(t_ptr->name, " of Weakness");
X break;
X case 6:
X t_ptr->flags |= 0x00000400;
X (void) strcat(t_ptr->name, " of Teleportation");
X break;
X case 7:
X t_ptr->p1 = -1;
X t_ptr->flags |= 0x00000020;
X (void) strcat(t_ptr->name, " of Ugliness");
X break;
X }
X t_ptr->p1 *= randint(5);
X }
X }
X break;
X
X case 45: /* Rings */
X switch(t_ptr->subval)
X {
X case 1: case 2: case 3: case 4: case 5: case 6:
X if (magik(cursed))
X {
X t_ptr->p1 = -m_bonus(1, 20, level);
X t_ptr->flags |= 0x80000000;
X t_ptr->cost = -t_ptr->cost;
X }
X else
X {
X t_ptr->p1 = m_bonus(1, 10, level);
X t_ptr->cost += t_ptr->p1*100;
X }
X break;
X case 7:
X if (magik(cursed))
X {
X t_ptr->p1 = -randint(3);
X t_ptr->flags |= 0x80000000;
X t_ptr->cost = -t_ptr->cost;
X }
X else
X t_ptr->p1 = 1;
X break;
X case 8:
X t_ptr->p1 = 5*m_bonus(1, 20, level);
X t_ptr->cost += t_ptr->p1*100;
X break;
X case 22: /* Increase damage */
X t_ptr->todam = m_bonus(1, 20, level);
X t_ptr->cost += t_ptr->todam*100;
X if (magik(cursed))
X {
X t_ptr->todam = -t_ptr->todam;
X t_ptr->flags |= 0x80000000;
X t_ptr->cost = -t_ptr->cost;
X }
X break;
X case 23: /* Increase To-Hit */
X t_ptr->tohit = m_bonus(1, 20, level);
X t_ptr->cost += t_ptr->todam*100;
X if (magik(cursed))
X {
X t_ptr->tohit = -t_ptr->tohit;
X t_ptr->flags |= 0x80000000;
X t_ptr->cost = -t_ptr->cost;
X }
X break;
X case 24: /* Protection */
X t_ptr->toac = m_bonus(1, 20, level);
X t_ptr->cost += t_ptr->todam*100;
X if (magik(cursed))
X {
X t_ptr->toac = -t_ptr->toac;
X t_ptr->flags |= 0x80000000;
X t_ptr->cost = -t_ptr->cost;
X }
X break;
X case 33: /* Slaying */
X t_ptr->todam = m_bonus(1, 25, level);
X t_ptr->tohit = m_bonus(1, 25, level);
X t_ptr->cost += (t_ptr->tohit+t_ptr->todam)*100;
X if (magik(cursed))
X {
X t_ptr->tohit = -t_ptr->tohit;
X t_ptr->todam = -t_ptr->todam;
X t_ptr->flags |= 0x80000000;
X t_ptr->cost = -t_ptr->cost;
X }
X break;
X default:
X break;
X }
X break;
X
X case 40: /* Amulets */
X switch(t_ptr->subval)
X {
X case 1: case 2: case 3: case 4: case 5: case 6:
X if (magik(cursed))
X {
X t_ptr->p1 = -m_bonus(1, 20, level);
X t_ptr->flags |= 0x80000000;
X t_ptr->cost = -t_ptr->cost;
X }
X else
X {
X t_ptr->p1 = m_bonus(1, 10, level);
X t_ptr->cost += t_ptr->p1*100;
X }
X break;
X case 7:
X t_ptr->p1 = 5*m_bonus(1, 25, level);
X if (magik(cursed))
X {
X t_ptr->p1 = -t_ptr->p1;
X t_ptr->cost = -t_ptr->cost;
X t_ptr->flags |= 0x80000000;
X }
X else
X t_ptr->cost += 20*t_ptr->p1;
X break;
X default:
X break;
X }
X break;
X
X /* Subval should be even for store, odd for dungeon*/
X /* Dungeon found ones will be partially charged */
X case 15: /* Lamps and torches*/
X if ((t_ptr->subval % 2) == 1)
X t_ptr->p1 = randint(t_ptr->p1);
X break;
X
X case 65: /* Wands */
X switch(t_ptr->subval)
X {
X case 1: t_ptr->p1 = randint(10) + 6; break;
X case 2: t_ptr->p1 = randint(8) + 6; break;
X case 3: t_ptr->p1 = randint(5) + 6; break;
X case 4: t_ptr->p1 = randint(8) + 6; break;
X case 5: t_ptr->p1 = randint(4) + 3; break;
X case 6: t_ptr->p1 = randint(8) + 6; break;
X case 7: t_ptr->p1 = randint(20) + 12; break;
X case 8: t_ptr->p1 = randint(20) + 12; break;
X case 9: t_ptr->p1 = randint(10) + 6; break;
X case 10: t_ptr->p1 = randint(12) + 6; break;
X case 11: t_ptr->p1 = randint(10) + 12; break;
X case 12: t_ptr->p1 = randint(3) + 3; break;
X case 13: t_ptr->p1 = randint(8) + 6; break;
X case 14: t_ptr->p1 = randint(10) + 6; break;
X case 15: t_ptr->p1 = randint(5) + 3; break;
X case 16: t_ptr->p1 = randint(5) + 3; break;
X case 17: t_ptr->p1 = randint(5) + 6; break;
X case 18: t_ptr->p1 = randint(5) + 4; break;
X case 19: t_ptr->p1 = randint(8) + 4; break;
X case 20: t_ptr->p1 = randint(6) + 2; break;
X case 21: t_ptr->p1 = randint(4) + 2; break;
X case 22: t_ptr->p1 = randint(8) + 6; break;
X case 23: t_ptr->p1 = randint(5) + 2; break;
X case 24: t_ptr->p1 = randint(12) + 12; break;
X default:
X break;
X }
X break;
X
X case 55: /* Staffs */
X switch(t_ptr->subval)
X {
X case 1: t_ptr->p1 = randint(20) + 12; break;
X case 2: t_ptr->p1 = randint(8) + 6; break;
X case 3: t_ptr->p1 = randint(5) + 6; break;
X case 4: t_ptr->p1 = randint(20) + 12; break;
X case 5: t_ptr->p1 = randint(15) + 6; break;
X case 6: t_ptr->p1 = randint(4) + 5; break;
X case 7: t_ptr->p1 = randint(5) + 3; break;
X case 8: t_ptr->p1 = randint(3) + 1; break;
X case 9: t_ptr->p1 = randint(3) + 1; break;
X case 10: t_ptr->p1 = randint(3) + 1; break;
X case 11: t_ptr->p1 = randint(5) + 6; break;
X case 12: t_ptr->p1 = randint(10) + 12; break;
X case 13: t_ptr->p1 = randint(5) + 6; break;
X case 14: t_ptr->p1 = randint(5) + 6; break;
X case 15: t_ptr->p1 = randint(5) + 6; break;
X case 16: t_ptr->p1 = randint(10) + 12; break;
X case 17: t_ptr->p1 = randint(3) + 4; break;
X case 18: t_ptr->p1 = randint(5) + 6; break;
X case 19: t_ptr->p1 = randint(5) + 6; break;
X case 20: t_ptr->p1 = randint(3) + 4; break;
X case 21: t_ptr->p1 = randint(10) + 12; break;
X case 22: t_ptr->p1 = randint(3) + 4; break;
X case 23: t_ptr->p1 = randint(3) + 4; break;
X case 24: t_ptr->p1 = randint(3) + 1; break;
X case 25: t_ptr->p1 = randint(10) + 6; break;
X default:
X break;
X }
X break;
X
X case 32: /* Cloaks */
X if (magik(chance))
X {
X if (magik(special))
X switch(randint(2))
X {
X case 1:
X (void) strcat(t_ptr->name, " of Protection");
X t_ptr->toac = m_bonus(2, 40, level);
X t_ptr->cost += 250 + t_ptr->toac*100;
X break;
X case 2:
X t_ptr->toac = m_bonus(1, 20, level);
X t_ptr->p1 = randint(3);
X t_ptr->flags |= 0x00000100;
X (void) strcat(t_ptr->name, " of Stealth (%P1)");
X t_ptr->cost += t_ptr->p1*500 + t_ptr->toac*100;
X break;
X }
X else
X {
X t_ptr->toac = m_bonus(1, 20, level);
X t_ptr->cost += t_ptr->toac+100;
X }
X }
X else if (magik(cursed))
X switch(randint(3))
X {
X case 1:
X t_ptr->flags |= 0x80000200;
X (void) strcat(t_ptr->name, " of Irritation");
X t_ptr->ac = 0;
X t_ptr->toac = -m_bonus(1, 10, level);
X t_ptr->tohit = -m_bonus(1, 10, level);
X t_ptr->todam = -m_bonus(1, 10, level);
X t_ptr->cost = 0;
X break;
X case 2:
X t_ptr->flags |= 0x80000000;
X (void) strcat(t_ptr->name, " of Vulnerability");
X t_ptr->ac = 0;
X t_ptr->toac = -m_bonus(10, 100, level+50);
X t_ptr->cost = 0;
X break;
X case 3:
X t_ptr->flags |= 0x80000000;
X (void) strcat(t_ptr->name, " of Enveloping");
X t_ptr->toac = -m_bonus(1, 10, level);
X t_ptr->tohit = -m_bonus(2, 40, level+10);
X t_ptr->todam = -m_bonus(2, 40, level+10);
X t_ptr->cost = 0;
X break;
X }
X break;
X
X case 2: /* Chests */
X switch(randint(level+4))
X {
X case 1:
X t_ptr->flags = 0;
X (void) strcat(t_ptr->name, "^ (Empty)");
X break;
X case 2:
X t_ptr->flags |= 0x00000001;
X (void) strcat(t_ptr->name, "^ (Locked)");
X break;
X case 3: case 4:
X t_ptr->flags |= 0x00000011;
X (void) strcat(t_ptr->name, "^ (Poison Needle)");
X break;
X case 5: case 6:
X t_ptr->flags |= 0x00000021;
X (void) strcat(t_ptr->name, "^ (Poison Needle)");
X break;
X case 7: case 8: case 9:
X t_ptr->flags |= 0x00000041;
X (void) strcat(t_ptr->name, "^ (Gas Trap)");
X break;
X case 10: case 11:
X t_ptr->flags |= 0x00000081;
X (void) strcat(t_ptr->name, "^ (Explosion Device)");
X break;
X case 12: case 13: case 14:
X t_ptr->flags |= 0x00000101;
X (void) strcat(t_ptr->name, "^ (Summoning Runes)");
X break;
X case 15: case 16: case 17:
X t_ptr->flags |= 0x00000071;
X (void) strcat(t_ptr->name, "^ (Multiple Traps)");
X break;
X default:
X t_ptr->flags |= 0x00000181;
X (void) strcat(t_ptr->name, "^ (Multiple Traps)");
X break;
X }
X break;
X
X case 10: case 11: case 12: case 13: /* Arrows, bolts, ammo, and spikes */
X if ((t_ptr->tval == 11) || (t_ptr->tval == 12))
X if (magik(chance))
X {
X t_ptr->tohit = m_bonus(1, 35, level);
X t_ptr->todam = m_bonus(1, 35, level);
X if (magik(special))
X switch(t_ptr->tval) /*SWITCH 1*/
X {
X case 11: case 12:
X switch(randint(10)) /*SWITCH 2*/
X {
X case 1: case 2: case 3:
X (void) strcat(t_ptr->name, " of Slaying");
X t_ptr->tohit += 5;
X t_ptr->todam += 5;
X t_ptr->cost += 20;
X break;
X case 4: case 5:
X t_ptr->flags |= 0x00040000;
X t_ptr->tohit += 2;
X t_ptr->todam += 4;
X (void) strcat(t_ptr->name, " of Fire");
X t_ptr->cost += 25;
X break;
X case 6: case 7:
X t_ptr->flags |= 0x00008000;
X t_ptr->tohit += 3;
X t_ptr->todam += 3;
X (void) strcat(t_ptr->name, " of Slay Evil");
X t_ptr->cost += 25;
X break;
X case 8: case 9:
X t_ptr->flags |= 0x01004000;
X t_ptr->tohit += 2;
X t_ptr->todam += 2;
X (void) strcat(t_ptr->name, " of Slay Monster");
X t_ptr->cost += 30;
X break;
X case 10:
X t_ptr->flags |= 0x00002000;
X t_ptr->tohit += 10;
X t_ptr->todam += 10;
X (void) strcat(t_ptr->name, " of Dragon Slaying");
X t_ptr->cost += 35;
X break;
X } /*SWITCH 2*/
X default:
X break;
X } /*SWITCH 1*/
X }
X else if (magik(cursed))
X {
X t_ptr->tohit = -m_bonus(5, 55, level);
X t_ptr->todam = -m_bonus(5, 55, level);
X t_ptr->flags |= 0x80000000;
X t_ptr->cost = 0;
X }
X
X t_ptr->number = 0;
X for (i = 0; i < 7; i++)
X t_ptr->number += randint(6);
X missile_ctr++;
X if (missile_ctr > 65534)
X missile_ctr = 1;
X t_ptr->subval = missile_ctr + 512;
X break;
X
X default:
X break;
X }
X}
X
X
END_OF_misc1.c
if test 39748 -ne `wc -c <misc1.c`; then
echo shar: \"misc1.c\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f scrolls.c -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"scrolls.c\"
else
echo shar: Extracting \"scrolls.c\" \(10750 characters\)
sed "s/^X//" >scrolls.c <<'END_OF_scrolls.c'
X#include <stdio.h>
X
X#include "constants.h"
X#include "types.h"
X#include "externs.h"
X
X#ifdef sun /* correct SUN stupidity in the stdio.h file */
Xchar *sprintf();
X#endif
X
Xextern int moria_flag;
X
X
X/* Scrolls for the reading -RAK- */
Xread_scroll()
X{
X unsigned int i;
X int j, k, l, item_val;
X int y, x;
X int tmp[5];
X vtype out_val, tmp_str;
X int redraw, ident, first, flag;
X treasure_type *i_ptr;
X struct misc *m_ptr;
X
X first = TRUE;
X reset_flag = TRUE;
X if (inven_ctr > 0)
X {
X if (find_range(70, 71, &j, &k))
X if (py.flags.blind > 0)
X msg_print("You can't see to read the scroll.");
X else if (no_light())
X msg_print("You have no light to read by.");
X else if (py.flags.confused > 0)
X {
X msg_print("The text seems to swim about the page!");
X msg_print("You are too confused to scanf...");
X }
X else
X {
X redraw = FALSE;
X if (get_item(&item_val, "Read which scroll?", &redraw, j, k))
X {
X i_ptr = &inventory[item_val];
X if (redraw) draw_cave();
X reset_flag = FALSE;
X i = i_ptr->flags;
X ident = FALSE;
X
X while (i != 0)
X {
X j = bit_pos(&i) + 1;
X if (i_ptr->tval == 71)
X j += 31;
X if (first)
X if ((j != 4) && (j != 25))
X {
X msg_print("As you read the scroll it vanishes.");
X first = FALSE;
X }
X
X /* Scrolls... */
X switch(j)
X {
X case 1:
X i_ptr = &inventory[22];
X if (i_ptr->tval != 0)
X {
X objdes(tmp_str, 22, FALSE);
X (void) sprintf(out_val, "Your %s glows faintly!",
X tmp_str);
X msg_print(out_val);
X if (enchant(&i_ptr->tohit))
X {
X i_ptr->flags &= 0x7FFFFFFF;
X py_bonuses(blank_treasure, 0);
X }
X else
X msg_print("The enchantment fails...");
X }
X ident = TRUE;
X break;
X case 2:
X i_ptr = &inventory[22];
X if (i_ptr->tval != 0)
X {
X objdes(tmp_str, 22, FALSE);
X (void) sprintf(out_val, "Your %s glows faintly!",
X tmp_str);
X msg_print(out_val);
X if (enchant(&i_ptr->todam))
X {
X i_ptr->flags &= 0x7FFFFFFF;
X py_bonuses(blank_treasure, 0);
X }
X else
X msg_print("The enchantment fails...");
X }
X ident = TRUE;
X break;
X case 3:
X k = 0;
X l = 0;
X if (inventory[25].tval != 0)
X {
X k++;
X tmp[k] = 25;
X }
X if (inventory[26].tval != 0)
X {
X k++;
X tmp[k] = 26;
X }
X if (inventory[31].tval != 0)
X {
X k++;
X tmp[k] = 31;
X }
X if (inventory[27].tval != 0)
X {
X k++;
X tmp[k] = 27;
X }
X if (inventory[23].tval != 0)
X {
X k++;
X tmp[k] = 23;
X }
X if (k > 0) l = tmp[randint(k)];
X if (0x80000000 & inventory[25].flags)
X l = 25;
X else if (0x80000000 & inventory[26].flags)
X l = 26;
X else if (0x80000000 & inventory[31].flags)
X l = 31;
X else if (0x80000000 & inventory[23].flags)
X l = 23;
X else if (0x80000000 & inventory[27].flags)
X l = 27;
X if (l > 0)
X {
X i_ptr = &inventory[l];
X objdes(tmp_str, l, FALSE);
X (void) sprintf(out_val, "Your %s glows faintly!",
X tmp_str);
X if (enchant(&i_ptr->toac))
X {
X i_ptr->flags &= 0x7FFFFFFF;
X py_bonuses(blank_treasure, 0);
X }
X else
X msg_print("The enchantment fails...");
X }
X ident = TRUE;
X break;
X case 4:
X identify(inventory[item_val]);
X msg_print("This is an identify scroll");
X msg_print(" ");
X if (ident_spell()) first = FALSE;
X break;
X case 5:
X if (remove_curse())
X {
X msg_print("You feel as if someone is watching over you.");
X ident = TRUE;
X }
X break;
X case 6:
X ident = light_area(char_row, char_col);
X break;
X case 7:
X ident = FALSE;
X for (k = 0; k < randint(3); k++)
X {
X y = char_row;
X x = char_col;
X ident |= summon_monster(&y, &x, FALSE);
X }
X break;
X case 8:
X teleport(10);
X ident = TRUE;
X break;
X case 9:
X teleport(100);
X ident = TRUE;
X break;
X case 10:
X dun_level += (-3) + 2*randint(2);
X if (dun_level < 1)
X dun_level = 1;
X moria_flag = TRUE;
X ident = TRUE;
X break;
X case 11:
X msg_print("Your hands begin to glow.");
X py.flags.confuse_monster = TRUE;
X ident = TRUE;
X break;
X case 12:
X ident = map_area();
X break;
X case 13:
X ident = sleep_monsters1(char_row, char_col);
X break;
X case 14:
X ident = warding_glyph();
X break;
X case 15:
X ident = detect_treasure();
X break;
X case 16:
X ident = detect_object();
X break;
X case 17:
X ident = detect_trap();
X break;
X case 18:
X ident = detect_sdoor();
X break;
X case 19:
X msg_print("This is a mass genocide scroll.");
X msg_print(" ");
X ident = mass_genocide();
X break;
X case 20:
X ident = detect_invisible();
X break;
X case 21:
X ident = aggravate_monster(20);
X msg_print("There is a high pitched humming noise");
X break;
X case 22:
X ident = trap_creation();
X break;
X case 23:
X ident = td_destroy();
X break;
X case 24:
X ident = door_creation();
X break;
X case 25:
X identify(inventory[item_val]);
X msg_print("This is a Recharge-Item scroll.");
X msg_print(" ");
X if (recharge(60)) first = FALSE;
X break;
X case 26:
X msg_print("This is a genocide scroll.");
X msg_print(" ");
X ident = genocide();
X break;
X case 27:
X ident = unlight_area(char_row, char_col);
X break;
X case 28:
X ident = protect_evil();
X break;
X case 29:
X ident = create_food();
X break;
X case 30:
X ident = dispell_creature(0x0008, 60);
X break;
X case 31:
X msg_print("That scroll appeared to be blank.");
X ident = TRUE;
X break;
X case 32:
X i_ptr = &inventory[22];
X if (i_ptr->tval != 0)
X {
X objdes(tmp_str, 22, FALSE);
X (void) sprintf(out_val, "Your %s glows brightly!",
X tmp_str);
X msg_print(out_val);
X flag = FALSE;
X for (k = 0; k < randint(2); k++)
X if (enchant(&i_ptr->tohit))
X flag = TRUE;
X for (k = 0; k < randint(2); k++)
X if (enchant(&i_ptr->todam))
X flag = TRUE;
X if (flag)
X {
X i_ptr->flags &= 0x7FFFFFFF;
X py_bonuses(blank_treasure, 0);
X }
X else
X msg_print("The enchantment fails...");
X }
X ident = TRUE;
X break;
X case 33:
X i_ptr = &inventory[22];
X if (i_ptr->tval != 0)
X {
X inventory[INVEN_MAX] = inventory[22];
X objdes(tmp_str, 22, FALSE);
X (void)sprintf(out_val,"Your %s glows black, fades",
X tmp_str);
X msg_print(out_val);
X i_ptr->tohit = -randint(5) - randint(5);
X i_ptr->todam = -randint(5) - randint(5);
X i_ptr->flags = 0x80000000;
X py_bonuses(inventory[INVEN_MAX], -1);
X ident = TRUE;
X }
X break;
X case 34:
X if (0x80000000 & inventory[25].flags)
X k = 25;
X else if (0x80000000 & inventory[26].flags)
X k = 26;
X else if (0x80000000 & inventory[31].flags)
X k = 31;
X else if (0x80000000 & inventory[23].flags)
X k = 23;
X else if (0x80000000 & inventory[27].flags)
X k = 27;
X else if (inventory[25].tval != 0)
X k = 25;
X else if (inventory[26].tval !=0)
X k = 26;
X else if (inventory[23].tval != 0)
X k = 23;
X else if (inventory[27].tval != 0)
X k = 27;
X else
X k = 0;
X if (k > 0)
X {
X i_ptr = &inventory[k];
X objdes(tmp_str, k, FALSE);
X (void) sprintf(out_val,"Your %s glows brightly!",
X tmp_str);
X msg_print(out_val);
X flag = FALSE;
X for (k = 0; k < randint(2) + 1; k++)
X if (enchant(&i_ptr->toac))
X flag = TRUE;
X if (flag)
X {
X i_ptr->flags &= 0x7FFFFFFF;
X py_bonuses(blank_treasure, 0);
X }
X else
X msg_print("The enchantment fails...");
X }
X ident = TRUE;
X break;
X case 35:
X if ((inventory[25].tval != 0) && (randint(4) == 1))
X k = 25;
X else if ((inventory[26].tval != 0) && (randint(3) ==1))
X k = 26;
X else if ((inventory[31].tval != 0) && (randint(3) ==1))
X k = 31;
X else if ((inventory[23].tval != 0) && (randint(3) ==1))
X k = 23;
X else if ((inventory[27].tval != 0) && (randint(3) ==1))
X k = 27;
X else if (inventory[25].tval != 0)
X k = 25;
X else if (inventory[26].tval != 0)
X k = 26;
X else if (inventory[31].tval != 0)
X k = 31;
X else if (inventory[23].tval != 0)
X k = 23;
X else if (inventory[27].tval != 0)
X k = 27;
X else
X k = 0;
X if (k > 0)
X {
X i_ptr = &inventory[k];
X inventory[INVEN_MAX] = inventory[k];
X objdes(tmp_str, k, FALSE);
X (void)sprintf(out_val,"Your %s glows black, fades.",
X tmp_str);
X msg_print(out_val);
X i_ptr->flags = 0x80000000;
X i_ptr->toac = -randint(5) - randint(5);
X py_bonuses(inventory[INVEN_MAX], -1);
X ident = TRUE;
X }
X break;
X case 36:
X ident = FALSE;
X for (k = 0; k < randint(3); k++)
X {
X y = char_row;
X x = char_col;
X ident |= summon_undead(&y, &x);
X }
X break;
X case 37:
X ident = bless(randint(12)+6);
X break;
X case 38:
X ident = bless(randint(24)+12);
X break;
X case 39:
X ident = bless(randint(48)+24);
X break;
X case 40:
X ident = TRUE;
X py.flags.word_recall = 25 + randint(30);
X msg_print("The air about you becomes charged...");
X break;
X case 41:
X ident = destroy_area(char_row, char_col);
X break;
X case 42:
X break;
X case 43:
X break;
X case 44:
X break;
X case 45:
X break;
X case 46:
X break;
X case 47:
X break;
X case 48:
X break;
X case 49:
X break;
X case 50:
X break;
X case 51:
X break;
X case 52:
X break;
X case 53:
X break;
X case 54:
X break;
X case 55:
X break;
X case 56:
X break;
X case 57:
X break;
X case 58:
X break;
X case 59:
X break;
X case 60:
X break;
X case 61:
X break;
X case 62:
X break;
X default:
X break;
X }
X /* End of Scrolls... */
X }
X if (!reset_flag)
X {
X if (ident)
X identify(inventory[item_val]);
X if (!first)
X {
X desc_remain(item_val);
X inven_destroy(item_val);
X if (i_ptr->flags != 0)
X {
X m_ptr = &py.misc;
X m_ptr->exp += (i_ptr->level/m_ptr->lev);
X prt_experience();
X }
X }
X }
X }
X else
X if (redraw) draw_cave();
X }
X else
X msg_print("You are not carrying any scrolls.");
X }
X else
X msg_print("But you are not carrying anything.");
X}
END_OF_scrolls.c
if test 10750 -ne `wc -c <scrolls.c`; then
echo shar: \"scrolls.c\" unpacked with wrong size!
fi
# end of overwriting check
fi
echo shar: End of archive 10 \(of 16\).
cp /dev/null ark10isdone
MISSING=""
for I in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 ; do
if test ! -f ark${I}isdone ; then
MISSING="${MISSING} ${I}"
fi
done
if test "${MISSING}" = "" ; then
echo You have unpacked all 16 archives.
rm -f ark[1-9]isdone ark[1-9][0-9]isdone
else
echo You still need to unpack the following archives:
echo " " ${MISSING}
fi
## End of shell archive.
exit 0