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.7 by pippijn, Thu Sep 7 10:01:58 2006 UTC vs.
Revision 1.12 by root, Sat Sep 16 22:24:13 2006 UTC

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

Diff Legend

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