![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to hit.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 hit.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[] = "@(#)hit.c 5.3 (Berkeley) 6/1/90";
25: #endif /* not lint */
26:
27: /*
28: * hit.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: object *fight_monster = 0;
42: char hit_message[80] = "";
43:
44: extern short halluc, blind, cur_level;
45: extern short add_strength, ring_exp, r_rings;
46: extern boolean being_held, interrupted, wizard, con_mon;
47:
48: mon_hit(monster)
49: register object *monster;
50: {
51: short damage, hit_chance;
52: char *mn;
53: float minus;
54:
55: if (fight_monster && (monster != fight_monster)) {
56: fight_monster = 0;
57: }
58: monster->trow = NO_ROOM;
59: if (cur_level >= (AMULET_LEVEL * 2)) {
60: hit_chance = 100;
61: } else {
62: hit_chance = monster->m_hit_chance;
63: hit_chance -= (((2 * rogue.exp) + (2 * ring_exp)) - r_rings);
64: }
65: if (wizard) {
66: hit_chance /= 2;
67: }
68: if (!fight_monster) {
69: interrupted = 1;
70: }
71: mn = mon_name(monster);
72:
73: if (!rand_percent(hit_chance)) {
74: if (!fight_monster) {
75: sprintf(hit_message + strlen(hit_message), "the %s misses", mn);
76: message(hit_message, 1);
77: hit_message[0] = 0;
78: }
79: return;
80: }
81: if (!fight_monster) {
82: sprintf(hit_message + strlen(hit_message), "the %s hit", mn);
83: message(hit_message, 1);
84: hit_message[0] = 0;
85: }
86: if (!(monster->m_flags & STATIONARY)) {
87: damage = get_damage(monster->m_damage, 1);
88: if (cur_level >= (AMULET_LEVEL * 2)) {
89: minus = (float) ((AMULET_LEVEL * 2) - cur_level);
90: } else {
91: minus = (float) get_armor_class(rogue.armor) * 3.00;
92: minus = minus/100.00 * (float) damage;
93: }
94: damage -= (short) minus;
95: } else {
96: damage = monster->stationary_damage++;
97: }
98: if (wizard) {
99: damage /= 3;
100: }
101: if (damage > 0) {
102: rogue_damage(damage, monster, 0);
103: }
104: if (monster->m_flags & SPECIAL_HIT) {
105: special_hit(monster);
106: }
107: }
108:
109: rogue_hit(monster, force_hit)
110: register object *monster;
111: boolean force_hit;
112: {
113: short damage, hit_chance;
114:
115: if (monster) {
116: if (check_imitator(monster)) {
117: return;
118: }
119: hit_chance = force_hit ? 100 : get_hit_chance(rogue.weapon);
120:
121: if (wizard) {
122: hit_chance *= 2;
123: }
124: if (!rand_percent(hit_chance)) {
125: if (!fight_monster) {
126: (void) strcpy(hit_message, "you miss ");
127: }
128: goto RET;
129: }
130: damage = get_weapon_damage(rogue.weapon);
131: if (wizard) {
132: damage *= 3;
133: }
134: if (con_mon) {
135: s_con_mon(monster);
136: }
137: if (mon_damage(monster, damage)) { /* still alive? */
138: if (!fight_monster) {
139: (void) strcpy(hit_message, "you hit ");
140: }
141: }
142: RET: check_gold_seeker(monster);
143: wake_up(monster);
144: }
145: }
146:
147: rogue_damage(d, monster, other)
148: short d;
149: object *monster;
150: short other;
151: {
152: if (d >= rogue.hp_current) {
153: rogue.hp_current = 0;
154: print_stats(STAT_HP);
155: killed_by(monster, other);
156: }
157: if (d > 0) {
158: rogue.hp_current -= d;
159: print_stats(STAT_HP);
160: }
161: }
162:
163: get_damage(ds, r)
164: char *ds;
165: boolean r;
166: {
167: register i = 0, j, n, d, total = 0;
168:
169: while (ds[i]) {
170: n = get_number(ds+i);
171: while (ds[i++] != 'd') ;
172: d = get_number(ds+i);
173: while ((ds[i] != '/') && ds[i]) i++;
174:
175: for (j = 0; j < n; j++) {
176: if (r) {
177: total += get_rand(1, d);
178: } else {
179: total += d;
180: }
181: }
182: if (ds[i] == '/') {
183: i++;
184: }
185: }
186: return(total);
187: }
188:
189: get_w_damage(obj)
190: object *obj;
191: {
192: char new_damage[12];
193: register to_hit, damage;
194: register i = 0;
195:
196: if ((!obj) || (obj->what_is != WEAPON)) {
197: return(-1);
198: }
199: to_hit = get_number(obj->damage) + obj->hit_enchant;
200: while (obj->damage[i++] != 'd') ;
201: damage = get_number(obj->damage + i) + obj->d_enchant;
202:
203: sprintf(new_damage, "%dd%d", to_hit, damage);
204:
205: return(get_damage(new_damage, 1));
206: }
207:
208: get_number(s)
209: register char *s;
210: {
211: register i = 0;
212: register total = 0;
213:
214: while ((s[i] >= '0') && (s[i] <= '9')) {
215: total = (10 * total) + (s[i] - '0');
216: i++;
217: }
218: return(total);
219: }
220:
221: long
222: lget_number(s)
223: char *s;
224: {
225: short i = 0;
226: long total = 0;
227:
228: while ((s[i] >= '0') && (s[i] <= '9')) {
229: total = (10 * total) + (s[i] - '0');
230: i++;
231: }
232: return(total);
233: }
234:
235: to_hit(obj)
236: object *obj;
237: {
238: if (!obj) {
239: return(1);
240: }
241: return(get_number(obj->damage) + obj->hit_enchant);
242: }
243:
244: damage_for_strength()
245: {
246: short strength;
247:
248: strength = rogue.str_current + add_strength;
249:
250: if (strength <= 6) {
251: return(strength-5);
252: }
253: if (strength <= 14) {
254: return(1);
255: }
256: if (strength <= 17) {
257: return(3);
258: }
259: if (strength <= 18) {
260: return(4);
261: }
262: if (strength <= 20) {
263: return(5);
264: }
265: if (strength <= 21) {
266: return(6);
267: }
268: if (strength <= 30) {
269: return(7);
270: }
271: return(8);
272: }
273:
274: mon_damage(monster, damage)
275: object *monster;
276: short damage;
277: {
278: char *mn;
279: short row, col;
280:
281: monster->hp_to_kill -= damage;
282:
283: if (monster->hp_to_kill <= 0) {
284: row = monster->row;
285: col = monster->col;
286: dungeon[row][col] &= ~MONSTER;
287: mvaddch(row, col, (int) get_dungeon_char(row, col));
288:
289: fight_monster = 0;
290: cough_up(monster);
291: mn = mon_name(monster);
292: sprintf(hit_message+strlen(hit_message), "defeated the %s", mn);
293: message(hit_message, 1);
294: hit_message[0] = 0;
295: add_exp(monster->kill_exp, 1);
296: take_from_pack(monster, &level_monsters);
297:
298: if (monster->m_flags & HOLDS) {
299: being_held = 0;
300: }
301: free_object(monster);
302: return(0);
303: }
304: return(1);
305: }
306:
307: fight(to_the_death)
308: boolean to_the_death;
309: {
310: short ch, c, d;
311: short row, col;
312: boolean first_miss = 1;
313: short possible_damage;
314: object *monster;
315:
316: while (!is_direction(ch = rgetchar(), &d)) {
317: sound_bell();
318: if (first_miss) {
319: message("direction?", 0);
320: first_miss = 0;
321: }
322: }
323: check_message();
324: if (ch == CANCEL) {
325: return;
326: }
327: row = rogue.row; col = rogue.col;
328: get_dir_rc(d, &row, &col, 0);
329:
330: c = mvinch(row, col);
331: if (((c < 'A') || (c > 'Z')) ||
332: (!can_move(rogue.row, rogue.col, row, col))) {
333: message("I see no monster there", 0);
334: return;
335: }
336: if (!(fight_monster = object_at(&level_monsters, row, col))) {
337: return;
338: }
339: if (!(fight_monster->m_flags & STATIONARY)) {
340: possible_damage = ((get_damage(fight_monster->m_damage, 0) * 2) / 3);
341: } else {
342: possible_damage = fight_monster->stationary_damage - 1;
343: }
344: while (fight_monster) {
345: (void) one_move_rogue(ch, 0);
346: if (((!to_the_death) && (rogue.hp_current <= possible_damage)) ||
347: interrupted || (!(dungeon[row][col] & MONSTER))) {
348: fight_monster = 0;
349: } else {
350: monster = object_at(&level_monsters, row, col);
351: if (monster != fight_monster) {
352: fight_monster = 0;
353: }
354: }
355: }
356: }
357:
358: get_dir_rc(dir, row, col, allow_off_screen)
359: short dir;
360: short *row, *col;
361: short allow_off_screen;
362: {
363: switch(dir) {
364: case LEFT:
365: if (allow_off_screen || (*col > 0)) {
366: (*col)--;
367: }
368: break;
369: case DOWN:
370: if (allow_off_screen || (*row < (DROWS-2))) {
371: (*row)++;
372: }
373: break;
374: case UPWARD:
375: if (allow_off_screen || (*row > MIN_ROW)) {
376: (*row)--;
377: }
378: break;
379: case RIGHT:
380: if (allow_off_screen || (*col < (DCOLS-1))) {
381: (*col)++;
382: }
383: break;
384: case UPLEFT:
385: if (allow_off_screen || ((*row > MIN_ROW) && (*col > 0))) {
386: (*row)--;
387: (*col)--;
388: }
389: break;
390: case UPRIGHT:
391: if (allow_off_screen || ((*row > MIN_ROW) && (*col < (DCOLS-1)))) {
392: (*row)--;
393: (*col)++;
394: }
395: break;
396: case DOWNRIGHT:
397: if (allow_off_screen || ((*row < (DROWS-2)) && (*col < (DCOLS-1)))) {
398: (*row)++;
399: (*col)++;
400: }
401: break;
402: case DOWNLEFT:
403: if (allow_off_screen || ((*row < (DROWS-2)) && (*col > 0))) {
404: (*row)++;
405: (*col)--;
406: }
407: break;
408: }
409: }
410:
411: get_hit_chance(weapon)
412: object *weapon;
413: {
414: short hit_chance;
415:
416: hit_chance = 40;
417: hit_chance += 3 * to_hit(weapon);
418: hit_chance += (((2 * rogue.exp) + (2 * ring_exp)) - r_rings);
419: return(hit_chance);
420: }
421:
422: get_weapon_damage(weapon)
423: object *weapon;
424: {
425: short damage;
426:
427: damage = get_w_damage(weapon);
428: damage += damage_for_strength();
429: damage += ((((rogue.exp + ring_exp) - r_rings) + 1) / 2);
430: return(damage);
431: }
432:
433: s_con_mon(monster)
434: object *monster;
435: {
436: if (con_mon) {
437: monster->m_flags |= CONFUSED;
438: monster->moves_confused += get_rand(12, 22);
439: message("the monster appears confused", 0);
440: con_mon = 0;
441: }
442: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.