[unix-history] / usr / src / games / rogue / hit.c

/*
 * Copyright (c) 1988 The Regents of the University of California.
 * All rights reserved.
 *
 * This code is derived from software contributed to Berkeley by
 * Timothy C. Stoehr.
 *
 * Redistribution and use in source and binary forms are permitted
 * provided that the above copyright notice and this paragraph are
 * duplicated in all such forms and that any documentation,
 * advertising materials, and other materials related to such
 * distribution and use acknowledge that the software was developed
 * by the University of California, Berkeley.  The name of the
 * University may not be used to endorse or promote products derived
 * from this software without specific prior written permission.
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 */

#ifndef lint
static char sccsid[] = "@(#)hit.c	5.2 (Berkeley) %G%";
#endif /* not lint */

/*
 * hit.c
 *
 * This source herein may be modified and/or distributed by anybody who
 * so desires, with the following restrictions:
 *    1.)  No portion of this notice shall be removed.
 *    2.)  Credit shall not be taken for the creation of this source.
 *    3.)  This code is not to be traded, sold, or used for personal
 *         gain or profit.
 *
 */

#include "rogue.h"

object *fight_monster = 0;
char hit_message[80] = "";

extern short halluc, blind, cur_level;
extern short add_strength, ring_exp, r_rings;
extern boolean being_held, interrupted, wizard, con_mon;

mon_hit(monster)
register object *monster;
{
	short damage, hit_chance;
	char *mn;
	float minus;

	if (fight_monster && (monster != fight_monster)) {
		fight_monster = 0;
	}
	monster->trow = NO_ROOM;
	if (cur_level >= (AMULET_LEVEL * 2)) {
		hit_chance = 100;
	} else {
		hit_chance = monster->m_hit_chance;
		hit_chance -= (((2 * rogue.exp) + (2 * ring_exp)) - r_rings);
	}
	if (wizard) {
		hit_chance /= 2;
	}
	if (!fight_monster) {
		interrupted = 1;
	}
	mn = mon_name(monster);

	if (!rand_percent(hit_chance)) {
		if (!fight_monster) {
			sprintf(hit_message + strlen(hit_message), "the %s misses", mn);
			message(hit_message, 1);
			hit_message[0] = 0;
		}
		return;
	}
	if (!fight_monster) {
		sprintf(hit_message + strlen(hit_message), "the %s hit", mn);
		message(hit_message, 1);
		hit_message[0] = 0;
	}
	if (!(monster->m_flags & STATIONARY)) {
		damage = get_damage(monster->m_damage, 1);
		if (cur_level >= (AMULET_LEVEL * 2)) {
			minus = (float) ((AMULET_LEVEL * 2) - cur_level);
		} else {
			minus = (float) get_armor_class(rogue.armor) * 3.00;
			minus = minus/100.00 * (float) damage;
		}
		damage -= (short) minus;
	} else {
		damage = monster->stationary_damage++;
	}
	if (wizard) {
		damage /= 3;
	}
	if (damage > 0) {
		rogue_damage(damage, monster, 0);
	}
	if (monster->m_flags & SPECIAL_HIT) {
		special_hit(monster);
	}
}

rogue_hit(monster, force_hit)
register object *monster;
boolean force_hit;
{
	short damage, hit_chance;

	if (monster) {
		if (check_imitator(monster)) {
			return;
		}
		hit_chance = force_hit ? 100 : get_hit_chance(rogue.weapon);

		if (wizard) {
			hit_chance *= 2;
		}
		if (!rand_percent(hit_chance)) {
			if (!fight_monster) {
				(void) strcpy(hit_message, "you miss  ");
			}
			goto RET;
		}
		damage = get_weapon_damage(rogue.weapon);
		if (wizard) {
			damage *= 3;
		}
		if (con_mon) {
			s_con_mon(monster);
		}
		if (mon_damage(monster, damage)) {	/* still alive? */
			if (!fight_monster) {
				(void) strcpy(hit_message, "you hit  ");
			}
		}
RET:	check_gold_seeker(monster);
		wake_up(monster);
	}
}

rogue_damage(d, monster, other)
short d;
object *monster;
short other;
{
	if (d >= rogue.hp_current) {
		rogue.hp_current = 0;
		print_stats(STAT_HP);
		killed_by(monster, other);
	}
	if (d > 0) {
		rogue.hp_current -= d;
		print_stats(STAT_HP);
	}
}

get_damage(ds, r)
char *ds;
boolean r;
{
	register i = 0, j, n, d, total = 0;

	while (ds[i]) {
		n = get_number(ds+i);
		while (ds[i++] != 'd') ;
		d = get_number(ds+i);
		while ((ds[i] != '/') && ds[i]) i++;

		for (j = 0; j < n; j++) {
			if (r) {
				total += get_rand(1, d);
			} else {
				total += d;
			}
		}
		if (ds[i] == '/') {
			i++;
		}
	}
	return(total);
}

get_w_damage(obj)
object *obj;
{
	char new_damage[12];
	register to_hit, damage;
	register i = 0;

	if ((!obj) || (obj->what_is != WEAPON)) {
		return(-1);
	}
	to_hit = get_number(obj->damage) + obj->hit_enchant;
	while (obj->damage[i++] != 'd') ;
	damage = get_number(obj->damage + i) + obj->d_enchant;

	sprintf(new_damage, "%dd%d", to_hit, damage);

