![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to zap.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / games / rogue|
Return to zap.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / games / rogue |
1.1 root 1: /*
2: * Copyright (c) 1988 The Regents of the University of California.
3: * All rights reserved.
4: *
5: * This code is derived from software contributed to Berkeley by
6: * Timothy C. Stoehr.
7: *
8: * Redistribution and use in source and binary forms are permitted
9: * provided that: (1) source distributions retain this entire copyright
10: * notice and comment, and (2) distributions including binaries display
11: * the following acknowledgement: ``This product includes software
12: * developed by the University of California, Berkeley and its contributors''
13: * in the documentation or other materials provided with the distribution
14: * and in all advertising materials mentioning features or use of this
15: * software. Neither the name of the University nor the names of its
16: * contributors may be used to endorse or promote products derived
17: * from this software without specific prior written permission.
18: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
19: * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
20: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
21: */
22:
23: #ifndef lint
24: static char sccsid[] = "@(#)zap.c 5.3 (Berkeley) 6/1/90";
25: #endif /* not lint */
26:
27: /*
28: * zap.c
29: *
30: * This source herein may be modified and/or distributed by anybody who
31: * so desires, with the following restrictions:
32: * 1.) No portion of this notice shall be removed.
33: * 2.) Credit shall not be taken for the creation of this source.
34: * 3.) This code is not to be traded, sold, or used for personal
35: * gain or profit.
36: *
37: */
38:
39: #include "rogue.h"
40:
41: boolean wizard = 0;
42:
43: extern boolean being_held, score_only, detect_monster;
44: extern short cur_room;
45:
46: zapp()
47: {
48: short wch;
49: boolean first_miss = 1;
50: object *wand;
51: short dir, d, row, col;
52: object *monster;
53:
54: while (!is_direction(dir = rgetchar(), &d)) {
55: sound_bell();
56: if (first_miss) {
57: message("direction? ", 0);
58: first_miss = 0;
59: }
60: }
61: check_message();
62: if (dir == CANCEL) {
63: return;
64: }
65: if ((wch = pack_letter("zap with what?", WAND)) == CANCEL) {
66: return;
67: }
68: check_message();
69:
70: if (!(wand = get_letter_object(wch))) {
71: message("no such item.", 0);
72: return;
73: }
74: if (wand->what_is != WAND) {
75: message("you can't zap with that", 0);
76: return;
77: }
78: if (wand->class <= 0) {
79: message("nothing happens", 0);
80: } else {
81: wand->class--;
82: row = rogue.row; col = rogue.col;
83: if ((wand->which_kind == COLD) || (wand->which_kind == FIRE)) {
84: bounce((short) wand->which_kind, d, row, col, 0);
85: } else {
86: monster = get_zapped_monster(d, &row, &col);
87: if (wand->which_kind == DRAIN_LIFE) {
88: wdrain_life(monster);
89: } else if (monster) {
90: wake_up(monster);
91: s_con_mon(monster);
92: zap_monster(monster, wand->which_kind);
93: relight();
94: }
95: }
96: }
97: (void) reg_move();
98: }
99:
100: object *
101: get_zapped_monster(dir, row, col)
102: short dir;
103: short *row, *col;
104: {
105: short orow, ocol;
106:
107: for (;;) {
108: orow = *row; ocol = *col;
109: get_dir_rc(dir, row, col, 0);
110: if (((*row == orow) && (*col == ocol)) ||
111: (dungeon[*row][*col] & (HORWALL | VERTWALL)) ||
112: (dungeon[*row][*col] == NOTHING)) {
113: return(0);
114: }
115: if (dungeon[*row][*col] & MONSTER) {
116: if (!imitating(*row, *col)) {
117: return(object_at(&level_monsters, *row, *col));
118: }
119: }
120: }
121: }
122:
123: zap_monster(monster, kind)
124: object *monster;
125: unsigned short kind;
126: {
127: short row, col;
128: object *nm;
129: short tc;
130:
131: row = monster->row;
132: col = monster->col;
133:
134: switch(kind) {
135: case SLOW_MONSTER:
136: if (monster->m_flags & HASTED) {
137: monster->m_flags &= (~HASTED);
138: } else {
139: monster->slowed_toggle = 0;
140: monster->m_flags |= SLOWED;
141: }
142: break;
143: case HASTE_MONSTER:
144: if (monster->m_flags & SLOWED) {
145: monster->m_flags &= (~SLOWED);
146: } else {
147: monster->m_flags |= HASTED;
148: }
149: break;
150: case TELE_AWAY:
151: tele_away(monster);
152: break;
153: case INVISIBILITY:
154: monster->m_flags |= INVISIBLE;
155: break;
156: case POLYMORPH:
157: if (monster->m_flags & HOLDS) {
158: being_held = 0;
159: }
160: nm = monster->next_monster;
161: tc = monster->trail_char;
162: (void) gr_monster(monster, get_rand(0, MONSTERS-1));
163: monster->row = row;
164: monster->col = col;
165: monster->next_monster = nm;
166: monster->trail_char = tc;
167: if (!(monster->m_flags & IMITATES)) {
168: wake_up(monster);
169: }
170: break;
171: case MAGIC_MISSILE:
172: rogue_hit(monster, 1);
173: break;
174: case CANCELLATION:
175: if (monster->m_flags & HOLDS) {
176: being_held = 0;
177: }
178: if (monster->m_flags & STEALS_ITEM) {
179: monster->drop_percent = 0;
180: }
181: monster->m_flags &= (~(FLIES | FLITS | SPECIAL_HIT | INVISIBLE |
182: FLAMES | IMITATES | CONFUSES | SEEKS_GOLD | HOLDS));
183: break;
184: case DO_NOTHING:
185: message("nothing happens", 0);
186: break;
187: }
188: }
189:
190: tele_away(monster)
191: object *monster;
192: {
193: short row, col;
194:
195: if (monster->m_flags & HOLDS) {
196: being_held = 0;
197: }
198: gr_row_col(&row, &col, (FLOOR | TUNNEL | STAIRS | OBJECT));
199: mvaddch(monster->row, monster->col, monster->trail_char);
200: dungeon[monster->row][monster->col] &= ~MONSTER;
201: monster->row = row; monster->col = col;
202: dungeon[row][col] |= MONSTER;
203: monster->trail_char = mvinch(row, col);
204: if (detect_monster || rogue_can_see(row, col)) {
205: mvaddch(row, col, gmc(monster));
206: }
207: }
208:
209: wizardize()
210: {
211: char buf[100];
212:
213: if (wizard) {
214: wizard = 0;
215: message("not wizard anymore", 0);
216: } else {
217: if (get_input_line("wizard's password:", "", buf, "", 0, 0)) {
218: (void) xxx(1);
219: xxxx(buf, strlen(buf));
220: if (!strncmp(buf, "\247\104\126\272\115\243\027", 7)) {
221: wizard = 1;
222: score_only = 1;
223: message("Welcome, mighty wizard!", 0);
224: } else {
225: message("sorry", 0);
226: }
227: }
228: }
229: }
230:
231: wdrain_life(monster)
232: object *monster;
233: {
234: short hp;
235: object *lmon, *nm;
236:
237: hp = rogue.hp_current / 3;
238: rogue.hp_current = (rogue.hp_current + 1) / 2;
239:
240: if (cur_room >= 0) {
241: lmon = level_monsters.next_monster;
242: while (lmon) {
243: nm = lmon->next_monster;
244: if (get_room_number(lmon->row, lmon->col) == cur_room) {
245: wake_up(lmon);
246: (void) mon_damage(lmon, hp);
247: }
248: lmon = nm;
249: }
250: } else {
251: if (monster) {
252: wake_up(monster);
253: (void) mon_damage(monster, hp);
254: }
255: }
256: print_stats(STAT_HP);
257: relight();
258: }
259:
260: bounce(ball, dir, row, col, r)
261: short ball, dir, row, col, r;
262: {
263: short orow, ocol;
264: char buf[DCOLS], *s;
265: short i, ch, new_dir = -1, damage;
266: static short btime;
267:
268: if (++r == 1) {
269: btime = get_rand(3, 6);
270: } else if (r > btime) {
271: return;
272: }
273:
274: if (ball == FIRE) {
275: s = "fire";
276: } else {
277: s = "ice";
278: }
279: if (r > 1) {
280: sprintf(buf, "the %s bounces", s);
281: message(buf, 0);
282: }
283: orow = row;
284: ocol = col;
285: do {
286: ch = mvinch(orow, ocol);
287: standout();
288: mvaddch(orow, ocol, ch);
289: get_dir_rc(dir, &orow, &ocol, 1);
290: } while (!( (ocol <= 0) ||
291: (ocol >= DCOLS-1) ||
292: (dungeon[orow][ocol] == NOTHING) ||
293: (dungeon[orow][ocol] & MONSTER) ||
294: (dungeon[orow][ocol] & (HORWALL | VERTWALL)) ||
295: ((orow == rogue.row) && (ocol == rogue.col))));
296: standend();
297: refresh();
298: do {
299: orow = row;
300: ocol = col;
301: ch = mvinch(row, col);
302: mvaddch(row, col, ch);
303: get_dir_rc(dir, &row, &col, 1);
304: } while (!( (col <= 0) ||
305: (col >= DCOLS-1) ||
306: (dungeon[row][col] == NOTHING) ||
307: (dungeon[row][col] & MONSTER) ||
308: (dungeon[row][col] & (HORWALL | VERTWALL)) ||
309: ((row == rogue.row) && (col == rogue.col))));
310:
311: if (dungeon[row][col] & MONSTER) {
312: object *monster;
313:
314: monster = object_at(&level_monsters, row, col);
315:
316: wake_up(monster);
317: if (rand_percent(33)) {
318: sprintf(buf, "the %s misses the %s", s, mon_name(monster));
319: message(buf, 0);
320: goto ND;
321: }
322: if (ball == FIRE) {
323: if (!(monster->m_flags & RUSTS)) {
324: if (monster->m_flags & FREEZES) {
325: damage = monster->hp_to_kill;
326: } else if (monster->m_flags & FLAMES) {
327: damage = (monster->hp_to_kill / 10) + 1;
328: } else {
329: damage = get_rand((rogue.hp_current / 3), rogue.hp_max);
330: }
331: } else {
332: damage = (monster->hp_to_kill / 2) + 1;
333: }
334: sprintf(buf, "the %s hits the %s", s, mon_name(monster));
335: message(buf, 0);
336: (void) mon_damage(monster, damage);
337: } else {
338: damage = -1;
339: if (!(monster->m_flags & FREEZES)) {
340: if (rand_percent(33)) {
341: message("the monster is frozen", 0);
342: monster->m_flags |= (ASLEEP | NAPPING);
343: monster->nap_length = get_rand(3, 6);
344: } else {
345: damage = rogue.hp_current / 4;
346: }
347: } else {
348: damage = -2;
349: }
350: if (damage != -1) {
351: sprintf(buf, "the %s hits the %s", s, mon_name(monster));
352: message(buf, 0);
353: (void) mon_damage(monster, damage);
354: }
355: }
356: } else if ((row == rogue.row) && (col == rogue.col)) {
357: if (rand_percent(10 + (3 * get_armor_class(rogue.armor)))) {
358: sprintf(buf, "the %s misses", s);
359: message(buf, 0);
360: goto ND;
361: } else {
362: damage = get_rand(3, (3 * rogue.exp));
363: if (ball == FIRE) {
364: damage = (damage * 3) / 2;
365: damage -= get_armor_class(rogue.armor);
366: }
367: sprintf(buf, "the %s hits", s);
368: rogue_damage(damage, (object *) 0,
369: ((ball == FIRE) ? KFIRE : HYPOTHERMIA));
370: message(buf, 0);
371: }
372: } else {
373: short nrow, ncol;
374:
375: ND: for (i = 0; i < 10; i++) {
376: dir = get_rand(0, DIRS-1);
377: nrow = orow;
378: ncol = ocol;
379: get_dir_rc(dir, &nrow, &ncol, 1);
380: if (((ncol >= 0) && (ncol <= DCOLS-1)) &&
381: (dungeon[nrow][ncol] != NOTHING) &&
382: (!(dungeon[nrow][ncol] & (VERTWALL | HORWALL)))) {
383: new_dir = dir;
384: break;
385: }
386: }
387: if (new_dir != -1) {
388: bounce(ball, new_dir, orow, ocol, r);
389: }
390: }
391: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.