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

/*
 * 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.
 *
 */

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

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