	return(get_damage(new_damage, 1));
}

get_number(s)
register char *s;
{
	register i = 0;
	register total = 0;

	while ((s[i] >= '0') && (s[i] <= '9')) {
		total = (10 * total) + (s[i] - '0');
		i++;
	}
	return(total);
}

long
lget_number(s)
char *s;
{
	short i = 0;
	long total = 0;

	while ((s[i] >= '0') && (s[i] <= '9')) {
		total = (10 * total) + (s[i] - '0');
		i++;
	}
	return(total);
}

to_hit(obj)
object *obj;
{
	if (!obj) {
		return(1);
	}
	return(get_number(obj->damage) + obj->hit_enchant);
}

damage_for_strength()
{
	short strength;

	strength = rogue.str_current + add_strength;

	if (strength <= 6) {
		return(strength-5);
	}
	if (strength <= 14) {
		return(1);
	}
	if (strength <= 17) {
		return(3);
	}
	if (strength <= 18) {
		return(4);
	}
	if (strength <= 20) {
		return(5);
	}
	if (strength <= 21) {
		return(6);
	}
	if (strength <= 30) {
		return(7);
	}
	return(8);
}

mon_damage(monster, damage)
object *monster;
short damage;
{
	char *mn;
	short row, col;

	monster->hp_to_kill -= damage;

	if (monster->hp_to_kill <= 0) {
		row = monster->row;
		col = monster->col;
		dungeon[row][col] &= ~MONSTER;
		mvaddch(row, col, (int) get_dungeon_char(row, col));

		fight_monster = 0;
		cough_up(monster);
		mn = mon_name(monster);
		sprintf(hit_message+strlen(hit_message), "defeated the %s", mn);
		message(hit_message, 1);
		hit_message[0] = 0;
		add_exp(monster->kill_exp, 1);
		take_from_pack(monster, &level_monsters);

		if (monster->m_flags & HOLDS) {
			being_held = 0;
		}
		free_object(monster);
		return(0);
	}
	return(1);
}

fight(to_the_death)
boolean to_the_death;
{
	short ch, c, d;
	short row, col;
	boolean first_miss = 1;
	short possible_damage;
	object *monster;

	while (!is_direction(ch = rgetchar(), &d)) {
		sound_bell();
		if (first_miss) {
			message("direction?", 0);
			first_miss = 0;
		}
	}
	check_message();
	if (ch == CANCEL) {
		return;
	}
	row = rogue.row; col = rogue.col;
	get_dir_rc(d, &row, &col, 0);

	c = mvinch(row, col);
	if (((c < 'A') || (c > 'Z')) ||
		(!can_move(rogue.row, rogue.col, row, col))) {
		message("I see no monster there", 0);
		return;
	}
	if (!(fight_monster = object_at(&level_monsters, row, col))) {
		return;
	}
	if (!(fight_monster->m_flags & STATIONARY)) {
		possible_damage = ((get_damage(fight_monster->m_damage, 0) * 2) / 3);
	} else {
		possible_damage = fight_monster->stationary_damage - 1;
	}
	while (fight_monster) {
		(void) one_move_rogue(ch, 0);
		if (((!to_the_death) && (rogue.hp_current <= possible_damage)) ||
			interrupted || (!(dungeon[row][col] & MONSTER))) {
			fight_monster = 0;
		} else {
			monster = object_at(&level_monsters, row, col);
			if (monster != fight_monster) {
				fight_monster = 0;
			}
		}
	}
}

get_dir_rc(dir, row, col, allow_off_screen)
short dir;
short *row, *col;
short allow_off_screen;
{
	switch(dir) {
	case LEFT:
		if (allow_off_screen || (*col > 0)) {
			(*col)--;
		}
		break;
	case DOWN:
		if (allow_off_screen || (*row < (DROWS-2))) {
			(*row)++;
		}
		break;
	case UPWARD:
		if (allow_off_screen || (*row > MIN_ROW)) {
			(*row)--;
		}
		break;
	case RIGHT:
		if (allow_off_screen || (*col < (DCOLS-1))) {
			(*col)++;
		}
		break;
	case UPLEFT:
		if (allow_off_screen || ((*row > MIN_ROW) && (*col > 0))) {
			(*row)--;
			(*col)--;
		}
		break;
	case UPRIGHT:
		if (allow_off_screen || ((*row > MIN_ROW) && (*col < (DCOLS-1)))) {
			(*row)--;
			(*col)++;
		}
		break;
	case DOWNRIGHT:
		if (allow_off_screen || ((*row < (DROWS-2)) && (*col < (DCOLS-1)))) {
			(*row)++;
			(*col)++;
		}
		break;
	case DOWNLEFT:
		if (allow_off_screen || ((*row < (DROWS-2)) && (*col > 0))) {
			(*row)++;
			(*col)--;
		}
		break;
	}
}

get_hit_chance(weapon)
object *weapon;
{
	short hit_chance;

	hit_chance = 40;
	hit_chance += 3 * to_hit(weapon);
	hit_chance += (((2 * rogue.exp) + (2 * ring_exp)) - r_rings);
	return(hit_chance);
}

get_weapon_damage(weapon)
object *weapon;
{
	short damage;

	damage = get_w_damage(weapon);
	damage += damage_for_strength();
	damage += ((((rogue.exp + ring_exp) - r_rings) + 1) / 2);
	return(damage);
}

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