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

Diff Legend

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