ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/server/monster.C
(Generate patch)

Comparing deliantra/server/server/monster.C (file contents):
Revision 1.6 by root, Sun Sep 3 00:18:42 2006 UTC vs.
Revision 1.21 by root, Sun Jan 14 23:35:04 2007 UTC

1/*
2 * static char *rcsid_monster_c =
3 * "$Id: monster.C,v 1.6 2006/09/03 00:18:42 root Exp $";
4 */
5
6/* 1/*
7 CrossFire, A Multiplayer game for X-windows 2 CrossFire, A Multiplayer game for X-windows
8 3
4 Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
9 Copyright (C) 2002 Mark Wedel & Crossfire Development Team 5 Copyright (C) 2002 Mark Wedel & Crossfire Development Team
10 Copyright (C) 1992 Frank Tore Johansen 6 Copyright (C) 1992 Frank Tore Johansen
11 7
12 This program is free software; you can redistribute it and/or modify 8 This program is free software; you can redistribute it and/or modify
13 it under the terms of the GNU General Public License as published by 9 it under the terms of the GNU General Public License as published by
… …
21 17
22 You should have received a copy of the GNU General Public License 18 You should have received a copy of the GNU General Public License
23 along with this program; if not, write to the Free Software 19 along with this program; if not, write to the Free Software
24 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 21
26 The authors can be reached via e-mail at crossfire-devel@real-time.com 22 The authors can be reached via e-mail at <crossfire@schmorp.de>
27*/ 23*/
28 24
29#include <global.h> 25#include <global.h>
30#ifndef __CEXTRACT__
31#include <sproto.h> 26#include <sproto.h>
32#include <spells.h> 27#include <spells.h>
33#include <skills.h> 28#include <skills.h>
34#endif
35 29
36
37#define MIN_MON_RADIUS 3 /* minimum monster detection radius */ 30#define MIN_MON_RADIUS 3 /* minimum monster detection radius */
38
39 31
40/* checks npc->enemy and returns that enemy if still valid, 32/* checks npc->enemy and returns that enemy if still valid,
41 * NULL otherwise. 33 * NULL otherwise.
42 * this is map tile aware. 34 * this is map tile aware.
43 * If this returns an enemy, the range vector rv should also be 35 * If this returns an enemy, the range vector rv should also be
44 * set to sane values. 36 * set to sane values.
45 */ 37 */
38object *
46object *check_enemy(object *npc, rv_vector *rv) { 39check_enemy (object *npc, rv_vector * rv)
47 40{
41
48 /* if this is pet, let him attack the same enemy as his owner 42 /* if this is pet, let him attack the same enemy as his owner
49 * TODO: when there is no ower enemy, try to find a target, 43 * TODO: when there is no ower enemy, try to find a target,
50 * which CAN attack the owner. */ 44 * which CAN attack the owner. */
51 if ((npc->attack_movement & HI4) == PETMOVE) 45 if ((npc->attack_movement & HI4) == PETMOVE)
52 { 46 {
53 if (npc->owner == NULL) 47 if (npc->owner == NULL)
54 npc->enemy = NULL; 48 npc->enemy = NULL;
55 else if (npc->enemy == NULL) 49 else if (npc->enemy == NULL)
56 npc->enemy = npc->owner->enemy; 50 npc->enemy = npc->owner->enemy;
57 } 51 }
58 52
59 /* periodically, a monster mayu change its target. Also, if the object 53 /* periodically, a monster mayu change its target. Also, if the object
60 * has been destroyed, etc, clear the enemy. 54 * has been destroyed, etc, clear the enemy.
61 * TODO: this should be changed, because it invokes to attack forced or 55 * TODO: this should be changed, because it invokes to attack forced or
62 * attacked monsters to leave the attacker alone, before it is destroyed 56 * attacked monsters to leave the attacker alone, before it is destroyed
63 */ 57 */
64 /* i had removed the random target leave, this invokes problems with friendly 58 /* i had removed the random target leave, this invokes problems with friendly
65 * objects, getting attacked and defending herself - they don't try to attack 59 * objects, getting attacked and defending herself - they don't try to attack
66 * again then but perhaps get attack on and on 60 * again then but perhaps get attack on and on
67 * If we include a aggravated flag in , we can handle evil vs evil and good vs good 61 * If we include a aggravated flag in , we can handle evil vs evil and good vs good
68 * too. */ 62 * too. */
69 63
70 if(npc->enemy) 64 if (npc->enemy)
71 { 65 {
72 /* I broke these if's apart to better be able to see what 66 /* I broke these if's apart to better be able to see what
73 * the grouping checks are. Code is the same. 67 * the grouping checks are. Code is the same.
74 */ 68 */
75 if ( QUERY_FLAG(npc->enemy,FLAG_REMOVED) || 69 if (QUERY_FLAG (npc->enemy, FLAG_REMOVED) ||
76 QUERY_FLAG(npc->enemy,FLAG_FREED) || 70 QUERY_FLAG (npc->enemy, FLAG_FREED) ||
77 !on_same_map(npc, npc->enemy) || 71 !on_same_map (npc, npc->enemy) || npc == npc->enemy || QUERY_FLAG (npc, FLAG_NEUTRAL) || QUERY_FLAG (npc->enemy, FLAG_NEUTRAL))
78 npc == npc->enemy ||
79 QUERY_FLAG(npc, FLAG_NEUTRAL) ||
80 QUERY_FLAG(npc->enemy, FLAG_NEUTRAL))
81 npc->enemy = NULL; 72 npc->enemy = NULL;
82 73
83 else if (QUERY_FLAG(npc, FLAG_FRIENDLY) && ( 74 else if (QUERY_FLAG (npc, FLAG_FRIENDLY) && ((QUERY_FLAG (npc->enemy, FLAG_FRIENDLY)
84 (QUERY_FLAG(npc->enemy, FLAG_FRIENDLY) && !(should_arena_attack(npc, npc->owner, npc->enemy))) || 75 && !(should_arena_attack (npc, npc->owner, npc->enemy)))
85 ((npc->enemy->type == PLAYER) && !(should_arena_attack(npc, npc->owner, npc->enemy))) 76 || ((npc->enemy->type == PLAYER) && !(should_arena_attack (npc, npc->owner, npc->enemy)))
86 || npc->enemy == npc->owner)) 77 || npc->enemy == npc->owner))
87 npc->enemy = NULL; 78 npc->enemy = NULL;
88 79
89 80
90 else if (!QUERY_FLAG(npc, FLAG_FRIENDLY) && 81 else if (!QUERY_FLAG (npc, FLAG_FRIENDLY) && (!QUERY_FLAG (npc->enemy, FLAG_FRIENDLY) && npc->enemy->type != PLAYER))
91 (!QUERY_FLAG(npc->enemy, FLAG_FRIENDLY) && npc->enemy->type!=PLAYER))
92 npc->enemy=NULL; 82 npc->enemy = NULL;
93 83
94 /* I've noticed that pets could sometimes get an arrow as the 84 /* I've noticed that pets could sometimes get an arrow as the
95 * target enemy - this code below makes sure the enemy is something 85 * target enemy - this code below makes sure the enemy is something
96 * that should be attacked. My guess is that the arrow hits 86 * that should be attacked. My guess is that the arrow hits
97 * the creature/owner, and so the creature then takes that 87 * the creature/owner, and so the creature then takes that
98 * as the enemy to attack. 88 * as the enemy to attack.
99 */ 89 */
100 else if (!QUERY_FLAG(npc->enemy, FLAG_MONSTER) && 90 else if (!QUERY_FLAG (npc->enemy, FLAG_MONSTER) &&
101 !QUERY_FLAG(npc->enemy,FLAG_GENERATOR) &&
102 npc->enemy->type!=PLAYER && npc->enemy->type != GOLEM) 91 !QUERY_FLAG (npc->enemy, FLAG_GENERATOR) && npc->enemy->type != PLAYER && npc->enemy->type != GOLEM)
103 npc->enemy=NULL; 92 npc->enemy = NULL;
104 93
105 } 94 }
106 return can_detect_enemy(npc,npc->enemy,rv)?npc->enemy:NULL; 95 return can_detect_enemy (npc, npc->enemy, rv) ? npc->enemy : NULL;
107} 96}
108 97
109/* Returns the nearest living creature (monster or generator). 98/* Returns the nearest living creature (monster or generator).
110 * Modified to deal with tiled maps properly. 99 * Modified to deal with tiled maps properly.
111 * Also fixed logic so that monsters in the lower directions were more 100 * Also fixed logic so that monsters in the lower directions were more
… …
118 * the first few directions, it could very well choose something 107 * the first few directions, it could very well choose something
119 * 3 spaces away even though something directly north is closer. 108 * 3 spaces away even though something directly north is closer.
120 * 109 *
121 * this function is map tile aware. 110 * this function is map tile aware.
122 */ 111 */
112object *
123object *find_nearest_living_creature(object *npc) { 113find_nearest_living_creature (object *npc)
114{
124 int i,mflags; 115 int i, mflags;
125 sint16 nx,ny; 116 sint16 nx, ny;
126 mapstruct *m; 117 maptile *m;
127 object *tmp;
128 int search_arr[SIZEOFFREE]; 118 int search_arr[SIZEOFFREE];
129 119
130 get_search_arr(search_arr); 120 get_search_arr (search_arr);
121
131 for(i=0;i<SIZEOFFREE;i++) { 122 for (i = 0; i < SIZEOFFREE; i++)
123 {
132 /* modified to implement smart searching using search_arr 124 /* modified to implement smart searching using search_arr
133 * guidance array to determine direction of search order 125 * guidance array to determine direction of search order
134 */ 126 */
135 nx = npc->x + freearr_x[search_arr[i]]; 127 nx = npc->x + freearr_x[search_arr[i]];
136 ny = npc->y + freearr_y[search_arr[i]]; 128 ny = npc->y + freearr_y[search_arr[i]];
137 m = npc->map; 129 m = npc->map;
138 130
139 mflags = get_map_flags(m, &m, nx, ny, &nx, &ny); 131 mflags = get_map_flags (m, &m, nx, ny, &nx, &ny);
132
140 if (mflags & P_OUT_OF_MAP) continue; 133 if (mflags & P_OUT_OF_MAP)
134 continue;
141 135
142 if (mflags & P_IS_ALIVE) { 136 if (mflags & P_IS_ALIVE)
143 tmp=get_map_ob(m,nx,ny); 137 {
144 while(tmp!=NULL && !QUERY_FLAG(tmp,FLAG_MONSTER)&& 138 for (object *tmp = m->at (nx, ny).top; tmp; tmp = tmp->below)
145 !QUERY_FLAG(tmp,FLAG_GENERATOR ) && tmp->type!=PLAYER) 139 if (tmp->flag [FLAG_MONSTER] || tmp->flag [FLAG_GENERATOR] || tmp->type == PLAYER)
146 tmp=tmp->above;
147
148 if (!tmp) {
149 LOG(llevDebug,"find_nearest_living_creature: map %s (%d,%d) has is_alive set but did not find a monster?\n",
150 m->path, nx, ny);
151 }
152 else {
153 if(can_see_monsterP(m,nx,ny,i)) 140 if (can_see_monsterP (m, nx, ny, i))
154 return tmp; 141 return tmp;
155 } 142 }
156 } /* is something living on this space */
157 } 143 }
158 return NULL; /* nothing found */ 144
145 return 0;
159} 146}
160 147
161 148
162/* Tries to find an enmy for npc. We pass the range vector since 149/* Tries to find an enmy for npc. We pass the range vector since
163 * our caller will find the information useful. 150 * our caller will find the information useful.
… …
165 * Fix function so that we always make calls to get_rangevector 152 * Fix function so that we always make calls to get_rangevector
166 * if we have a valid target - function as not doing so in 153 * if we have a valid target - function as not doing so in
167 * many cases. 154 * many cases.
168 */ 155 */
169 156
157object *
170object *find_enemy(object *npc, rv_vector *rv) 158find_enemy (object *npc, rv_vector * rv)
171{ 159{
172 object *attacker, *tmp=NULL; 160 object *attacker, *tmp = NULL;
173 161
174 attacker = npc->attacked_by; /* save this for later use. This can be a attacker. */ 162 attacker = npc->attacked_by; /* save this for later use. This can be a attacker. */
175 npc->attacked_by = NULL; /* always clear the attacker entry */ 163 npc->attacked_by = 0; /* always clear the attacker entry */
176 164
177 /* if we berserk, we don't care about others - we attack all we can find */ 165 /* if we berserk, we don't care about others - we attack all we can find */
178 if(QUERY_FLAG(npc,FLAG_BERSERK)) { 166 if (QUERY_FLAG (npc, FLAG_BERSERK))
167 {
179 tmp = find_nearest_living_creature(npc); 168 tmp = find_nearest_living_creature (npc);
169
170 if (tmp)
180 if (tmp) get_rangevector(npc, tmp, rv, 0); 171 get_rangevector (npc, tmp, rv, 0);
181 return tmp; 172 return tmp;
182 } 173 }
183 174
184 /* Here is the main enemy selection. 175 /* Here is the main enemy selection.
185 * We want this: if there is an enemy, attack him until its not possible or 176 * We want this: if there is an enemy, attack him until its not possible or
186 * one of both is dead. 177 * one of both is dead.
187 * If we have no enemy and we are... 178 * If we have no enemy and we are...
188 * a monster: try to find a player, a pet or a friendly monster 179 * a monster: try to find a player, a pet or a friendly monster
189 * a friendly: only target a monster which is targeting you first or targeting a player 180 * a friendly: only target a monster which is targeting you first or targeting a player
190 * a neutral: fight a attacker (but there should be none), then do nothing 181 * a neutral: fight a attacker (but there should be none), then do nothing
191 * a pet: attack player enemy or a monster 182 * a pet: attack player enemy or a monster
192 */ 183 */
193 184
194 /* pet move */ 185 /* pet move */
195 if ((npc->attack_movement & HI4) == PETMOVE) { 186 if ((npc->attack_movement & HI4) == PETMOVE)
187 {
196 tmp= get_pet_enemy(npc,rv); 188 tmp = get_pet_enemy (npc, rv);
189
190 if (tmp)
197 if (tmp) get_rangevector(npc, tmp, rv, 0); 191 get_rangevector (npc, tmp, rv, 0);
192
198 return tmp; 193 return tmp;
199 }
200 194 }
195
201 /* we check our old enemy. */ 196 /* we check our old enemy. */
202 if((tmp=check_enemy(npc, rv))==NULL) 197 if (!(tmp = check_enemy (npc, rv)))
203 { 198 {
204 if(attacker) /* if we have an attacker, check him */ 199 if (attacker) /* if we have an attacker, check him */
205 { 200 {
206 /* we want be sure this is the right one! */ 201 /* TODO: thats not finished */
207 if(attacker->count == npc->attacked_by_count) 202 /* we don't want a fight evil vs evil or good against non evil */
203
204 if (QUERY_FLAG (npc, FLAG_NEUTRAL) || QUERY_FLAG (attacker, FLAG_NEUTRAL) || /* neutral */
205 (QUERY_FLAG (npc, FLAG_FRIENDLY) && QUERY_FLAG (attacker, FLAG_FRIENDLY)) ||
206 (!QUERY_FLAG (npc, FLAG_FRIENDLY) && (!QUERY_FLAG (attacker, FLAG_FRIENDLY) && attacker->type != PLAYER)))
207 CLEAR_FLAG (npc, FLAG_SLEEP); /* skip it, but lets wakeup */
208 else if (on_same_map (npc, attacker)) /* thats the only thing we must know... */
208 { 209 {
209 /* TODO: thats not finished */
210 /* we don't want a fight evil vs evil or good against non evil */
211
212 if( QUERY_FLAG(npc, FLAG_NEUTRAL) || QUERY_FLAG(attacker, FLAG_NEUTRAL) || /* neutral */
213 (QUERY_FLAG(npc, FLAG_FRIENDLY) && QUERY_FLAG(attacker, FLAG_FRIENDLY)) ||
214 (!QUERY_FLAG(npc, FLAG_FRIENDLY) &&
215 (!QUERY_FLAG(attacker, FLAG_FRIENDLY) && attacker->type!=PLAYER)) )
216 CLEAR_FLAG(npc,FLAG_SLEEP); /* skip it, but lets wakeup */
217 else if(on_same_map(npc, attacker)) /* thats the only thing we must know... */
218 {
219 CLEAR_FLAG(npc,FLAG_SLEEP); /* well, NOW we really should wake up! */ 210 CLEAR_FLAG (npc, FLAG_SLEEP); /* well, NOW we really should wake up! */
220 npc->enemy = attacker; 211 npc->enemy = attacker;
221 return attacker; /* yes, we face our attacker! */ 212 return attacker; /* yes, we face our attacker! */
222 }
223 } 213 }
224 } 214 }
225 215
226 /* we have no legal enemy or attacker, so we try to target a new one */ 216 /* we have no legal enemy or attacker, so we try to target a new one */
227 if(!QUERY_FLAG(npc, FLAG_UNAGGRESSIVE) && !QUERY_FLAG(npc, FLAG_FRIENDLY) && 217 if (!QUERY_FLAG (npc, FLAG_UNAGGRESSIVE) && !QUERY_FLAG (npc, FLAG_FRIENDLY) && !QUERY_FLAG (npc, FLAG_NEUTRAL))
228 !QUERY_FLAG(npc, FLAG_NEUTRAL))
229 { 218 {
230 npc->enemy = get_nearest_player(npc); 219 npc->enemy = get_nearest_player (npc);
231 if (npc->enemy) 220 if (npc->enemy)
232 tmp = check_enemy(npc,rv); 221 tmp = check_enemy (npc, rv);
233 }
234 222 }
235 }
236 223
224 }
225
237 return tmp; 226 return tmp;
238} 227}
239 228
240/* Sees if this monster should wake up. 229/* Sees if this monster should wake up.
241 * Currently, this is only called from move_monster, and 230 * Currently, this is only called from move_monster, and
242 * if enemy is set, then so should be rv. 231 * if enemy is set, then so should be rv.
243 * returns 1 if the monster should wake up, 0 otherwise. 232 * returns 1 if the monster should wake up, 0 otherwise.
244 */ 233 */
245 234
235int
246int check_wakeup(object *op, object *enemy, rv_vector *rv) { 236check_wakeup (object *op, object *enemy, rv_vector * rv)
237{
247 int radius = op->stats.Wis>MIN_MON_RADIUS?op->stats.Wis:MIN_MON_RADIUS; 238 int radius = op->stats.Wis > MIN_MON_RADIUS ? op->stats.Wis : MIN_MON_RADIUS;
248 239
249 /* Trim work - if no enemy, no need to do anything below */ 240 /* Trim work - if no enemy, no need to do anything below */
250 if (!enemy) return 0; 241 if (!enemy)
242 return 0;
251 243
252 /* blinded monsters can only find nearby objects to attack */ 244 /* blinded monsters can only find nearby objects to attack */
253 if(QUERY_FLAG(op, FLAG_BLIND)) 245 if (QUERY_FLAG (op, FLAG_BLIND))
254 radius = MIN_MON_RADIUS; 246 radius = MIN_MON_RADIUS;
255 247
256 /* This covers the situation where the monster is in the dark 248 /* This covers the situation where the monster is in the dark
257 * and has an enemy. If the enemy has no carried light (or isnt 249 * and has an enemy. If the enemy has no carried light (or isnt
258 * glowing!) then the monster has trouble finding the enemy. 250 * glowing!) then the monster has trouble finding the enemy.
259 * Remember we already checked to see if the monster can see in 251 * Remember we already checked to see if the monster can see in
260 * the dark. */ 252 * the dark. */
261 253
262 else if(op->map && op->map->darkness>0 && enemy && !enemy->invisible && 254 else if (op->map && op->map->darkness > 0 && enemy && !enemy->invisible &&
263 !stand_in_light(enemy) &&
264 (!QUERY_FLAG(op,FLAG_SEE_IN_DARK) || !QUERY_FLAG(op,FLAG_SEE_INVISIBLE))) { 255 !stand_in_light (enemy) && (!QUERY_FLAG (op, FLAG_SEE_IN_DARK) || !QUERY_FLAG (op, FLAG_SEE_INVISIBLE)))
256 {
265 int dark = radius/(op->map->darkness); 257 int dark = radius / (op->map->darkness);
258
266 radius = (dark>MIN_MON_RADIUS)?(dark+1):MIN_MON_RADIUS; 259 radius = (dark > MIN_MON_RADIUS) ? (dark + 1) : MIN_MON_RADIUS;
267 } 260 }
268 else if(!QUERY_FLAG(op,FLAG_SLEEP)) return 1; 261 else if (!QUERY_FLAG (op, FLAG_SLEEP))
262 return 1;
269 263
270 /* enemy should already be on this map, so don't really need to check 264 /* enemy should already be on this map, so don't really need to check
271 * for that. 265 * for that.
272 */ 266 */
273 if (rv->distance < (QUERY_FLAG(enemy, FLAG_STEALTH)?(radius/2)+1:radius)) { 267 if (rv->distance < (unsigned int) (QUERY_FLAG (enemy, FLAG_STEALTH) ? (radius / 2) + 1 : radius))
268 {
274 CLEAR_FLAG(op,FLAG_SLEEP); 269 CLEAR_FLAG (op, FLAG_SLEEP);
270 return 1;
271 }
272 return 0;
273}
274
275int
276move_randomly (object *op)
277{
278 int i;
279
280 /* Give up to 15 chances for a monster to move randomly */
281 for (i = 0; i < 15; i++)
282 {
283 if (move_object (op, RANDOM () % 8 + 1))
275 return 1; 284 return 1;
276 } 285 }
277 return 0; 286 return 0;
278}
279
280int move_randomly(object *op) {
281 int i;
282
283 /* Give up to 15 chances for a monster to move randomly */
284 for(i=0;i<15;i++) {
285 if(move_object(op,RANDOM()%8+1))
286 return 1;
287 }
288 return 0;
289} 287}
290 288
291/* 289/*
292 * Move-monster returns 1 if the object has been freed, otherwise 0. 290 * Move-monster returns 1 if the object has been freed, otherwise 0.
293 */ 291 */
294 292
293int
295int move_monster(object *op) { 294move_monster (object *op)
295{
296 int dir, diff, pre_att_dir; /* elmex: pre_att_dir remembers the direction before attack movement */ 296 int dir, diff, pre_att_dir; /* elmex: pre_att_dir remembers the direction before attack movement */
297 object *owner, *enemy, *part, *oph=op; 297 object *owner, *enemy, *part, *oph = op;
298 rv_vector rv; 298 rv_vector rv;
299 299
300 /* Monsters not on maps don't do anything. These monsters are things 300 /* Monsters not on maps don't do anything. These monsters are things
301 * Like royal guards in city dwellers inventories. 301 * Like royal guards in city dwellers inventories.
302 */ 302 */
303 if (!op->map) return 0; 303 if (!op->map)
304 return 0;
304 305
305 /* for target facing, we copy this value here for fast access */ 306 /* for target facing, we copy this value here for fast access */
306 if(oph->head) /* force update the head - one arch one pic */ 307 if (oph->head) /* force update the head - one arch one pic */
307 oph = oph->head; 308 oph = oph->head;
308 309
309 if (QUERY_FLAG(op, FLAG_NO_ATTACK)) /* we never ever attack */ 310 if (QUERY_FLAG (op, FLAG_NO_ATTACK)) /* we never ever attack */
310 enemy = op->enemy = NULL; 311 enemy = op->enemy = NULL;
311 else if((enemy= find_enemy(op, &rv))) 312 else if ((enemy = find_enemy (op, &rv)))
312 {
313 /* we have an enemy, just tell him we want him dead */ 313 /* we have an enemy, just tell him we want him dead */
314 enemy->attacked_by = op; /* our ptr */ 314 enemy->attacked_by = op; /* our ptr */
315 enemy->attacked_by_count = op->count; /* our tag */ 315
316 }
317
318 /* generate hp, if applicable */ 316 /* generate hp, if applicable */
319 if(op->stats.Con > 0 && op->stats.hp < op->stats.maxhp) { 317 if (op->stats.Con > 0 && op->stats.hp < op->stats.maxhp)
318 {
320 319
321 /* last heal is in funny units. Dividing by speed puts 320 /* last heal is in funny units. Dividing by speed puts
322 * the regeneration rate on a basis of time instead of 321 * the regeneration rate on a basis of time instead of
323 * #moves the monster makes. The scaling by 8 is 322 * #moves the monster makes. The scaling by 8 is
324 * to capture 8th's of a hp fraction regens 323 * to capture 8th's of a hp fraction regens
325 * 324 *
326 * Cast to sint32 before comparing to maxhp since otherwise an (sint16) 325 * Cast to sint32 before comparing to maxhp since otherwise an (sint16)
327 * overflow might produce monsters with negative hp. 326 * overflow might produce monsters with negative hp.
328 */ 327 */
329 328
330 op->last_heal+= (int)((float)(8*op->stats.Con)/FABS(op->speed)); 329 op->last_heal += (int) ((float) (8 * op->stats.Con) / FABS (op->speed));
331 op->stats.hp = MIN((sint32)op->stats.hp+op->last_heal/32, op->stats.maxhp); /* causes Con/4 hp/tick */ 330 op->stats.hp = MIN ((sint32) op->stats.hp + op->last_heal / 32, op->stats.maxhp); /* causes Con/4 hp/tick */
332 op->last_heal%=32; 331 op->last_heal %= 32;
333 332
334 /* So if the monster has gained enough HP that they are no longer afraid */ 333 /* So if the monster has gained enough HP that they are no longer afraid */
335 if (QUERY_FLAG(op,FLAG_RUN_AWAY) && 334 if (QUERY_FLAG (op, FLAG_RUN_AWAY) && op->stats.hp >= (signed short) (((float) op->run_away / (float) 100) * (float) op->stats.maxhp))
336 op->stats.hp >= (signed short)(((float)op->run_away/(float)100)*
337 (float)op->stats.maxhp))
338 CLEAR_FLAG(op, FLAG_RUN_AWAY); 335 CLEAR_FLAG (op, FLAG_RUN_AWAY);
339 336
340 if(op->stats.hp>op->stats.maxhp) 337 if (op->stats.hp > op->stats.maxhp)
341 op->stats.hp=op->stats.maxhp; 338 op->stats.hp = op->stats.maxhp;
342 } 339 }
343 340
344 /* generate sp, if applicable */ 341 /* generate sp, if applicable */
345 if(op->stats.Pow > 0 && op->stats.sp < op->stats.maxsp) { 342 if (op->stats.Pow > 0 && op->stats.sp < op->stats.maxsp)
343 {
346 344
347 /* last_sp is in funny units. Dividing by speed puts 345 /* last_sp is in funny units. Dividing by speed puts
348 * the regeneration rate on a basis of time instead of 346 * the regeneration rate on a basis of time instead of
349 * #moves the monster makes. The scaling by 8 is 347 * #moves the monster makes. The scaling by 8 is
350 * to capture 8th's of a sp fraction regens 348 * to capture 8th's of a sp fraction regens
351 * 349 *
352 * Cast to sint32 before comparing to maxhp since otherwise an (sint16) 350 * Cast to sint32 before comparing to maxhp since otherwise an (sint16)
353 * overflow might produce monsters with negative sp. 351 * overflow might produce monsters with negative sp.
354 */ 352 */
355 353
356 op->last_sp+= (int)((float)(8*op->stats.Pow)/FABS(op->speed)); 354 op->last_sp += (int) ((float) (8 * op->stats.Pow) / FABS (op->speed));
357 op->stats.sp = MIN(op->stats.sp+op->last_sp/128, op->stats.maxsp); /* causes Pow/16 sp/tick */ 355 op->stats.sp = MIN (op->stats.sp + op->last_sp / 128, op->stats.maxsp); /* causes Pow/16 sp/tick */
358 op->last_sp%=128; 356 op->last_sp %= 128;
359 } 357 }
360 358
361 /* this should probably get modified by many more values. 359 /* this should probably get modified by many more values.
362 * (eg, creatures resistance to fear, level, etc. ) 360 * (eg, creatures resistance to fear, level, etc. )
363 */ 361 */
364 if(QUERY_FLAG(op, FLAG_SCARED) &&!(RANDOM()%20)) { 362 if (QUERY_FLAG (op, FLAG_SCARED) && !(RANDOM () % 20))
363 {
365 CLEAR_FLAG(op,FLAG_SCARED); /* Time to regain some "guts"... */ 364 CLEAR_FLAG (op, FLAG_SCARED); /* Time to regain some "guts"... */
366 } 365 }
367 366
368 if (INVOKE_OBJECT (MONSTER_MOVE, op, ARG_OBJECT (op->enemy))) 367 if (INVOKE_OBJECT (MONSTER_MOVE, op, ARG_OBJECT (op->enemy)))
369 return QUERY_FLAG (op, FLAG_FREED); 368 return QUERY_FLAG (op, FLAG_FREED);
370 369
371 if ( QUERY_FLAG(op, FLAG_SLEEP) || QUERY_FLAG(op, FLAG_BLIND) || 370 if (QUERY_FLAG (op, FLAG_SLEEP) || QUERY_FLAG (op, FLAG_BLIND) ||
372 ((op->map->darkness>0) && !QUERY_FLAG(op,FLAG_SEE_IN_DARK) && 371 ((op->map->darkness > 0) && !QUERY_FLAG (op, FLAG_SEE_IN_DARK) && !QUERY_FLAG (op, FLAG_SEE_INVISIBLE)))
373 !QUERY_FLAG(op,FLAG_SEE_INVISIBLE))) { 372 {
374 if(!check_wakeup(op,enemy,&rv)) 373 if (!check_wakeup (op, enemy, &rv))
375 return 0; 374 return 0;
376 } 375 }
377 376
378 /* check if monster pops out of hidden spot */ 377 /* check if monster pops out of hidden spot */
378 if (op->hide)
379 if(op->hide) do_hidden_move(op); 379 do_hidden_move (op);
380 380
381 if(op->pick_up) 381 if (op->pick_up)
382 monster_check_pickup(op); 382 monster_check_pickup (op);
383 383
384 if(op->will_apply) 384 if (op->will_apply)
385 monster_apply_below(op); /* Check for items to apply below */ 385 monster_apply_below (op); /* Check for items to apply below */
386 386
387 /* If we don't have an enemy, do special movement or the like */ 387 /* If we don't have an enemy, do special movement or the like */
388 if(!enemy) { 388 if (!enemy)
389 {
389 if(QUERY_FLAG(op, FLAG_ONLY_ATTACK)) { 390 if (QUERY_FLAG (op, FLAG_ONLY_ATTACK))
390 remove_ob(op); 391 {
391 free_object(op); 392 op->destroy ();
392 return 1; 393 return 1;
393 } 394 }
394 395
395 /* Probably really a bug for a creature to have both 396 /* Probably really a bug for a creature to have both
396 * stand still and a movement type set. 397 * stand still and a movement type set.
397 */ 398 */
398 if(!QUERY_FLAG(op, FLAG_STAND_STILL)) { 399 if (!QUERY_FLAG (op, FLAG_STAND_STILL))
400 {
399 if (op->attack_movement & HI4) 401 if (op->attack_movement & HI4)
400 { 402 {
401 switch (op->attack_movement & HI4) { 403 switch (op->attack_movement & HI4)
404 {
402 case (PETMOVE): 405 case (PETMOVE):
403 pet_move (op); 406 pet_move (op);
404 break; 407 break;
405 408
406 case (CIRCLE1): 409 case (CIRCLE1):
407 circ1_move (op); 410 circ1_move (op);
408 break; 411 break;
409 412
410 case (CIRCLE2): 413 case (CIRCLE2):
411 circ2_move (op); 414 circ2_move (op);
412 break; 415 break;
413 416
414 case (PACEV): 417 case (PACEV):
415 pace_movev(op); 418 pace_movev (op);
416 break; 419 break;
417 420
418 case (PACEH): 421 case (PACEH):
419 pace_moveh(op); 422 pace_moveh (op);
420 break; 423 break;
421 424
422 case (PACEV2): 425 case (PACEV2):
423 pace2_movev (op); 426 pace2_movev (op);
424 break; 427 break;
425 428
426 case (PACEH2): 429 case (PACEH2):
427 pace2_moveh (op); 430 pace2_moveh (op);
428 break; 431 break;
429 432
430 case (RANDO): 433 case (RANDO):
431 rand_move (op); 434 rand_move (op);
432 break; 435 break;
433 436
434 case (RANDO2): 437 case (RANDO2):
435 move_randomly (op); 438 move_randomly (op);
436 break; 439 break;
437 } 440 }
441 return 0;
442 }
443 else if (QUERY_FLAG (op, FLAG_RANDOM_MOVE))
444 (void) move_randomly (op);
445
446 } /* stand still */
447 return 0;
448 } /* no enemy */
449
450 /* We have an enemy. Block immediately below is for pets */
451 if ((op->attack_movement & HI4) == PETMOVE && (owner = op->owner) != NULL && !on_same_map (op, owner))
452 return follow_owner (op, owner);
453
454 /* doppleganger code to change monster facing to that of the nearest
455 * player. Hmm. The code is here, but no monster in the current
456 * arch set uses it.
457 */
458 if ((op->race != NULL) && strcmp (op->race, "doppleganger") == 0)
459 {
460 op->face = enemy->face;
461 op->name = enemy->name;
462 }
463
464 /* Calculate range information for closest body part - this
465 * is used for the 'skill' code, which isn't that smart when
466 * it comes to figuring it out - otherwise, giants throw boulders
467 * into themselves.
468 */
469 get_rangevector (op, enemy, &rv, 0);
470
471 /* Move the check for scared up here - if the monster was scared,
472 * we were not doing any of the logic below, so might as well save
473 * a few cpu cycles.
474 */
475 if (!QUERY_FLAG (op, FLAG_SCARED))
476 {
477 rv_vector rv1;
478
479 /* now we test every part of an object .... this is a real ugly piece of code */
480 for (part = op; part != NULL; part = part->more)
481 {
482 get_rangevector (part, enemy, &rv1, 0x1);
483 dir = rv1.direction;
484
485 /* hm, not sure about this part - in original was a scared flag here too
486 * but that we test above... so can be old code here
487 */
488 if (QUERY_FLAG (op, FLAG_RUN_AWAY))
489 dir = absdir (dir + 4);
490 if (QUERY_FLAG (op, FLAG_CONFUSED))
491 dir = absdir (dir + RANDOM () % 3 + RANDOM () % 3 - 2);
492
493 if (QUERY_FLAG (op, FLAG_CAST_SPELL) && !(RANDOM () % 3))
494 {
495 if (monster_cast_spell (op, part, enemy, dir, &rv1))
438 return 0; 496 return 0;
439 } 497 }
440 else if (QUERY_FLAG(op,FLAG_RANDOM_MOVE))
441 (void) move_randomly(op);
442 498
443 } /* stand still */
444 return 0;
445 } /* no enemy */
446
447 /* We have an enemy. Block immediately below is for pets */
448 if((op->attack_movement&HI4) == PETMOVE && (owner = get_owner(op)) != NULL && !on_same_map(op,owner))
449 return follow_owner(op, owner);
450
451 /* doppleganger code to change monster facing to that of the nearest
452 * player. Hmm. The code is here, but no monster in the current
453 * arch set uses it.
454 */
455 if ( (op->race != NULL)&& strcmp(op->race,"doppleganger") == 0)
456 {
457 op->face = enemy->face;
458 op->name = enemy->name;
459 }
460
461 /* Calculate range information for closest body part - this
462 * is used for the 'skill' code, which isn't that smart when
463 * it comes to figuring it out - otherwise, giants throw boulders
464 * into themselves.
465 */
466 get_rangevector(op, enemy, &rv, 0);
467
468 /* Move the check for scared up here - if the monster was scared,
469 * we were not doing any of the logic below, so might as well save
470 * a few cpu cycles.
471 */
472 if (!QUERY_FLAG(op, FLAG_SCARED))
473 {
474 rv_vector rv1;
475
476 /* now we test every part of an object .... this is a real ugly piece of code */
477 for (part=op; part!=NULL; part=part->more) {
478 get_rangevector(part, enemy, &rv1, 0x1);
479 dir=rv1.direction;
480
481 /* hm, not sure about this part - in original was a scared flag here too
482 * but that we test above... so can be old code here
483 */
484 if(QUERY_FLAG(op,FLAG_RUN_AWAY))
485 dir=absdir(dir+4);
486 if(QUERY_FLAG(op,FLAG_CONFUSED))
487 dir = absdir(dir + RANDOM()%3 + RANDOM()%3 - 2);
488
489 if(QUERY_FLAG(op,FLAG_CAST_SPELL) && !(RANDOM()%3)) {
490 if(monster_cast_spell(op,part,enemy,dir,&rv1))
491 return 0;
492 }
493
494 if(QUERY_FLAG(op,FLAG_READY_SCROLL) && !(RANDOM()%3)) { 499 if (QUERY_FLAG (op, FLAG_READY_SCROLL) && !(RANDOM () % 3))
495 if(monster_use_scroll(op,part,enemy,dir,&rv1))
496 return 0;
497 }
498
499 if(QUERY_FLAG(op,FLAG_READY_RANGE)&&!(RANDOM()%3)) {
500 if(monster_use_range(op,part,enemy,dir))
501 return 0;
502 }
503 if(QUERY_FLAG(op,FLAG_READY_SKILL)&&!(RANDOM()%3)) {
504 if(monster_use_skill(op,rv.part,enemy,rv.direction))
505 return 0;
506 }
507 if(QUERY_FLAG(op,FLAG_READY_BOW)&&!(RANDOM()%2)) {
508 if(monster_use_bow(op,part,enemy,dir))
509 return 0;
510 }
511 } /* for processing of all parts */
512 } /* If not scared */
513
514
515 part = rv.part;
516 dir=rv.direction;
517
518 if(QUERY_FLAG(op, FLAG_SCARED) || QUERY_FLAG(op,FLAG_RUN_AWAY))
519 dir=absdir(dir+4);
520
521 if(QUERY_FLAG(op,FLAG_CONFUSED))
522 dir = absdir(dir + RANDOM()%3 + RANDOM()%3 - 2);
523
524 pre_att_dir = dir; /* remember the original direction */
525
526 if ((op->attack_movement & LO4) && !QUERY_FLAG(op, FLAG_SCARED))
527 {
528 switch (op->attack_movement & LO4) {
529 case DISTATT:
530 dir = dist_att (dir,op,enemy,part,&rv);
531 break;
532
533 case RUNATT:
534 dir = run_att (dir,op,enemy,part,&rv);
535 break;
536
537 case HITRUN:
538 dir = hitrun_att(dir,op,enemy);
539 break;
540
541 case WAITATT:
542 dir = wait_att (dir,op,enemy,part,&rv);
543 break;
544
545 case RUSH: /* default - monster normally moves towards player */
546 case ALLRUN:
547 break;
548
549 case DISTHIT:
550 dir = disthit_att (dir,op,enemy,part,&rv);
551 break;
552
553 case WAIT2:
554 dir = wait_att2 (dir,op,enemy,part,&rv);
555 break;
556
557 default:
558 LOG(llevDebug,"Illegal low mon-move: %d\n",op->attack_movement & LO4);
559 }
560 }
561
562 if (!dir)
563 return 0;
564
565 if (!QUERY_FLAG(op,FLAG_STAND_STILL)) {
566 if(move_object(op,dir)) /* Can the monster move directly toward player? */
567 { 500 {
568 /* elmex: Turn our monster after it moved if it has DISTATT attack */ 501 if (monster_use_scroll (op, part, enemy, dir, &rv1))
569 if ((op->attack_movement & LO4) == DISTATT)
570 op->direction = pre_att_dir;
571
572 return 0;
573 }
574
575 if(QUERY_FLAG(op, FLAG_SCARED) || !can_hit(part,enemy,&rv)
576 || QUERY_FLAG(op,FLAG_RUN_AWAY)) {
577
578 /* Try move around corners if !close */
579 int maxdiff = (QUERY_FLAG(op, FLAG_ONLY_ATTACK) || RANDOM()&1) ? 1 : 2;
580 for(diff = 1; diff <= maxdiff; diff++) {
581 /* try different detours */
582 int m = 1-(RANDOM()&2); /* Try left or right first? */
583 if(move_object(op,absdir(dir + diff*m)) ||
584 move_object(op,absdir(dir - diff*m)))
585 return 0; 502 return 0;
586 } 503 }
504
505 if (QUERY_FLAG (op, FLAG_READY_RANGE) && !(RANDOM () % 3))
506 {
507 if (monster_use_range (op, part, enemy, dir))
508 return 0;
509 }
510 if (QUERY_FLAG (op, FLAG_READY_SKILL) && !(RANDOM () % 3))
511 {
512 if (monster_use_skill (op, rv.part, enemy, rv.direction))
513 return 0;
514 }
515 if (QUERY_FLAG (op, FLAG_READY_BOW) && !(RANDOM () % 2))
516 {
517 if (monster_use_bow (op, part, enemy, dir))
518 return 0;
519 }
520 } /* for processing of all parts */
521 } /* If not scared */
522
523
524 part = rv.part;
525 dir = rv.direction;
526
527 if (QUERY_FLAG (op, FLAG_SCARED) || QUERY_FLAG (op, FLAG_RUN_AWAY))
528 dir = absdir (dir + 4);
529
530 if (QUERY_FLAG (op, FLAG_CONFUSED))
531 dir = absdir (dir + RANDOM () % 3 + RANDOM () % 3 - 2);
532
533 pre_att_dir = dir; /* remember the original direction */
534
535 if ((op->attack_movement & LO4) && !QUERY_FLAG (op, FLAG_SCARED))
536 {
537 switch (op->attack_movement & LO4)
587 } 538 {
539 case DISTATT:
540 dir = dist_att (dir, op, enemy, part, &rv);
541 break;
542
543 case RUNATT:
544 dir = run_att (dir, op, enemy, part, &rv);
545 break;
546
547 case HITRUN:
548 dir = hitrun_att (dir, op, enemy);
549 break;
550
551 case WAITATT:
552 dir = wait_att (dir, op, enemy, part, &rv);
553 break;
554
555 case RUSH: /* default - monster normally moves towards player */
556 case ALLRUN:
557 break;
558
559 case DISTHIT:
560 dir = disthit_att (dir, op, enemy, part, &rv);
561 break;
562
563 case WAIT2:
564 dir = wait_att2 (dir, op, enemy, part, &rv);
565 break;
566
567 default:
568 LOG (llevDebug, "Illegal low mon-move: %d\n", op->attack_movement & LO4);
569 }
570 }
571
572 if (!dir)
573 return 0;
574
575 if (!QUERY_FLAG (op, FLAG_STAND_STILL))
576 {
577 if (move_object (op, dir)) /* Can the monster move directly toward player? */
578 {
579 /* elmex: Turn our monster after it moved if it has DISTATT attack */
580 if ((op->attack_movement & LO4) == DISTATT)
581 op->direction = pre_att_dir;
582
583 return 0;
584 }
585
586 if (QUERY_FLAG (op, FLAG_SCARED) || !can_hit (part, enemy, &rv) || QUERY_FLAG (op, FLAG_RUN_AWAY))
587 {
588
589 /* Try move around corners if !close */
590 int maxdiff = (QUERY_FLAG (op, FLAG_ONLY_ATTACK) || RANDOM () & 1) ? 1 : 2;
591
592 for (diff = 1; diff <= maxdiff; diff++)
593 {
594 /* try different detours */
595 int m = 1 - (RANDOM () & 2); /* Try left or right first? */
596
597 if (move_object (op, absdir (dir + diff * m)) || move_object (op, absdir (dir - diff * m)))
598 return 0;
599 }
600 }
588 } /* if monster is not standing still */ 601 } /* if monster is not standing still */
589 602
590 /* elmex: Turn our monster after it moved if it has DISTATT attack */ 603 /* elmex: Turn our monster after it moved if it has DISTATT attack */
591 if ((op->attack_movement & LO4) == DISTATT) 604 if ((op->attack_movement & LO4) == DISTATT)
592 op->direction = pre_att_dir; 605 op->direction = pre_att_dir;
593 606
594 /* 607 /*
595 * Eneq(@csd.uu.se): Patch to make RUN_AWAY or SCARED monsters move a random 608 * Eneq(@csd.uu.se): Patch to make RUN_AWAY or SCARED monsters move a random
596 * direction if they can't move away. 609 * direction if they can't move away.
597 */ 610 */
598 if (!QUERY_FLAG(op, FLAG_ONLY_ATTACK)&&(QUERY_FLAG(op,FLAG_RUN_AWAY)||QUERY_FLAG(op, FLAG_SCARED))) 611 if (!QUERY_FLAG (op, FLAG_ONLY_ATTACK) && (QUERY_FLAG (op, FLAG_RUN_AWAY) || QUERY_FLAG (op, FLAG_SCARED)))
599 if(move_randomly(op)) 612 if (move_randomly (op))
600 return 0; 613 return 0;
601 614
602 /* 615 /*
603 * Try giving the monster a new enemy - the player that is closest 616 * Try giving the monster a new enemy - the player that is closest
604 * to it. In this way, it won't just keep trying to get to a target 617 * to it. In this way, it won't just keep trying to get to a target
605 * that is inaccessible. 618 * that is inaccessible.
606 * This could be more clever - it should go through a list of several 619 * This could be more clever - it should go through a list of several
607 * enemies, as it is now, you could perhaps get situations where there 620 * enemies, as it is now, you could perhaps get situations where there
608 * are two players flanking the monster at close distance, but which 621 * are two players flanking the monster at close distance, but which
609 * the monster can't get to, and a third one at a far distance that 622 * the monster can't get to, and a third one at a far distance that
610 * the monster could get to - as it is, the monster won't look at that 623 * the monster could get to - as it is, the monster won't look at that
611 * third one. 624 * third one.
612 */ 625 */
613 if (!QUERY_FLAG(op, FLAG_FRIENDLY) && enemy == op->enemy) 626 if (!QUERY_FLAG (op, FLAG_FRIENDLY) && enemy == op->enemy)
614 { 627 {
615 object *nearest_player = get_nearest_player(op); 628 object *nearest_player = get_nearest_player (op);
629
616 if (nearest_player && nearest_player != enemy && !can_hit(part,enemy,&rv)) { 630 if (nearest_player && nearest_player != enemy && !can_hit (part, enemy, &rv))
631 {
617 op->enemy = NULL; 632 op->enemy = NULL;
618 enemy = nearest_player; 633 enemy = nearest_player;
619 } 634 }
620 } 635 }
621 636
622 if(!QUERY_FLAG(op, FLAG_SCARED)&&can_hit(part,enemy,&rv)) 637 if (!QUERY_FLAG (op, FLAG_SCARED) && can_hit (part, enemy, &rv))
623 { 638 {
624 /* The adjustement to wc that was here before looked totally bogus - 639 /* The adjustement to wc that was here before looked totally bogus -
625 * since wc can in fact get negative, that would mean by adding 640 * since wc can in fact get negative, that would mean by adding
626 * the current wc, the creature gets better? Instead, just 641 * the current wc, the creature gets better? Instead, just
627 * add a fixed amount - nasty creatures that are runny away should 642 * add a fixed amount - nasty creatures that are runny away should
628 * still be pretty nasty. 643 * still be pretty nasty.
629 */ 644 */
630 if(QUERY_FLAG(op,FLAG_RUN_AWAY)) 645 if (QUERY_FLAG (op, FLAG_RUN_AWAY))
631 { 646 {
632 part->stats.wc+=10; 647 part->stats.wc += 10;
633 (void)skill_attack(enemy,part,0,NULL, NULL); 648 (void) skill_attack (enemy, part, 0, NULL, NULL);
634 part->stats.wc-=10; 649 part->stats.wc -= 10;
635 } 650 }
636 else 651 else
637 (void)skill_attack(enemy,part,0,NULL, NULL); 652 (void) skill_attack (enemy, part, 0, NULL, NULL);
638 } /* if monster is in attack range */ 653 } /* if monster is in attack range */
639 654
640 if(QUERY_FLAG(part,FLAG_FREED)) /* Might be freed by ghost-attack or hit-back */ 655 if (QUERY_FLAG (part, FLAG_FREED)) /* Might be freed by ghost-attack or hit-back */
641 return 1; 656 return 1;
642 657
643 if(QUERY_FLAG(op, FLAG_ONLY_ATTACK)) 658 if (QUERY_FLAG (op, FLAG_ONLY_ATTACK))
659 {
660 op->remove ();
661 op->destroy ();
662 return 1;
644 { 663 }
645 remove_ob(op); 664 return 0;
646 free_object(op); 665}
666
667int
668can_hit (object *ob1, object *ob2, rv_vector * rv)
669{
670 object *more;
671 rv_vector rv1;
672
673 if (QUERY_FLAG (ob1, FLAG_CONFUSED) && !(RANDOM () % 3))
674 return 0;
675
676 if (abs (rv->distance_x) < 2 && abs (rv->distance_y) < 2)
677 return 1;
678
679 /* check all the parts of ob2 - just because we can't get to
680 * its head doesn't mean we don't want to pound its feet
681 */
682 for (more = ob2->more; more != NULL; more = more->more)
683 {
684 get_rangevector (ob1, more, &rv1, 0);
685 if (abs (rv1.distance_x) < 2 && abs (rv1.distance_y) < 2)
647 return 1; 686 return 1;
648 } 687 }
649 return 0; 688 return 0;
650}
651
652int can_hit(object *ob1,object *ob2, rv_vector *rv) {
653 object *more;
654 rv_vector rv1;
655
656 if(QUERY_FLAG(ob1,FLAG_CONFUSED)&&!(RANDOM()%3))
657 return 0;
658
659 if (abs(rv->distance_x)<2&&abs(rv->distance_y)<2) return 1;
660
661 /* check all the parts of ob2 - just because we can't get to
662 * its head doesn't mean we don't want to pound its feet
663 */
664 for (more = ob2->more; more!=NULL; more = more->more) {
665 get_rangevector(ob1, more, &rv1, 0);
666 if (abs(rv1.distance_x)<2&&abs(rv1.distance_y)<2) return 1;
667 }
668 return 0;
669 689
670} 690}
671 691
672/* Returns 1 is monster should cast spell sp at an enemy 692/* Returns 1 is monster should cast spell sp at an enemy
673 * Returns 0 if the monster should not cast this spell. 693 * Returns 0 if the monster should not cast this spell.
… …
683 * This could be a lot smarter - if there are few monsters around, 703 * This could be a lot smarter - if there are few monsters around,
684 * then disease might not be as bad. Likewise, if the monster is damaged, 704 * then disease might not be as bad. Likewise, if the monster is damaged,
685 * the right type of healing spell could be useful. 705 * the right type of healing spell could be useful.
686 */ 706 */
687 707
708static int
688static int monster_should_cast_spell(object *monster, object *spell_ob) 709monster_should_cast_spell (object *monster, object *spell_ob)
689{ 710{
690 if (spell_ob->subtype == SP_BOLT || spell_ob->subtype == SP_BULLET || 711 if (spell_ob->subtype == SP_BOLT || spell_ob->subtype == SP_BULLET ||
691 spell_ob->subtype == SP_EXPLOSION || spell_ob->subtype == SP_CONE || 712 spell_ob->subtype == SP_EXPLOSION || spell_ob->subtype == SP_CONE ||
692 spell_ob->subtype == SP_BOMB || spell_ob->subtype == SP_SMITE || 713 spell_ob->subtype == SP_BOMB || spell_ob->subtype == SP_SMITE ||
693 spell_ob->subtype == SP_MAGIC_MISSILE || spell_ob->subtype == SP_SUMMON_GOLEM || 714 spell_ob->subtype == SP_MAGIC_MISSILE || spell_ob->subtype == SP_SUMMON_GOLEM ||
694 spell_ob->subtype == SP_MAGIC_WALL || spell_ob->subtype == SP_SUMMON_MONSTER || 715 spell_ob->subtype == SP_MAGIC_WALL || spell_ob->subtype == SP_SUMMON_MONSTER ||
695 spell_ob->subtype == SP_MOVING_BALL || spell_ob->subtype == SP_SWARM || 716 spell_ob->subtype == SP_MOVING_BALL || spell_ob->subtype == SP_SWARM || spell_ob->subtype == SP_INVISIBLE)
696 spell_ob->subtype == SP_INVISIBLE)
697 717
698 return 1;
699
700 return 0; 718 return 1;
719
720 return 0;
701} 721}
702 722
703 723
704#define MAX_KNOWN_SPELLS 20 724#define MAX_KNOWN_SPELLS 20
705 725
706/* Returns a randomly selected spell. This logic is still 726/* Returns a randomly selected spell. This logic is still
707 * less than ideal. This code also only seems to deal with 727 * less than ideal. This code also only seems to deal with
708 * wizard spells, as the check is against sp, and not grace. 728 * wizard spells, as the check is against sp, and not grace.
709 * can mosnters know cleric spells? 729 * can mosnters know cleric spells?
710 */ 730 */
731object *
711object *monster_choose_random_spell(object *monster) { 732monster_choose_random_spell (object *monster)
733{
712 object *altern[MAX_KNOWN_SPELLS]; 734 object *altern[MAX_KNOWN_SPELLS];
713 object *tmp; 735 object *tmp;
714 int i=0; 736 int i = 0;
715 737
716 for(tmp=monster->inv;tmp!=NULL;tmp=tmp->below) 738 for (tmp = monster->inv; tmp != NULL; tmp = tmp->below)
717 if (tmp->type==SPELLBOOK || tmp->type==SPELL) { 739 if (tmp->type == SPELLBOOK || tmp->type == SPELL)
740 {
718 /* Check and see if it's actually a useful spell. 741 /* Check and see if it's actually a useful spell.
719 * If its a spellbook, the spell is actually the inventory item. 742 * If its a spellbook, the spell is actually the inventory item.
720 * if it is a spell, then it is just the object itself. 743 * if it is a spell, then it is just the object itself.
721 */ 744 */
722 if (monster_should_cast_spell(monster, (tmp->type==SPELLBOOK)?tmp->inv:tmp)) { 745 if (monster_should_cast_spell (monster, (tmp->type == SPELLBOOK) ? tmp->inv : tmp))
746 {
723 altern[i++]=tmp; 747 altern[i++] = tmp;
724 if(i==MAX_KNOWN_SPELLS) 748 if (i == MAX_KNOWN_SPELLS)
725 break; 749 break;
726 } 750 }
727 } 751 }
728 if(!i) 752 if (!i)
729 return NULL; 753 return NULL;
730 return altern[RANDOM()%i]; 754 return altern[RANDOM () % i];
731} 755}
732 756
733/* This checks to see if the monster should cast a spell/ability. 757/* This checks to see if the monster should cast a spell/ability.
734 * it returns true if the monster casts a spell, 0 if he doesn't. 758 * it returns true if the monster casts a spell, 0 if he doesn't.
735 * head is the head of the monster. 759 * head is the head of the monster.
… …
737 * pl is the target. 761 * pl is the target.
738 * dir is the direction to case. 762 * dir is the direction to case.
739 * rv is the vector which describes where the enemy is. 763 * rv is the vector which describes where the enemy is.
740 */ 764 */
741 765
766int
742int monster_cast_spell(object *head, object *part,object *pl,int dir, rv_vector *rv) { 767monster_cast_spell (object *head, object *part, object *pl, int dir, rv_vector * rv)
768{
743 object *spell_item; 769 object *spell_item;
744 object *owner; 770 object *owner;
745 rv_vector rv1; 771 rv_vector rv1;
746 772
747 /* If you want monsters to cast spells over friends, this spell should 773 /* If you want monsters to cast spells over friends, this spell should
748 * be removed. It probably should be in most cases, since monsters still 774 * be removed. It probably should be in most cases, since monsters still
749 * don't care about residual effects (ie, casting a cone which may have a 775 * don't care about residual effects (ie, casting a cone which may have a
750 * clear path to the player, the side aspects of the code will still hit 776 * clear path to the player, the side aspects of the code will still hit
751 * other monsters) 777 * other monsters)
752 */ 778 */
753 if(!(dir=path_to_player(part,pl,0))) 779 if (!(dir = path_to_player (part, pl, 0)))
754 return 0; 780 return 0;
781
782 if (QUERY_FLAG (head, FLAG_FRIENDLY) && (owner = head->owner) != NULL)
755 783 {
756 if(QUERY_FLAG(head,FLAG_FRIENDLY) && (owner = get_owner(head)) != NULL) {
757 get_rangevector(head, owner, &rv1, 0x1); 784 get_rangevector (head, owner, &rv1, 0x1);
758 if(dirdiff(dir,rv1.direction) < 2) { 785 if (dirdiff (dir, rv1.direction) < 2)
759 return 0; /* Might hit owner with spell */
760 } 786 {
787 return 0; /* Might hit owner with spell */
788 }
761 } 789 }
762 790
763 if(QUERY_FLAG(head,FLAG_CONFUSED)) 791 if (QUERY_FLAG (head, FLAG_CONFUSED))
764 dir = absdir(dir + RANDOM()%3 + RANDOM()%3 - 2); 792 dir = absdir (dir + RANDOM () % 3 + RANDOM () % 3 - 2);
765 793
766 /* If the monster hasn't already chosen a spell, choose one 794 /* If the monster hasn't already chosen a spell, choose one
767 * I'm not sure if it really make sense to pre-select spells (events 795 * I'm not sure if it really make sense to pre-select spells (events
768 * could be different by the time the monster goes again). 796 * could be different by the time the monster goes again).
769 */ 797 */
770 if(head->spellitem==NULL) { 798 if (head->spellitem == NULL)
799 {
771 if((spell_item=monster_choose_random_spell(head))==NULL) { 800 if ((spell_item = monster_choose_random_spell (head)) == NULL)
801 {
772 LOG(llevMonster,"Turned off spells in %s\n",&head->name); 802 LOG (llevMonster, "Turned off spells in %s\n", &head->name);
773 CLEAR_FLAG(head, FLAG_CAST_SPELL); /* Will be turned on when picking up book */ 803 CLEAR_FLAG (head, FLAG_CAST_SPELL); /* Will be turned on when picking up book */
774 return 0; 804 return 0;
775 } 805 }
776 if (spell_item->type == SPELLBOOK) { 806 if (spell_item->type == SPELLBOOK)
807 {
777 if (!spell_item->inv) { 808 if (!spell_item->inv)
809 {
778 LOG(llevError,"spellbook %s does not contain a spell?\n", &spell_item->name); 810 LOG (llevError, "spellbook %s does not contain a spell?\n", &spell_item->name);
779 return 0; 811 return 0;
780 } 812 }
781 spell_item=spell_item->inv; 813 spell_item = spell_item->inv;
782 } 814 }
783 } 815 }
784 else 816 else
785 spell_item=head->spellitem; 817 spell_item = head->spellitem;
786 818
787 if (!spell_item) return 0; 819 if (!spell_item)
820 return 0;
788 821
789 /* Best guess this is a defensive/healing spell */ 822 /* Best guess this is a defensive/healing spell */
790 if (spell_item->range<=1 || spell_item->stats.dam < 0) 823 if (spell_item->range <= 1 || spell_item->stats.dam < 0)
791 dir = 0; 824 dir = 0;
792 825
793 /* Monster doesn't have enough spell-points */ 826 /* Monster doesn't have enough spell-points */
794 if(head->stats.sp<SP_level_spellpoint_cost(head,spell_item, SPELL_MANA)) 827 if (head->stats.sp < SP_level_spellpoint_cost (head, spell_item, SPELL_MANA))
795 return 0; 828 return 0;
796 829
797 if(head->stats.grace<SP_level_spellpoint_cost(head,spell_item, SPELL_GRACE)) 830 if (head->stats.grace < SP_level_spellpoint_cost (head, spell_item, SPELL_GRACE))
798 return 0; 831 return 0;
799 832
800 head->stats.sp-=SP_level_spellpoint_cost(head,spell_item, SPELL_MANA); 833 head->stats.sp -= SP_level_spellpoint_cost (head, spell_item, SPELL_MANA);
801 head->stats.grace-=SP_level_spellpoint_cost(head,spell_item, SPELL_GRACE); 834 head->stats.grace -= SP_level_spellpoint_cost (head, spell_item, SPELL_GRACE);
802 835
803 /* set this to null, so next time monster will choose something different */ 836 /* set this to null, so next time monster will choose something different */
804 head->spellitem = NULL; 837 head->spellitem = NULL;
805 838
806 return cast_spell(part,part,dir, spell_item, NULL); 839 return cast_spell (part, part, dir, spell_item, NULL);
807} 840}
808 841
809 842
843int
810int monster_use_scroll(object *head, object *part,object *pl,int dir, rv_vector *rv) { 844monster_use_scroll (object *head, object *part, object *pl, int dir, rv_vector * rv)
845{
811 object *scroll; 846 object *scroll;
812 object *owner; 847 object *owner;
813 rv_vector rv1; 848 rv_vector rv1;
814 849
815 /* If you want monsters to cast spells over friends, this spell should 850 /* If you want monsters to cast spells over friends, this spell should
816 * be removed. It probably should be in most cases, since monsters still 851 * be removed. It probably should be in most cases, since monsters still
817 * don't care about residual effects (ie, casting a cone which may have a 852 * don't care about residual effects (ie, casting a cone which may have a
818 * clear path to the player, the side aspects of the code will still hit 853 * clear path to the player, the side aspects of the code will still hit
819 * other monsters) 854 * other monsters)
820 */ 855 */
821 if(!(dir=path_to_player(part,pl,0))) 856 if (!(dir = path_to_player (part, pl, 0)))
822 return 0; 857 return 0;
858
859 if (QUERY_FLAG (head, FLAG_FRIENDLY) && (owner = head->owner) != NULL)
823 860 {
824 if(QUERY_FLAG(head,FLAG_FRIENDLY) && (owner = get_owner(head)) != NULL) {
825 get_rangevector(head, owner, &rv1, 0x1); 861 get_rangevector (head, owner, &rv1, 0x1);
826 if(dirdiff(dir,rv1.direction) < 2) { 862 if (dirdiff (dir, rv1.direction) < 2)
827 return 0; /* Might hit owner with spell */
828 } 863 {
864 return 0; /* Might hit owner with spell */
865 }
829 } 866 }
830 867
831 if(QUERY_FLAG(head,FLAG_CONFUSED)) 868 if (QUERY_FLAG (head, FLAG_CONFUSED))
832 dir = absdir(dir + RANDOM()%3 + RANDOM()%3 - 2); 869 dir = absdir (dir + RANDOM () % 3 + RANDOM () % 3 - 2);
833 870
834 for (scroll=head->inv; scroll; scroll=scroll->below) 871 for (scroll = head->inv; scroll; scroll = scroll->below)
835 if (scroll->type == SCROLL && monster_should_cast_spell(head, scroll->inv)) break; 872 if (scroll->type == SCROLL && monster_should_cast_spell (head, scroll->inv))
873 break;
836 874
837 /* Used up all his scrolls, so nothing do to */ 875 /* Used up all his scrolls, so nothing do to */
838 if (!scroll) { 876 if (!scroll)
877 {
839 CLEAR_FLAG(head, FLAG_READY_SCROLL); 878 CLEAR_FLAG (head, FLAG_READY_SCROLL);
840 return 0; 879 return 0;
841 } 880 }
842 881
843 /* Spell should be cast on caster (ie, heal, strength) */ 882 /* Spell should be cast on caster (ie, heal, strength) */
844 if (scroll->inv->range==0) 883 if (scroll->inv->range == 0)
845 dir = 0; 884 dir = 0;
846 885
847 apply_scroll(part, scroll, dir); 886 apply_scroll (part, scroll, dir);
848 return 1; 887 return 1;
849} 888}
850 889
851/* monster_use_skill()-implemented 95-04-28 to allow monster skill use. 890/* monster_use_skill()-implemented 95-04-28 to allow monster skill use.
852 * Note that monsters do not need the skills SK_MELEE_WEAPON and 891 * Note that monsters do not need the skills SK_MELEE_WEAPON and
853 * SK_MISSILE_WEAPON to make those respective attacks, if we 892 * SK_MISSILE_WEAPON to make those respective attacks, if we
… …
856 * 895 *
857 * The skills we are treating here are all but those. -b.t. 896 * The skills we are treating here are all but those. -b.t.
858 * 897 *
859 * At the moment this is only useful for throwing, perhaps for 898 * At the moment this is only useful for throwing, perhaps for
860 * stealing. TODO: This should be more integrated in the game. -MT, 25.11.01 899 * stealing. TODO: This should be more integrated in the game. -MT, 25.11.01
861 */ 900 */
862 901
902int
863int monster_use_skill(object *head, object *part, object *pl,int dir) { 903monster_use_skill (object *head, object *part, object *pl, int dir)
904{
864 object *skill, *owner; 905 object *skill, *owner;
865 906
866 if(!(dir=path_to_player(part,pl,0))) 907 if (!(dir = path_to_player (part, pl, 0)))
867 return 0; 908 return 0;
868 909
869 if(QUERY_FLAG(head,FLAG_FRIENDLY) && (owner = get_owner(head)) != NULL) { 910 if (QUERY_FLAG (head, FLAG_FRIENDLY) && (owner = head->owner) != NULL)
911 {
870 int dir2 = find_dir_2(head->x-owner->x, head->y-owner->y); 912 int dir2 = find_dir_2 (head->x - owner->x, head->y - owner->y);
913
871 if(dirdiff(dir,dir2) < 1) 914 if (dirdiff (dir, dir2) < 1)
872 return 0; /* Might hit owner with skill -thrown rocks for example ?*/ 915 return 0; /* Might hit owner with skill -thrown rocks for example ? */
873 } 916 }
874 if(QUERY_FLAG(head,FLAG_CONFUSED)) 917 if (QUERY_FLAG (head, FLAG_CONFUSED))
875 dir = absdir(dir + RANDOM()%3 + RANDOM()%3 - 2); 918 dir = absdir (dir + RANDOM () % 3 + RANDOM () % 3 - 2);
876 919
877 /* skill selection - monster will use the next unused skill. 920 /* skill selection - monster will use the next unused skill.
878 * well...the following scenario will allow the monster to 921 * well...the following scenario will allow the monster to
879 * toggle between 2 skills. One day it would be nice to make 922 * toggle between 2 skills. One day it would be nice to make
880 * more skills available to monsters. 923 * more skills available to monsters.
881 */ 924 */
882 925
883 for(skill=head->inv;skill!=NULL;skill=skill->below) 926 for (skill = head->inv; skill != NULL; skill = skill->below)
884 if(skill->type==SKILL && skill!=head->chosen_skill) { 927 if (skill->type == SKILL && skill != head->chosen_skill)
928 {
885 head->chosen_skill=skill; 929 head->chosen_skill = skill;
886 break; 930 break;
887 } 931 }
888 932
889 if(!skill && !head->chosen_skill) { 933 if (!skill && !head->chosen_skill)
934 {
890 LOG(llevDebug,"Error: Monster %s (%d) has FLAG_READY_SKILL without skill.\n", 935 LOG (llevDebug, "Error: Monster %s (%d) has FLAG_READY_SKILL without skill.\n", &head->name, head->count);
891 &head->name,head->count);
892 CLEAR_FLAG(head, FLAG_READY_SKILL); 936 CLEAR_FLAG (head, FLAG_READY_SKILL);
893 return 0; 937 return 0;
894 } 938 }
895 /* use skill */ 939 /* use skill */
896 return do_skill(head, part, head->chosen_skill,dir,NULL); 940 return do_skill (head, part, head->chosen_skill, dir, NULL);
897} 941}
898 942
899/* Monster will use a ranged spell attack. */ 943/* Monster will use a ranged spell attack. */
900 944
945int
901int monster_use_range(object *head,object *part,object *pl,int dir) 946monster_use_range (object *head, object *part, object *pl, int dir)
902 { 947{
903 object *wand, *owner; 948 object *wand, *owner;
904 int at_least_one = 0; 949 int at_least_one = 0;
905 950
906 if(!(dir=path_to_player(part,pl,0))) 951 if (!(dir = path_to_player (part, pl, 0)))
907 return 0; 952 return 0;
908 953
909 if(QUERY_FLAG(head,FLAG_FRIENDLY) && (owner = get_owner(head)) != NULL) { 954 if (QUERY_FLAG (head, FLAG_FRIENDLY) && (owner = head->owner) != NULL)
955 {
910 int dir2 = find_dir_2(head->x-owner->x, head->y-owner->y); 956 int dir2 = find_dir_2 (head->x - owner->x, head->y - owner->y);
957
911 if(dirdiff(dir,dir2) < 2) 958 if (dirdiff (dir, dir2) < 2)
912 return 0; /* Might hit owner with spell */ 959 return 0; /* Might hit owner with spell */
913 } 960 }
914 if(QUERY_FLAG(head,FLAG_CONFUSED)) 961 if (QUERY_FLAG (head, FLAG_CONFUSED))
915 dir = absdir(dir + RANDOM()%3 + RANDOM()%3 - 2); 962 dir = absdir (dir + RANDOM () % 3 + RANDOM () % 3 - 2);
916 963
917 for(wand=head->inv;wand!=NULL;wand=wand->below) 964 for (wand = head->inv; wand != NULL; wand = wand->below)
918 { 965 {
919 if (wand->type == WAND) 966 if (wand->type == WAND)
967 {
968 /* Found a wand, let's see if it has charges left */
969 at_least_one = 1;
970 if (wand->stats.food <= 0)
971 continue;
972
973 cast_spell (head, wand, dir, wand->inv, NULL);
974
975 if (!(--wand->stats.food))
920 { 976 {
921 /* Found a wand, let's see if it has charges left */ 977 if (wand->arch)
922 at_least_one = 1;
923 if( wand->stats.food<=0 )
924 continue;
925
926 cast_spell( head, wand, dir, wand->inv, NULL );
927
928 if ( !( --wand->stats.food ) )
929 { 978 {
930 if ( wand->arch )
931 {
932 CLEAR_FLAG(wand, FLAG_ANIMATE); 979 CLEAR_FLAG (wand, FLAG_ANIMATE);
933 wand->face = wand->arch->clone.face; 980 wand->face = wand->arch->clone.face;
934 wand->speed = 0; 981 wand->set_speed (0);
935 update_ob_speed(wand);
936 }
937 } 982 }
938 /* Success */
939 return 1;
940 } 983 }
984 /* Success */
985 return 1;
986 }
941 else if ( wand->type == ROD || wand->type==HORN ) { 987 else if (wand->type == ROD || wand->type == HORN)
988 {
942 /* Found rod/horn, let's use it if possible */ 989 /* Found rod/horn, let's use it if possible */
943 at_least_one = 1; 990 at_least_one = 1;
944 if( wand->stats.hp < MAX( wand->inv->stats.sp, wand->inv->stats.grace ) ) 991 if (wand->stats.hp < MAX (wand->inv->stats.sp, wand->inv->stats.grace))
945 continue; 992 continue;
946 993
947 /* drain charge before casting spell - can be a case where the 994 /* drain charge before casting spell - can be a case where the
948 * spell destroys the monster, and rod, so if done after, results 995 * spell destroys the monster, and rod, so if done after, results
949 * in crash. 996 * in crash.
950 */ 997 */
951 drain_rod_charge( wand ); 998 drain_rod_charge (wand);
952 cast_spell( head, wand, dir, wand->inv, NULL ); 999 cast_spell (head, wand, dir, wand->inv, NULL);
953 1000
954 /* Success */ 1001 /* Success */
955 return 1; 1002 return 1;
956 } 1003 }
957 } 1004 }
958 1005
959 if ( at_least_one ) 1006 if (at_least_one)
960 return 0; 1007 return 0;
961 1008
962 LOG(llevError,"Error: Monster %s (%d) HAS_READY_RANG() without wand/horn/rod.\n", 1009 LOG (llevError, "Error: Monster %s (%d) HAS_READY_RANG() without wand/horn/rod.\n", &head->name, head->count);
963 &head->name,head->count);
964 CLEAR_FLAG(head, FLAG_READY_RANGE); 1010 CLEAR_FLAG (head, FLAG_READY_RANGE);
965 return 0; 1011 return 0;
966 } 1012}
967 1013
1014int
968int monster_use_bow(object *head, object *part, object *pl, int dir) { 1015monster_use_bow (object *head, object *part, object *pl, int dir)
1016{
969 object *owner; 1017 object *owner;
970 1018
971 if(!(dir=path_to_player(part,pl,0))) 1019 if (!(dir = path_to_player (part, pl, 0)))
972 return 0; 1020 return 0;
973 if(QUERY_FLAG(head,FLAG_CONFUSED)) 1021 if (QUERY_FLAG (head, FLAG_CONFUSED))
974 dir = absdir(dir + RANDOM()%3 + RANDOM()%3 - 2); 1022 dir = absdir (dir + RANDOM () % 3 + RANDOM () % 3 - 2);
975 1023
976 if(QUERY_FLAG(head,FLAG_FRIENDLY) && (owner = get_owner(head)) != NULL) { 1024 if (QUERY_FLAG (head, FLAG_FRIENDLY) && (owner = head->owner) != NULL)
1025 {
977 int dir2 = find_dir_2(head->x-owner->x, head->y-owner->y); 1026 int dir2 = find_dir_2 (head->x - owner->x, head->y - owner->y);
1027
978 if(dirdiff(dir,dir2) < 1) 1028 if (dirdiff (dir, dir2) < 1)
979 return 0; /* Might hit owner with arrow */ 1029 return 0; /* Might hit owner with arrow */
980 } 1030 }
981 1031
982 /* in server/player.c */ 1032 /* in server/player.c */
983 return fire_bow(head, part, NULL, dir, 0, part->x, part->y); 1033 return fire_bow (head, part, NULL, dir, 0, part->x, part->y);
984 1034
985} 1035}
986 1036
987/* Checks if putting on 'item' will make 'who' do more 1037/* Checks if putting on 'item' will make 'who' do more
988 * damage. This is a very simplistic check - also checking things 1038 * damage. This is a very simplistic check - also checking things
989 * like speed and ac are also relevant. 1039 * like speed and ac are also relevant.
990 * 1040 *
991 * return true if item is a better object. 1041 * return true if item is a better object.
992 */ 1042 */
993 1043
1044int
994int check_good_weapon(object *who, object *item) { 1045check_good_weapon (object *who, object *item)
1046{
995 object *other_weap; 1047 object *other_weap;
996 int val=0, i; 1048 int val = 0, i;
997 1049
998 for(other_weap=who->inv;other_weap!=NULL;other_weap=other_weap->below) 1050 for (other_weap = who->inv; other_weap != NULL; other_weap = other_weap->below)
999 if(other_weap->type==item->type&&QUERY_FLAG(other_weap,FLAG_APPLIED)) 1051 if (other_weap->type == item->type && QUERY_FLAG (other_weap, FLAG_APPLIED))
1000 break; 1052 break;
1001 1053
1002 if(other_weap==NULL) /* No other weapons */ 1054 if (other_weap == NULL) /* No other weapons */
1003 return 1; 1055 return 1;
1004 1056
1005 /* Rather than go through and apply the new one, and see if it is 1057 /* Rather than go through and apply the new one, and see if it is
1006 * better, just do some simple checks 1058 * better, just do some simple checks
1007 * Put some multipliers for things that hvae several effects, 1059 * Put some multipliers for things that hvae several effects,
1008 * eg, magic affects both damage and wc, so it has more weight 1060 * eg, magic affects both damage and wc, so it has more weight
1009 */ 1061 */
1010 1062
1011 val = item->stats.dam - other_weap->stats.dam; 1063 val = item->stats.dam - other_weap->stats.dam;
1012 val += (item->magic - other_weap->magic) * 3; 1064 val += (item->magic - other_weap->magic) * 3;
1013 /* Monsters don't really get benefits from things like regen rates 1065 /* Monsters don't really get benefits from things like regen rates
1014 * from items. But the bonus for their stats are very important. 1066 * from items. But the bonus for their stats are very important.
1015 */ 1067 */
1016 for (i=0; i<NUM_STATS; i++) 1068 for (i = 0; i < NUM_STATS; i++)
1017 val += (get_attr_value(&item->stats, i) - get_attr_value(&other_weap->stats, i))*2; 1069 val += (get_attr_value (&item->stats, i) - get_attr_value (&other_weap->stats, i)) * 2;
1018 1070
1019 if (val > 0) return 1; 1071 if (val > 0)
1072 return 1;
1073 else
1020 else return 0; 1074 return 0;
1021 1075
1022} 1076}
1023 1077
1078int
1024int check_good_armour(object *who, object *item) { 1079check_good_armour (object *who, object *item)
1080{
1025 object *other_armour; 1081 object *other_armour;
1026 int val=0,i; 1082 int val = 0, i;
1027 1083
1028 for (other_armour = who->inv; other_armour != NULL; 1084 for (other_armour = who->inv; other_armour != NULL; other_armour = other_armour->below)
1029 other_armour = other_armour->below)
1030 if (other_armour->type == item->type && QUERY_FLAG(other_armour,FLAG_APPLIED)) 1085 if (other_armour->type == item->type && QUERY_FLAG (other_armour, FLAG_APPLIED))
1031 break; 1086 break;
1032 1087
1033 if (other_armour == NULL) /* No other armour, use the new */ 1088 if (other_armour == NULL) /* No other armour, use the new */
1034 return 1; 1089 return 1;
1035 1090
1036 /* Like above function , see which is better */ 1091 /* Like above function , see which is better */
1037 val = item->stats.ac - other_armour->stats.ac; 1092 val = item->stats.ac - other_armour->stats.ac;
1038 val = (item->resist[ATNR_PHYSICAL] - other_armour->resist[ATNR_PHYSICAL])/5; 1093 val = (item->resist[ATNR_PHYSICAL] - other_armour->resist[ATNR_PHYSICAL]) / 5;
1039 val += (item->magic - other_armour->magic) * 3; 1094 val += (item->magic - other_armour->magic) * 3;
1040 1095
1041 /* for the other protections, do weigh them very much in the equation - 1096 /* for the other protections, do weigh them very much in the equation -
1042 * it is the armor protection which is most important, because there is 1097 * it is the armor protection which is most important, because there is
1043 * no good way to know what the player may attack the monster with. 1098 * no good way to know what the player may attack the monster with.
1044 * So if the new item has better protection than the old, give that higher 1099 * So if the new item has better protection than the old, give that higher
1045 * value. If the reverse, then decrease the value of this item some. 1100 * value. If the reverse, then decrease the value of this item some.
1046 */ 1101 */
1047 for (i=1; i <NROFATTACKS; i++) { 1102 for (i = 1; i < NROFATTACKS; i++)
1103 {
1048 if (item->resist[i] > other_armour->resist[i]) val++; 1104 if (item->resist[i] > other_armour->resist[i])
1105 val++;
1049 else if (item->resist[i] < other_armour->resist[i]) val--; 1106 else if (item->resist[i] < other_armour->resist[i])
1107 val--;
1050 } 1108 }
1051 1109
1052 /* Very few armours have stats, so not much need to worry about those. */ 1110 /* Very few armours have stats, so not much need to worry about those. */
1053 1111
1054 if (val > 0) return 1; 1112 if (val > 0)
1113 return 1;
1114 else
1055 else return 0; 1115 return 0;
1056 1116
1057} 1117}
1058 1118
1059/* 1119/*
1060 * monster_check_pickup(): checks for items that monster can pick up. 1120 * monster_check_pickup(): checks for items that monster can pick up.
… …
1070 * became a recursive loop. It may be better to call monster_check_apply 1130 * became a recursive loop. It may be better to call monster_check_apply
1071 * after we pick everything up, since that function may call others which 1131 * after we pick everything up, since that function may call others which
1072 * affect stacking on this space. 1132 * affect stacking on this space.
1073 */ 1133 */
1074 1134
1135void
1075void monster_check_pickup(object *monster) { 1136monster_check_pickup (object *monster)
1137{
1076 object *tmp,*next; 1138 object *tmp, *next;
1077 int next_tag;
1078 1139
1079 for(tmp=monster->below;tmp!=NULL;tmp=next) { 1140 for (tmp = monster->below; tmp != NULL; tmp = next)
1141 {
1080 next=tmp->below; 1142 next = tmp->below;
1081 next_tag = next ? next->count : 0;
1082 if (monster_can_pick(monster,tmp)) { 1143 if (monster_can_pick (monster, tmp))
1083 remove_ob(tmp); 1144 {
1145 tmp->remove ();
1084 tmp = insert_ob_in_ob(tmp,monster); 1146 tmp = insert_ob_in_ob (tmp, monster);
1085 (void) monster_check_apply(monster,tmp); 1147 (void) monster_check_apply (monster, tmp);
1086 } 1148 }
1087 /* We could try to re-establish the cycling, of the space, but probably 1149 /* We could try to re-establish the cycling, of the space, but probably
1088 * not a big deal to just bail out. 1150 * not a big deal to just bail out.
1089 */ 1151 */
1090 if (next && was_destroyed(next, next_tag)) return; 1152 if (next && next->destroyed ())
1153 return;
1091 } 1154 }
1092} 1155}
1093 1156
1094/* 1157/*
1095 * monster_can_pick(): If the monster is interested in picking up 1158 * monster_can_pick(): If the monster is interested in picking up
1096 * the item, then return 0. Otherwise 0. 1159 * the item, then return 0. Otherwise 0.
1097 * Instead of pick_up, flags for "greed", etc, should be used. 1160 * Instead of pick_up, flags for "greed", etc, should be used.
1098 * I've already utilized flags for bows, wands, rings, etc, etc. -Frank. 1161 * I've already utilized flags for bows, wands, rings, etc, etc. -Frank.
1099 */ 1162 */
1100 1163
1164int
1101int monster_can_pick(object *monster, object *item) { 1165monster_can_pick (object *monster, object *item)
1166{
1102 int flag=0; 1167 int flag = 0;
1103 int i; 1168 int i;
1104 1169
1105 if(!can_pick(monster,item)) 1170 if (!can_pick (monster, item))
1106 return 0; 1171 return 0;
1107 1172
1108 if(QUERY_FLAG(item,FLAG_UNPAID)) 1173 if (QUERY_FLAG (item, FLAG_UNPAID))
1109 return 0; 1174 return 0;
1110 1175
1111 if (monster->pick_up&64) /* All */ 1176 if (monster->pick_up & 64) /* All */
1112 flag=1; 1177 flag = 1;
1113 1178
1179 else
1114 else switch(item->type) { 1180 switch (item->type)
1181 {
1115 case MONEY: 1182 case MONEY:
1116 case GEM: 1183 case GEM:
1117 flag=monster->pick_up&2; 1184 flag = monster->pick_up & 2;
1118 break; 1185 break;
1119 1186
1120 case FOOD: 1187 case FOOD:
1121 flag=monster->pick_up&4; 1188 flag = monster->pick_up & 4;
1122 break; 1189 break;
1123 1190
1124 case WEAPON: 1191 case WEAPON:
1125 flag=(monster->pick_up&8)||QUERY_FLAG(monster,FLAG_USE_WEAPON); 1192 flag = (monster->pick_up & 8) || QUERY_FLAG (monster, FLAG_USE_WEAPON);
1126 break; 1193 break;
1127 1194
1128 case ARMOUR: 1195 case ARMOUR:
1129 case SHIELD: 1196 case SHIELD:
1130 case HELMET: 1197 case HELMET:
1131 case BOOTS: 1198 case BOOTS:
1132 case GLOVES: 1199 case GLOVES:
1133 case GIRDLE: 1200 case GIRDLE:
1134 flag=(monster->pick_up&16)||QUERY_FLAG(monster,FLAG_USE_ARMOUR); 1201 flag = (monster->pick_up & 16) || QUERY_FLAG (monster, FLAG_USE_ARMOUR);
1135 break; 1202 break;
1136 1203
1137 case SKILL: 1204 case SKILL:
1138 flag=QUERY_FLAG(monster,FLAG_CAN_USE_SKILL); 1205 flag = QUERY_FLAG (monster, FLAG_CAN_USE_SKILL);
1139 break; 1206 break;
1140 1207
1141 case RING: 1208 case RING:
1142 flag=QUERY_FLAG(monster,FLAG_USE_RING); 1209 flag = QUERY_FLAG (monster, FLAG_USE_RING);
1143 break; 1210 break;
1144 1211
1145 case WAND: 1212 case WAND:
1146 case HORN: 1213 case HORN:
1147 case ROD: 1214 case ROD:
1148 flag=QUERY_FLAG(monster,FLAG_USE_RANGE); 1215 flag = QUERY_FLAG (monster, FLAG_USE_RANGE);
1149 break; 1216 break;
1150 1217
1151 case SPELLBOOK: 1218 case SPELLBOOK:
1152 flag=(monster->arch!=NULL&&QUERY_FLAG((&monster->arch->clone),FLAG_CAST_SPELL)); 1219 flag = (monster->arch != NULL && QUERY_FLAG ((&monster->arch->clone), FLAG_CAST_SPELL));
1153 break; 1220 break;
1154 1221
1155 case SCROLL: 1222 case SCROLL:
1156 flag = QUERY_FLAG(monster,FLAG_USE_SCROLL); 1223 flag = QUERY_FLAG (monster, FLAG_USE_SCROLL);
1157 break; 1224 break;
1158 1225
1159 case BOW: 1226 case BOW:
1160 case ARROW: 1227 case ARROW:
1161 flag=QUERY_FLAG(monster,FLAG_USE_BOW); 1228 flag = QUERY_FLAG (monster, FLAG_USE_BOW);
1162 break; 1229 break;
1163 } 1230 }
1164 /* Simplistic check - if the monster has a location to equip it, he will 1231 /* Simplistic check - if the monster has a location to equip it, he will
1165 * pick it up. Note that this doesn't handle cases where an item may 1232 * pick it up. Note that this doesn't handle cases where an item may
1166 * use several locations. 1233 * use several locations.
1167 */ 1234 */
1168 for (i=0; i < NUM_BODY_LOCATIONS; i++) { 1235 for (i = 0; i < NUM_BODY_LOCATIONS; i++)
1236 {
1169 if (monster->body_info[i] && item->body_info[i]) { 1237 if (monster->body_info[i] && item->body_info[i])
1238 {
1170 flag=1; 1239 flag = 1;
1171 break; 1240 break;
1172 } 1241 }
1173 } 1242 }
1174 1243
1175 if (((!(monster->pick_up&32))&&flag) || ((monster->pick_up&32)&&(!flag))) 1244 if (((!(monster->pick_up & 32)) && flag) || ((monster->pick_up & 32) && (!flag)))
1176 return 1;
1177 return 0; 1245 return 1;
1246 return 0;
1178} 1247}
1179 1248
1180/* 1249/*
1181 * monster_apply_below(): 1250 * monster_apply_below():
1182 * Vick's (vick@bern.docs.uu.se) @921107 -> If a monster who's 1251 * Vick's (vick@bern.docs.uu.se) @921107 -> If a monster who's
1183 * eager to apply things, encounters something apply-able, 1252 * eager to apply things, encounters something apply-able,
1184 * then make him apply it 1253 * then make him apply it
1185 */ 1254 */
1186 1255
1256void
1187void monster_apply_below(object *monster) { 1257monster_apply_below (object *monster)
1258{
1188 object *tmp, *next; 1259 object *tmp, *next;
1189 1260
1190 for(tmp=monster->below;tmp!=NULL;tmp=next) { 1261 for (tmp = monster->below; tmp != NULL; tmp = next)
1262 {
1191 next=tmp->below; 1263 next = tmp->below;
1192 switch (tmp->type) { 1264 switch (tmp->type)
1265 {
1193 case CF_HANDLE: 1266 case CF_HANDLE:
1194 case TRIGGER: 1267 case TRIGGER:
1195 if (monster->will_apply&1) 1268 if (monster->will_apply & 1)
1196 manual_apply(monster,tmp,0); 1269 manual_apply (monster, tmp, 0);
1197 break; 1270 break;
1198 1271
1199 case TREASURE: 1272 case TREASURE:
1200 if (monster->will_apply&2) 1273 if (monster->will_apply & 2)
1201 manual_apply(monster,tmp,0); 1274 manual_apply (monster, tmp, 0);
1202 break; 1275 break;
1203 1276
1204 } 1277 }
1205 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR)) 1278 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))
1206 break; 1279 break;
1207 } 1280 }
1208} 1281}
1209 1282
1210/* 1283/*
1211 * monster_check_apply() is meant to be called after an item is 1284 * monster_check_apply() is meant to be called after an item is
… …
1217 * they can pick up all that they can use. 1290 * they can pick up all that they can use.
1218 */ 1291 */
1219 1292
1220/* Sept 96, fixed this so skills will be readied -b.t.*/ 1293/* Sept 96, fixed this so skills will be readied -b.t.*/
1221 1294
1295void
1222void monster_check_apply(object *mon, object *item) { 1296monster_check_apply (object *mon, object *item)
1297{
1223 1298
1224 int flag = 0; 1299 int flag = 0;
1225 1300
1226 if(item->type==SPELLBOOK&&
1227 mon->arch!=NULL&&(QUERY_FLAG((&mon->arch->clone),FLAG_CAST_SPELL))) { 1301 if (item->type == SPELLBOOK && mon->arch != NULL && (QUERY_FLAG ((&mon->arch->clone), FLAG_CAST_SPELL)))
1302 {
1228 SET_FLAG(mon, FLAG_CAST_SPELL); 1303 SET_FLAG (mon, FLAG_CAST_SPELL);
1229 return; 1304 return;
1230 } 1305 }
1231 1306
1232 /* If for some reason, this item is already applied, no more work to do */ 1307 /* If for some reason, this item is already applied, no more work to do */
1233 if(QUERY_FLAG(item,FLAG_APPLIED)) return; 1308 if (QUERY_FLAG (item, FLAG_APPLIED))
1234
1235 /* Might be better not to do this - if the monster can fire a bow,
1236 * it is possible in his wanderings, he will find one to use. In
1237 * which case, it would be nice to have ammo for it.
1238 */
1239 if(QUERY_FLAG(mon,FLAG_USE_BOW) && item->type==ARROW) {
1240 /* Check for the right kind of bow */
1241 object *bow;
1242 for(bow=mon->inv;bow!=NULL;bow=bow->below)
1243 if(bow->type==BOW && bow->race==item->race) {
1244 SET_FLAG(mon, FLAG_READY_BOW);
1245 LOG(llevMonster,"Found correct bow for arrows.\n");
1246 return; /* nothing more to do for arrows */
1247 }
1248 }
1249
1250 if (item->type == TREASURE && mon->will_apply & WILL_APPLY_TREASURE) flag=1;
1251 /* Eating food gets hp back */
1252 else if (item->type == FOOD && mon->will_apply & WILL_APPLY_FOOD) flag=1;
1253 else if (item->type == SCROLL && QUERY_FLAG(mon, FLAG_USE_SCROLL)) {
1254 if (!item->inv)
1255 LOG(llevDebug,"Monster %d having scroll %d with empty inventory!", mon->count, item->count);
1256 else if (monster_should_cast_spell(mon, item->inv))
1257 SET_FLAG(mon, FLAG_READY_SCROLL);
1258 /* Don't use it right now */
1259 return;
1260 }
1261 else if (item->type == WEAPON) flag = check_good_weapon(mon,item);
1262 else if (IS_ARMOR(item)) flag = check_good_armour(mon,item);
1263 /* Should do something more, like make sure this is a better item */
1264 else if (item->type == RING)
1265 flag=1;
1266 else if ( item->type==WAND || item->type == ROD || item->type==HORN )
1267 {
1268 /* We never really 'ready' the wand/rod/horn, because that would mean the
1269 * weapon would get undone.
1270 */
1271 if (!(can_apply_object(mon, item) & CAN_APPLY_NOT_MASK))
1272 {
1273 SET_FLAG(mon, FLAG_READY_RANGE);
1274 SET_FLAG(item, FLAG_APPLIED);
1275 }
1276 return;
1277 }
1278 else if (item->type == BOW) {
1279 /* We never really 'ready' the bow, because that would mean the
1280 * weapon would get undone.
1281 */
1282 if (!(can_apply_object(mon, item) & CAN_APPLY_NOT_MASK))
1283 SET_FLAG(mon, FLAG_READY_BOW);
1284 return;
1285 }
1286 else if ( item->type == SKILL )
1287 {
1288 /*
1289 * skills are specials: monsters must have the 'FLAG_READY_SKILL' flag set,
1290 * else they can't use the skill...
1291 * Skills also don't need to get applied, so return now.
1292 */
1293 SET_FLAG(mon, FLAG_READY_SKILL);
1294 return;
1295 }
1296
1297
1298 /* if we don't match one of the above types, return now.
1299 * can_apply_object will say that we can apply things like flesh,
1300 * bolts, and whatever else, because it only checks against the
1301 * body_info locations.
1302 */
1303 if (!flag) return;
1304
1305 /* Check to see if the monster can use this item. If not, no need
1306 * to do further processing. Note that can_apply_object already checks
1307 * for the CAN_USE flags.
1308 */
1309 if (can_apply_object(mon, item) & CAN_APPLY_NOT_MASK) return;
1310
1311 /* should only be applying this item, not unapplying it.
1312 * also, ignore status of curse so they can take off old armour.
1313 * monsters have some advantages after all.
1314 */
1315 manual_apply(mon, item, AP_APPLY | AP_IGNORE_CURSE);
1316
1317 return; 1309 return;
1318}
1319 1310
1311 /* Might be better not to do this - if the monster can fire a bow,
1312 * it is possible in his wanderings, he will find one to use. In
1313 * which case, it would be nice to have ammo for it.
1314 */
1315 if (QUERY_FLAG (mon, FLAG_USE_BOW) && item->type == ARROW)
1316 {
1317 /* Check for the right kind of bow */
1318 object *bow;
1319
1320 for (bow = mon->inv; bow != NULL; bow = bow->below)
1321 if (bow->type == BOW && bow->race == item->race)
1322 {
1323 SET_FLAG (mon, FLAG_READY_BOW);
1324 LOG (llevMonster, "Found correct bow for arrows.\n");
1325 return; /* nothing more to do for arrows */
1326 }
1327 }
1328
1329 if (item->type == TREASURE && mon->will_apply & WILL_APPLY_TREASURE)
1330 flag = 1;
1331 /* Eating food gets hp back */
1332 else if (item->type == FOOD && mon->will_apply & WILL_APPLY_FOOD)
1333 flag = 1;
1334 else if (item->type == SCROLL && QUERY_FLAG (mon, FLAG_USE_SCROLL))
1335 {
1336 if (!item->inv)
1337 LOG (llevDebug, "Monster %d having scroll %d with empty inventory!", mon->count, item->count);
1338 else if (monster_should_cast_spell (mon, item->inv))
1339 SET_FLAG (mon, FLAG_READY_SCROLL);
1340 /* Don't use it right now */
1341 return;
1342 }
1343 else if (item->type == WEAPON)
1344 flag = check_good_weapon (mon, item);
1345 else if (item->is_armor ())
1346 flag = check_good_armour (mon, item);
1347 /* Should do something more, like make sure this is a better item */
1348 else if (item->type == RING)
1349 flag = 1;
1350 else if (item->type == WAND || item->type == ROD || item->type == HORN)
1351 {
1352 /* We never really 'ready' the wand/rod/horn, because that would mean the
1353 * weapon would get undone.
1354 */
1355 if (!(can_apply_object (mon, item) & CAN_APPLY_NOT_MASK))
1356 {
1357 SET_FLAG (mon, FLAG_READY_RANGE);
1358 SET_FLAG (item, FLAG_APPLIED);
1359 }
1360 return;
1361 }
1362 else if (item->type == BOW)
1363 {
1364 /* We never really 'ready' the bow, because that would mean the
1365 * weapon would get undone.
1366 */
1367 if (!(can_apply_object (mon, item) & CAN_APPLY_NOT_MASK))
1368 SET_FLAG (mon, FLAG_READY_BOW);
1369 return;
1370 }
1371 else if (item->type == SKILL)
1372 {
1373 /*
1374 * skills are specials: monsters must have the 'FLAG_READY_SKILL' flag set,
1375 * else they can't use the skill...
1376 * Skills also don't need to get applied, so return now.
1377 */
1378 SET_FLAG (mon, FLAG_READY_SKILL);
1379 return;
1380 }
1381
1382
1383 /* if we don't match one of the above types, return now.
1384 * can_apply_object will say that we can apply things like flesh,
1385 * bolts, and whatever else, because it only checks against the
1386 * body_info locations.
1387 */
1388 if (!flag)
1389 return;
1390
1391 /* Check to see if the monster can use this item. If not, no need
1392 * to do further processing. Note that can_apply_object already checks
1393 * for the CAN_USE flags.
1394 */
1395 if (can_apply_object (mon, item) & CAN_APPLY_NOT_MASK)
1396 return;
1397
1398 /* should only be applying this item, not unapplying it.
1399 * also, ignore status of curse so they can take off old armour.
1400 * monsters have some advantages after all.
1401 */
1402 manual_apply (mon, item, AP_APPLY | AP_IGNORE_CURSE);
1403
1404 return;
1405}
1406
1407void
1320void npc_call_help(object *op) { 1408npc_call_help (object *op)
1409{
1321 int x,y, mflags; 1410 int x, y, mflags;
1322 object *npc; 1411 object *npc;
1323 sint16 sx, sy; 1412 sint16 sx, sy;
1324 mapstruct *m; 1413 maptile *m;
1325 1414
1326 for(x = -3; x < 4; x++) 1415 for (x = -3; x < 4; x++)
1327 for(y = -3; y < 4; y++) { 1416 for (y = -3; y < 4; y++)
1417 {
1328 m = op->map; 1418 m = op->map;
1329 sx = op->x + x; 1419 sx = op->x + x;
1330 sy = op->y + y; 1420 sy = op->y + y;
1331 mflags = get_map_flags(m, &m, sx, sy, &sx, &sy); 1421 mflags = get_map_flags (m, &m, sx, sy, &sx, &sy);
1332 /* If nothing alive on this space, no need to search the space. */ 1422 /* If nothing alive on this space, no need to search the space. */
1333 if ((mflags & P_OUT_OF_MAP) || !(mflags & P_IS_ALIVE)) 1423 if ((mflags & P_OUT_OF_MAP) || !(mflags & P_IS_ALIVE))
1334 continue; 1424 continue;
1335 1425
1336 for(npc = get_map_ob(m,sx,sy);npc!=NULL;npc=npc->above) 1426 for (npc = GET_MAP_OB (m, sx, sy); npc != NULL; npc = npc->above)
1337 if(QUERY_FLAG(npc, FLAG_ALIVE)&&QUERY_FLAG(npc, FLAG_UNAGGRESSIVE)) 1427 if (QUERY_FLAG (npc, FLAG_ALIVE) && QUERY_FLAG (npc, FLAG_UNAGGRESSIVE))
1338 npc->enemy = op->enemy; 1428 npc->enemy = op->enemy;
1339 } 1429 }
1340} 1430}
1341 1431
1342 1432
1433int
1343int dist_att (int dir , object *ob, object *enemy, object *part, rv_vector *rv) { 1434dist_att (int dir, object *ob, object *enemy, object *part, rv_vector * rv)
1435{
1344 1436
1345 if (can_hit(part,enemy,rv)) 1437 if (can_hit (part, enemy, rv))
1346 return dir; 1438 return dir;
1347 if (rv->distance < 10) 1439 if (rv->distance < 10)
1348 return absdir(dir+4); 1440 return absdir (dir + 4);
1349 else if (rv->distance>18) 1441 else if (rv->distance > 18)
1350 return dir; 1442 return dir;
1351 return 0; 1443 return 0;
1352} 1444}
1353 1445
1446int
1354int run_att (int dir, object *ob, object *enemy,object *part, rv_vector *rv) { 1447run_att (int dir, object *ob, object *enemy, object *part, rv_vector * rv)
1448{
1355 1449
1356 if ((can_hit (part,enemy,rv) && ob->move_status <20) || ob->move_status <20) { 1450 if ((can_hit (part, enemy, rv) && ob->move_status < 20) || ob->move_status < 20)
1451 {
1357 ob->move_status++; 1452 ob->move_status++;
1358 return (dir); 1453 return (dir);
1359 } 1454 }
1360 else if (ob->move_status >20) 1455 else if (ob->move_status > 20)
1361 ob->move_status = 0;
1362 return absdir (dir+4);
1363}
1364
1365int hitrun_att (int dir, object *ob,object *enemy) {
1366 if (ob->move_status ++ < 25)
1367 return dir;
1368 else if (ob->move_status <50)
1369 return absdir (dir+4);
1370 else
1371 ob->move_status = 0;
1372 return absdir(dir+4);
1373}
1374
1375int wait_att (int dir, object *ob,object *enemy,object *part,rv_vector *rv) {
1376
1377 int inrange = can_hit (part, enemy,rv);
1378
1379 if (ob->move_status || inrange)
1380 ob->move_status++;
1381
1382 if (ob->move_status == 0)
1383 return 0;
1384 else if (ob->move_status <10)
1385 return dir;
1386 else if (ob->move_status <15)
1387 return absdir(dir+4);
1388 ob->move_status = 0; 1456 ob->move_status = 0;
1457 return absdir (dir + 4);
1458}
1459
1460int
1461hitrun_att (int dir, object *ob, object *enemy)
1462{
1463 if (ob->move_status++ < 25)
1389 return 0; 1464 return dir;
1390} 1465 else if (ob->move_status < 50)
1391
1392int disthit_att (int dir, object *ob, object *enemy, object *part,rv_vector *rv) {
1393
1394 /* The logic below here looked plain wrong before. Basically, what should
1395 * happen is that if the creatures hp percentage falls below run_away,
1396 * the creature should run away (dir+4)
1397 * I think its wrong for a creature to have a zero maxhp value, but
1398 * at least one map has this set, and whatever the map contains, the
1399 * server should try to be resilant enough to avoid the problem
1400 */
1401 if (ob->stats.maxhp && (ob->stats.hp*100)/ob->stats.maxhp < ob->run_away)
1402 return absdir(dir+4);
1403 return dist_att (dir,ob,enemy,part,rv);
1404}
1405
1406int wait_att2 (int dir, object *ob,object *enemy,object *part, rv_vector *rv) {
1407 if (rv->distance < 9)
1408 return absdir (dir+4); 1466 return absdir (dir + 4);
1409 return 0; 1467 else
1410}
1411
1412void circ1_move (object *ob) {
1413 static int circle [12] = {3,3,4,5,5,6,7,7,8,1,1,2};
1414 if(++ob->move_status > 11)
1415 ob->move_status = 0; 1468 ob->move_status = 0;
1416 if (!(move_object(ob,circle[ob->move_status]))) 1469 return absdir (dir + 4);
1417 (void) move_object(ob,RANDOM()%8+1);
1418} 1470}
1419 1471
1472int
1473wait_att (int dir, object *ob, object *enemy, object *part, rv_vector * rv)
1474{
1475
1476 int inrange = can_hit (part, enemy, rv);
1477
1478 if (ob->move_status || inrange)
1479 ob->move_status++;
1480
1481 if (ob->move_status == 0)
1482 return 0;
1483 else if (ob->move_status < 10)
1484 return dir;
1485 else if (ob->move_status < 15)
1486 return absdir (dir + 4);
1487 ob->move_status = 0;
1488 return 0;
1489}
1490
1491int
1492disthit_att (int dir, object *ob, object *enemy, object *part, rv_vector * rv)
1493{
1494
1495 /* The logic below here looked plain wrong before. Basically, what should
1496 * happen is that if the creatures hp percentage falls below run_away,
1497 * the creature should run away (dir+4)
1498 * I think its wrong for a creature to have a zero maxhp value, but
1499 * at least one map has this set, and whatever the map contains, the
1500 * server should try to be resilant enough to avoid the problem
1501 */
1502 if (ob->stats.maxhp && (ob->stats.hp * 100) / ob->stats.maxhp < ob->run_away)
1503 return absdir (dir + 4);
1504 return dist_att (dir, ob, enemy, part, rv);
1505}
1506
1507int
1508wait_att2 (int dir, object *ob, object *enemy, object *part, rv_vector * rv)
1509{
1510 if (rv->distance < 9)
1511 return absdir (dir + 4);
1512 return 0;
1513}
1514
1515void
1420void circ2_move (object *ob) { 1516circ1_move (object *ob)
1517{
1421 static int circle[20] = {3,3,3,4,4,5,5,5,6,6,7,7,7,8,8,1,1,1,2,2}; 1518 static int circle[12] = { 3, 3, 4, 5, 5, 6, 7, 7, 8, 1, 1, 2 };
1422 if(++ob->move_status > 19) 1519 if (++ob->move_status > 11)
1423 ob->move_status = 0; 1520 ob->move_status = 0;
1424 if(!(move_object(ob,circle[ob->move_status]))) 1521 if (!(move_object (ob, circle[ob->move_status])))
1425 (void) move_object(ob,RANDOM()%8+1); 1522 (void) move_object (ob, RANDOM () % 8 + 1);
1426} 1523}
1427 1524
1525void
1526circ2_move (object *ob)
1527{
1528 static int circle[20] = { 3, 3, 3, 4, 4, 5, 5, 5, 6, 6, 7, 7, 7, 8, 8, 1, 1, 1, 2, 2 };
1529 if (++ob->move_status > 19)
1530 ob->move_status = 0;
1531 if (!(move_object (ob, circle[ob->move_status])))
1532 (void) move_object (ob, RANDOM () % 8 + 1);
1533}
1534
1535void
1428void pace_movev(object *ob) { 1536pace_movev (object *ob)
1537{
1429 if (ob->move_status++ > 6) 1538 if (ob->move_status++ > 6)
1430 ob->move_status = 0; 1539 ob->move_status = 0;
1431 if (ob->move_status < 4) 1540 if (ob->move_status < 4)
1432 (void) move_object (ob,5); 1541 (void) move_object (ob, 5);
1433 else 1542 else
1434 (void) move_object(ob,1); 1543 (void) move_object (ob, 1);
1435} 1544}
1436 1545
1546void
1437void pace_moveh (object *ob) { 1547pace_moveh (object *ob)
1548{
1438 if (ob->move_status++ > 6) 1549 if (ob->move_status++ > 6)
1439 ob->move_status = 0; 1550 ob->move_status = 0;
1440 if (ob->move_status < 4) 1551 if (ob->move_status < 4)
1441 (void) move_object(ob,3); 1552 (void) move_object (ob, 3);
1442 else 1553 else
1443 (void) move_object(ob,7); 1554 (void) move_object (ob, 7);
1444} 1555}
1445 1556
1557void
1446void pace2_movev (object *ob) { 1558pace2_movev (object *ob)
1559{
1447 if (ob->move_status ++ > 16) 1560 if (ob->move_status++ > 16)
1448 ob->move_status = 0; 1561 ob->move_status = 0;
1449 if (ob->move_status <6) 1562 if (ob->move_status < 6)
1450 (void) move_object (ob,5); 1563 (void) move_object (ob, 5);
1451 else if (ob->move_status < 8) 1564 else if (ob->move_status < 8)
1452 return; 1565 return;
1453 else if (ob->move_status <13) 1566 else if (ob->move_status < 13)
1454 (void) move_object (ob,1); 1567 (void) move_object (ob, 1);
1568 else
1455 else return; 1569 return;
1456} 1570}
1457 1571
1572void
1458void pace2_moveh (object *ob) { 1573pace2_moveh (object *ob)
1574{
1459 if (ob->move_status ++ > 16) 1575 if (ob->move_status++ > 16)
1460 ob->move_status = 0; 1576 ob->move_status = 0;
1461 if (ob->move_status <6) 1577 if (ob->move_status < 6)
1462 (void) move_object (ob,3); 1578 (void) move_object (ob, 3);
1463 else if (ob->move_status < 8) 1579 else if (ob->move_status < 8)
1464 return; 1580 return;
1465 else if (ob->move_status <13) 1581 else if (ob->move_status < 13)
1466 (void) move_object (ob,7); 1582 (void) move_object (ob, 7);
1583 else
1467 else return; 1584 return;
1468} 1585}
1469 1586
1587void
1470void rand_move (object *ob) { 1588rand_move (object *ob)
1589{
1471 int i; 1590 int i;
1472 if (ob->move_status <1 || ob->move_status >8 || 1591
1473 !(move_object(ob,ob->move_status|| ! (RANDOM()% 9)))) 1592 if (ob->move_status < 1 || ob->move_status > 8 || !(move_object (ob, ob->move_status || !(RANDOM () % 9))))
1474 for (i = 0; i < 5; i++) 1593 for (i = 0; i < 5; i++)
1475 if (move_object(ob,ob->move_status = RANDOM()%8+1)) 1594 if (move_object (ob, ob->move_status = RANDOM () % 8 + 1))
1476 return; 1595 return;
1477} 1596}
1478 1597
1598void
1479void check_earthwalls(object *op, mapstruct *m, int x, int y) { 1599check_earthwalls (object *op, maptile *m, int x, int y)
1600{
1480 object *tmp; 1601 object *tmp;
1602
1481 for (tmp = get_map_ob(m, x, y); tmp!=NULL; tmp=tmp->above) { 1603 for (tmp = GET_MAP_OB (m, x, y); tmp != NULL; tmp = tmp->above)
1604 {
1482 if (tmp->type == EARTHWALL) { 1605 if (tmp->type == EARTHWALL)
1606 {
1483 hit_player(tmp,op->stats.dam,op,AT_PHYSICAL,1); 1607 hit_player (tmp, op->stats.dam, op, AT_PHYSICAL, 1);
1484 return; 1608 return;
1485 } 1609 }
1486 } 1610 }
1487} 1611}
1488 1612
1613void
1489void check_doors(object *op, mapstruct *m, int x, int y) { 1614check_doors (object *op, maptile *m, int x, int y)
1615{
1490 object *tmp; 1616 object *tmp;
1617
1491 for (tmp = get_map_ob(m, x, y); tmp!=NULL; tmp=tmp->above) { 1618 for (tmp = GET_MAP_OB (m, x, y); tmp != NULL; tmp = tmp->above)
1619 {
1492 if (tmp->type == DOOR) { 1620 if (tmp->type == DOOR)
1621 {
1493 hit_player(tmp,1000,op,AT_PHYSICAL,1); 1622 hit_player (tmp, 1000, op, AT_PHYSICAL, 1);
1494 return; 1623 return;
1495 } 1624 }
1496 } 1625 }
1497} 1626}
1498 1627
1499/* find_mon_throw_ob() - modeled on find_throw_ob 1628/* find_mon_throw_ob() - modeled on find_throw_ob
… …
1502 * furniture, even if they are not good throwable objects. 1631 * furniture, even if they are not good throwable objects.
1503 * Probably better to have the monster throw a throwable object 1632 * Probably better to have the monster throw a throwable object
1504 * first, then throw any non equipped weapon. 1633 * first, then throw any non equipped weapon.
1505 */ 1634 */
1506 1635
1636object *
1507object *find_mon_throw_ob( object *op ) { 1637find_mon_throw_ob (object *op)
1638{
1508 object *tmp = NULL; 1639 object *tmp = NULL;
1509
1510 if(op->head) tmp=op->head; else tmp=op;
1511 1640
1641 if (op->head)
1642 tmp = op->head;
1643 else
1644 tmp = op;
1645
1512 /* New throw code: look through the inventory. Grap the first legal is_thrown 1646 /* New throw code: look through the inventory. Grap the first legal is_thrown
1513 * marked item and throw it to the enemy. 1647 * marked item and throw it to the enemy.
1514 */ 1648 */
1515 1649
1516 for(tmp=op->inv;tmp;tmp=tmp->below) { 1650 for (tmp = op->inv; tmp; tmp = tmp->below)
1651 {
1517 1652
1518 /* Can't throw invisible objects or items that are applied */ 1653 /* Can't throw invisible objects or items that are applied */
1519 if(tmp->invisible || QUERY_FLAG(tmp,FLAG_APPLIED)) continue; 1654 if (tmp->invisible || QUERY_FLAG (tmp, FLAG_APPLIED))
1655 continue;
1520 1656
1521 if(QUERY_FLAG(tmp,FLAG_IS_THROWN)) 1657 if (QUERY_FLAG (tmp, FLAG_IS_THROWN))
1522 break; 1658 break;
1523 1659
1524 } 1660 }
1525 1661
1526#ifdef DEBUG_THROW 1662#ifdef DEBUG_THROW
1527 LOG(llevDebug,"%s chooses to throw: %s (%d)\n",op->name, 1663 LOG (llevDebug, "%s chooses to throw: %s (%d)\n", op->name, !(tmp) ? "(nothing)" : query_name (tmp), tmp ? tmp->count : -1);
1528 !(tmp)?"(nothing)":query_name(tmp),tmp?tmp->count:-1);
1529#endif 1664#endif
1530 1665
1531 return tmp; 1666 return tmp;
1532} 1667}
1533 1668
1534/* determine if we can 'detect' the enemy. Check for walls blocking the 1669/* determine if we can 'detect' the enemy. Check for walls blocking the
1535 * los. Also, just because its hidden/invisible, we may be sensitive/smart 1670 * los. Also, just because its hidden/invisible, we may be sensitive/smart
1536 * enough (based on Wis & Int) to figure out where the enemy is. -b.t. 1671 * enough (based on Wis & Int) to figure out where the enemy is. -b.t.
… …
1539 * OR y distance being within some range - that seemed wrong - both should 1674 * OR y distance being within some range - that seemed wrong - both should
1540 * be within the valid range. MSW 2001-08-05 1675 * be within the valid range. MSW 2001-08-05
1541 * Returns 0 if enemy can not be detected, 1 if it is detected 1676 * Returns 0 if enemy can not be detected, 1 if it is detected
1542 */ 1677 */
1543 1678
1679int
1544int can_detect_enemy (object *op, object *enemy, rv_vector *rv) { 1680can_detect_enemy (object *op, object *enemy, rv_vector * rv)
1681{
1545 int radius = MIN_MON_RADIUS, hide_discovery; 1682 int radius = MIN_MON_RADIUS, hide_discovery;
1546 1683
1547 /* null detection for any of these condtions always */ 1684 /* null detection for any of these condtions always */
1548 if(!op || !enemy || !op->map || !enemy->map) 1685 if (!op || !enemy || !op->map || !enemy->map)
1549 return 0; 1686 return 0;
1550 1687
1551 /* If the monster (op) has no way to get to the enemy, do nothing */ 1688 /* If the monster (op) has no way to get to the enemy, do nothing */
1552 if (!on_same_map(op, enemy)) 1689 if (!on_same_map (op, enemy))
1553 return 0; 1690 return 0;
1554 1691
1555 get_rangevector(op, enemy, rv, 0); 1692 get_rangevector (op, enemy, rv, 0);
1556 1693
1557 /* Monsters always ignore the DM */ 1694 /* Monsters always ignore the DM */
1558 if ( ( op->type != PLAYER ) && QUERY_FLAG( enemy, FLAG_WIZ ) ) 1695 if ((op->type != PLAYER) && QUERY_FLAG (enemy, FLAG_WIZ))
1559 return 0; 1696 return 0;
1560 1697
1561 /* simple check. Should probably put some range checks in here. */ 1698 /* simple check. Should probably put some range checks in here. */
1562 if(can_see_enemy(op,enemy)) return 1; 1699 if (can_see_enemy (op, enemy))
1700 return 1;
1563 1701
1564 /* The rest of this is for monsters. Players are on their own for 1702 /* The rest of this is for monsters. Players are on their own for
1565 * finding enemies! 1703 * finding enemies!
1566 */ 1704 */
1567 if(op->type==PLAYER) return 0; 1705 if (op->type == PLAYER)
1706 return 0;
1568 1707
1569 /* Quality invisible? Bah, we wont see them w/o SEE_INVISIBLE 1708 /* Quality invisible? Bah, we wont see them w/o SEE_INVISIBLE
1570 * flag (which was already checked) in can_see_enmy (). Lets get out of here 1709 * flag (which was already checked) in can_see_enmy (). Lets get out of here
1571 */ 1710 */
1572 if(enemy->invisible && (!enemy->contr || (!enemy->contr->tmp_invis && !enemy->contr->hidden))) 1711 if (enemy->invisible && (!enemy->contr || (!enemy->contr->tmp_invis && !enemy->contr->hidden)))
1573 return 0; 1712 return 0;
1574 1713
1575 /* use this for invis also */ 1714 /* use this for invis also */
1576 hide_discovery = op->stats.Int/5; 1715 hide_discovery = op->stats.Int / 5;
1577 1716
1578 /* Determine Detection radii */ 1717 /* Determine Detection radii */
1579 if(!enemy->hide) /* to detect non-hidden (eg dark/invis enemy) */ 1718 if (!enemy->hide) /* to detect non-hidden (eg dark/invis enemy) */
1580 radius = (op->stats.Wis/5)+1>MIN_MON_RADIUS?(op->stats.Wis/5)+1:MIN_MON_RADIUS; 1719 radius = (op->stats.Wis / 5) + 1 > MIN_MON_RADIUS ? (op->stats.Wis / 5) + 1 : MIN_MON_RADIUS;
1720 else
1581 else { /* a level/INT/Dex adjustment for hiding */ 1721 { /* a level/INT/Dex adjustment for hiding */
1582 object *sk_hide; 1722 object *sk_hide;
1583 int bonus = (op->level/2) + (op->stats.Int/5); 1723 int bonus = (op->level / 2) + (op->stats.Int / 5);
1584 1724
1585 if(enemy->type==PLAYER) { 1725 if (enemy->type == PLAYER)
1726 {
1586 if((sk_hide = find_skill_by_number(enemy,SK_HIDING))) 1727 if ((sk_hide = find_skill_by_number (enemy, SK_HIDING)))
1587 bonus -= sk_hide->level; 1728 bonus -= sk_hide->level;
1588 else { 1729 else
1730 {
1589 LOG(llevError,"can_detect_enemy() got hidden player w/o hiding skill!\n"); 1731 LOG (llevError, "can_detect_enemy() got hidden player w/o hiding skill!\n");
1590 make_visible(enemy); 1732 make_visible (enemy);
1591 radius=radius<MIN_MON_RADIUS?MIN_MON_RADIUS:radius; 1733 radius = radius < MIN_MON_RADIUS ? MIN_MON_RADIUS : radius;
1592 } 1734 }
1593 } 1735 }
1594 else /* enemy is not a player */ 1736 else /* enemy is not a player */
1595 bonus -= enemy->level; 1737 bonus -= enemy->level;
1596 1738
1597 radius += bonus/5; 1739 radius += bonus / 5;
1598 hide_discovery += bonus*5; 1740 hide_discovery += bonus * 5;
1599 } /* else creature has modifiers for hiding */ 1741 } /* else creature has modifiers for hiding */
1600 1742
1601 /* Radii stealth adjustment. Only if you are stealthy 1743 /* Radii stealth adjustment. Only if you are stealthy
1602 * will you be able to sneak up closer to creatures */ 1744 * will you be able to sneak up closer to creatures */
1603 if(QUERY_FLAG(enemy,FLAG_STEALTH)) 1745 if (QUERY_FLAG (enemy, FLAG_STEALTH))
1604 radius = radius/2, hide_discovery = hide_discovery/3; 1746 radius = radius / 2, hide_discovery = hide_discovery / 3;
1605 1747
1606 /* Radii adjustment for enemy standing in the dark */ 1748 /* Radii adjustment for enemy standing in the dark */
1607 if(op->map->darkness>0 && !stand_in_light(enemy)) { 1749 if (op->map->darkness > 0 && !stand_in_light (enemy))
1750 {
1608 /* on dark maps body heat can help indicate location with infravision 1751 /* on dark maps body heat can help indicate location with infravision
1609 * undead don't have body heat, so no benefit detecting them. 1752 * undead don't have body heat, so no benefit detecting them.
1610 */ 1753 */
1611 if(QUERY_FLAG(op,FLAG_SEE_IN_DARK) && !is_true_undead(enemy)) 1754 if (QUERY_FLAG (op, FLAG_SEE_IN_DARK) && !is_true_undead (enemy))
1612 radius += op->map->darkness/2; 1755 radius += op->map->darkness / 2;
1613 else 1756 else
1614 radius -= op->map->darkness/2; 1757 radius -= op->map->darkness / 2;
1615 1758
1616 /* op next to a monster (and not in complete darkness) 1759 /* op next to a monster (and not in complete darkness)
1617 * the monster should have a chance to see you. 1760 * the monster should have a chance to see you.
1618 */ 1761 */
1619 if(radius<MIN_MON_RADIUS && op->map->darkness<5 && rv->distance<=1) 1762 if (radius < MIN_MON_RADIUS && op->map->darkness < 5 && rv->distance <= 1)
1620 radius = MIN_MON_RADIUS; 1763 radius = MIN_MON_RADIUS;
1621 } /* if on dark map */ 1764 } /* if on dark map */
1622 1765
1623 /* Lets not worry about monsters that have incredible detection 1766 /* Lets not worry about monsters that have incredible detection
1624 * radii, we only need to worry here about things the player can 1767 * radii, we only need to worry here about things the player can
1625 * (potentially) see. This is 13, as that is the maximum size the player 1768 * (potentially) see. This is 13, as that is the maximum size the player
1626 * may have for their map - in that way, creatures at the edge will 1769 * may have for their map - in that way, creatures at the edge will
1627 * do something. Note that the distance field in the 1770 * do something. Note that the distance field in the
1628 * vector is real distance, so in theory this should be 18 to 1771 * vector is real distance, so in theory this should be 18 to
1629 * find that. 1772 * find that.
1630 */ 1773 */
1631 if(radius>13) radius = 13; 1774 if (radius > 13)
1775 radius = 13;
1632 1776
1633 /* Enemy in range! Now test for detection */ 1777 /* Enemy in range! Now test for detection */
1634 if ((int) rv->distance <= radius) { 1778 if ((int) rv->distance <= radius)
1779 {
1635 /* ah, we are within range, detected? take cases */ 1780 /* ah, we are within range, detected? take cases */
1636 if(!enemy->invisible) /* enemy in dark squares... are seen! */ 1781 if (!enemy->invisible) /* enemy in dark squares... are seen! */
1637 return 1; 1782 return 1;
1638 1783
1639 /* hidden or low-quality invisible */ 1784 /* hidden or low-quality invisible */
1640 if(enemy->hide && (rv->distance <= 1) && (RANDOM()%100<=hide_discovery)) { 1785 if (enemy->hide && (rv->distance <= 1) && (RANDOM () % 100 <= hide_discovery))
1786 {
1641 make_visible(enemy); 1787 make_visible (enemy);
1642 /* inform players of new status */ 1788 /* inform players of new status */
1643 if(enemy->type==PLAYER && player_can_view(enemy,op)) 1789 if (enemy->type == PLAYER && player_can_view (enemy, op))
1644 new_draw_info_format(NDI_UNIQUE,0, enemy, 1790 new_draw_info_format (NDI_UNIQUE, 0, enemy, "You are discovered by %s!", &op->name);
1645 "You are discovered by %s!",&op->name);
1646 return 1; /* detected enemy */ 1791 return 1; /* detected enemy */
1647 } 1792 }
1648 else if (enemy->invisible) { 1793 else if (enemy->invisible)
1794 {
1649 /* Change this around - instead of negating the invisible, just 1795 /* Change this around - instead of negating the invisible, just
1650 * return true so that the mosnter that managed to detect you can 1796 * return true so that the mosnter that managed to detect you can
1651 * do something to you. Decreasing the duration of invisible 1797 * do something to you. Decreasing the duration of invisible
1652 * doesn't make a lot of sense IMO, as a bunch of stupid creatures 1798 * doesn't make a lot of sense IMO, as a bunch of stupid creatures
1653 * can then basically negate the spell. The spell isn't negated - 1799 * can then basically negate the spell. The spell isn't negated -
1654 * they just know where you are! 1800 * they just know where you are!
1655 */ 1801 */
1656 if ((RANDOM() % 50) <= hide_discovery) { 1802 if ((RANDOM () % 50) <= hide_discovery)
1803 {
1657 if (enemy->type == PLAYER) { 1804 if (enemy->type == PLAYER)
1658 new_draw_info_format(NDI_UNIQUE,0, enemy, 1805 {
1659 "You see %s noticing your position.", query_name(op)); 1806 new_draw_info_format (NDI_UNIQUE, 0, enemy, "You see %s noticing your position.", query_name (op));
1660 } 1807 }
1661 return 1; 1808 return 1;
1662 } 1809 }
1663 } 1810 }
1664 } /* within range */ 1811 } /* within range */
1665 1812
1666 /* Wasn't detected above, so still hidden */ 1813 /* Wasn't detected above, so still hidden */
1667 return 0; 1814 return 0;
1668} 1815}
1669 1816
1670/* determine if op stands in a lighted square. This is not a very 1817/* determine if op stands in a lighted square. This is not a very
1671 * intellegent algorithm. For one thing, we ignore los here, SO it 1818 * intellegent algorithm. For one thing, we ignore los here, SO it
1672 * is possible for a bright light to illuminate a player on the 1819 * is possible for a bright light to illuminate a player on the
1673 * other side of a wall (!). 1820 * other side of a wall (!).
1674 */ 1821 */
1675 1822
1823int
1676int stand_in_light( object *op) { 1824stand_in_light (object *op)
1825{
1677 sint16 nx,ny; 1826 sint16 nx, ny;
1678 mapstruct *m; 1827 maptile *m;
1679 1828
1680 1829
1830 if (!op)
1681 if(!op) return 0; 1831 return 0;
1682 if(op->glow_radius > 0) return 1; 1832 if (op->glow_radius > 0)
1833 return 1;
1683 1834
1684 if(op->map) { 1835 if (op->map)
1836 {
1685 int x, y, x1, y1; 1837 int x, y, x1, y1;
1686
1687
1688 1838
1839
1840
1689 /* Check the spaces with the max light radius to see if any of them 1841 /* Check the spaces with the max light radius to see if any of them
1690 * have lights, and if any of them light the player enough, then return 1. 1842 * have lights, and if any of them light the player enough, then return 1.
1691 */ 1843 */
1692 for (x = op->x - MAX_LIGHT_RADII; x <= op->x + MAX_LIGHT_RADII; x++) { 1844 for (x = op->x - MAX_LIGHT_RADII; x <= op->x + MAX_LIGHT_RADII; x++)
1845 {
1693 for (y = op->y - MAX_LIGHT_RADII; y <= op->y + MAX_LIGHT_RADII; y++) { 1846 for (y = op->y - MAX_LIGHT_RADII; y <= op->y + MAX_LIGHT_RADII; y++)
1847 {
1694 m = op->map; 1848 m = op->map;
1695 nx = x; 1849 nx = x;
1696 ny = y; 1850 ny = y;
1697 1851
1698 if (get_map_flags(m, &m, nx, ny, &nx, &ny) & P_OUT_OF_MAP) continue; 1852 if (get_map_flags (m, &m, nx, ny, &nx, &ny) & P_OUT_OF_MAP)
1853 continue;
1699 1854
1700 x1 = abs(x - op->x)*abs(x - op->x); 1855 x1 = abs (x - op->x) * abs (x - op->x);
1701 y1 = abs(y - op->y)*abs(y - op->y); 1856 y1 = abs (y - op->y) * abs (y - op->y);
1702 if (isqrt(x1 + y1) < GET_MAP_LIGHT(m, nx, ny)) return 1; 1857 if (isqrt (x1 + y1) < GET_MAP_LIGHT (m, nx, ny))
1858 return 1;
1703 } 1859 }
1704 } 1860 }
1705 } 1861 }
1706 return 0; 1862 return 0;
1707} 1863}
1708 1864
1709 1865
1710/* assuming no walls/barriers, lets check to see if its *possible* 1866/* assuming no walls/barriers, lets check to see if its *possible*
1711 * to see an enemy. Note, "detection" is different from "seeing". 1867 * to see an enemy. Note, "detection" is different from "seeing".
1712 * See can_detect_enemy() for more details. -b.t. 1868 * See can_detect_enemy() for more details. -b.t.
1713 * return 0 if can't be seen, 1 if can be 1869 * return 0 if can't be seen, 1 if can be
1714 */ 1870 */
1715 1871
1872int
1716int can_see_enemy (object *op, object *enemy) { 1873can_see_enemy (object *op, object *enemy)
1874{
1717 object *looker = op->head?op->head:op; 1875 object *looker = op->head ? op->head : op;
1718 1876
1719 /* safety */ 1877 /* safety */
1720 if(!looker||!enemy||!QUERY_FLAG(looker,FLAG_ALIVE)) 1878 if (!looker || !enemy || !QUERY_FLAG (looker, FLAG_ALIVE))
1721 return 0; 1879 return 0;
1722 1880
1723 /* we dont give a full treatment of xrays here (shorter range than normal, 1881 /* we dont give a full treatment of xrays here (shorter range than normal,
1724 * see through walls). Should we change the code elsewhere to make you 1882 * see through walls). Should we change the code elsewhere to make you
1725 * blind even if you can xray? 1883 * blind even if you can xray?
1726 */ 1884 */
1727 if(QUERY_FLAG(looker,FLAG_BLIND) && !QUERY_FLAG(looker,FLAG_XRAYS)) 1885 if (QUERY_FLAG (looker, FLAG_BLIND) && !QUERY_FLAG (looker, FLAG_XRAYS))
1886 return 0;
1887
1888 /* checking for invisible things */
1889 if (enemy->invisible)
1890 {
1891 /* HIDDEN ENEMY. by definition, you can't see hidden stuff!
1892 * However,if you carry any source of light, then the hidden
1893 * creature is seeable (and stupid) */
1894
1895 if (has_carried_lights (enemy))
1896 {
1897 if (enemy->hide)
1898 {
1899 make_visible (enemy);
1900 new_draw_info (NDI_UNIQUE, 0, enemy, "Your light reveals your hiding spot!");
1901 }
1902 return 1;
1903 }
1904 else if (enemy->hide)
1905 return 0;
1906
1907 /* Invisible enemy. Break apart the check for invis undead/invis looker
1908 * into more simple checks - the QUERY_FLAG doesn't return 1/0 values,
1909 * and making it a conditional makes the code pretty ugly.
1910 */
1911 if (!QUERY_FLAG (looker, FLAG_SEE_INVISIBLE))
1912 {
1913 if (makes_invisible_to (enemy, looker))
1728 return 0; 1914 return 0;
1729
1730 /* checking for invisible things */
1731 if(enemy->invisible) {
1732 /* HIDDEN ENEMY. by definition, you can't see hidden stuff!
1733 * However,if you carry any source of light, then the hidden
1734 * creature is seeable (and stupid) */
1735
1736 if(has_carried_lights(enemy)) {
1737 if(enemy->hide) {
1738 make_visible(enemy);
1739 new_draw_info(NDI_UNIQUE,0, enemy,
1740 "Your light reveals your hiding spot!");
1741 } 1915 }
1742 return 1; 1916 }
1743 } else if (enemy->hide) return 0;
1744
1745 /* Invisible enemy. Break apart the check for invis undead/invis looker
1746 * into more simple checks - the QUERY_FLAG doesn't return 1/0 values,
1747 * and making it a conditional makes the code pretty ugly.
1748 */
1749 if (!QUERY_FLAG(looker,FLAG_SEE_INVISIBLE)) {
1750 if (makes_invisible_to(enemy, looker)) return 0;
1751 }
1752 } else if(looker->type==PLAYER) /* for players, a (possible) shortcut */ 1917 else if (looker->type == PLAYER) /* for players, a (possible) shortcut */
1753 if(player_can_view(looker,enemy)) return 1; 1918 if (player_can_view (looker, enemy))
1919 return 1;
1754 1920
1755 /* ENEMY IN DARK MAP. Without infravision, the enemy is not seen 1921 /* ENEMY IN DARK MAP. Without infravision, the enemy is not seen
1756 * unless they carry a light or stand in light. Darkness doesnt 1922 * unless they carry a light or stand in light. Darkness doesnt
1757 * inhibit the undead per se (but we should give their archs 1923 * inhibit the undead per se (but we should give their archs
1758 * CAN_SEE_IN_DARK, this is just a safety 1924 * CAN_SEE_IN_DARK, this is just a safety
1759 * we care about the enemy maps status, not the looker. 1925 * we care about the enemy maps status, not the looker.
1760 * only relevant for tiled maps, but it is possible that the 1926 * only relevant for tiled maps, but it is possible that the
1761 * enemy is on a bright map and the looker on a dark - in that 1927 * enemy is on a bright map and the looker on a dark - in that
1762 * case, the looker can still see the enemy 1928 * case, the looker can still see the enemy
1763 */ 1929 */
1764 if(enemy->map->darkness>0&&!stand_in_light(enemy) 1930 if (enemy->map->darkness > 0 && !stand_in_light (enemy)
1765 &&(!QUERY_FLAG(looker,FLAG_SEE_IN_DARK)|| 1931 && (!QUERY_FLAG (looker, FLAG_SEE_IN_DARK) || !is_true_undead (looker) || !QUERY_FLAG (looker, FLAG_XRAYS)))
1766 !is_true_undead(looker)||!QUERY_FLAG(looker,FLAG_XRAYS)))
1767 return 0; 1932 return 0;
1768 1933
1769 return 1; 1934 return 1;
1770} 1935}
1771

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines