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

Comparing deliantra/server/server/attack.C (file contents):
Revision 1.8 by root, Sun Sep 3 00:18:42 2006 UTC vs.
Revision 1.41 by root, Mon Jan 15 00:40:49 2007 UTC

1/*
2 * static char *rcsid_attack_c =
3 * "$Id: attack.C,v 1.8 2006/09/03 00:18:42 root Exp $";
4 */
5/* 1/*
6 CrossFire, A Multiplayer game for X-windows 2 CrossFire, A Multiplayer game for X-windows
7 3
4 Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
8 Copyright (C) 2002 Mark Wedel & Crossfire Development Team 5 Copyright (C) 2002 Mark Wedel & Crossfire Development Team
9 Copyright (C) 1992 Frank Tore Johansen 6 Copyright (C) 1992 Frank Tore Johansen
10 7
11 This program is free software; you can redistribute it and/or modify 8 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by 9 it under the terms of the GNU General Public License as published by
… …
20 17
21 You should have received a copy of the GNU General Public License 18 You should have received a copy of the GNU General Public License
22 along with this program; if not, write to the Free Software 19 along with this program; if not, write to the Free Software
23 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 21
25 The authors can be reached via e-mail to crossfire-devel@real-time.com 22 The authors can be reached via e-mail to <crossfire@schmorp.de>
26*/ 23*/
27#include <assert.h> 24#include <assert.h>
28#include <global.h> 25#include <global.h>
29#include <living.h> 26#include <living.h>
30#include <material.h> 27#include <material.h>
31#include <skills.h> 28#include <skills.h>
32 29
33#ifndef __CEXTRACT__ 30#ifndef __CEXTRACT__
34#include <sproto.h> 31# include <sproto.h>
35#endif 32#endif
36 33
37#include <sounds.h> 34#include <sounds.h>
38 35
39typedef struct att_msg_str { 36typedef struct att_msg_str
37{
40 char *msg1; 38 char *msg1;
41 char *msg2; 39 char *msg2;
42} att_msg; 40} att_msg;
43 41
44/*#define ATTACK_DEBUG*/ 42/*#define ATTACK_DEBUG*/
45 43
46/* cancels object *op. Cancellation basically means an object loses 44/* cancels object *op. Cancellation basically means an object loses
47 * its magical benefits. 45 * its magical benefits.
48 */ 46 */
47void
49void cancellation(object *op) 48cancellation (object *op)
50{ 49{
51 object *tmp; 50 object *tmp;
52 51
53 if (op->invisible) 52 if (op->invisible)
54 return; 53 return;
55 54
56 if (QUERY_FLAG (op, FLAG_ALIVE) || op->type == CONTAINER || op->type == THROWN_OBJ) { 55 if (QUERY_FLAG (op, FLAG_ALIVE) || op->type == CONTAINER || op->type == THROWN_OBJ)
56 {
57 /* Recur through the inventory */ 57 /* Recur through the inventory */
58 for(tmp=op->inv;tmp!=NULL;tmp=tmp->below) 58 for (tmp = op->inv; tmp != NULL; tmp = tmp->below)
59 if (!did_make_save_item(tmp, AT_CANCELLATION,op)) 59 if (!did_make_save_item (tmp, AT_CANCELLATION, op))
60 cancellation(tmp); 60 cancellation (tmp);
61 } 61 }
62 else if(FABS(op->magic)<=(rndm(0, 5))) { 62 else if (FABS (op->magic) <= (rndm (0, 5)))
63 {
63 /* Nullify this object. This code could probably be more complete */ 64 /* Nullify this object. This code could probably be more complete */
64 /* in what abilities it should cancel */ 65 /* in what abilities it should cancel */
65 op->magic=0; 66 op->magic = 0;
66 CLEAR_FLAG(op, FLAG_DAMNED); 67 CLEAR_FLAG (op, FLAG_DAMNED);
67 CLEAR_FLAG(op, FLAG_CURSED); 68 CLEAR_FLAG (op, FLAG_CURSED);
68 CLEAR_FLAG(op, FLAG_KNOWN_MAGICAL); 69 CLEAR_FLAG (op, FLAG_KNOWN_MAGICAL);
69 CLEAR_FLAG(op, FLAG_KNOWN_CURSED); 70 CLEAR_FLAG (op, FLAG_KNOWN_CURSED);
70 if (op->env && op->env->type == PLAYER) { 71 if (op->env && op->env->type == PLAYER)
72 {
71 esrv_send_item (op->env, op); 73 esrv_send_item (op->env, op);
72 } 74 }
73 } 75 }
74} 76}
75
76
77 77
78/* did_make_save_item just checks to make sure the item actually 78/* did_make_save_item just checks to make sure the item actually
79 * made its saving throw based on the tables. It does not take 79 * made its saving throw based on the tables. It does not take
80 * any further action (like destroying the item). 80 * any further action (like destroying the item).
81 */ 81 */
82 82int
83int did_make_save_item(object *op, int type, object *originator) { 83did_make_save_item (object *op, int type, object *originator)
84{
84 int i, roll, saves=0, attacks=0, number; 85 int i, roll, saves = 0, attacks = 0, number;
85 materialtype_t *mt; 86 materialtype_t *mt;
86 87
87 if (op->materialname == NULL) { 88 if (op->materialname == NULL)
89 {
88 for (mt = materialt; mt != NULL && mt->next != NULL; mt=mt->next) { 90 for (mt = materialt; mt != NULL && mt->next != NULL; mt = mt->next)
89 if (op->material & mt->material) 91 if (op->material & mt->material)
90 break; 92 break;
91 } 93 }
92 } else 94 else
93 mt = name_to_material(op->materialname); 95 mt = name_to_material (op->materialname);
96
94 if (mt == NULL) 97 if (mt == NULL)
95 return TRUE;
96 roll = rndm(1, 20);
97
98 /* the attacktypes have no meaning for object saves
99 * If the type is only magic, don't adjust type - basically, if
100 * pure magic is hitting an object, it should save. However, if it
101 * is magic teamed with something else, then strip out the
102 * magic type, and instead let the fire, cold, or whatever component
103 * destroy the item. Otherwise, you get the case of poisoncloud
104 * destroying objects because it has magic attacktype.
105 */
106 if (type != AT_MAGIC)
107 type &= ~(AT_CONFUSION|AT_DRAIN|AT_GHOSTHIT|AT_POISON|AT_SLOW|
108 AT_PARALYZE|AT_TURN_UNDEAD|AT_FEAR|AT_DEPLETE|AT_DEATH|
109 AT_COUNTERSPELL|AT_HOLYWORD|AT_BLIND|AT_LIFE_STEALING|
110 AT_MAGIC);
111
112 if (type == 0)
113 return TRUE;
114 if (roll == 20)
115 return TRUE;
116 if (roll == 1)
117 return FALSE;
118
119 for (number=0; number < NROFATTACKS; number++) {
120 i = 1<<number;
121 if (!(i&type))
122 continue;
123 attacks++;
124 if (op->resist[number] == 100)
125 saves++;
126 else if (roll >= mt->save[number] - op->magic - op->resist[number]/100)
127 saves++;
128 else if ((20-mt->save[number])/3 > originator->stats.dam)
129 saves++;
130 }
131
132 if (saves==attacks || attacks==0)
133 return TRUE;
134 if ((saves==0) || (rndm(1, attacks) > saves))
135 return FALSE;
136 return TRUE; 98 return TRUE;
99
100 roll = rndm (1, 20);
101
102 /* the attacktypes have no meaning for object saves
103 * If the type is only magic, don't adjust type - basically, if
104 * pure magic is hitting an object, it should save. However, if it
105 * is magic teamed with something else, then strip out the
106 * magic type, and instead let the fire, cold, or whatever component
107 * destroy the item. Otherwise, you get the case of poisoncloud
108 * destroying objects because it has magic attacktype.
109 */
110 if (type != AT_MAGIC)
111 type &= ~(AT_CONFUSION | AT_DRAIN | AT_GHOSTHIT | AT_POISON | AT_SLOW |
112 AT_PARALYZE | AT_TURN_UNDEAD | AT_FEAR | AT_DEPLETE | AT_DEATH |
113 AT_COUNTERSPELL | AT_HOLYWORD | AT_BLIND | AT_LIFE_STEALING | AT_MAGIC);
114
115 if (type == 0)
116 return TRUE;
117 if (roll == 20)
118 return TRUE;
119 if (roll == 1)
120 return FALSE;
121
122 for (number = 0; number < NROFATTACKS; number++)
123 {
124 i = 1 << number;
125 if (!(i & type))
126 continue;
127 attacks++;
128 if (op->resist[number] == 100)
129 saves++;
130 else if (roll >= mt->save[number] - op->magic - op->resist[number] / 100)
131 saves++;
132 else if ((20 - mt->save[number]) / 3 > originator->stats.dam)
133 saves++;
134 }
135
136 if (saves == attacks || attacks == 0)
137 return TRUE;
138 if ((saves == 0) || (rndm (1, attacks) > saves))
139 return FALSE;
140 return TRUE;
137} 141}
138 142
139/* This function calls did_make_save_item. It then performs the 143/* This function calls did_make_save_item. It then performs the
140 * appropriate actions to the item (such as burning the item up, 144 * appropriate actions to the item (such as burning the item up,
141 * calling cancellation, etc.) 145 * calling cancellation, etc.)
142 */ 146 */
143 147
148void
144void save_throw_object (object *op, int type, object *originator) 149save_throw_object (object *op, int type, object *originator)
145{ 150{
146 if ( ! did_make_save_item (op, type,originator)) 151 if (!did_make_save_item (op, type, originator))
147 { 152 {
148 object *env=op->env; 153 object *env = op->env;
149 int x=op->x,y=op->y; 154 int x = op->x, y = op->y;
150 mapstruct *m=op->map; 155 maptile *m = op->map;
151 156
152 op = stop_item (op); 157 op = stop_item (op);
153 if (op == NULL) 158 if (op == NULL)
154 return; 159 return;
155 160
156 /* Hacked the following so that type LIGHTER will work. 161 /* Hacked the following so that type LIGHTER will work.
157 * Also, objects which are potenital "lights" that are hit by 162 * Also, objects which are potenital "lights" that are hit by
158 * flame/elect attacks will be set to glow. "lights" are any 163 * flame/elect attacks will be set to glow. "lights" are any
159 * object with +/- glow_radius and an "other_arch" to change to. 164 * object with +/- glow_radius and an "other_arch" to change to.
160 * (and please note that we cant fail our save and reach this 165 * (and please note that we cant fail our save and reach this
161 * function if the object doesnt contain a material that can burn. 166 * function if the object doesnt contain a material that can burn.
162 * So forget lighting magical swords on fire with this!) -b.t. 167 * So forget lighting magical swords on fire with this!) -b.t.
163 */ 168 */
164 if(type&(AT_FIRE|AT_ELECTRICITY) 169 if (type & (AT_FIRE | AT_ELECTRICITY) && op->other_arch && QUERY_FLAG (op, FLAG_IS_LIGHTABLE))
165 &&op->other_arch&&QUERY_FLAG(op, FLAG_IS_LIGHTABLE)) { 170 {
166 const char *arch=op->other_arch->name; 171 const char *arch = op->other_arch->name;
167 172
168 op = decrease_ob_nr (op, 1); 173 op = decrease_ob_nr (op, 1);
174
169 if (op) 175 if (op)
170 fix_stopped_item (op, m, originator); 176 fix_stopped_item (op, m, originator);
177
171 if((op = get_archetype(arch))!=NULL) { 178 if ((op = get_archetype (arch)) != NULL)
179 {
172 if(env) { 180 if (env)
181 {
173 op->x=env->x,op->y=env->y; 182 op->x = env->x, op->y = env->y;
174 insert_ob_in_ob(op,env); 183 insert_ob_in_ob (op, env);
175 if (env->contr) 184 if (env->contr)
176 esrv_send_item(env, op); 185 esrv_send_item (env, op);
177 } else {
178 op->x=x,op->y=y;
179 insert_ob_in_map(op,m,originator,0);
180 }
181 } 186 }
187 else
182 return; 188 {
183 } 189 op->x = x, op->y = y;
184 if(type&AT_CANCELLATION) { /* Cancellation. */
185 cancellation(op);
186 fix_stopped_item (op, m, originator);
187 return;
188 }
189 if(op->nrof>1) {
190 op = decrease_ob_nr(op,rndm(0, op->nrof-1));
191 if (op)
192 fix_stopped_item (op, m, originator); 190 insert_ob_in_map (op, m, originator, 0);
193 } else {
194 if (op->env) {
195 object *tmp= is_player_inv(op->env);
196
197 if (tmp) {
198 esrv_del_item(tmp->contr, op->count);
199 } 191 }
200 } 192 }
201 if ( ! QUERY_FLAG (op, FLAG_REMOVED)) 193
202 remove_ob(op); 194 return;
203 free_object(op); 195 }
196
197 if (type & AT_CANCELLATION)
198 { /* Cancellation. */
199 cancellation (op);
200 fix_stopped_item (op, m, originator);
201 return;
202 }
203
204 if (op->nrof > 1)
204 } 205 {
206 op = decrease_ob_nr (op, rndm (0, op->nrof - 1));
207
208 if (op)
209 fix_stopped_item (op, m, originator);
210 }
211 else
212 {
213 if (op->env)
214 {
215 object *tmp = op->in_player ();
216
217 if (tmp)
218 esrv_del_item (tmp->contr, op->count);
219 }
220
221 op->destroy ();
222 }
223
205 if(type&(AT_FIRE|AT_ELECTRICITY)) { 224 if (type & (AT_FIRE | AT_ELECTRICITY))
206 if(env) { 225 if (env)
226 {
207 op=get_archetype("burnout"); 227 op = get_archetype ("burnout");
208 op->x=env->x,op->y=env->y; 228 op->x = env->x, op->y = env->y;
209 insert_ob_in_ob(op,env); 229 insert_ob_in_ob (op, env);
210 } else { 230 }
231 else
211 replace_insert_ob_in_map("burnout",originator); 232 replace_insert_ob_in_map ("burnout", originator);
212 } 233
213 } 234 return;
235 }
236
237 /* The value of 50 is arbitrary. */
238 if (type & AT_COLD && (op->resist[ATNR_COLD] < 50) && !QUERY_FLAG (op, FLAG_NO_PICK) && (RANDOM () & 2))
239 {
240 object *tmp;
241 archetype *at = archetype::find ("icecube");
242
243 if (at == NULL)
214 return; 244 return;
215 } 245
216 /* The value of 50 is arbitrary. */
217 if(type&AT_COLD &&(op->resist[ATNR_COLD]<50) &&
218 !QUERY_FLAG(op,FLAG_NO_PICK)&&(RANDOM()&2)) {
219 object *tmp;
220 archetype *at = find_archetype("icecube");
221 if (at == NULL)
222 return;
223 op = stop_item (op); 246 op = stop_item (op);
224 if (op == NULL) 247 if (op == NULL)
225 return;
226 if ((tmp = present_arch(at,op->map,op->x,op->y)) == NULL) {
227 tmp = arch_to_object(at);
228 tmp->x=op->x,tmp->y=op->y;
229 /* This was in the old (pre new movement code) -
230 * icecubes have slow_move set to 1 - don't want
231 * that for ones we create.
232 */
233 tmp->move_slow_penalty=0;
234 tmp->move_slow=0;
235 insert_ob_in_map(tmp,op->map,originator,0);
236 }
237 if ( ! QUERY_FLAG (op, FLAG_REMOVED))
238 remove_ob(op);
239 (void) insert_ob_in_ob(op,tmp);
240 return; 248 return;
249
250 if ((tmp = present_arch (at, op->map, op->x, op->y)) == NULL)
251 {
252 tmp = arch_to_object (at);
253 tmp->x = op->x, tmp->y = op->y;
254 /* This was in the old (pre new movement code) -
255 * icecubes have slow_move set to 1 - don't want
256 * that for ones we create.
257 */
258 tmp->move_slow_penalty = 0;
259 tmp->move_slow = 0;
260 insert_ob_in_map (tmp, op->map, originator, 0);
261 }
262
263 if (!QUERY_FLAG (op, FLAG_REMOVED))
264 op->remove ();
265
266 insert_ob_in_ob (op, tmp);
267 return;
241 } 268 }
242} 269}
243 270
244/* Object op is hitting the map. 271/* Object op is hitting the map.
245 * op is going in direction 'dir' 272 * op is going in direction 'dir'
246 * type is the attacktype of the object. 273 * type is the attacktype of the object.
247 * full_hit is set if monster area does not matter. 274 * full_hit is set if monster area does not matter.
248 * returns 1 if it hits something, 0 otherwise. 275 * returns 1 if it hits something, 0 otherwise.
249 */ 276 */
250 277
278int
251int hit_map(object *op, int dir, int type, int full_hit) { 279hit_map (object *op, int dir, int type, int full_hit)
252 object *tmp, *next; 280{
253 mapstruct *map; 281 maptile *map;
254 sint16 x, y; 282 sint16 x, y;
255 int retflag=0; /* added this flag.. will return 1 if it hits a monster */ 283 int retflag = 0; /* added this flag.. will return 1 if it hits a monster */
256 284
257 tag_t op_tag, next_tag=0;
258
259 if (QUERY_FLAG (op, FLAG_FREED)) { 285 if (QUERY_FLAG (op, FLAG_FREED))
286 {
260 LOG (llevError, "BUG: hit_map(): free object\n"); 287 LOG (llevError, "BUG: hit_map(): free object\n");
261 return 0; 288 return 0;
262 } 289 }
263 290
264 if (QUERY_FLAG (op, FLAG_REMOVED) || op->env != NULL) { 291 if (QUERY_FLAG (op, FLAG_REMOVED) || op->env != NULL)
292 {
265 LOG (llevError, "BUG: hit_map(): hitter (arch %s, name %s) not on a map\n", 293 LOG (llevError, "BUG: hit_map(): hitter (arch %s, name %s) not on a map\n", &op->arch->name, &op->name);
266 &op->arch->name, &op->name);
267 return 0; 294 return 0;
268 } 295 }
269 296
270 if ( ! op->map) { 297 if (!op->map)
298 {
271 LOG (llevError,"BUG: hit_map(): %s has no map\n", &op->name); 299 LOG (llevError, "BUG: hit_map(): %s has no map\n", &op->name);
272 return 0; 300 return 0;
273 } 301 }
274 302
275 if (op->head) op=op->head; 303 if (op->head)
304 op = op->head;
276 305
277 op_tag = op->count;
278
279 map = op->map; 306 map = op->map;
280 x = op->x + freearr_x[dir]; 307 x = op->x + freearr_x[dir];
281 y = op->y + freearr_y[dir]; 308 y = op->y + freearr_y[dir];
282 309
283 int mflags = get_map_flags(map, &map, x, y, &x, &y); 310 if (!xy_normalise (map, x, y))
311 return 0;
312
284 // elmex: a safe map tile can't be hit! 313 // elmex: a safe map tile can't be hit!
285 // this should prevent most harmful effects on items and players there. 314 // this should prevent most harmful effects on items and players there.
286 if ((mflags & P_OUT_OF_MAP) || (mflags & P_SAFE)) 315 mapspace &ms = map->at (x, y);
316
317 if (ms.flags () & P_SAFE)
287 return 0; 318 return 0;
288 319
289 /* peterm: a few special cases for special attacktypes --counterspell 320 /* peterm: a few special cases for special attacktypes --counterspell
290 * must be out here because it strikes things which are not alive 321 * must be out here because it strikes things which are not alive
291 */ 322 */
292 323 if (type & (AT_COUNTERSPELL | AT_CHAOS))
324 {
293 if (type & AT_COUNTERSPELL) { 325 if (type & AT_COUNTERSPELL)
326 {
294 counterspell(op,dir); /* see spell_effect.c */ 327 counterspell (op, dir); /* see spell_effect.c */
295 328
296 /* If the only attacktype is counterspell or magic, don't need 329 /* If the only attacktype is counterspell or magic, don't need
297 * to do any further processing. 330 * to do any further processing.
298 */ 331 */
299 if(!(type & ~(AT_COUNTERSPELL|AT_MAGIC))){ 332 if (!(type & ~(AT_COUNTERSPELL | AT_MAGIC)))
300 return 0; 333 return 0;
301 } 334
302 type &= ~AT_COUNTERSPELL; 335 type &= ~AT_COUNTERSPELL;
303 } 336 }
304 337
305 if(type & AT_CHAOS){ 338 if (type & AT_CHAOS)
339 {
306 shuffle_attack(op,1); /*1 flag tells it to change the face */ 340 shuffle_attack (op, 1); /* flag tells it to change the face */
307 update_object(op,UP_OBJ_FACE); 341 update_object (op, UP_OBJ_FACE);
308 type &= ~AT_CHAOS; 342 type &= ~AT_CHAOS;
343 }
309 } 344 }
310 345
311 next = get_map_ob (map, x, y);
312 if (next)
313 next_tag = next->count;
314
315 while (next) {
316 if (was_destroyed (next, next_tag)) {
317 /* There may still be objects that were above 'next', but there is no 346 /* There may still be objects that were above 'next', but there is no
318 * simple way to find out short of copying all object references and 347 * simple way to find out short of copying all object references and
319 * tags into a temporary array before we start processing the first 348 * tags into a temporary array before we start processing the first
320 * object. That's why we just abort. 349 * object. That's why we just abort on destroy.
321 * 350 *
322 * This happens whenever attack spells (like fire) hit a pile 351 * This happens whenever attack spells (like fire) hit a pile
323 * of objects. This is not a bug - nor an error. The errormessage 352 * of objects. This is not a bug - nor an error.
324 * below was spamming the logs for absolutely no reason. 353 */
354 for (object *next = ms.bot; next && !next->destroyed (); )
355 {
356 object *tmp = next;
357 next = tmp->above;
358
359 /* Something could have happened to 'tmp' while 'tmp->below' was processed.
360 * For example, 'tmp' was put in an icecube.
361 * This is one of the few cases where on_same_map should not be used.
325 */ 362 */
326 /* LOG (llevDebug, "hit_map(): next object destroyed\n"); */ 363 if (tmp->map != map || tmp->x != x || tmp->y != y)
364 continue;
365
366 if (QUERY_FLAG (tmp, FLAG_ALIVE))
367 {
368 hit_player (tmp, op->stats.dam, op, type, full_hit);
369 retflag |= 1;
370
371 if (op->destroyed ())
327 break; 372 break;
328 } 373 }
329 tmp = next; 374 /* Here we are potentially destroying an object. If the object has
330 next = tmp->above; 375 * NO_PASS set, it is also immune - you can't destroy walls. Note
331 if (next) 376 * that weak walls have is_alive set, which prevent objects from
332 next_tag = next->count; 377 * passing over/through them. We don't care what type of movement
378 * the wall blocks - if it blocks any type of movement, can't be
379 * destroyed right now.
380 */
381 else if ((tmp->material || tmp->materialname) && op->stats.dam > 0 && !tmp->move_block)
382 {
383 save_throw_object (tmp, type, op);
333 384
334 if (QUERY_FLAG (tmp, FLAG_FREED)) { 385 if (op->destroyed ())
335 LOG (llevError, "BUG: hit_map(): found freed object\n");
336 break; 386 break;
337 } 387 }
338
339 /* Something could have happened to 'tmp' while 'tmp->below' was processed.
340 * For example, 'tmp' was put in an icecube.
341 * This is one of the few cases where on_same_map should not be used.
342 */
343 if (tmp->map != map || tmp->x != x || tmp->y != y)
344 continue;
345
346 if (QUERY_FLAG (tmp, FLAG_ALIVE)) {
347 hit_player(tmp,op->stats.dam,op,type,full_hit);
348 retflag |=1;
349 if (was_destroyed (op, op_tag))
350 break;
351 }
352 /* Here we are potentially destroying an object. If the object has
353 * NO_PASS set, it is also immune - you can't destroy walls. Note
354 * that weak walls have is_alive set, which prevent objects from
355 * passing over/through them. We don't care what type of movement
356 * the wall blocks - if it blocks any type of movement, can't be
357 * destroyed right now.
358 */
359 else if ((tmp->material || tmp->materialname) && op->stats.dam > 0 &&
360 !tmp->move_block) {
361 save_throw_object(tmp,type,op);
362 if (was_destroyed (op, op_tag))
363 break;
364 }
365 } 388 }
389
366 return 0; 390 return 0;
367} 391}
368 392
393void
369void attack_message(int dam, int type, object *op, object *hitter) { 394attack_message (int dam, int type, object *op, object *hitter)
395{
370 char buf[MAX_BUF], buf1[MAX_BUF], buf2[MAX_BUF]; 396 char buf[MAX_BUF], buf1[MAX_BUF], buf2[MAX_BUF];
371 int i, found=0; 397 int i, found = 0;
372 mapstruct *map; 398 maptile *map;
373 object *next, *tmp; 399 object *next, *tmp;
374 400
375 /* put in a few special messages for some of the common attacktypes 401 /* put in a few special messages for some of the common attacktypes
376 * a player might have. For example, fire, electric, cold, etc 402 * a player might have. For example, fire, electric, cold, etc
377 * [garbled 20010919] 403 * [garbled 20010919]
378 */ 404 */
379 405
380 if (dam == 9998 && op->type == DOOR) { 406 if (dam == 9998 && op->type == DOOR)
407 {
381 sprintf(buf1, "unlock %s", &op->name); 408 sprintf (buf1, "unlock %s", &op->name);
382 sprintf(buf2, " unlocks"); 409 sprintf (buf2, " unlocks");
383 found++; 410 found++;
411 }
412 if (dam < 0)
384 } 413 {
385 if(dam<0) {
386 sprintf(buf1, "hit %s", &op->name); 414 sprintf (buf1, "hit %s", &op->name);
387 sprintf(buf2, " hits"); 415 sprintf (buf2, " hits");
388 found++; 416 found++;
417 }
389 } else if(dam==0) { 418 else if (dam == 0)
419 {
390 sprintf(buf1, "missed %s", &op->name); 420 sprintf (buf1, "missed %s", &op->name);
391 sprintf(buf2, " misses"); 421 sprintf (buf2, " misses");
392 found++; 422 found++;
423 }
393 } else if ((hitter->type == DISEASE || hitter->type == SYMPTOM || 424 else if ((hitter->type == DISEASE || hitter->type == SYMPTOM ||
394 hitter->type == POISONING || 425 hitter->type == POISONING || (type & AT_POISON && op->is_alive ())) && !found)
395 (type & AT_POISON && IS_LIVE(op))) && !found) { 426 {
396 for (i=0; i < MAXATTACKMESS && attack_mess[ATM_SUFFER][i].level != -1; 427 for (i = 0; i < MAXATTACKMESS && attack_mess[ATM_SUFFER][i].level != -1; i++)
397 i++) 428 if (dam < attack_mess[ATM_SUFFER][i].level || attack_mess[ATM_SUFFER][i + 1].level == -1)
398 if (dam < attack_mess[ATM_SUFFER][i].level 429 {
399 || attack_mess[ATM_SUFFER][i+1].level == -1) { 430 sprintf (buf1, "%s %s%s", attack_mess[ATM_SUFFER][i].buf1, &op->name, attack_mess[ATM_SUFFER][i].buf2);
400 sprintf(buf1, "%s %s%s", attack_mess[ATM_SUFFER][i].buf1,
401 &op->name, attack_mess[ATM_SUFFER][i].buf2);
402 strcpy (buf2, attack_mess[ATM_SUFFER][i].buf3); 431 strcpy (buf2, attack_mess[ATM_SUFFER][i].buf3);
432 found++;
433 break;
434 }
435 }
436 else if (op->type == DOOR && !found)
437 {
438 for (i = 0; i < MAXATTACKMESS && attack_mess[ATM_DOOR][i].level != -1; i++)
439 if (dam < attack_mess[ATM_DOOR][i].level || attack_mess[ATM_DOOR][i + 1].level == -1)
440 {
441 sprintf (buf1, "%s %s%s", attack_mess[ATM_DOOR][i].buf1, &op->name, attack_mess[ATM_DOOR][i].buf2);
442 strcpy (buf2, attack_mess[ATM_DOOR][i].buf3);
443 found++;
444 break;
445 }
446 }
447 else if (hitter->type == PLAYER && op->is_alive ())
448 {
449 if (USING_SKILL (hitter, SK_KARATE))
450 {
451 for (i = 0; i < MAXATTACKMESS && attack_mess[ATM_KARATE][i].level != -1; i++)
452 if (dam < attack_mess[ATM_KARATE][i].level || attack_mess[ATM_KARATE][i + 1].level == -1)
453 {
454 sprintf (buf1, "%s %s%s", attack_mess[ATM_KARATE][i].buf1, &op->name, attack_mess[ATM_KARATE][i].buf2);
455 strcpy (buf2, attack_mess[ATM_KARATE][i].buf3);
403 found++; 456 found++;
404 break; 457 break;
405 } 458 }
406 } else if (op->type == DOOR && !found) { 459 }
460 else if (USING_SKILL (hitter, SK_CLAWING))
461 {
407 for (i=0; i < MAXATTACKMESS && attack_mess[ATM_DOOR][i].level != -1; 462 for (i = 0; i < MAXATTACKMESS && attack_mess[ATM_CLAW][i].level != -1; i++)
463 if (dam < attack_mess[ATM_CLAW][i].level || attack_mess[ATM_CLAW][i + 1].level == -1)
408 i++) 464 {
409 if (dam < attack_mess[ATM_DOOR][i].level 465 sprintf (buf1, "%s %s%s", attack_mess[ATM_CLAW][i].buf1, &op->name, attack_mess[ATM_CLAW][i].buf2);
410 || attack_mess[ATM_DOOR][i+1].level == -1) {
411 sprintf(buf1, "%s %s%s", attack_mess[ATM_DOOR][i].buf1,
412 &op->name, attack_mess[ATM_DOOR][i].buf2);
413 strcpy (buf2, attack_mess[ATM_DOOR][i].buf3); 466 strcpy (buf2, attack_mess[ATM_CLAW][i].buf3);
414 found++; 467 found++;
415 break; 468 break;
416 }
417 } else if (hitter->type == PLAYER && IS_LIVE(op)) {
418 if (USING_SKILL(hitter, SK_KARATE)) {
419 for (i=0; i < MAXATTACKMESS && attack_mess[ATM_KARATE][i].level != -1;
420 i++)
421 if (dam < attack_mess[ATM_KARATE][i].level
422 || attack_mess[ATM_KARATE][i+1].level == -1) {
423 sprintf(buf1, "%s %s%s", attack_mess[ATM_KARATE][i].buf1,
424 &op->name, attack_mess[ATM_KARATE][i].buf2);
425 strcpy (buf2, attack_mess[ATM_KARATE][i].buf3);
426 found++;
427 break;
428 } 469 }
429 } else if (USING_SKILL(hitter, SK_CLAWING)) {
430 for (i=0; i < MAXATTACKMESS && attack_mess[ATM_CLAW][i].level != -1;
431 i++)
432 if (dam < attack_mess[ATM_CLAW][i].level
433 || attack_mess[ATM_CLAW][i+1].level == -1) {
434 sprintf(buf1, "%s %s%s", attack_mess[ATM_CLAW][i].buf1,
435 &op->name, attack_mess[ATM_CLAW][i].buf2);
436 strcpy (buf2, attack_mess[ATM_CLAW][i].buf3);
437 found++;
438 break;
439 } 470 }
440 } else if (USING_SKILL(hitter, SK_PUNCHING)) { 471 else if (USING_SKILL (hitter, SK_PUNCHING))
472 {
441 for (i=0; i < MAXATTACKMESS && attack_mess[ATM_PUNCH][i].level != -1; 473 for (i = 0; i < MAXATTACKMESS && attack_mess[ATM_PUNCH][i].level != -1; i++)
474 if (dam < attack_mess[ATM_PUNCH][i].level || attack_mess[ATM_PUNCH][i + 1].level == -1)
442 i++) 475 {
443 if (dam < attack_mess[ATM_PUNCH][i].level
444 || attack_mess[ATM_PUNCH][i+1].level == -1) {
445 sprintf(buf1, "%s %s%s", attack_mess[ATM_PUNCH][i].buf1, 476 sprintf (buf1, "%s %s%s", attack_mess[ATM_PUNCH][i].buf1, &op->name, attack_mess[ATM_PUNCH][i].buf2);
446 &op->name, attack_mess[ATM_PUNCH][i].buf2);
447 strcpy (buf2, attack_mess[ATM_PUNCH][i].buf3); 477 strcpy (buf2, attack_mess[ATM_PUNCH][i].buf3);
448 found++;
449 break;
450 }
451 }
452 }
453 if (found) {
454 /* done */
455 } else if (IS_ARROW(hitter) && (type == AT_PHYSICAL || type == AT_MAGIC)) {
456 sprintf(buf1, "hit"); /* just in case */
457 for (i=0; i < MAXATTACKMESS; i++)
458 if (dam < attack_mess[ATM_ARROW][i].level
459 || attack_mess[ATM_ARROW][i+1].level == -1) {
460 strcpy (buf2, attack_mess[ATM_ARROW][i].buf3);
461 found++; 478 found++;
462 break; 479 break;
480 }
481 }
482 }
483
484 if (found)
485 {
486 /* done */
487 }
488 else if (hitter->is_arrow () && (type == AT_PHYSICAL || type == AT_MAGIC))
489 {
490 sprintf (buf1, "hit"); /* just in case */
491 for (i = 0; i < MAXATTACKMESS; i++)
492 if (dam < attack_mess[ATM_ARROW][i].level || attack_mess[ATM_ARROW][i + 1].level == -1)
493 {
494 strcpy (buf2, attack_mess[ATM_ARROW][i].buf3);
495 found++;
496 break;
497 }
498 }
499 else if (type & AT_DRAIN && op->is_alive ())
500 {
501 /* drain is first, because some items have multiple attypes */
502 for (i = 0; i < MAXATTACKMESS && attack_mess[ATM_DRAIN][i].level != -1; i++)
503 if (dam < attack_mess[ATM_DRAIN][i].level || attack_mess[ATM_DRAIN][i + 1].level == -1)
504 {
505 sprintf (buf1, "%s %s%s", attack_mess[ATM_DRAIN][i].buf1, &op->name, attack_mess[ATM_DRAIN][i].buf2);
506 strcpy (buf2, attack_mess[ATM_DRAIN][i].buf3);
507 found++;
508 break;
509 }
510 }
511 else if (type & AT_ELECTRICITY && op->is_alive ())
512 {
513 for (i = 0; i < MAXATTACKMESS && attack_mess[ATM_ELEC][i].level != -1; i++)
514 if (dam < attack_mess[ATM_ELEC][i].level || attack_mess[ATM_ELEC][i + 1].level == -1)
515 {
516 sprintf (buf1, "%s %s%s", attack_mess[ATM_ELEC][i].buf1, &op->name, attack_mess[ATM_ELEC][i].buf2);
517 strcpy (buf2, attack_mess[ATM_ELEC][i].buf3);
518 found++;
519 break;
520 }
521 }
522 else if (type & AT_COLD && op->is_alive ())
523 {
524 for (i = 0; i < MAXATTACKMESS && attack_mess[ATM_COLD][i].level != -1; i++)
525 if (dam < attack_mess[ATM_COLD][i].level || attack_mess[ATM_COLD][i + 1].level == -1)
526 {
527 sprintf (buf1, "%s %s%s", attack_mess[ATM_COLD][i].buf1, &op->name, attack_mess[ATM_COLD][i].buf2);
528 strcpy (buf2, attack_mess[ATM_COLD][i].buf3);
529 found++;
530 break;
531 }
532 }
533 else if (type & AT_FIRE)
534 {
535 for (i = 0; i < MAXATTACKMESS && attack_mess[ATM_FIRE][i].level != -1; i++)
536 if (dam < attack_mess[ATM_FIRE][i].level || attack_mess[ATM_FIRE][i + 1].level == -1)
537 {
538 sprintf (buf1, "%s %s%s", attack_mess[ATM_FIRE][i].buf1, &op->name, attack_mess[ATM_FIRE][i].buf2);
539 strcpy (buf2, attack_mess[ATM_FIRE][i].buf3);
540 found++;
541 break;
542 }
543 }
544 else if (hitter->current_weapon != NULL)
545 {
546 int mtype;
547
548 switch (hitter->current_weapon->weapontype)
549 {
550 case WEAP_HIT:
551 mtype = ATM_BASIC;
552 break;
553 case WEAP_SLASH:
554 mtype = ATM_SLASH;
555 break;
556 case WEAP_PIERCE:
557 mtype = ATM_PIERCE;
558 break;
559 case WEAP_CLEAVE:
560 mtype = ATM_CLEAVE;
561 break;
562 case WEAP_SLICE:
563 mtype = ATM_SLICE;
564 break;
565 case WEAP_STAB:
566 mtype = ATM_STAB;
567 break;
568 case WEAP_WHIP:
569 mtype = ATM_WHIP;
570 break;
571 case WEAP_CRUSH:
572 mtype = ATM_CRUSH;
573 break;
574 case WEAP_BLUD:
575 mtype = ATM_BLUD;
576 break;
577 default:
578 mtype = ATM_BASIC;
579 break;
580 }
581 for (i = 0; i < MAXATTACKMESS && attack_mess[mtype][i].level != -1; i++)
582 if (dam < attack_mess[mtype][i].level || attack_mess[mtype][i + 1].level == -1)
583 {
584 sprintf (buf1, "%s %s%s", attack_mess[mtype][i].buf1, &op->name, attack_mess[mtype][i].buf2);
585 strcpy (buf2, attack_mess[mtype][i].buf3);
586 found++;
587 break;
588 }
589 }
590 else
591 {
592 for (i = 0; i < MAXATTACKMESS && attack_mess[ATM_BASIC][i].level != -1; i++)
593 if (dam < attack_mess[ATM_BASIC][i].level || attack_mess[ATM_BASIC][i + 1].level == -1)
594 {
595 sprintf (buf1, "%s %s%s", attack_mess[ATM_BASIC][i].buf1, &op->name, attack_mess[ATM_BASIC][i].buf2);
596 strcpy (buf2, attack_mess[ATM_BASIC][i].buf3);
597 found++;
598 break;
599 }
600 }
601
602 if (!found)
603 {
604 strcpy (buf1, "hit");
605 strcpy (buf2, " hits");
606 }
607
608 /* bail out if a monster is casting spells */
609 if (!(hitter->type == PLAYER || (hitter->owner != NULL && hitter->owner->type == PLAYER)))
610 return;
611
612 /* scale down magic considerably. */
613 if (type & AT_MAGIC && rndm (0, 5))
614 return;
615
616 /* Did a player hurt another player? Inform both! */
617 if (op->type == PLAYER && (hitter->owner == NULL ? hitter->type : hitter->owner->type) == PLAYER)
618 {
619 if (hitter->owner != NULL)
620 sprintf (buf, "%s's %s%s you.", &hitter->owner->name, &hitter->name, buf2);
621 else
622 {
623 sprintf (buf, "%s%s you.", &hitter->name, buf2);
624 if (dam != 0)
625 {
626 if (dam < 10)
627 play_sound_player_only (op->contr, SOUND_PLAYER_IS_HIT1, 0, 0);
628 else if (dam < 20)
629 play_sound_player_only (op->contr, SOUND_PLAYER_IS_HIT2, 0, 0);
630 else
631 play_sound_player_only (op->contr, SOUND_PLAYER_IS_HIT3, 0, 0);
463 } 632 }
464 } else if (type & AT_DRAIN && IS_LIVE(op)) {
465 /* drain is first, because some items have multiple attypes */
466 for (i=0; i < MAXATTACKMESS && attack_mess[ATM_DRAIN][i].level != -1;
467 i++)
468 if (dam < attack_mess[ATM_DRAIN][i].level
469 || attack_mess[ATM_DRAIN][i+1].level == -1) {
470 sprintf(buf1, "%s %s%s", attack_mess[ATM_DRAIN][i].buf1,
471 &op->name, attack_mess[ATM_DRAIN][i].buf2);
472 strcpy (buf2, attack_mess[ATM_DRAIN][i].buf3);
473 found++;
474 break;
475 } 633 }
476 } else if (type & AT_ELECTRICITY && IS_LIVE(op)) {
477 for (i=0; i < MAXATTACKMESS && attack_mess[ATM_ELEC][i].level != -1;
478 i++)
479 if (dam < attack_mess[ATM_ELEC][i].level
480 || attack_mess[ATM_ELEC][i+1].level == -1) {
481 sprintf(buf1, "%s %s%s", attack_mess[ATM_ELEC][i].buf1,
482 &op->name, attack_mess[ATM_ELEC][i].buf2);
483 strcpy (buf2, attack_mess[ATM_ELEC][i].buf3);
484 found++;
485 break;
486 }
487 } else if (type & AT_COLD && IS_LIVE(op)) {
488 for (i=0; i < MAXATTACKMESS && attack_mess[ATM_COLD][i].level != -1;
489 i++)
490 if (dam < attack_mess[ATM_COLD][i].level
491 || attack_mess[ATM_COLD][i+1].level == -1) {
492 sprintf(buf1, "%s %s%s", attack_mess[ATM_COLD][i].buf1,
493 &op->name, attack_mess[ATM_COLD][i].buf2);
494 strcpy (buf2, attack_mess[ATM_COLD][i].buf3);
495 found++;
496 break;
497 }
498 } else if (type & AT_FIRE) {
499 for (i=0; i < MAXATTACKMESS && attack_mess[ATM_FIRE][i].level != -1;
500 i++)
501 if (dam < attack_mess[ATM_FIRE][i].level
502 || attack_mess[ATM_FIRE][i+1].level == -1) {
503 sprintf(buf1, "%s %s%s", attack_mess[ATM_FIRE][i].buf1,
504 &op->name, attack_mess[ATM_FIRE][i].buf2);
505 strcpy (buf2, attack_mess[ATM_FIRE][i].buf3);
506 found++;
507 break;
508 }
509 } else if (hitter->current_weapon != NULL) {
510 int mtype;
511 switch (hitter->current_weapon->weapontype) {
512 case WEAP_HIT: mtype = ATM_BASIC; break;
513 case WEAP_SLASH: mtype = ATM_SLASH; break;
514 case WEAP_PIERCE: mtype = ATM_PIERCE; break;
515 case WEAP_CLEAVE: mtype = ATM_CLEAVE; break;
516 case WEAP_SLICE: mtype = ATM_SLICE; break;
517 case WEAP_STAB: mtype = ATM_STAB; break;
518 case WEAP_WHIP: mtype = ATM_WHIP; break;
519 case WEAP_CRUSH: mtype = ATM_CRUSH; break;
520 case WEAP_BLUD: mtype = ATM_BLUD; break;
521 default: mtype = ATM_BASIC; break;
522 }
523 for (i=0; i < MAXATTACKMESS && attack_mess[mtype][i].level != -1;
524 i++)
525 if (dam < attack_mess[mtype][i].level
526 || attack_mess[mtype][i+1].level == -1) {
527 sprintf(buf1, "%s %s%s", attack_mess[mtype][i].buf1,
528 &op->name, attack_mess[mtype][i].buf2);
529 strcpy (buf2, attack_mess[mtype][i].buf3);
530 found++;
531 break;
532 }
533 } else {
534 for (i=0; i < MAXATTACKMESS && attack_mess[ATM_BASIC][i].level != -1;
535 i++)
536 if (dam < attack_mess[ATM_BASIC][i].level
537 || attack_mess[ATM_BASIC][i+1].level == -1) {
538 sprintf(buf1, "%s %s%s", attack_mess[ATM_BASIC][i].buf1,
539 &op->name, attack_mess[ATM_BASIC][i].buf2);
540 strcpy (buf2, attack_mess[ATM_BASIC][i].buf3);
541 found++;
542 break;
543 }
544 }
545
546 if (!found) {
547 strcpy (buf1, "hit");
548 strcpy (buf2, " hits");
549 }
550
551 /* bail out if a monster is casting spells */
552 if (!(hitter->type == PLAYER ||
553 (get_owner(hitter) != NULL && hitter->owner->type == PLAYER)))
554 return;
555
556 /* scale down magic considerably. */
557 if (type & AT_MAGIC && rndm(0, 5))
558 return;
559
560 /* Did a player hurt another player? Inform both! */
561 if(op->type==PLAYER &&
562 (get_owner(hitter)==NULL?hitter->type:hitter->owner->type)==PLAYER) {
563 if(get_owner(hitter)!=NULL)
564 sprintf(buf,"%s's %s%s you.",
565 &hitter->owner->name, &hitter->name, buf2);
566 else {
567 sprintf(buf,"%s%s you.", &hitter->name, buf2);
568 if (dam != 0) {
569 if (dam < 10)
570 play_sound_player_only(op->contr, SOUND_PLAYER_IS_HIT1,0,0);
571 else if (dam < 20)
572 play_sound_player_only(op->contr, SOUND_PLAYER_IS_HIT2,0,0);
573 else
574 play_sound_player_only(op->contr, SOUND_PLAYER_IS_HIT3,0,0);
575 }
576 }
577 new_draw_info(NDI_BLACK, 0,op,buf); 634 new_draw_info (NDI_BLACK, 0, op, buf);
578 } /* end of player hitting player */ 635 } /* end of player hitting player */
579 636
580 if(hitter->type==PLAYER) { 637 if (hitter->type == PLAYER)
638 {
581 sprintf(buf,"You %s.",buf1); 639 sprintf (buf, "You %s.", buf1);
582 if (dam != 0) { 640 if (dam != 0)
641 {
583 if (dam < 10) 642 if (dam < 10)
584 play_sound_player_only(hitter->contr, SOUND_PLAYER_HITS1,0,0); 643 play_sound_player_only (hitter->contr, SOUND_PLAYER_HITS1, 0, 0);
585 else if (dam < 20) 644 else if (dam < 20)
586 play_sound_player_only(hitter->contr, SOUND_PLAYER_HITS2,0,0); 645 play_sound_player_only (hitter->contr, SOUND_PLAYER_HITS2, 0, 0);
587 else 646 else
588 play_sound_player_only(hitter->contr, SOUND_PLAYER_HITS3,0,0); 647 play_sound_player_only (hitter->contr, SOUND_PLAYER_HITS3, 0, 0);
589 } 648 }
590 new_draw_info(NDI_BLACK, 0, hitter, buf); 649 new_draw_info (NDI_BLACK, 0, hitter, buf);
650 }
591 } else if(get_owner(hitter)!=NULL&&hitter->owner->type==PLAYER) { 651 else if (hitter->owner != NULL && hitter->owner->type == PLAYER)
652 {
592 /* look for stacked spells and start reducing the message chances */ 653 /* look for stacked spells and start reducing the message chances */
593 if (hitter->type == SPELL_EFFECT && 654 if (hitter->type == SPELL_EFFECT && (hitter->subtype == SP_EXPLOSION || hitter->subtype == SP_BULLET || hitter->subtype == SP_CONE))
594 (hitter->subtype == SP_EXPLOSION || 655 {
595 hitter->subtype == SP_BULLET ||
596 hitter->subtype == SP_CONE)) {
597 i=4; 656 i = 4;
598 map = hitter->map; 657 map = hitter->map;
599 if (out_of_map(map, hitter->x, hitter->y)) 658 if (out_of_map (map, hitter->x, hitter->y))
600 return;
601 next = get_map_ob(map, hitter->x, hitter->y);
602 if (next)
603 while(next) {
604 if (next->type == SPELL_EFFECT &&
605 (next->subtype == SP_EXPLOSION || next->subtype==SP_BULLET ||
606 next->subtype == SP_CONE))
607 i*=3;
608 tmp = next;
609 next = tmp->above;
610 }
611 if (i < 0)
612 return;
613 if (rndm(0, i) != 0)
614 return;
615 } else if (rndm(0, 5) != 0)
616 return; 659 return;
660 next = GET_MAP_OB (map, hitter->x, hitter->y);
661 if (next)
662 while (next)
663 {
664 if (next->type == SPELL_EFFECT && (next->subtype == SP_EXPLOSION || next->subtype == SP_BULLET || next->subtype == SP_CONE))
665 i *= 3;
666 tmp = next;
667 next = tmp->above;
668 }
669 if (i < 0)
670 return;
671 if (rndm (0, i) != 0)
672 return;
673 }
674 else if (rndm (0, 5) != 0)
675 return;
617 sprintf(buf,"Your %s%s %s.", &hitter->name, buf2, &op->name); 676 sprintf (buf, "Your %s%s %s.", &hitter->name, buf2, &op->name);
618 play_sound_map(op->map, op->x, op->y, SOUND_PLAYER_HITS4); 677 play_sound_map (op->map, op->x, op->y, SOUND_PLAYER_HITS4);
619 new_draw_info(NDI_BLACK, 0, hitter->owner, buf); 678 new_draw_info (NDI_BLACK, 0, hitter->owner, buf);
620 } 679 }
621} 680}
622 681
623 682
683static int
624static int get_attack_mode (object **target, object **hitter, 684get_attack_mode (object **target, object **hitter, int *simple_attack)
625 int *simple_attack)
626{ 685{
627 if (QUERY_FLAG (*target, FLAG_FREED) || QUERY_FLAG (*hitter, FLAG_FREED)) { 686 if (QUERY_FLAG (*target, FLAG_FREED) || QUERY_FLAG (*hitter, FLAG_FREED))
687 {
628 LOG (llevError, "BUG: get_attack_mode(): freed object\n"); 688 LOG (llevError, "BUG: get_attack_mode(): freed object\n");
629 return 1; 689 return 1;
630 } 690 }
631 if ((*target)->head) 691 if ((*target)->head)
632 *target = (*target)->head; 692 *target = (*target)->head;
633 if ((*hitter)->head) 693 if ((*hitter)->head)
634 *hitter = (*hitter)->head; 694 *hitter = (*hitter)->head;
635 if ((*hitter)->env != NULL || (*target)->env != NULL) { 695 if ((*hitter)->env != NULL || (*target)->env != NULL)
696 {
636 *simple_attack = 1; 697 *simple_attack = 1;
637 return 0; 698 return 0;
638 } 699 }
639 if (QUERY_FLAG (*target, FLAG_REMOVED) 700 if (QUERY_FLAG (*target, FLAG_REMOVED)
640 || QUERY_FLAG (*hitter, FLAG_REMOVED)
641 || (*hitter)->map == NULL || !on_same_map((*hitter), (*target))) 701 || QUERY_FLAG (*hitter, FLAG_REMOVED) || (*hitter)->map == NULL || !on_same_map ((*hitter), (*target)))
642 { 702 {
643 LOG (llevError, "BUG: hitter (arch %s, name %s) with no relation to " 703 LOG (llevError, "BUG: hitter (arch %s, name %s) with no relation to " "target\n", &(*hitter)->arch->name, &(*hitter)->name);
644 "target\n", &(*hitter)->arch->name, &(*hitter)->name);
645 return 1; 704 return 1;
646 } 705 }
647 *simple_attack = 0; 706 *simple_attack = 0;
648 return 0; 707 return 0;
649} 708}
650 709
710static int
651static int abort_attack (object *target, object *hitter, int simple_attack) 711abort_attack (object *target, object *hitter, int simple_attack)
652{ 712{
713
653/* Check if target and hitter are still in a relation similar to the one 714/* Check if target and hitter are still in a relation similar to the one
654 * determined by get_attack_mode(). Returns true if the relation has changed. 715 * determined by get_attack_mode(). Returns true if the relation has changed.
655 */ 716 */
656 int new_mode; 717 int new_mode;
657 718
658 if (hitter->env == target || target->env == hitter) 719 if (hitter->env == target || target->env == hitter)
659 new_mode = 1; 720 new_mode = 1;
660 else if (QUERY_FLAG (hitter, FLAG_REMOVED) 721 else if (QUERY_FLAG (hitter, FLAG_REMOVED) || QUERY_FLAG (target, FLAG_REMOVED) || hitter->map == NULL || !on_same_map (hitter, target))
661 || QUERY_FLAG (target, FLAG_REMOVED)
662 || hitter->map == NULL || !on_same_map(hitter, target))
663 return 1; 722 return 1;
664 else 723 else
665 new_mode = 0; 724 new_mode = 0;
666 return new_mode != simple_attack; 725 return new_mode != simple_attack;
667} 726}
668 727
669static void thrown_item_effect (object *, object *); 728static void thrown_item_effect (object *, object *);
670 729
730static int
671static int attack_ob_simple (object *op, object *hitter, int base_dam, 731attack_ob_simple (object *op, object *hitter, int base_dam, int base_wc)
672 int base_wc)
673{ 732{
674 int simple_attack, roll, dam=0; 733 int simple_attack, roll, dam = 0;
675 uint32 type; 734 uint32 type;
676 shstr op_name; 735 shstr op_name;
677 tag_t op_tag, hitter_tag;
678 736
679 if (get_attack_mode (&op, &hitter, &simple_attack)) 737 if (get_attack_mode (&op, &hitter, &simple_attack))
738 goto error;
739
740 if (hitter->current_weapon)
741 if (INVOKE_OBJECT (WEAPON_ATTACK, hitter->current_weapon, ARG_OBJECT (hitter), ARG_OBJECT (op)))
742 return RESULT_INT (0);
743
744 if (INVOKE_OBJECT (ATTACK, op, ARG_OBJECT (hitter)))
745 return RESULT_INT (0);
746
747 /*
748 * A little check to make it more difficult to dance forward and back
749 * to avoid ever being hit by monsters.
750 */
751 if (!simple_attack && QUERY_FLAG (op, FLAG_MONSTER) && op->speed_left > -(FABS (op->speed)) * 0.3)
752 {
753 /* Decrease speed BEFORE calling process_object. Otherwise, an
754 * infinite loop occurs, with process_object calling move_monster,
755 * which then gets here again. By decreasing the speed before
756 * we call process_object, the 'if' statement above will fail.
757 */
758 op->speed_left--;
759 process_object (op);
760
761 if (op->destroyed () || hitter->destroyed () || abort_attack (op, hitter, simple_attack))
680 goto error; 762 goto error;
681
682 if (hitter->current_weapon)
683 if (INVOKE_OBJECT (WEAPON_ATTACK, hitter->current_weapon, ARG_OBJECT (hitter), ARG_OBJECT (op)))
684 return RESULT_INT (0);
685
686 if (INVOKE_OBJECT (ATTACK, op, ARG_OBJECT (hitter)))
687 return RESULT_INT (0);
688
689 op_tag = op->count;
690 hitter_tag = hitter->count;
691
692 /*
693 * A little check to make it more difficult to dance forward and back
694 * to avoid ever being hit by monsters.
695 */
696 if ( ! simple_attack && QUERY_FLAG (op, FLAG_MONSTER)
697 && op->speed_left > -(FABS(op->speed))*0.3)
698 { 763 }
699 /* Decrease speed BEFORE calling process_object. Otherwise, an
700 * infinite loop occurs, with process_object calling move_monster,
701 * which then gets here again. By decreasing the speed before
702 * we call process_object, the 'if' statement above will fail.
703 */
704 op->speed_left--;
705 process_object(op);
706 if (was_destroyed (op, op_tag) || was_destroyed (hitter, hitter_tag)
707 || abort_attack (op, hitter, simple_attack))
708 goto error;
709 }
710 764
711 op_name = op->name; 765 op_name = op->name;
712 766
713 roll=random_roll(1, 20, hitter, PREFER_HIGH); 767 roll = random_roll (1, 20, hitter, PREFER_HIGH);
714 768
715 /* Adjust roll for various situations. */ 769 /* Adjust roll for various situations. */
716 if ( ! simple_attack) 770 if (!simple_attack)
717 roll += adj_attackroll(hitter,op); 771 roll += adj_attackroll (hitter, op);
718 772
719 /* See if we hit the creature */ 773 /* See if we hit the creature */
720 if(roll==20 || op->stats.ac>=base_wc-roll) { 774 if (roll == 20 || op->stats.ac >= base_wc - roll)
775 {
721 int hitdam = base_dam; 776 int hitdam = base_dam;
777
722 if (settings.casting_time == TRUE) { 778 if (settings.casting_time == TRUE)
779 {
723 if ((hitter->type == PLAYER)&&(hitter->casting_time > -1)){ 780 if ((hitter->type == PLAYER) && (hitter->casting_time > -1))
781 {
724 hitter->casting_time = -1; 782 hitter->casting_time = -1;
725 new_draw_info(NDI_UNIQUE, 0,hitter,"You attacked and lost " 783 new_draw_info (NDI_UNIQUE, 0, hitter, "You attacked and lost your spell!");
726 "your spell!");
727 } 784 }
728 if ((op->casting_time > -1)&&(hitdam > 0)){ 785 if ((op->casting_time > -1) && (hitdam > 0))
786 {
729 op->casting_time = -1; 787 op->casting_time = -1;
730 if (op->type == PLAYER) { 788 if (op->type == PLAYER)
789 {
731 new_draw_info(NDI_UNIQUE, 0,op,"You were hit and lost " 790 new_draw_info (NDI_UNIQUE, 0, op, "You were hit and lost your spell!");
732 "your spell!"); 791 new_draw_info_format (NDI_ALL | NDI_UNIQUE, 5, NULL, "%s was hit by %s and lost a spell.", &op_name, &hitter->name);
733 new_draw_info_format(NDI_ALL|NDI_UNIQUE,5,NULL,
734 "%s was hit by %s and lost a spell.",
735 &op_name,&hitter->name);
736 } 792 }
737 } 793 }
738 } 794 }
739 if ( ! simple_attack) 795 if (!simple_attack)
740 { 796 {
741 /* If you hit something, the victim should *always* wake up. 797 /* If you hit something, the victim should *always* wake up.
742 * Before, invisible hitters could avoid doing this. 798 * Before, invisible hitters could avoid doing this.
743 * -b.t. */ 799 * -b.t. */
744 if (QUERY_FLAG (op, FLAG_SLEEP)) 800 if (QUERY_FLAG (op, FLAG_SLEEP))
745 CLEAR_FLAG(op,FLAG_SLEEP); 801 CLEAR_FLAG (op, FLAG_SLEEP);
746 802
747 /* If the victim can't see the attacker, it may alert others 803 /* If the victim can't see the attacker, it may alert others
748 * for help. */ 804 * for help. */
749 if (op->type != PLAYER && ! can_see_enemy (op, hitter) 805 if (op->type != PLAYER && !can_see_enemy (op, hitter) && !op->owner && rndm (0, op->stats.Int))
750 && ! get_owner (op) && rndm(0, op->stats.Int))
751 npc_call_help (op); 806 npc_call_help (op);
752 807
753 /* if you were hidden and hit by a creature, you are discovered*/ 808 /* if you were hidden and hit by a creature, you are discovered */
754 if (op->hide && QUERY_FLAG (hitter, FLAG_ALIVE)) { 809 if (op->hide && QUERY_FLAG (hitter, FLAG_ALIVE))
810 {
755 make_visible (op); 811 make_visible (op);
756 if (op->type == PLAYER) 812 if (op->type == PLAYER)
757 new_draw_info (NDI_UNIQUE, 0, op, 813 new_draw_info (NDI_UNIQUE, 0, op, "You were hit by a wild attack. " "You are no longer hidden!");
758 "You were hit by a wild attack. "
759 "You are no longer hidden!");
760 } 814 }
761 815
762 /* thrown items (hitter) will have various effects 816 /* thrown items (hitter) will have various effects
763 * when they hit the victim. For things like thrown daggers, 817 * when they hit the victim. For things like thrown daggers,
764 * this sets 'hitter' to the actual dagger, and not the 818 * this sets 'hitter' to the actual dagger, and not the
765 * wrapper object. 819 * wrapper object.
766 */ 820 */
767 thrown_item_effect (hitter, op); 821 thrown_item_effect (hitter, op);
768 if (was_destroyed (hitter, hitter_tag)
769 || was_destroyed (op, op_tag)
770 || abort_attack (op, hitter, simple_attack))
771 goto leave;
772 }
773 822
774 /* Need to do at least 1 damage, otherwise there is no point 823 if (hitter->destroyed () || op->destroyed () || abort_attack (op, hitter, simple_attack))
775 * to go further and it will cause FPE's below.
776 */
777 if (hitdam<=0) hitdam=1;
778
779 type=hitter->attacktype;
780 if(!type) type=AT_PHYSICAL;
781 /* Handle monsters that hit back */
782 if ( ! simple_attack && QUERY_FLAG (op, FLAG_HITBACK)
783 && QUERY_FLAG (hitter, FLAG_ALIVE))
784 {
785 if (op->attacktype & AT_ACID && hitter->type==PLAYER)
786 new_draw_info(NDI_UNIQUE, 0,hitter,"You are splashed by acid!\n");
787 hit_player(hitter, random_roll(0, (op->stats.dam), hitter,
788 PREFER_LOW),op, op->attacktype, 1);
789 if (was_destroyed (op, op_tag)
790 || was_destroyed (hitter, hitter_tag)
791 || abort_attack (op, hitter, simple_attack))
792 goto leave;
793 }
794
795 /* In the new attack code, it should handle multiple attack
796 * types in its area, so remove it from here.
797 */
798 dam=hit_player(op, random_roll(1, hitdam, hitter, PREFER_HIGH),
799 hitter, type, 1);
800 if (was_destroyed (op, op_tag) || was_destroyed (hitter, hitter_tag)
801 || abort_attack (op, hitter, simple_attack))
802 goto leave; 824 goto leave;
803 } /* end of if hitter hit op */ 825 }
826
827 /* Need to do at least 1 damage, otherwise there is no point
828 * to go further and it will cause FPE's below.
829 */
830 if (hitdam <= 0)
831 hitdam = 1;
832
833 type = hitter->attacktype;
834
835 if (!type)
836 type = AT_PHYSICAL;
837
838 /* Handle monsters that hit back */
839 if (!simple_attack && QUERY_FLAG (op, FLAG_HITBACK) && QUERY_FLAG (hitter, FLAG_ALIVE))
840 {
841 if (op->attacktype & AT_ACID && hitter->type == PLAYER)
842 new_draw_info (NDI_UNIQUE, 0, hitter, "You are splashed by acid!\n");
843
844 hit_player (hitter, random_roll (0, (op->stats.dam), hitter, PREFER_LOW), op, op->attacktype, 1);
845
846 if (op->destroyed () || hitter->destroyed () || abort_attack (op, hitter, simple_attack))
847 goto leave;
848 }
849
850 /* In the new attack code, it should handle multiple attack
851 * types in its area, so remove it from here.
852 */
853 dam = hit_player (op, random_roll (1, hitdam, hitter, PREFER_HIGH), hitter, type, 1);
854
855 if (op->destroyed () || hitter->destroyed () || abort_attack (op, hitter, simple_attack))
856 goto leave;
857 } /* end of if hitter hit op */
804 /* if we missed, dam=0 */ 858 /* if we missed, dam=0 */
805 859
806 /*attack_message(dam, type, op, hitter);*/ 860 /*attack_message(dam, type, op, hitter); */
807 861
808 goto leave; 862 goto leave;
809 863
810 error: 864error:
811 dam = 1; 865 dam = 1;
812 866
813 leave: 867leave:
814 868
815 return dam; 869 return dam;
816} 870}
817 871
872int
818int attack_ob (object *op, object *hitter) 873attack_ob (object *op, object *hitter)
819{ 874{
820 875
821 if (hitter->head) 876 if (hitter->head)
822 hitter = hitter->head; 877 hitter = hitter->head;
823 return attack_ob_simple (op, hitter, hitter->stats.dam, hitter->stats.wc); 878 return attack_ob_simple (op, hitter, hitter->stats.dam, hitter->stats.wc);
824} 879}
825 880
826/* op is the arrow, tmp is what is stopping the arrow. 881/* op is the arrow, tmp is what is stopping the arrow.
827 * 882 *
828 * Returns 1 if op was inserted into tmp's inventory, 0 otherwise. 883 * Returns 1 if op was inserted into tmp's inventory, 0 otherwise.
829 */ 884 */
885static int
830static int stick_arrow (object *op, object *tmp) 886stick_arrow (object *op, object *tmp)
831{ 887{
832 /* If the missile hit a player, we insert it in their inventory. 888 /* If the missile hit a player, we insert it in their inventory.
833 * However, if the missile is heavy, we don't do so (assume it falls 889 * However, if the missile is heavy, we don't do so (assume it falls
834 * to the ground after a hit). What a good value for this is up to 890 * to the ground after a hit). What a good value for this is up to
835 * debate - 5000 is 5 kg, so arrows, knives, and other light weapons 891 * debate - 5000 is 5 kg, so arrows, knives, and other light weapons
836 * stick around. 892 * stick around.
837 */ 893 */
838 if (op->weight <= 5000 && tmp->stats.hp >= 0) { 894 if (op->weight <= 5000 && tmp->stats.hp >= 0)
895 {
839 if(tmp->head != NULL) 896 if (tmp->head != NULL)
840 tmp = tmp->head; 897 tmp = tmp->head;
841 remove_ob (op); 898
899 op->remove ();
842 op = insert_ob_in_ob(op,tmp); 900 op = insert_ob_in_ob (op, tmp);
901
843 if (tmp->type== PLAYER) 902 if (tmp->type == PLAYER)
844 esrv_send_item (tmp, op); 903 esrv_send_item (tmp, op);
904
845 return 1; 905 return 1;
906 }
846 } else 907 else
847 return 0; 908 return 0;
848} 909}
849 910
850/* hit_with_arrow() disassembles the missile, attacks the victim and 911/* hit_with_arrow() disassembles the missile, attacks the victim and
851 * reassembles the missile. 912 * reassembles the missile.
852 * 913 *
853 * It returns a pointer to the reassembled missile, or NULL if the missile 914 * It returns a pointer to the reassembled missile, or NULL if the missile
854 * isn't available anymore. 915 * isn't available anymore.
855 */ 916 */
917object *
856object *hit_with_arrow (object *op, object *victim) 918hit_with_arrow (object *op, object *victim)
857{ 919{
858 object *container, *hitter; 920 object *container, *hitter;
859 int hit_something = 0; 921 int hit_something = 0;
860 tag_t victim_tag, hitter_tag;
861 sint16 victim_x, victim_y;
862 922
863 /* Disassemble missile */ 923 /* Disassemble missile */
864 if (op->inv) { 924 if (op->inv)
925 {
865 container = op; 926 container = op;
866 hitter = op->inv; 927 hitter = op->inv;
867 remove_ob (hitter); 928 hitter->remove ();
868 insert_ob_in_map(hitter, container->map,hitter,INS_NO_MERGE | INS_NO_WALK_ON); 929 insert_ob_in_map (hitter, container->map, hitter, INS_NO_MERGE | INS_NO_WALK_ON);
869 /* Note that we now have an empty THROWN_OBJ on the map. Code that 930 /* Note that we now have an empty THROWN_OBJ on the map. Code that
870 * might be called until this THROWN_OBJ is either reassembled or 931 * might be called until this THROWN_OBJ is either reassembled or
871 * removed at the end of this function must be able to deal with empty 932 * removed at the end of this function must be able to deal with empty
872 * THROWN_OBJs. */ 933 * THROWN_OBJs. */
873 } else { 934 }
935 else
936 {
874 container = NULL; 937 container = 0;
875 hitter = op; 938 hitter = op;
876 } 939 }
877 940
878 /* Try to hit victim */ 941 /* Try to hit victim */
879 victim_x = victim->x;
880 victim_y = victim->y;
881 victim_tag = victim->count;
882 hitter_tag = hitter->count;
883
884 hit_something = attack_ob_simple (victim, hitter, op->stats.dam, op->stats.wc); 942 hit_something = attack_ob_simple (victim, hitter, op->stats.dam, op->stats.wc);
885 943
886 /* Arrow attacks door, rune of summoning is triggered, demon is put on 944 /* Arrow attacks door, rune of summoning is triggered, demon is put on
887 * arrow, move_apply() calls this function, arrow sticks in demon, 945 * arrow, move_apply() calls this function, arrow sticks in demon,
888 * attack_ob_simple() returns, and we've got an arrow that still exists 946 * attack_ob_simple() returns, and we've got an arrow that still exists
889 * but is no longer on the map. Ugh. (Beware: Such things can happen at 947 * but is no longer on the map. Ugh. (Beware: Such things can happen at
890 * other places as well!) 948 * other places as well!)
891 */ 949 */
892 if (was_destroyed (hitter, hitter_tag) || hitter->env != NULL) { 950 if (hitter->destroyed () || hitter->env != NULL)
951 {
893 if (container) { 952 if (container)
894 remove_ob (container);
895 free_object (container);
896 } 953 {
954 container->remove ();
955 container->destroy ();
956 }
957
897 return NULL; 958 return 0;
898 } 959 }
899 960
900 /* Missile hit victim */ 961 /* Missile hit victim */
901 /* if the speed is > 10, then this is a fast moving arrow, we go straight 962 /* if the speed is > 10, then this is a fast moving arrow, we go straight
902 * through the target 963 * through the target
903 */ 964 */
904 if (hit_something && op->speed <= 10.0) 965 if (hit_something && op->speed <= 10.0)
905 { 966 {
906 /* Stop arrow */ 967 /* Stop arrow */
907 if (container == NULL) { 968 if (!container)
969 {
908 hitter = fix_stopped_arrow (hitter); 970 hitter = fix_stopped_arrow (hitter);
909 if (hitter == NULL) 971 if (!hitter)
910 return NULL; 972 return 0;
973 }
911 } else { 974 else
912 remove_ob (container); 975 container->destroy ();
913 free_object (container);
914 }
915 976
916 /* Try to stick arrow into victim */ 977 /* Try to stick arrow into victim */
917 if ( ! was_destroyed (victim, victim_tag) 978 if (!victim->destroyed () && stick_arrow (hitter, victim))
918 && stick_arrow (hitter, victim))
919 return NULL; 979 return 0;
920 980
921 /* Else try to put arrow on victim's map square 981 /* Else try to put arrow on victim's map square
922 * remove check for P_WALL here. If the arrow got to this 982 * remove check for P_WALL here. If the arrow got to this
923 * space, that is good enough - with the new movement code, 983 * space, that is good enough - with the new movement code,
924 * there is now the potential for lots of spaces where something 984 * there is now the potential for lots of spaces where something
925 * can fly over but not otherwise move over. What is the correct 985 * can fly over but not otherwise move over. What is the correct
926 * way to handle those otherwise? 986 * way to handle those otherwise?
927 */ 987 */
928 if (victim_x != hitter->x || victim_y != hitter->y) { 988 if (victim->x != hitter->x || victim->y != hitter->y)
929 remove_ob (hitter); 989 {
990 hitter->remove ();
930 hitter->x = victim_x; 991 hitter->x = victim->x;
931 hitter->y = victim_y; 992 hitter->y = victim->y;
932 insert_ob_in_map (hitter, victim->map, hitter,0); 993 insert_ob_in_map (hitter, victim->map, hitter, 0);
994 }
933 } else { 995 else
934 /* Else leave arrow where it is */ 996 /* Else leave arrow where it is */
935 merge_ob (hitter, NULL); 997 merge_ob (hitter, NULL);
936 } 998
937 return NULL; 999 return 0;
938 } 1000 }
939 1001
940 if (hit_something && op->speed >= 10.0) 1002 if (hit_something && op->speed >= 10.0)
941 op->speed -= 1.0; 1003 op->speed -= 1.0;
942 1004
943 /* Missile missed victim - reassemble missile */ 1005 /* Missile missed victim - reassemble missile */
944 if (container) { 1006 if (container)
945 remove_ob (hitter); 1007 {
1008 hitter->remove ();
946 insert_ob_in_ob (hitter, container); 1009 insert_ob_in_ob (hitter, container);
947 } 1010 }
1011
948 return op; 1012 return op;
949} 1013}
950 1014
951 1015
1016void
952void tear_down_wall(object *op) 1017tear_down_wall (object *op)
953{ 1018{
954 int perc=0; 1019 int perc = 0;
955 1020
956 if (!op->stats.maxhp) { 1021 if (!op->stats.maxhp)
1022 {
957 LOG(llevError, "TEAR_DOWN wall %s had no maxhp.\n", &op->name); 1023 LOG (llevError, "TEAR_DOWN wall %s had no maxhp.\n", &op->name);
958 perc = 1; 1024 perc = 1;
1025 }
959 } else if(!GET_ANIM_ID(op)) { 1026 else if (!GET_ANIM_ID (op))
1027 {
960 /* Object has been called - no animations, so remove it */ 1028 /* Object has been called - no animations, so remove it */
961 if(op->stats.hp<0) { 1029 if (op->stats.hp < 0)
962 remove_ob(op); /* Should update LOS */ 1030 op->destroy ();
963 free_object(op);
964 /* Don't know why this is here - remove_ob should do it for us */
965 /*update_position(m, x, y);*/
966 } 1031
967 return; /* no animations, so nothing more to do */ 1032 return; /* no animations, so nothing more to do */
968 } 1033 }
969 perc = NUM_ANIMATIONS(op) 1034
970 - ((int)NUM_ANIMATIONS(op)*op->stats.hp)/op->stats.maxhp; 1035 perc = NUM_ANIMATIONS (op) - ((int) NUM_ANIMATIONS (op) * op->stats.hp) / op->stats.maxhp;
1036
971 if (perc >= (int) NUM_ANIMATIONS(op)) 1037 if (perc >= (int) NUM_ANIMATIONS (op))
972 perc = NUM_ANIMATIONS(op)-1; 1038 perc = NUM_ANIMATIONS (op) - 1;
973 else if (perc < 1) 1039 else if (perc < 1)
974 perc = 1; 1040 perc = 1;
1041
975 SET_ANIMATION(op, perc); 1042 SET_ANIMATION (op, perc);
976 update_object(op,UP_OBJ_FACE); 1043 update_object (op, UP_OBJ_FACE);
977 if(perc==NUM_ANIMATIONS(op)-1) { /* Reached the last animation */ 1044
1045 if (perc == NUM_ANIMATIONS (op) - 1)
1046 { /* Reached the last animation */
978 if(op->face==blank_face) { 1047 if (op->face == blank_face)
979 /* If the last face is blank, remove the ob */ 1048 /* If the last face is blank, remove the ob */
980 remove_ob(op); /* Should update LOS */ 1049 op->destroy ();
981 free_object(op); 1050 else
982
983 /* remove_ob should call update_position for us */
984 /*update_position(m, x, y);*/
985
986 } else { /* The last face was not blank, leave an image */ 1051 { /* The last face was not blank, leave an image */
987 CLEAR_FLAG(op, FLAG_BLOCKSVIEW); 1052 CLEAR_FLAG (op, FLAG_BLOCKSVIEW);
988 update_all_los(op->map, op->x, op->y); 1053 update_all_los (op->map, op->x, op->y);
989 op->move_block = 0; 1054 op->move_block = 0;
990 CLEAR_FLAG(op, FLAG_ALIVE); 1055 CLEAR_FLAG (op, FLAG_ALIVE);
991 } 1056 }
992 } 1057 }
993} 1058}
994 1059
1060void
995void scare_creature(object *target, object *hitter) 1061scare_creature (object *target, object *hitter)
996{ 1062{
997 object *owner = get_owner(hitter); 1063 object *owner = hitter->owner;
998 1064
999 if (!owner) owner=hitter; 1065 if (!owner)
1066 owner = hitter;
1000 1067
1001 SET_FLAG(target, FLAG_SCARED); 1068 SET_FLAG (target, FLAG_SCARED);
1002 if (!target->enemy) target->enemy=owner; 1069 if (!target->enemy)
1070 target->enemy = owner;
1003} 1071}
1004 1072
1005 1073
1006/* This returns the amount of damage hitter does to op with the 1074/* This returns the amount of damage hitter does to op with the
1007 * appropriate attacktype. Only 1 attacktype should be set at a time. 1075 * appropriate attacktype. Only 1 attacktype should be set at a time.
1008 * This doesn't damage the player, but returns how much it should 1076 * This doesn't damage the player, but returns how much it should
1009 * take. However, it will do other effects (paralyzation, slow, etc.) 1077 * take. However, it will do other effects (paralyzation, slow, etc.)
1010 * Note - changed for PR code - we now pass the attack number and not 1078 * Note - changed for PR code - we now pass the attack number and not
1011 * the attacktype. Makes it easier for the PR code. */ 1079 * the attacktype. Makes it easier for the PR code. */
1012 1080
1081int
1013int hit_player_attacktype(object *op, object *hitter, int dam, 1082hit_player_attacktype (object *op, object *hitter, int dam, uint32 attacknum, int magic)
1014 uint32 attacknum, int magic) { 1083{
1015
1016 int doesnt_slay = 1; 1084 int doesnt_slay = 1;
1017 1085
1018 /* Catch anyone that may be trying to send us a bitmask instead of the number */ 1086 /* Catch anyone that may be trying to send us a bitmask instead of the number */
1019 if (attacknum >= NROFATTACKS) { 1087 if (attacknum >= NROFATTACKS)
1088 {
1020 LOG(llevError, "hit_player_attacktype: Invalid attacknumber passed: %u\n", attacknum); 1089 LOG (llevError, "hit_player_attacktype: Invalid attacknumber passed: %u\n", attacknum);
1021 return 0; 1090 return 0;
1022 }
1023 1091 }
1092
1024 if (dam < 0) { 1093 if (dam < 0)
1094 {
1025 LOG(llevError,"hit_player_attacktype called with negative damage: %d\n", dam); 1095 LOG (llevError, "hit_player_attacktype called with negative damage: %d\n", dam);
1026 return 0; 1096 return 0;
1027 }
1028 1097 }
1098
1029 /* AT_INTERNAL is supposed to do exactly dam. Put a case here so 1099 /* AT_INTERNAL is supposed to do exactly dam. Put a case here so
1030 * people can't mess with that or it otherwise get confused. */ 1100 * people can't mess with that or it otherwise get confused. */
1031 if (attacknum == ATNR_INTERNAL) return dam; 1101 if (attacknum == ATNR_INTERNAL)
1032 1102 return dam;
1103
1033 if (hitter->slaying) { 1104 if (hitter->slaying)
1105 {
1034 if(((op->race != NULL) && strstr(hitter->slaying, op->race)) || 1106 if (((op->race != NULL) && strstr (hitter->slaying, op->race)) ||
1035 (op->arch && (op->arch->name != NULL) && 1107 (op->arch && (op->arch->name != NULL) && strstr (op->arch->name, hitter->slaying)))
1036 strstr(op->arch->name, hitter->slaying))
1037 ){ 1108 {
1038 doesnt_slay = 0; 1109 doesnt_slay = 0;
1039 dam *= 3; 1110 dam *= 3;
1040 } 1111 }
1041 } 1112 }
1042 1113
1043 /* Adjust the damage for resistance. Note that neg. values increase damage. */ 1114 /* Adjust the damage for resistance. Note that neg. values increase damage. */
1044 if (op->resist[attacknum]) { 1115 if (op->resist[attacknum])
1116 {
1045 /* basically: dam = dam*(100-op->resist[attacknum])/100; 1117 /* basically: dam = dam*(100-op->resist[attacknum])/100;
1046 * in case 0>dam>1, we try to "simulate" a float value-effect */ 1118 * in case 0>dam>1, we try to "simulate" a float value-effect */
1047 dam *= (100-op->resist[attacknum]); 1119 dam *= (100 - op->resist[attacknum]);
1048 if (dam >= 100) dam /= 100; 1120 if (dam >= 100)
1121 dam /= 100;
1049 else 1122 else
1050 dam = (dam > (random_roll(0, 99, op, PREFER_LOW))) ? 1 : 0; 1123 dam = (dam > (random_roll (0, 99, op, PREFER_LOW))) ? 1 : 0;
1051 } 1124 }
1052 1125
1053 /* Special hack. By default, if immune to something, you 1126 /* Special hack. By default, if immune to something, you
1054 * shouldn't need to worry. However, acid is an exception, since 1127 * shouldn't need to worry. However, acid is an exception, since
1055 * it can still damage your items. Only include attacktypes if 1128 * it can still damage your items. Only include attacktypes if
1056 * special processing is needed */ 1129 * special processing is needed */
1057 1130
1058 if ((op->resist[attacknum] >= 100) && 1131 if ((op->resist[attacknum] >= 100) && doesnt_slay && (attacknum != ATNR_ACID))
1059 doesnt_slay && (attacknum != ATNR_ACID))
1060 return 0; 1132 return 0;
1061 1133
1062 /* Keep this in order - makes things easier to find */ 1134 /* Keep this in order - makes things easier to find */
1135
1136 switch (attacknum)
1063 1137 {
1064 switch(attacknum) {
1065 case ATNR_PHYSICAL: 1138 case ATNR_PHYSICAL:
1066 /* here also check for diseases */ 1139 /* here also check for diseases */
1067 check_physically_infect(op, hitter); 1140 check_physically_infect (op, hitter);
1068 break; 1141 break;
1069 1142
1070 /* Don't need to do anything for: 1143 /* Don't need to do anything for:
1071 magic, 1144 magic,
1072 fire, 1145 fire,
1073 electricity, 1146 electricity,
1074 cold */ 1147 cold */
1075 1148
1076 case ATNR_CONFUSION: 1149 case ATNR_CONFUSION:
1077 case ATNR_POISON: 1150 case ATNR_POISON:
1078 case ATNR_SLOW: 1151 case ATNR_SLOW:
1079 case ATNR_PARALYZE: 1152 case ATNR_PARALYZE:
1080 case ATNR_FEAR: 1153 case ATNR_FEAR:
1081 case ATNR_CANCELLATION: 1154 case ATNR_CANCELLATION:
1082 case ATNR_DEPLETE: 1155 case ATNR_DEPLETE:
1083 case ATNR_BLIND: 1156 case ATNR_BLIND:
1084 { 1157 {
1085 /* chance for inflicting a special attack depends on the 1158 /* chance for inflicting a special attack depends on the
1086 * difference between attacker's and defender's level 1159 * difference between attacker's and defender's level
1087 */ 1160 */
1088 int level_diff = MIN(110, MAX(0, op->level - hitter->level)); 1161 int level_diff = MIN (110, MAX (0, op->level - hitter->level));
1089 1162
1090 /* First, only creatures/players with speed can be affected. 1163 /* First, only creatures/players with speed can be affected.
1091 * Second, just getting hit doesn't mean it always affects 1164 * Second, just getting hit doesn't mean it always affects
1092 * you. Third, you still get a saving through against the 1165 * you. Third, you still get a saving through against the
1093 * effect. 1166 * effect.
1094 */ 1167 */
1095 if (op->speed && 1168 if (op->speed &&
1096 (QUERY_FLAG(op, FLAG_MONSTER) || op->type==PLAYER) && 1169 (QUERY_FLAG (op, FLAG_MONSTER) || op->type == PLAYER) &&
1097 !(rndm(0, (attacknum == ATNR_SLOW?6:3)-1)) && 1170 !(rndm (0, (attacknum == ATNR_SLOW ? 6 : 3) - 1)) && !did_make_save (op, level_diff, op->resist[attacknum] / 10))
1098 !did_make_save(op, level_diff, op->resist[attacknum]/10)) { 1171 {
1099 1172
1100 /* Player has been hit by something */ 1173 /* Player has been hit by something */
1101 if (attacknum == ATNR_CONFUSION) confuse_player(op,hitter,dam); 1174 if (attacknum == ATNR_CONFUSION)
1175 confuse_player (op, hitter, dam);
1102 else if (attacknum == ATNR_POISON) poison_player(op,hitter,dam); 1176 else if (attacknum == ATNR_POISON)
1177 poison_player (op, hitter, dam);
1103 else if (attacknum == ATNR_SLOW) slow_player(op,hitter,dam); 1178 else if (attacknum == ATNR_SLOW)
1104 else if (attacknum == ATNR_PARALYZE) paralyze_player(op,hitter,dam); 1179 slow_player (op, hitter, dam);
1180 else if (attacknum == ATNR_PARALYZE)
1181 paralyze_player (op, hitter, dam);
1105 else if (attacknum == ATNR_FEAR) scare_creature(op, hitter); 1182 else if (attacknum == ATNR_FEAR)
1183 scare_creature (op, hitter);
1106 else if (attacknum == ATNR_CANCELLATION) cancellation(op); 1184 else if (attacknum == ATNR_CANCELLATION)
1185 cancellation (op);
1107 else if (attacknum == ATNR_DEPLETE) drain_stat(op); 1186 else if (attacknum == ATNR_DEPLETE)
1187 op->drain_stat ();
1108 else if (attacknum == ATNR_BLIND && !QUERY_FLAG(op,FLAG_UNDEAD) && 1188 else if (attacknum == ATNR_BLIND && !QUERY_FLAG (op, FLAG_UNDEAD) && !QUERY_FLAG (op, FLAG_GENERATOR))
1109 !QUERY_FLAG(op,FLAG_GENERATOR)) blind_player(op,hitter,dam); 1189 blind_player (op, hitter, dam);
1110 } 1190 }
1111 dam = 0; /* These are all effects and don't do real damage */ 1191 dam = 0; /* These are all effects and don't do real damage */
1112 } 1192 }
1113 break; 1193 break;
1114 case ATNR_ACID: 1194 case ATNR_ACID:
1115 { 1195 {
1116 int flag=0; 1196 int flag = 0;
1117 1197
1118 /* Items only get corroded if you're not on a battleground and 1198 /* Items only get corroded if you're not on a battleground and
1119 * if your acid resistance is below 50%. */ 1199 * if your acid resistance is below 50%. */
1120 if (!op_on_battleground(op, NULL, NULL) && 1200 if (!op_on_battleground (op, NULL, NULL) && (op->resist[ATNR_ACID] < 50))
1121 (op->resist[ATNR_ACID] < 50))
1122 { 1201 {
1123 object *tmp; 1202 object *tmp;
1203
1124 for(tmp=op->inv; tmp!=NULL; tmp=tmp->below) { 1204 for (tmp = op->inv; tmp != NULL; tmp = tmp->below)
1205 {
1125 if(tmp->invisible) 1206 if (tmp->invisible)
1126 continue; 1207 continue;
1127 if(!QUERY_FLAG(tmp, FLAG_APPLIED) || 1208 if (!QUERY_FLAG (tmp, FLAG_APPLIED) || (tmp->resist[ATNR_ACID] >= 10))
1128 (tmp->resist[ATNR_ACID] >= 10))
1129 /* >= 10% acid res. on itmes will protect these */ 1209 /* >= 10% acid res. on itmes will protect these */
1130 continue; 1210 continue;
1131 if(!(tmp->material & M_IRON)) 1211 if (!(tmp->material & M_IRON))
1132 continue; 1212 continue;
1133 if(tmp->magic < -4) /* Let's stop at -5 */ 1213 if (tmp->magic < -4) /* Let's stop at -5 */
1134 continue; 1214 continue;
1135 if(tmp->type==RING || 1215 if (tmp->type == RING ||
1136 /* removed boots and gloves from exclusion list in 1216 /* removed boots and gloves from exclusion list in
1137 PR */ 1217 PR */
1138 tmp->type==GIRDLE || 1218 tmp->type == GIRDLE || tmp->type == AMULET || tmp->type == WAND || tmp->type == ROD || tmp->type == HORN)
1139 tmp->type==AMULET ||
1140 tmp->type==WAND ||
1141 tmp->type==ROD ||
1142 tmp->type==HORN)
1143 continue; /* To avoid some strange effects */ 1219 continue; /* To avoid some strange effects */
1144 1220
1145 /* High damage acid has better chance of corroding 1221 /* High damage acid has better chance of corroding
1146 objects */ 1222 objects */
1147 if(rndm(0, dam+4) >
1148 random_roll(0, 39, op, PREFER_HIGH)+2*tmp->magic) { 1223 if (rndm (0, dam + 4) > random_roll (0, 39, op, PREFER_HIGH) + 2 * tmp->magic)
1224 {
1149 if(op->type == PLAYER) 1225 if (op->type == PLAYER)
1150 /* Make this more visible */ 1226 /* Make this more visible */
1151 new_draw_info_format(NDI_UNIQUE|NDI_RED,0, op, 1227 new_draw_info_format (NDI_UNIQUE | NDI_RED, 0, op,
1152 "The %s's acid corrodes your %s!", 1228 "The %s's acid corrodes your %s!", query_name (hitter), query_name (tmp));
1153 query_name(hitter), query_name(tmp));
1154 flag = 1; 1229 flag = 1;
1155 tmp->magic--; 1230 tmp->magic--;
1156 if(op->type == PLAYER) 1231 if (op->type == PLAYER)
1157 esrv_send_item(op, tmp); 1232 esrv_send_item (op, tmp);
1233 }
1158 } 1234 }
1235 if (flag)
1236 op->update_stats (); /* Something was corroded */
1159 } 1237 }
1160 if(flag)
1161 fix_player(op); /* Something was corroded */
1162 }
1163 } 1238 }
1164 break; 1239 break;
1165 case ATNR_DRAIN: 1240 case ATNR_DRAIN:
1166 { 1241 {
1167 /* rate is the proportion of exp drained. High rate means 1242 /* rate is the proportion of exp drained. High rate means
1168 * not much is drained, low rate means a lot is drained. 1243 * not much is drained, low rate means a lot is drained.
1169 */ 1244 */
1170 int rate; 1245 int rate;
1171 1246
1172 if(op->resist[ATNR_DRAIN] >= 0) 1247 if (op->resist[ATNR_DRAIN] >= 0)
1173 rate = 400 + op->resist[ATNR_DRAIN] * 3; 1248 rate = 400 + op->resist[ATNR_DRAIN] * 3;
1174 else 1249 else
1175 rate = 400 * 100 / (100 - op->resist[ATNR_DRAIN]); 1250 rate = 400 * 100 / (100 - op->resist[ATNR_DRAIN]);
1176 1251
1177 if(op->stats.exp <= rate) { 1252 if (op->stats.exp <= rate)
1253 {
1178 if(op->type == GOLEM) 1254 if (op->type == GOLEM)
1179 dam = 999; /* Its force is "sucked" away. 8) */ 1255 dam = 999; /* Its force is "sucked" away. 8) */
1180 else 1256 else
1181 /* If we can't drain, lets try to do physical damage */ 1257 /* If we can't drain, lets try to do physical damage */
1182 dam = hit_player_attacktype(op, hitter, dam, ATNR_PHYSICAL, magic); 1258 dam = hit_player_attacktype (op, hitter, dam, ATNR_PHYSICAL, magic);
1259 }
1183 } else { 1260 else
1261 {
1184 /* Randomly give the hitter some hp */ 1262 /* Randomly give the hitter some hp */
1185 if(hitter->stats.hp<hitter->stats.maxhp && 1263 if (hitter->stats.hp < hitter->stats.maxhp &&
1186 (op->level > hitter->level) && 1264 (op->level > hitter->level) && random_roll (0, (op->level - hitter->level + 2), hitter, PREFER_HIGH) > 3)
1187 random_roll(0, (op->level-hitter->level+2), hitter, PREFER_HIGH)>3)
1188 hitter->stats.hp++; 1265 hitter->stats.hp++;
1189 1266
1190 /* Can't do drains on battleground spaces. 1267 /* Can't do drains on battleground spaces.
1191 * Move the wiz check up here - before, the hitter wouldn't gain exp 1268 * Move the wiz check up here - before, the hitter wouldn't gain exp
1192 * exp, but the wiz would still lose exp! If drainee is a wiz, 1269 * exp, but the wiz would still lose exp! If drainee is a wiz,
1193 * nothing happens. 1270 * nothing happens.
1194 * Try to credit the owner. We try to display player -> player drain 1271 * Try to credit the owner. We try to display player -> player drain
1195 * attacks, hence all the != PLAYER checks. 1272 * attacks, hence all the != PLAYER checks.
1196 */ 1273 */
1197 if (!op_on_battleground(hitter, NULL, NULL) && !QUERY_FLAG(op,FLAG_WAS_WIZ)) { 1274 if (!op_on_battleground (hitter, NULL, NULL) && !QUERY_FLAG (op, FLAG_WAS_WIZ))
1275 {
1198 object *owner = get_owner(hitter); 1276 object *owner = hitter->owner;
1199 1277
1200 if (owner && owner != hitter) { 1278 if (owner && owner != hitter)
1279 {
1201 if (op->type != PLAYER || owner->type != PLAYER) 1280 if (op->type != PLAYER || owner->type != PLAYER)
1202 change_exp(owner, op->stats.exp/(rate*2), 1281 change_exp (owner, op->stats.exp / (rate * 2),
1203 hitter->chosen_skill ? hitter->chosen_skill->skill : (const char *)0, SK_EXP_TOTAL); 1282 hitter->chosen_skill ? hitter->chosen_skill->skill : (const char *) 0, SK_EXP_TOTAL);
1283 }
1204 } else if (op->type != PLAYER || hitter->type != PLAYER) { 1284 else if (op->type != PLAYER || hitter->type != PLAYER)
1285 {
1205 change_exp(hitter, op->stats.exp/(rate*2), 1286 change_exp (hitter, op->stats.exp / (rate * 2),
1206 hitter->chosen_skill ? hitter->chosen_skill->skill : (const char*)0, 0); 1287 hitter->chosen_skill ? hitter->chosen_skill->skill : (const char *) 0, 0);
1288 }
1289 change_exp (op, -op->stats.exp / rate, NULL, 0);
1207 } 1290 }
1208 change_exp(op,-op->stats.exp/rate, NULL, 0);
1209 }
1210 dam = 1; /* Drain is an effect. Still return 1 - otherwise, if you have pure 1291 dam = 1; /* Drain is an effect. Still return 1 - otherwise, if you have pure
1211 * drain attack, you won't know that you are actually sucking out EXP, 1292 * drain attack, you won't know that you are actually sucking out EXP,
1212 * as the messages will say you missed 1293 * as the messages will say you missed
1213 */ 1294 */
1214 } 1295 }
1215 } 1296 }
1216 break; 1297 break;
1217 case ATNR_TURN_UNDEAD: 1298 case ATNR_TURN_UNDEAD:
1218 { 1299 {
1219 if (QUERY_FLAG(op,FLAG_UNDEAD)) { 1300 if (QUERY_FLAG (op, FLAG_UNDEAD))
1220 object *owner = get_owner(hitter) == NULL ? hitter : get_owner(hitter); 1301 {
1302 object *owner = hitter->owner ? (object *)hitter->owner : hitter;
1221 object *god = find_god (determine_god (owner)); 1303 object *god = find_god (determine_god (owner));
1222 int div = 1; 1304 int div = 1;
1223 1305
1224 /* if undead are not an enemy of your god, you turn them 1306 /* if undead are not an enemy of your god, you turn them
1225 * at half strength */ 1307 * at half strength */
1226 if (! god || ! god->slaying ||
1227 strstr (god->slaying, undead_name) == NULL) 1308 if (!god || !god->slaying || strstr (god->slaying, undead_name) == NULL)
1228 div = 2; 1309 div = 2;
1229 /* Give a bonus if you resist turn undead */ 1310 /* Give a bonus if you resist turn undead */
1230 if (op->level * div < 1311 if (op->level * div < (turn_bonus[owner->stats.Wis] + owner->level + (op->resist[ATNR_TURN_UNDEAD] / 100)))
1231 (turn_bonus[owner->stats.Wis]+owner->level +
1232 (op->resist[ATNR_TURN_UNDEAD]/100)))
1233 scare_creature(op, owner); 1312 scare_creature (op, owner);
1234 } 1313 }
1235 else 1314 else
1236 dam = 0; /* don't damage non undead - should we damage 1315 dam = 0; /* don't damage non undead - should we damage
1237 undead? */ 1316 undead? */
1238 } break; 1317 }
1239 case ATNR_DEATH:
1240 deathstrike_player(op, hitter, &dam);
1241 break; 1318 break;
1319 case ATNR_DEATH:
1320 deathstrike_player (op, hitter, &dam);
1321 break;
1242 case ATNR_CHAOS: 1322 case ATNR_CHAOS:
1243 LOG(llevError, 1323 LOG (llevError, "%s was hit by %s with non-specific chaos.\n", op->debug_desc (), hitter->debug_desc2 ());
1244 "%s was hit by %s with non-specific chaos.\n",
1245 query_name(op),
1246 query_name(hitter));
1247 dam = 0; 1324 dam = 0;
1248 break; 1325 break;
1249 case ATNR_COUNTERSPELL: 1326 case ATNR_COUNTERSPELL:
1250 LOG(llevError, 1327 LOG (llevError, "%s was hit by %s with counterspell attack.\n", op->debug_desc (), hitter->debug_desc2 ());
1251 "%s was hit by %s with counterspell attack.\n",
1252 query_name(op),
1253 query_name(hitter));
1254 dam = 0; 1328 dam = 0;
1255 /* This should never happen. Counterspell is handled 1329 /* This should never happen. Counterspell is handled
1256 * seperately and filtered out. If this does happen, 1330 * seperately and filtered out. If this does happen,
1257 * Counterspell has no effect on anything but spells, so it 1331 * Counterspell has no effect on anything but spells, so it
1258 * does no damage. */ 1332 * does no damage. */
1259 break; 1333 break;
1260 case ATNR_HOLYWORD: 1334 case ATNR_HOLYWORD:
1261 { 1335 {
1262 /* This has already been handled by hit_player, 1336 /* This has already been handled by hit_player,
1263 * no need to check twice -- DAMN */ 1337 * no need to check twice -- DAMN */
1264 1338 object *owner = hitter->owner ? (object *)hitter->owner : hitter;
1265 object *owner = get_owner(hitter)==NULL?hitter:get_owner(hitter); 1339
1266
1267 /* As with turn undead above, give a bonus on the saving throw */ 1340 /* As with turn undead above, give a bonus on the saving throw */
1268 if((op->level+(op->resist[ATNR_HOLYWORD]/100)) < 1341 if ((op->level + (op->resist[ATNR_HOLYWORD] / 100)) < owner->level + turn_bonus[owner->stats.Wis])
1269 owner->level+turn_bonus[owner->stats.Wis])
1270 scare_creature(op, owner); 1342 scare_creature (op, owner);
1343 }
1271 } break; 1344 break;
1272 case ATNR_LIFE_STEALING: 1345 case ATNR_LIFE_STEALING:
1273 { 1346 {
1274 int new_hp; 1347 int new_hp;
1348
1275 /* this is replacement to drain for players, instead of taking 1349 /* this is replacement to drain for players, instead of taking
1276 * exp it takes hp. It is geared for players, probably not 1350 * exp it takes hp. It is geared for players, probably not
1277 * much use giving it to monsters 1351 * much use giving it to monsters
1278 * 1352 *
1279 * life stealing doesn't do a lot of damage, but it gives the 1353 * life stealing doesn't do a lot of damage, but it gives the
1280 * damage it does do to the player. Given that, 1354 * damage it does do to the player. Given that,
1281 * it only does 1/10'th normal damage (hence the divide by 1355 * it only does 1/10'th normal damage (hence the divide by
1282 * 1000). 1356 * 1000).
1283 */ 1357 */
1284 /* You can't steal life from something undead */ 1358 /* You can't steal life from something undead */
1285 if ((op->type == GOLEM) || (QUERY_FLAG(op, FLAG_UNDEAD))) return 0; 1359 if ((op->type == GOLEM) || (QUERY_FLAG (op, FLAG_UNDEAD)))
1360 return 0;
1286 /* If drain protection is higher than life stealing, use that */ 1361 /* If drain protection is higher than life stealing, use that */
1287 if (op->resist[ATNR_DRAIN] >= op->resist[ATNR_LIFE_STEALING]) 1362 if (op->resist[ATNR_DRAIN] >= op->resist[ATNR_LIFE_STEALING])
1288 dam = (dam*(100 - op->resist[ATNR_DRAIN])) / 3000; 1363 dam = (dam * (100 - op->resist[ATNR_DRAIN])) / 3000;
1364 else
1289 else dam = (dam*(100 - op->resist[ATNR_LIFE_STEALING])) / 3000; 1365 dam = (dam * (100 - op->resist[ATNR_LIFE_STEALING])) / 3000;
1290 /* You die at -1 hp, not zero. */ 1366 /* You die at -1 hp, not zero. */
1291 if (dam > (op->stats.hp+1)) dam = op->stats.hp+1; 1367 if (dam > (op->stats.hp + 1))
1368 dam = op->stats.hp + 1;
1292 new_hp = hitter->stats.hp + dam; 1369 new_hp = hitter->stats.hp + dam;
1293 if (new_hp > hitter->stats.maxhp) new_hp = hitter->stats.maxhp; 1370 if (new_hp > hitter->stats.maxhp)
1294 if (new_hp > hitter->stats.hp) hitter->stats.hp = new_hp; 1371 new_hp = hitter->stats.maxhp;
1372 if (new_hp > hitter->stats.hp)
1373 hitter->stats.hp = new_hp;
1295 } 1374 }
1296 } 1375 }
1376
1297 return dam; 1377 return dam;
1298} 1378}
1299
1300 1379
1301/* GROS: This code comes from hit_player. It has been made external to 1380/* GROS: This code comes from hit_player. It has been made external to
1302 * allow script procedures to "kill" objects in a combat-like fashion. 1381 * allow script procedures to "kill" objects in a combat-like fashion.
1303 * It was initially used by (kill-object) developed for the Collector's 1382 * It was initially used by (kill-object) developed for the Collector's
1304 * Sword. Note that nothing has been changed from the original version 1383 * Sword. Note that nothing has been changed from the original version
… …
1311 * This function was a bit of a mess with hitter getting changed, 1390 * This function was a bit of a mess with hitter getting changed,
1312 * values being stored away but not used, etc. I've cleaned it up 1391 * values being stored away but not used, etc. I've cleaned it up
1313 * a bit - I think it should be functionally equivalant. 1392 * a bit - I think it should be functionally equivalant.
1314 * MSW 2002-07-17 1393 * MSW 2002-07-17
1315 */ 1394 */
1395int
1316int kill_object(object *op,int dam, object *hitter, int type) 1396kill_object (object *op, int dam, object *hitter, int type)
1317{ 1397{
1318 char buf[MAX_BUF]; 1398 char buf[MAX_BUF];
1319 const char *skill; 1399 const char *skill;
1320 int maxdam=0; 1400 int maxdam = 0;
1321 int battleg=0; /* true if op standing on battleground */ 1401 int battleg = 0; /* true if op standing on battleground */
1322 int pk=0; /* true if op and what controls hitter are both players*/ 1402 int pk = 0; /* true if op and what controls hitter are both players */
1323 object *owner=NULL; 1403 object *owner = NULL;
1324 object *skop=NULL; 1404 object *skop = NULL;
1325 1405
1326 if (op->stats.hp>=0) 1406 if (op->stats.hp >= 0)
1327 return -1; 1407 return -1;
1328 1408
1329 if (INVOKE_OBJECT (KILL, op, ARG_OBJECT (hitter))) 1409 if (INVOKE_OBJECT (KILL, op, ARG_OBJECT (hitter)))
1330 return 0; 1410 return 0;
1331 1411
1332 /* maxdam needs to be the amount of damage it took to kill 1412 /* maxdam needs to be the amount of damage it took to kill
1333 * this creature. The function(s) that call us have already 1413 * this creature. The function(s) that call us have already
1334 * adjusted the creatures HP total, so that is negative. 1414 * adjusted the creatures HP total, so that is negative.
1335 */ 1415 */
1336 maxdam = dam + op->stats.hp + 1; 1416 maxdam = dam + op->stats.hp + 1;
1337 1417
1338 if(QUERY_FLAG(op,FLAG_BLOCKSVIEW)) 1418 if (QUERY_FLAG (op, FLAG_BLOCKSVIEW))
1339 update_all_los(op->map,op->x, op->y); /* makes sure los will be recalculated */ 1419 update_all_los (op->map, op->x, op->y); /* makes sure los will be recalculated */
1340 1420
1341 if(op->type==DOOR) { 1421 if (op->type == DOOR)
1422 {
1342 op->speed = 0.1; 1423 op->set_speed (0.1);
1343 update_ob_speed(op);
1344 op->speed_left= -0.05; 1424 op->speed_left = -0.05;
1345 return maxdam; 1425 return maxdam;
1346 } 1426 }
1427
1347 if(QUERY_FLAG (op, FLAG_FRIENDLY) && op->type != PLAYER) { 1428 if (QUERY_FLAG (op, FLAG_FRIENDLY) && op->type != PLAYER)
1429 {
1348 remove_friendly_object(op); 1430 remove_friendly_object (op);
1349 if (get_owner (op) != NULL && op->owner->type == PLAYER && 1431
1350 op->owner->contr->ranges[range_golem] == op) { 1432 if (op->owner && op->owner->type == PLAYER && op->owner->contr->ranges[range_golem] == op)
1351 op->owner->contr->ranges[range_golem]=NULL; 1433 op->owner->contr->ranges[range_golem] = 0;
1352 op->owner->contr->golem_count=0;
1353 }
1354 1434
1355 remove_ob(op); 1435 op->destroy ();
1356 free_object(op);
1357 return maxdam; 1436 return maxdam;
1358 } 1437 }
1359 1438
1360 /* Now lets start dealing with experience we get for killing something */ 1439 /* Now lets start dealing with experience we get for killing something */
1361 1440
1362 owner=get_owner(hitter); 1441 owner = hitter->owner;
1363 if(owner==NULL) 1442 if (!owner)
1364 owner=hitter; 1443 owner = hitter;
1365 1444
1366 /* is the victim (op) standing on battleground? */ 1445 /* is the victim (op) standing on battleground? */
1367 if (op_on_battleground(op, NULL, NULL)) battleg=1; 1446 if (op_on_battleground (op, NULL, NULL))
1368 1447 battleg = 1;
1448
1369 /* is this player killing?*/ 1449 /* is this player killing? */
1370 if (op->type == PLAYER && owner->type == PLAYER) pk=1; 1450 if (op->type == PLAYER && owner->type == PLAYER)
1451 pk = 1;
1371 1452
1372 /* Player killed something */ 1453 /* Player killed something */
1373 if(owner->type==PLAYER) { 1454 if (owner->type == PLAYER)
1455 {
1374 Log_Kill(owner->name, 1456 Log_Kill (owner->name,
1375 query_name(op),op->type, 1457 query_name (op), op->type, (owner != hitter) ? query_name (hitter) : NULL, (owner != hitter) ? hitter->type : 0);
1376 (owner!=hitter) ? query_name(hitter) : NULL,
1377 (owner!=hitter) ? hitter->type : 0);
1378 1458
1379 /* Log players killing other players - makes it easier to detect 1459 /* Log players killing other players - makes it easier to detect
1380 * and filter out malicious player killers - that is why the 1460 * and filter out malicious player killers - that is why the
1381 * ip address is included. 1461 * ip address is included.
1382 */ 1462 */
1383 if (op->type == PLAYER && !battleg) { 1463 if (op->type == PLAYER && !battleg)
1464 {
1384 time_t t=time(NULL); 1465 time_t t = time (NULL);
1385 struct tm *tmv; 1466 struct tm *tmv;
1386 char buf[256]; 1467 char buf[256];
1387 1468
1388 tmv = localtime(&t); 1469 tmv = localtime (&t);
1389 strftime(buf, 256,"%a %b %d %H:%M:%S %Y", tmv); 1470 strftime (buf, 256, "%a %b %d %H:%M:%S %Y", tmv);
1390 1471
1391 LOG(llevInfo,"%s PLAYER_KILL_PLAYER: %s (%s) killed %s\n", 1472 LOG (llevInfo, "%s PLAYER_KILL_PLAYER: %s (%s) killed %s\n", buf, &owner->name, owner->contr->ns->host, query_name (op));
1392 buf, &owner->name, owner->contr->socket.host, query_name(op));
1393 } 1473 }
1394 1474
1395 /* try to filter some things out - basically, if you are 1475 /* try to filter some things out - basically, if you are
1396 * killing a level 1 creature and your level 20, you 1476 * killing a level 1 creature and your level 20, you
1397 * probably don't want to see that. 1477 * probably don't want to see that.
1398 */ 1478 */
1399 if ( owner->level < op->level * 2|| op->stats.exp>1000) { 1479 if (owner->level < op->level * 2 || op->stats.exp > 1000)
1480 {
1400 if(owner!=hitter) { 1481 if (owner != hitter)
1401 new_draw_info_format(NDI_BLACK, 0, owner, 1482 new_draw_info_format (NDI_BLACK, 0, owner, "You killed %s with %s.", query_name (op), query_name (hitter));
1402 "You killed %s with %s.",query_name(op), 1483 else
1403 query_name(hitter)); 1484 new_draw_info_format (NDI_BLACK, 0, owner, "You killed %s.", query_name (op));
1485
1486 /* Only play sounds for melee kills */
1487 if (hitter->type == PLAYER)
1488 play_sound_map (owner->map, owner->x, owner->y, SOUND_PLAYER_KILLS);
1489 }
1490
1491 /* If a player kills another player, not on
1492 * battleground, the "killer" looses 1 luck. Since this is
1493 * not reversible, it's actually quite a pain IMHO. -AV
1494 * Fix bug in that we were changing the luck of the hitter, not
1495 * player that the object belonged to - so if you killed another player
1496 * with spells, pets, whatever, there was no penalty.
1497 * Changed to make luck penalty configurable in settings.
1498 */
1499 if (op->type == PLAYER && owner != op && !battleg)
1500 owner->change_luck (-settings.pk_luck_penalty);
1501
1502 /* This code below deals with finding the appropriate skill
1503 * to credit exp to. This is a bit problematic - we should
1504 * probably never really have to look at current_weapon->skill
1505 */
1506 skill = 0;
1507
1508 if (hitter->skill && hitter->type != PLAYER)
1509 skill = hitter->skill;
1510 else if (owner->chosen_skill)
1511 {
1512 skill = owner->chosen_skill->skill;
1513 skop = owner->chosen_skill;
1514 }
1515 else if (QUERY_FLAG (owner, FLAG_READY_WEAPON))
1516 skill = owner->current_weapon->skill;
1517 else
1518 LOG (llevError, "kill_object - unable to find skill that killed monster\n");
1519
1520 /* We have the skill we want to credit to - now find the object this goes
1521 * to. Make sure skop is an actual skill, and not a skill tool!
1522 */
1523 if ((!skop || skop->type != SKILL) && skill)
1524 {
1525 int i;
1526
1527 for (i = 0; i < NUM_SKILLS; i++)
1528 if (owner->contr->last_skill_ob[i] && !strcmp (owner->contr->last_skill_ob[i]->skill, skill))
1529 {
1530 skop = owner->contr->last_skill_ob[i];
1531 break;
1532 }
1533 }
1534 } /* Was it a player that hit somethign */
1535 else
1536 skill = 0;
1537
1538 /* Pet (or spell) killed something. */
1539 if (owner != hitter)
1540 sprintf (buf, "%s killed %s with %s%s%s.", &owner->name,
1541 query_name (op), query_name (hitter), battleg ? " (duel)" : "", pk ? " (pk)" : "");
1542 else
1543 sprintf (buf, "%s killed %s%s%s%s.", &hitter->name, &op->name,
1544 (QUERY_FLAG (hitter, FLAG_MONSTER)) || hitter->type == PLAYER ?
1545 " in hand to hand combat" : "", battleg ? " (duel)" : "", pk ? " (pk)" : "");
1546
1547 /* These may have been set in the player code section above */
1548 if (!skop)
1549 skop = hitter->chosen_skill;
1550
1551 if (!skill && skop)
1552 skill = skop->skill;
1553
1554 new_draw_info (NDI_ALL, op->type == PLAYER ? 1 : 10, NULL, buf);
1555
1556 /* If you didn't kill yourself, and your not the wizard */
1557 if (owner != op && !QUERY_FLAG (op, FLAG_WAS_WIZ))
1558 {
1559 int exp;
1560
1561 /* Really don't give much experience for killing other players */
1562 // schmorp: temporarily? reduce the amount of exp gained for pking enourmously
1563 if (op->type == PLAYER)
1564 {
1565 if (battleg)
1566 {
1567 new_draw_info (NDI_UNIQUE, 0, owner, "Your foe has fallen!");
1568 new_draw_info (NDI_UNIQUE, 0, owner, "VICTORY!!!");
1404 } 1569 }
1405 else { 1570 else
1406 new_draw_info_format(NDI_BLACK, 0, owner, 1571 exp = op->stats.exp / 1000;
1407 "You killed %s.",query_name(op)); 1572 }
1573 else
1574 exp = calc_skill_exp (owner, op, skop);
1575
1576 /* if op is standing on "battleground" (arena), no way to gain
1577 * exp by killing him
1578 */
1579 if (battleg)
1580 exp = 0;
1581
1582 /* Don't know why this is set this way - doesn't make
1583 * sense to just divide everything by two for no reason.
1584 */
1585
1586 if (!settings.simple_exp)
1587 exp = exp / 2;
1588
1589 if (owner->type != PLAYER || owner->contr->party == NULL)
1590 change_exp (owner, exp, skill, 0);
1591 else
1592 {
1593 int shares = 0, count = 0;
1594 player *pl;
1595 partylist *party = owner->contr->party;
1596
1597 add_kill_to_party (party, query_name (owner), query_name (op), exp);
1598
1599 for_all_players (pl)
1600 if (party && pl->ob->contr->party == party && on_same_map (pl->ob, owner))
1601 {
1602 count++;
1603 shares += (pl->ob->level + 4);
1604 }
1605
1606 if (count == 1 || shares > exp || !shares)
1607 change_exp (owner, exp, skill, SK_EXP_TOTAL);
1608 else
1609 {
1610 int share = exp / shares, given = 0, nexp;
1611
1612 for_all_players (pl)
1613 if (party && pl->ob->contr->party == party && on_same_map (pl->ob, owner))
1614 {
1615 nexp = (pl->ob->level + 4) * share;
1616 change_exp (pl->ob, nexp, skill, SK_EXP_TOTAL);
1617 given += nexp;
1618 }
1619
1620 exp -= given;
1621 /* give any remainder to the player */
1622 change_exp (owner, exp, skill, SK_EXP_ADD_SKILL);
1408 } 1623 }
1409 /* Only play sounds for melee kills */ 1624 } /* else part of a party */
1410 if (hitter->type == PLAYER) 1625 } /* end if person didn't kill himself */
1411 play_sound_map(owner->map, owner->x, owner->y, SOUND_PLAYER_KILLS); 1626
1627 if (op->type != PLAYER)
1628 {
1629 if (QUERY_FLAG (op, FLAG_FRIENDLY))
1412 } 1630 {
1631 object *owner1 = op->owner;
1413 1632
1414 /* If a player kills another player, not on 1633 if (owner1 && owner1->type == PLAYER)
1415 * battleground, the "killer" looses 1 luck. Since this is
1416 * not reversible, it's actually quite a pain IMHO. -AV
1417 * Fix bug in that we were changing the luck of the hitter, not
1418 * player that the object belonged to - so if you killed another player
1419 * with spells, pets, whatever, there was no penalty.
1420 * Changed to make luck penalty configurable in settings.
1421 */
1422 if(op->type == PLAYER && owner != op && !battleg)
1423 change_luck(owner, -settings.pk_luck_penalty);
1424
1425 /* This code below deals with finding the appropriate skill
1426 * to credit exp to. This is a bit problematic - we should
1427 * probably never really have to look at current_weapon->skill
1428 */
1429 skill = NULL;
1430 if (hitter->skill && hitter->type!=PLAYER) skill = hitter->skill;
1431 else if (owner->chosen_skill) {
1432 skill = owner->chosen_skill->skill;
1433 skop = owner->chosen_skill;
1434 }
1435 else if (QUERY_FLAG(owner, FLAG_READY_WEAPON)) skill=owner->current_weapon->skill;
1436 else
1437 LOG(llevError,"kill_object - unable to find skill that killed monster\n");
1438
1439 /* We have the skill we want to credit to - now find the object this goes
1440 * to. Make sure skop is an actual skill, and not a skill tool!
1441 */
1442 if ((!skop || skop->type != SKILL) && skill) {
1443 int i;
1444
1445 for (i=0; i<NUM_SKILLS; i++)
1446 if (owner->contr->last_skill_ob[i] &&
1447 !strcmp(owner->contr->last_skill_ob[i]->skill, skill)) {
1448 skop = owner->contr->last_skill_ob[i];
1449 break;
1450 } 1634 {
1451 } 1635 play_sound_player_only (owner1->contr, SOUND_PET_IS_KILLED, 0, 0);
1452 } /* Was it a player that hit somethign */ 1636 /* Maybe we should include the owner that killed this, maybe not */
1453 else { 1637 new_draw_info_format (NDI_UNIQUE, 0, owner1, "Your pet, the %s, is killed by %s.", &op->name, &hitter->name);
1454 skill = NULL;
1455 }
1456
1457 /* Pet (or spell) killed something. */
1458 if(owner != hitter ) {
1459 (void) sprintf(buf,"%s killed %s with %s%s%s.",&owner->name,
1460 query_name(op),query_name(hitter), battleg? " (duel)":"", pk? " (pk)":"");
1461 }
1462 else {
1463 (void) sprintf(buf,"%s killed %s%s%s%s.",&hitter->name,&op->name,
1464 (QUERY_FLAG(hitter, FLAG_MONSTER)) || hitter->type == PLAYER ?
1465 " in hand to hand combat":"", battleg? " (duel)":"", pk? " (pk)":"");
1466 }
1467 /* These may have been set in the player code section above */
1468 if (!skop) skop = hitter->chosen_skill;
1469 if (!skill && skop) skill=skop->skill;
1470
1471 new_draw_info(NDI_ALL, op->type==PLAYER?1:10, NULL, buf);
1472
1473
1474 /* If you didn't kill yourself, and your not the wizard */
1475 if(owner!=op && !QUERY_FLAG(op, FLAG_WAS_WIZ)) {
1476 int exp;
1477
1478 /* Really don't give much experience for killing other players */
1479 // schmorp: temporary? reduce the amount of exp gained for pking enourmously
1480 if (op->type==PLAYER) {
1481 if (battleg) {
1482 new_draw_info(NDI_UNIQUE, 0,owner, "Your foe has fallen!");
1483 new_draw_info(NDI_UNIQUE, 0,owner, "VICTORY!!!");
1484 } 1638 }
1485 else
1486 exp = op->stats.exp / 1000;
1487 }
1488 else
1489 exp = calc_skill_exp(owner, op, skop);
1490 1639
1491 /* if op is standing on "battleground" (arena), no way to gain
1492 * exp by killing him
1493 */
1494 if (battleg) exp = 0;
1495
1496 /* Don't know why this is set this way - doesn't make
1497 * sense to just divide everything by two for no reason.
1498 */
1499
1500 if (!settings.simple_exp)
1501 exp=exp/2;
1502
1503 if(owner->type!=PLAYER || owner->contr->party==NULL) {
1504 change_exp(owner,exp, skill, 0);
1505 }
1506 else {
1507 int shares=0,count=0;
1508
1509 player *pl;
1510
1511 partylist *party=owner->contr->party;
1512#ifdef PARTY_KILL_LOG
1513 add_kill_to_party(party, query_name(owner), query_name(op), exp);
1514#endif
1515 for(pl=first_player;pl!=NULL;pl=pl->next) {
1516 if(party && pl->ob->contr->party==party && on_same_map(pl->ob, owner)) {
1517 count++;
1518 shares+=(pl->ob->level+4);
1519 }
1520 }
1521 if(count==1 || shares>exp)
1522 change_exp(owner,exp, skill, SK_EXP_TOTAL);
1523 else {
1524 int share=exp/shares,given=0,nexp;
1525 for(pl=first_player;pl!=NULL;pl=pl->next) {
1526 if(party && pl->ob->contr->party==party && on_same_map(pl->ob, owner)) {
1527 nexp=(pl->ob->level+4)*share;
1528 change_exp(pl->ob,nexp, skill, SK_EXP_TOTAL);
1529 given+=nexp;
1530 }
1531 }
1532 exp-=given;
1533 /* give any remainder to the player */
1534 change_exp(owner,exp, skill, SK_EXP_ADD_SKILL);
1535 }
1536 } /* else part of a party */
1537
1538 } /* end if person didn't kill himself */
1539
1540 if(op->type!=PLAYER) {
1541 if(QUERY_FLAG(op,FLAG_FRIENDLY)) {
1542 object *owner1 = get_owner(op);
1543
1544 if(owner1!= NULL && owner1->type == PLAYER) {
1545 play_sound_player_only(owner1->contr, SOUND_PET_IS_KILLED,0,0);
1546 /* Maybe we should include the owner that killed this, maybe not */
1547 new_draw_info_format(NDI_UNIQUE, 0,owner1,"Your pet, the %s, is killed by %s.",
1548 &op->name,&hitter->name);
1549 }
1550 remove_friendly_object(op); 1640 remove_friendly_object (op);
1551 } 1641 }
1552 remove_ob(op); 1642
1553 free_object(op); 1643 op->destroy ();
1644 }
1645 else
1554 } 1646 {
1555 /* Player has been killed! */ 1647 /* Player has been killed! */
1556 else {
1557 if(owner->type==PLAYER) { 1648 if (owner->type == PLAYER)
1558 snprintf(op->contr->killer, BIG_NAME, "%s the %s", &owner->name, owner->contr->title); 1649 snprintf (op->contr->killer, sizeof (op->contr->killer), "%s the %s", &owner->name, owner->contr->title);
1559 }
1560 else { 1650 else
1561 strncpy(op->contr->killer,hitter->name,BIG_NAME); 1651 assign (op->contr->killer, hitter->name);
1562 op->contr->killer[BIG_NAME-1]='\0';
1563 }
1564 } 1652 }
1653
1565 /* This was return -1 - that doesn't seem correct - if we return -1, process 1654 /* This was return -1 - that doesn't seem correct - if we return -1, process
1566 * continues in the calling function. 1655 * continues in the calling function.
1567 */ 1656 */
1568 return maxdam; 1657 return maxdam;
1569} 1658}
1570 1659
1571/* Find out if this is friendly fire (PVP and attacker is peaceful) or not 1660/* Find out if this is friendly fire (PVP and attacker is peaceful) or not
1572 * Returns 0 this is not friendly fire 1661 * Returns 0 this is not friendly fire
1573 */ 1662 */
1574 1663
1664int
1575int friendly_fire(object *op, object *hitter){ 1665friendly_fire (object *op, object *hitter)
1666{
1576 object *owner; 1667 object *owner;
1577 int friendlyfire; 1668 int friendlyfire;
1578
1579 if (hitter->head) hitter=hitter->head;
1580 1669
1670 if (hitter->head)
1671 hitter = hitter->head;
1672
1581 friendlyfire = 0; 1673 friendlyfire = 0;
1582 1674
1583 if(op->type == PLAYER) { 1675 if (op->type == PLAYER)
1676 {
1584 if (op_on_battleground (hitter, 0, 0)) 1677 if (op_on_battleground (hitter, 0, 0))
1585 return 0; 1678 return 0;
1586 1679
1587 if(hitter->type == PLAYER && hitter->contr->peaceful == 1) 1680 if (hitter->type == PLAYER && hitter->contr->peaceful == 1)
1588 return 1; 1681 return 1;
1589 1682
1590 if((owner = get_owner(hitter))!=NULL) { 1683 if ((owner = hitter->owner) != NULL)
1684 {
1591 if(owner->type == PLAYER && owner->contr->peaceful == 1) 1685 if (owner->type == PLAYER && owner->contr->peaceful == 1)
1592 friendlyfire = 2; 1686 friendlyfire = 2;
1593 } 1687 }
1594 1688
1595 if (hitter->type == SPELL || hitter->type == POISONING || 1689 if (hitter->type == SPELL || hitter->type == POISONING || hitter->type == DISEASE || hitter->type == RUNE)
1596 hitter->type == DISEASE || hitter->type == RUNE)
1597 friendlyfire = 0; 1690 friendlyfire = 0;
1598 } 1691 }
1599 return friendlyfire; 1692 return friendlyfire;
1600} 1693}
1601 1694
1602 1695
1603/* This isn't used just for players, but in fact most objects. 1696/* This isn't used just for players, but in fact most objects.
1604 * op is the object to be hit, dam is the amount of damage, hitter 1697 * op is the object to be hit, dam is the amount of damage, hitter
1605 * is what is hitting the object, type is the attacktype, and 1698 * is what is hitting the object, type is the attacktype, and
1606 * full_hit is set if monster area does not matter. 1699 * full_hit is set if monster area does not matter.
1607 * dam is base damage - protections/vulnerabilities/slaying matches can 1700 * dam is base damage - protections/vulnerabilities/slaying matches can
1608 * modify it. 1701 * modify it.
1609 */ 1702 */
1610
1611 /* Oct 95 - altered the following slightly for MULTIPLE_GODS hack 1703/* Oct 95 - altered the following slightly for MULTIPLE_GODS hack
1612 * which needs new attacktype AT_HOLYWORD to work . b.t. */ 1704 * which needs new attacktype AT_HOLYWORD to work . b.t. */
1613 1705int
1614int hit_player(object *op,int dam, object *hitter, int type, int full_hit) { 1706hit_player (object *op, int dam, object *hitter, int type, int full_hit)
1707{
1615 int maxdam=0, ndam=0, attacktype=1, magic=(type & AT_MAGIC); 1708 int maxdam = 0, ndam = 0, attacktype = 1, magic = (type & AT_MAGIC);
1616 int maxattacktype, attacknum; 1709 int maxattacktype, attacknum;
1617 int body_attack = op && op->head; /* Did we hit op's head? */ 1710 int body_attack = op && op->head; /* Did we hit op's head? */
1618 int simple_attack; 1711 int simple_attack;
1619 tag_t op_tag, hitter_tag;
1620 int rtn_kill = 0; 1712 int rtn_kill = 0;
1621 int friendlyfire; 1713 int friendlyfire;
1622 1714
1623 if (get_attack_mode (&op, &hitter, &simple_attack)) 1715 if (get_attack_mode (&op, &hitter, &simple_attack))
1716 return 0;
1717
1718 /* very simple: if our target has no_damage 1 set or is wiz, we can't hurt him */
1719 if (QUERY_FLAG (op, FLAG_WIZ) || QUERY_FLAG (op, FLAG_NO_DAMAGE))
1720 return 0;
1721
1722#ifdef PROHIBIT_PLAYERKILL
1723 if (op->type == PLAYER)
1724 {
1725 object *owner = hitter->owner;
1726
1727 if (!owner)
1728 owner = hitter;
1729
1730 if (owner->type == PLAYER && (!op_on_battleground (op, 0, 0) && (op->contr->peaceful || owner->contr->peaceful)) && op != owner)
1624 return 0; 1731 return 0;
1732 }
1733#endif
1625 1734
1626 /* very simple: if our target has no_damage 1 set or is wiz, we can't hurt him */ 1735 if (body_attack)
1627 if (QUERY_FLAG (op, FLAG_WIZ) || QUERY_FLAG (op, FLAG_NO_DAMAGE)) 1736 {
1737 /* slow and paralyze must hit the head. But we don't want to just
1738 * return - we still need to process other attacks the spell still
1739 * might have. So just remove the paralyze and slow attacktypes,
1740 * and keep on processing if we have other attacktypes.
1741 * return if only magic or nothing is left - under normal code
1742 * we don't attack with pure magic if there is another attacktype.
1743 * Only do processing if the initial attacktype includes one of those
1744 * attack so we don't cancel out things like magic bullet.
1745 */
1746 if (type & (AT_PARALYZE | AT_SLOW))
1747 {
1748 type &= ~(AT_PARALYZE | AT_SLOW);
1749
1750 if (!type || type == AT_MAGIC)
1628 return 0; 1751 return 0;
1752 }
1753 }
1629 1754
1630#ifdef PROHIBIT_PLAYERKILL 1755 if (!simple_attack && op->type == DOOR)
1631 if (op->type == PLAYER) { 1756 {
1632 object *owner = get_owner (hitter); 1757 object *tmp;
1633 if (!owner) owner = hitter; 1758
1634 if (owner->type == PLAYER 1759 for (tmp = op->inv; tmp != NULL; tmp = tmp->below)
1635 && (!op_on_battleground (op, 0, 0) && (op->contr->peaceful || owner->contr->peaceful)) 1760 if (tmp->type == RUNE || tmp->type == TRAP)
1636 && op != owner) { 1761 {
1762 spring_trap (tmp, hitter);
1763
1764 if (hitter->destroyed () || op->destroyed () || abort_attack (op, hitter, simple_attack))
1637 return 0; 1765 return 0;
1766
1767 break;
1638 } 1768 }
1769 }
1770
1771 if (!QUERY_FLAG (op, FLAG_ALIVE) || op->stats.hp < 0)
1639 } 1772 {
1773 /* FIXME: If a player is killed by a rune in a door, the
1774 * destroyed() check above doesn't return, and might get here.
1775 */
1776 LOG (llevDebug, "victim (arch %s, name %s) already dead in " "hit_player()\n", &op->arch->name, &op->name);
1777 return 0;
1778 }
1779
1780#ifdef ATTACK_DEBUG
1781 LOG (llevDebug, "hit player: attacktype %d, dam %d\n", type, dam);
1640#endif 1782#endif
1641 1783
1642 op_tag = op->count;
1643 hitter_tag = hitter->count;
1644
1645 if (body_attack) {
1646 /* slow and paralyze must hit the head. But we don't want to just
1647 * return - we still need to process other attacks the spell still
1648 * might have. So just remove the paralyze and slow attacktypes,
1649 * and keep on processing if we have other attacktypes.
1650 * return if only magic or nothing is left - under normal code
1651 * we don't attack with pure magic if there is another attacktype.
1652 * Only do processing if the initial attacktype includes one of those
1653 * attack so we don't cancel out things like magic bullet.
1654 */
1655 if (type & (AT_PARALYZE | AT_SLOW)) {
1656 type &= ~(AT_PARALYZE | AT_SLOW);
1657 if (!type || type==AT_MAGIC) return 0;
1658 }
1659 }
1660
1661 if ( ! simple_attack && op->type == DOOR) {
1662 object *tmp;
1663 for (tmp = op->inv; tmp != NULL; tmp = tmp->below)
1664 if (tmp->type == RUNE || tmp->type == TRAP) {
1665 spring_trap (tmp, hitter);
1666 if (was_destroyed (hitter, hitter_tag)
1667 || was_destroyed (op, op_tag)
1668 || abort_attack (op, hitter, simple_attack))
1669 return 0;
1670 break;
1671 }
1672 }
1673
1674 if ( ! QUERY_FLAG (op, FLAG_ALIVE) || op->stats.hp < 0) {
1675 /* FIXME: If a player is killed by a rune in a door, the
1676 * was_destroyed() check above doesn't return, and might get here.
1677 */
1678 LOG (llevDebug, "victim (arch %s, name %s) already dead in "
1679 "hit_player()\n", &op->arch->name, &op->name);
1680 return 0;
1681 }
1682
1683#ifdef ATTACK_DEBUG
1684 LOG(llevDebug,"hit player: attacktype %d, dam %d\n", type, dam);
1685#endif
1686
1687 if (magic) { 1784 if (magic)
1785 {
1688 /* basically: dam = dam*(100-op->resist[attacknum])/100; 1786 /* basically: dam = dam*(100-op->resist[attacknum])/100;
1689 * in case 0>dam>1, we try to "simulate" a float value-effect */ 1787 * in case 0>dam>1, we try to "simulate" a float value-effect */
1690 dam = dam*(100-op->resist[ATNR_MAGIC]); 1788 dam = dam * (100 - op->resist[ATNR_MAGIC]);
1691 if (dam >= 100) 1789 if (dam >= 100)
1692 dam /= 100; 1790 dam /= 100;
1693 else 1791 else
1694 dam = (dam > (rndm(0, 99))) ? 1 : 0; 1792 dam = (dam > (rndm (0, 99))) ? 1 : 0;
1695 } 1793 }
1696 1794
1697 /* AT_CHAOS here is a weapon or monster. Spells are handled by hit_map 1795 /* AT_CHAOS here is a weapon or monster. Spells are handled by hit_map
1698 * If the attacktype still has chaos, shuffle it, then clear the Chaos bit 1796 * If the attacktype still has chaos, shuffle it, then clear the Chaos bit
1699 */ 1797 */
1700 if(type & AT_CHAOS){ 1798 if (type & AT_CHAOS)
1799 {
1701 shuffle_attack(op,0); /*0 flag tells it to not change the face */ 1800 shuffle_attack (op, 0); /*0 flag tells it to not change the face */
1702 update_object(op,UP_OBJ_FACE); 1801 update_object (op, UP_OBJ_FACE);
1703 type &= ~AT_CHAOS; 1802 type &= ~AT_CHAOS;
1704 } 1803 }
1705 1804
1706 /* Holyword is really an attacktype modifier (like magic is). If 1805 /* Holyword is really an attacktype modifier (like magic is). If
1707 * holyword is part of an attacktype, then make sure the creature is 1806 * holyword is part of an attacktype, then make sure the creature is
1708 * a proper match, otherwise no damage. 1807 * a proper match, otherwise no damage.
1709 */ 1808 */
1710 if (type & AT_HOLYWORD) { 1809 if (type & AT_HOLYWORD)
1810 {
1711 object *god; 1811 object *god;
1812
1712 if ((!hitter->slaying || 1813 if ((!hitter->slaying ||
1713 (!(op->race && strstr(hitter->slaying,op->race)) && 1814 (!(op->race && strstr (hitter->slaying, op->race)) &&
1714 !(op->name && strstr(hitter->slaying,op->name)))) && 1815 !(op->name && strstr (hitter->slaying, op->name)))) &&
1715 (!QUERY_FLAG(op,FLAG_UNDEAD) || 1816 (!QUERY_FLAG (op, FLAG_UNDEAD) ||
1716 (hitter->title != NULL 1817 (hitter->title != NULL
1717 && (god = find_god(determine_god(hitter))) != NULL 1818 && (god = find_god (determine_god (hitter))) != NULL && god->race != NULL && strstr (god->race, undead_name) != NULL)))
1718 && god->race != NULL
1719 && strstr(god->race,undead_name) != NULL)))
1720 return 0; 1819 return 0;
1721 } 1820 }
1722 1821
1723 maxattacktype = type; /* initialize this to something */ 1822 maxattacktype = type; /* initialise this to something */
1724 for (attacknum=0; attacknum<NROFATTACKS; attacknum++, attacktype=1<<attacknum) { 1823 for (attacknum = 0; attacknum < NROFATTACKS; attacknum++, attacktype = 1 << attacknum)
1824 {
1725 /* Magic isn't really a true attack type - it gets combined with other 1825 /* Magic isn't really a true attack type - it gets combined with other
1726 * attack types. As such, skip it over. However, if magic is 1826 * attack types. As such, skip it over. However, if magic is
1727 * the only attacktype in the group, then still attack with it 1827 * the only attacktype in the group, then still attack with it
1728 */ 1828 */
1729 if ((attacktype==AT_MAGIC) && (type & ~AT_MAGIC)) continue; 1829 if ((attacktype == AT_MAGIC) && (type & ~AT_MAGIC))
1830 continue;
1730 1831
1731 /* Go through and hit the player with each attacktype, one by one. 1832 /* Go through and hit the player with each attacktype, one by one.
1732 * hit_player_attacktype only figures out the damage, doesn't inflict 1833 * hit_player_attacktype only figures out the damage, doesn't inflict
1733 * it. It will do the appropriate action for attacktypes with 1834 * it. It will do the appropriate action for attacktypes with
1734 * effects (slow, paralization, etc. 1835 * effects (slow, paralization, etc.
1735 */ 1836 */
1736 if (type & attacktype) { 1837 if (type & attacktype)
1838 {
1737 ndam=hit_player_attacktype(op,hitter,dam,attacknum,magic); 1839 ndam = hit_player_attacktype (op, hitter, dam, attacknum, magic);
1738 /* the >= causes us to prefer messages from special attacks, if 1840 /* the >= causes us to prefer messages from special attacks, if
1739 * the damage is equal. 1841 * the damage is equal.
1740 */ 1842 */
1741 if (ndam >= maxdam) { 1843 if (ndam >= maxdam)
1844 {
1742 maxdam = ndam; 1845 maxdam = ndam;
1743 maxattacktype = 1<<attacknum; 1846 maxattacktype = 1 << attacknum;
1744 } 1847 }
1745 } 1848 }
1746 } 1849 }
1747 1850
1748 /* if this is friendly fire then do a set % of damage only 1851 /* if this is friendly fire then do a set % of damage only
1749 * Note - put a check in to make sure this attack is actually 1852 * Note - put a check in to make sure this attack is actually
1750 * doing damage - otherwise, the +1 in the code below will make 1853 * doing damage - otherwise, the +1 in the code below will make
1751 * an attack do damage before when it otherwise didn't 1854 * an attack do damage before when it otherwise didn't
1752 */ 1855 */
1753 friendlyfire = friendly_fire(op, hitter); 1856 friendlyfire = friendly_fire (op, hitter);
1754 if (friendlyfire && maxdam){ 1857 if (friendlyfire && maxdam)
1858 {
1755 maxdam = ((dam * settings.set_friendly_fire) / 100); 1859 maxdam = ((dam * settings.set_friendly_fire) / 100);
1756#ifndef COZY_SERVER 1860#ifndef COZY_SERVER
1861 maxdam++;
1862#endif
1863
1864#ifdef ATTACK_DEBUG
1865 LOG (llevDebug, "Friendly fire (type:%d setting: %d%) did %d damage dropped to %d\n",
1866 friendlyfire, settings.set_friendly_fire, dam, maxdam);
1867#endif
1868 }
1869
1870 if (!full_hit)
1871 {
1872 archetype *at;
1873 int area;
1874 int remainder;
1875
1876 area = 0;
1877 for (at = op->arch; at != NULL; at = at->more)
1878 area++;
1879 assert (area > 0);
1880
1881 /* basically: maxdam /= area; we try to "simulate" a float
1882 value-effect */
1883 remainder = 100 * (maxdam % area) / area;
1884 maxdam /= area;
1885 if (RANDOM () % 100 < remainder)
1757 maxdam++; 1886 maxdam++;
1887 }
1888
1889#ifdef ATTACK_DEBUG
1890 LOG (llevDebug, "Attacktype %d did %d damage\n", type, maxdam);
1758#endif 1891#endif
1759
1760#ifdef ATTACK_DEBUG
1761 LOG(llevDebug,"Friendly fire (type:%d setting: %d%) did %d damage dropped to %d\n",
1762 friendlyfire, settings.set_friendly_fire, dam, maxdam);
1763#endif
1764 }
1765 1892
1766 if (!full_hit) { 1893 if (hitter->owner)
1767 archetype *at;
1768 int area;
1769 int remainder;
1770
1771 area = 0;
1772 for(at = op->arch; at != NULL; at = at->more)
1773 area++;
1774 assert(area > 0);
1775
1776 /* basically: maxdam /= area; we try to "simulate" a float
1777 value-effect */
1778 remainder = 100*(maxdam%area)/area;
1779 maxdam /= area;
1780 if (RANDOM()%100 < remainder)
1781 maxdam++;
1782 }
1783
1784#ifdef ATTACK_DEBUG
1785 LOG(llevDebug,"Attacktype %d did %d damage\n", type, maxdam);
1786#endif
1787
1788 if(get_owner(hitter))
1789 op->enemy=hitter->owner; 1894 op->enemy = hitter->owner;
1790 else if (QUERY_FLAG(hitter,FLAG_ALIVE)) 1895 else if (QUERY_FLAG (hitter, FLAG_ALIVE))
1791 op->enemy=hitter; 1896 op->enemy = hitter;
1792 1897
1793 if(QUERY_FLAG(op,FLAG_UNAGGRESSIVE) && op->type != PLAYER) { 1898 if (QUERY_FLAG (op, FLAG_UNAGGRESSIVE) && op->type != PLAYER)
1899 {
1794 /* The unaggressives look after themselves 8) */ 1900 /* The unaggressives look after themselves 8) */
1795 CLEAR_FLAG(op, FLAG_UNAGGRESSIVE); 1901 CLEAR_FLAG (op, FLAG_UNAGGRESSIVE);
1796 npc_call_help(op); 1902 npc_call_help (op);
1797 } 1903 }
1798 1904
1799 if (magic && did_make_save(op, op->level, 0)) 1905 if (magic && did_make_save (op, op->level, 0))
1800 maxdam=maxdam/2; 1906 maxdam = maxdam / 2;
1801 1907
1802 attack_message(maxdam, maxattacktype, op, hitter); 1908 attack_message (maxdam, maxattacktype, op, hitter);
1803 1909
1804 op->stats.hp-=maxdam; 1910 op->stats.hp -= maxdam;
1805 1911
1806 /* Eneq(@csd.uu.se): Check to see if monster runs away. */ 1912 /* Eneq(@csd.uu.se): Check to see if monster runs away. */
1807 if ((op->stats.hp>=0) && 1913 if ((op->stats.hp >= 0) &&
1808 (QUERY_FLAG(op, FLAG_MONSTER) || op->type == PLAYER) && 1914 (QUERY_FLAG (op, FLAG_MONSTER) || op->type == PLAYER) &&
1809 op->stats.hp<(signed short)(((float)op->run_away/(float)100)* 1915 op->stats.hp < (signed short) (((float) op->run_away / (float) 100) * (float) op->stats.maxhp))
1810 (float)op->stats.maxhp)) { 1916 {
1811 1917
1812 if (QUERY_FLAG(op, FLAG_MONSTER)) 1918 if (QUERY_FLAG (op, FLAG_MONSTER))
1813 SET_FLAG(op, FLAG_RUN_AWAY); 1919 SET_FLAG (op, FLAG_RUN_AWAY);
1814 else 1920 else
1815 scare_creature(op, hitter); 1921 scare_creature (op, hitter);
1816 } 1922 }
1817 1923
1818 if(QUERY_FLAG(op,FLAG_TEAR_DOWN)) { 1924 if (QUERY_FLAG (op, FLAG_TEAR_DOWN))
1925 {
1819 if (maxdam) 1926 if (maxdam)
1820 tear_down_wall(op); 1927 tear_down_wall (op);
1928
1821 return maxdam; /* nothing more to do for wall */ 1929 return maxdam; /* nothing more to do for wall */
1822 } 1930 }
1823 1931
1824 /* See if the creature has been killed */ 1932 /* See if the creature has been killed */
1825 rtn_kill = kill_object(op, maxdam, hitter, type); 1933 rtn_kill = kill_object (op, maxdam, hitter, type);
1826 if (rtn_kill != -1) 1934 if (rtn_kill != -1)
1827 return rtn_kill; 1935 return rtn_kill;
1828 1936
1829 1937
1830 /* Used to be ghosthit removal - we now use the ONE_HIT flag. Note 1938 /* Used to be ghosthit removal - we now use the ONE_HIT flag. Note
1831 * that before if the player was immune to ghosthit, the monster 1939 * that before if the player was immune to ghosthit, the monster
1832 * remained - that is no longer the case. 1940 * remained - that is no longer the case.
1833 */ 1941 */
1834 if(QUERY_FLAG(hitter, FLAG_ONE_HIT)) { 1942 if (QUERY_FLAG (hitter, FLAG_ONE_HIT))
1943 {
1835 if(QUERY_FLAG(hitter,FLAG_FRIENDLY)) 1944 if (QUERY_FLAG (hitter, FLAG_FRIENDLY))
1836 remove_friendly_object(hitter); 1945 remove_friendly_object (hitter);
1837 remove_ob(hitter); 1946
1838 free_object(hitter); 1947 hitter->destroy ();
1839 } 1948 }
1840 /* Lets handle creatures that are splitting now */ 1949 /* Lets handle creatures that are splitting now */
1841 else if(type&AT_PHYSICAL&&!QUERY_FLAG(op, FLAG_FREED)&&QUERY_FLAG(op,FLAG_SPLITTING)) { 1950 else if (type & AT_PHYSICAL && !QUERY_FLAG (op, FLAG_FREED) && QUERY_FLAG (op, FLAG_SPLITTING))
1951 {
1842 int i; 1952 int i;
1843 int friendly = QUERY_FLAG(op,FLAG_FRIENDLY); 1953 int friendly = QUERY_FLAG (op, FLAG_FRIENDLY);
1844 int unaggressive = QUERY_FLAG(op, FLAG_UNAGGRESSIVE); 1954 int unaggressive = QUERY_FLAG (op, FLAG_UNAGGRESSIVE);
1845 object *owner = get_owner(op); 1955 object *owner = op->owner;
1846 1956
1847 if(!op->other_arch) { 1957 if (!op->other_arch)
1958 {
1848 LOG(llevError,"SPLITTING without other_arch error.\n"); 1959 LOG (llevError, "SPLITTING without other_arch error.\n");
1849 return maxdam; 1960 return maxdam;
1850 } 1961 }
1851 remove_ob(op); 1962
1852 for(i=0;i<NROFNEWOBJS(op);i++) { /* This doesn't handle op->more yet */ 1963 op->remove ();
1964
1965 for (i = 0; i < NROFNEWOBJS (op); i++)
1966 { /* This doesn't handle op->more yet */
1853 object *tmp=arch_to_object(op->other_arch); 1967 object *tmp = arch_to_object (op->other_arch);
1854 int j; 1968 int j;
1855 1969
1856 tmp->stats.hp=op->stats.hp; 1970 tmp->stats.hp = op->stats.hp;
1971
1857 if (friendly) { 1972 if (friendly)
1858 SET_FLAG(tmp, FLAG_FRIENDLY); 1973 {
1859 add_friendly_object(tmp); 1974 add_friendly_object (tmp);
1860 tmp->attack_movement = PETMOVE; 1975 tmp->attack_movement = PETMOVE;
1976
1861 if (owner!=NULL) 1977 if (owner)
1862 set_owner(tmp,owner); 1978 tmp->set_owner (owner);
1863 } 1979 }
1980
1864 if (unaggressive) 1981 if (unaggressive)
1865 SET_FLAG(tmp, FLAG_UNAGGRESSIVE); 1982 SET_FLAG (tmp, FLAG_UNAGGRESSIVE);
1983
1866 j=find_first_free_spot(tmp,op->map,op->x,op->y); 1984 j = find_first_free_spot (tmp, op->map, op->x, op->y);
1985
1867 if (j==-1) /* No spot to put this monster */ 1986 if (j == -1) /* No spot to put this monster */
1868 free_object(tmp); 1987 tmp->destroy ();
1869 else { 1988 else
1989 {
1870 tmp->x=op->x+freearr_x[j],tmp->y=op->y+freearr_y[j]; 1990 tmp->x = op->x + freearr_x[j], tmp->y = op->y + freearr_y[j];
1871 insert_ob_in_map(tmp,op->map,NULL,0); 1991 insert_ob_in_map (tmp, op->map, NULL, 0);
1872 } 1992 }
1873 } 1993 }
1874 if(friendly) 1994
1875 remove_friendly_object(op); 1995 op->destroy ();
1876 free_object(op);
1877 } 1996 }
1878 else if(type & AT_DRAIN && hitter->type==GRIMREAPER&&hitter->value++>10) { 1997 else if (type & AT_DRAIN && hitter->type == GRIMREAPER && hitter->value++ > 10)
1879 remove_ob(hitter); 1998 hitter->destroy ();
1880 free_object(hitter); 1999
1881 }
1882 return maxdam; 2000 return maxdam;
1883} 2001}
1884 2002
1885 2003
2004void
1886void poison_player(object *op, object *hitter, int dam) 2005poison_player (object *op, object *hitter, int dam)
1887{ 2006{
1888 archetype *at = find_archetype("poisoning"); 2007 archetype *at = archetype::find ("poisoning");
1889 object *tmp=present_arch_in_ob(at,op); 2008 object *tmp = present_arch_in_ob (at, op);
1890 2009
1891 if(tmp==NULL) { 2010 if (tmp == NULL)
2011 {
1892 if((tmp=arch_to_object(at))==NULL) 2012 if ((tmp = arch_to_object (at)) == NULL)
1893 LOG(llevError,"Failed to clone arch poisoning.\n"); 2013 LOG (llevError, "Failed to clone arch poisoning.\n");
1894 else { 2014 else
2015 {
1895 tmp = insert_ob_in_ob(tmp,op); 2016 tmp = insert_ob_in_ob (tmp, op);
1896 /* peterm: give poisoning some teeth. It should 2017 /* peterm: give poisoning some teeth. It should
1897 * be able to kill things better than it does: 2018 * be able to kill things better than it does:
1898 * damage should be dependent something--I choose to 2019 * damage should be dependent something--I choose to
1899 * do this: if it's a monster, the damage from the 2020 * do this: if it's a monster, the damage from the
1900 * poisoning goes as the level of the monster/2. 2021 * poisoning goes as the level of the monster/2.
1901 * If anything else, goes as damage. 2022 * If anything else, goes as damage.
1902 */ 2023 */
1903 2024
1904 if(QUERY_FLAG(hitter,FLAG_ALIVE)) 2025 if (QUERY_FLAG (hitter, FLAG_ALIVE))
1905 tmp->stats.dam += hitter->level/2; 2026 tmp->stats.dam += hitter->level / 2;
1906 else 2027 else
1907 tmp->stats.dam = dam; 2028 tmp->stats.dam = dam;
1908 2029
1909 copy_owner(tmp,hitter); /* so we get credit for poisoning kills */ 2030 tmp->set_owner (hitter); /* so we get credit for poisoning kills */
1910 if(hitter->skill && hitter->skill != tmp->skill) { 2031 if (hitter->skill && hitter->skill != tmp->skill)
2032 {
1911 tmp->skill = hitter->skill; 2033 tmp->skill = hitter->skill;
1912 } 2034 }
1913 2035
1914 tmp->stats.food+=dam; /* more damage, longer poisoning */ 2036 tmp->stats.food += dam; /* more damage, longer poisoning */
1915 2037
1916 if(op->type==PLAYER) { 2038 if (op->type == PLAYER)
2039 {
1917 /* player looses stats, maximum is -10 of each */ 2040 /* player looses stats, maximum is -10 of each */
1918 tmp->stats.Con= MAX(-(dam/4+1), -10); 2041 tmp->stats.Con = MAX (-(dam / 4 + 1), -10);
1919 tmp->stats.Str= MAX(-(dam/3+2), -10); 2042 tmp->stats.Str = MAX (-(dam / 3 + 2), -10);
1920 tmp->stats.Dex= MAX(-(dam/6+1), -10); 2043 tmp->stats.Dex = MAX (-(dam / 6 + 1), -10);
1921 tmp->stats.Int= MAX(-dam/7, -10); 2044 tmp->stats.Int = MAX (-dam / 7, -10);
1922 SET_FLAG(tmp,FLAG_APPLIED); 2045 SET_FLAG (tmp, FLAG_APPLIED);
1923 fix_player(op); 2046 op->update_stats ();
1924 new_draw_info(NDI_UNIQUE, 0,op,"You suddenly feel very ill."); 2047 new_draw_info (NDI_UNIQUE, 0, op, "You suddenly feel very ill.");
1925 } 2048 }
1926 if (hitter->type == PLAYER) 2049 if (hitter->type == PLAYER)
1927 new_draw_info_format(NDI_UNIQUE, 0, hitter, "You poison %s.", &op->name); 2050 new_draw_info_format (NDI_UNIQUE, 0, hitter, "You poison %s.", &op->name);
1928 else if (get_owner(hitter) != NULL && hitter->owner->type == PLAYER) 2051 else if (hitter->owner != NULL && hitter->owner->type == PLAYER)
1929 new_draw_info_format(NDI_UNIQUE, 0, hitter->owner, 2052 new_draw_info_format (NDI_UNIQUE, 0, hitter->owner, "Your %s poisons %s.", &hitter->name, &op->name);
1930 "Your %s poisons %s.", &hitter->name, &op->name);
1931 } 2053 }
1932 tmp->speed_left=0; 2054 tmp->speed_left = 0;
1933 } 2055 }
1934 else 2056 else
1935 tmp->stats.food++; 2057 tmp->stats.food++;
1936} 2058}
1937 2059
2060void
1938void slow_player(object *op,object *hitter,int dam) 2061slow_player (object *op, object *hitter, int dam)
2062{
1939{ archetype *at = find_archetype("slowness"); 2063 archetype *at = archetype::find ("slowness");
1940 object *tmp; 2064 object *tmp;
2065
1941 if(at == NULL) { 2066 if (at == NULL)
2067 {
1942 LOG(llevError,"Can't find slowness archetype.\n"); 2068 LOG (llevError, "Can't find slowness archetype.\n");
1943 } 2069 }
1944 if((tmp=present_arch_in_ob(at,op)) == NULL) { 2070 if ((tmp = present_arch_in_ob (at, op)) == NULL)
2071 {
1945 tmp = arch_to_object(at); 2072 tmp = arch_to_object (at);
1946 tmp = insert_ob_in_ob(tmp,op); 2073 tmp = insert_ob_in_ob (tmp, op);
1947 new_draw_info(NDI_UNIQUE, 0,op,"The world suddenly moves very fast!"); 2074 new_draw_info (NDI_UNIQUE, 0, op, "The world suddenly moves very fast!");
2075 }
1948 } else 2076 else
1949 tmp->stats.food++; 2077 tmp->stats.food++;
1950 SET_FLAG(tmp, FLAG_APPLIED); 2078 SET_FLAG (tmp, FLAG_APPLIED);
1951 tmp->speed_left=0; 2079 tmp->speed_left = 0;
1952 fix_player(op); 2080 op->update_stats ();
1953} 2081}
1954 2082
2083void
1955void confuse_player(object *op, object *hitter, int dam) 2084confuse_player (object *op, object *hitter, int dam)
1956{ 2085{
1957 object *tmp; 2086 object *tmp;
1958 int maxduration; 2087 int maxduration;
1959 2088
1960 tmp = present_in_ob_by_name(FORCE,"confusion", op); 2089 tmp = present_in_ob_by_name (FORCE, "confusion", op);
1961 if(!tmp) { 2090 if (!tmp)
2091 {
1962 tmp = get_archetype(FORCE_NAME); 2092 tmp = get_archetype (FORCE_NAME);
1963 tmp = insert_ob_in_ob(tmp,op); 2093 tmp = insert_ob_in_ob (tmp, op);
1964 }
1965 2094 }
2095
1966 /* Duration added per hit and max. duration of confusion both depend 2096 /* Duration added per hit and max. duration of confusion both depend
1967 * on the player's resistance 2097 * on the player's resistance
1968 */ 2098 */
1969 tmp->speed = 0.05; 2099 tmp->speed = 0.05;
1970 tmp->subtype = FORCE_CONFUSION; 2100 tmp->subtype = FORCE_CONFUSION;
1971 tmp->duration = 8 + MAX(1, 5*(100-op->resist[ATNR_CONFUSION])/100); 2101 tmp->duration = 8 + MAX (1, 5 * (100 - op->resist[ATNR_CONFUSION]) / 100);
1972 tmp->name = "confusion"; 2102 tmp->name = "confusion";
1973 maxduration = MAX(2, 30*(100-op->resist[ATNR_CONFUSION])/100); 2103 maxduration = MAX (2, 30 * (100 - op->resist[ATNR_CONFUSION]) / 100);
1974 if( tmp->duration > maxduration) 2104 if (tmp->duration > maxduration)
1975 tmp->duration = maxduration; 2105 tmp->duration = maxduration;
1976 2106
1977 if(op->type == PLAYER && !QUERY_FLAG(op,FLAG_CONFUSED)) 2107 if (op->type == PLAYER && !QUERY_FLAG (op, FLAG_CONFUSED))
1978 new_draw_info(NDI_UNIQUE, 0,op,"You suddenly feel very confused!"); 2108 new_draw_info (NDI_UNIQUE, 0, op, "You suddenly feel very confused!");
1979 SET_FLAG(op, FLAG_CONFUSED); 2109 SET_FLAG (op, FLAG_CONFUSED);
1980} 2110}
1981 2111
2112void
1982void blind_player(object *op, object *hitter, int dam) 2113blind_player (object *op, object *hitter, int dam)
1983{ 2114{
1984 object *tmp,*owner; 2115 object *tmp, *owner;
1985 2116
1986 /* Save some work if we know it isn't going to affect the player */ 2117 /* Save some work if we know it isn't going to affect the player */
1987 if (op->resist[ATNR_BLIND]==100) return; 2118 if (op->resist[ATNR_BLIND] == 100)
2119 return;
1988 2120
1989 tmp = present_in_ob(BLINDNESS,op); 2121 tmp = present_in_ob (BLINDNESS, op);
1990 if(!tmp) { 2122 if (!tmp)
2123 {
1991 tmp = get_archetype("blindness"); 2124 tmp = get_archetype ("blindness");
1992 SET_FLAG(tmp, FLAG_BLIND); 2125 SET_FLAG (tmp, FLAG_BLIND);
1993 SET_FLAG(tmp, FLAG_APPLIED); 2126 SET_FLAG (tmp, FLAG_APPLIED);
1994 /* use floats so we don't lose too much precision due to rounding errors. 2127 /* use floats so we don't lose too much precision due to rounding errors.
1995 * speed is a float anyways. 2128 * speed is a float anyways.
1996 */ 2129 */
1997 tmp->speed = tmp->speed * (100.0 - (float)op->resist[ATNR_BLIND]) / 100; 2130 tmp->speed = tmp->speed * (100.0 - (float) op->resist[ATNR_BLIND]) / 100;
1998 2131
1999 tmp = insert_ob_in_ob(tmp,op); 2132 tmp = insert_ob_in_ob (tmp, op);
2000 change_abil(op,tmp); /* Mostly to display any messages */ 2133 change_abil (op, tmp); /* Mostly to display any messages */
2001 fix_player(op); /* This takes care of some other stuff */ 2134 op->update_stats (); /* This takes care of some other stuff */
2002 2135
2003 if(hitter->owner) owner = get_owner(hitter); 2136 if (hitter->owner)
2137 owner = hitter->owner;
2138 else
2004 else owner = hitter; 2139 owner = hitter;
2005 2140
2006 new_draw_info_format(NDI_UNIQUE,0,owner, 2141 new_draw_info_format (NDI_UNIQUE, 0, owner, "Your attack blinds %s!", query_name (op));
2007 "Your attack blinds %s!",query_name(op));
2008 } 2142 }
2009 tmp->stats.food += dam; 2143 tmp->stats.food += dam;
2010 if(tmp->stats.food > 10) tmp->stats.food = 10; 2144 if (tmp->stats.food > 10)
2145 tmp->stats.food = 10;
2011} 2146}
2012 2147
2148void
2013void paralyze_player(object *op, object *hitter, int dam) 2149paralyze_player (object *op, object *hitter, int dam)
2014{ 2150{
2015 float effect,max; 2151 float effect, max;
2152
2016 /* object *tmp; */ 2153 /* object *tmp; */
2017 2154
2018 /* This is strange stuff... someone knows for what this is 2155 /* This is strange stuff... someone knows for what this is
2019 * written? Well, i think this can and should be removed 2156 * written? Well, i think this can and should be removed
2020 */ 2157 */
2021 2158
2022 /* 2159 /*
2023 if((tmp=present(PARAIMAGE,op->map,op->x,op->y))==NULL) { 2160 if((tmp=present(PARAIMAGE,op->map,op->x,op->y))==NULL) {
2024 tmp=clone_arch(PARAIMAGE); 2161 tmp=clone_arch(PARAIMAGE);
2025 tmp->x=op->x,tmp->y=op->y; 2162 tmp->x=op->x,tmp->y=op->y;
2026 insert_ob_in_map(tmp,op->map,tmp,INS_NO_MERGE | INS_NO_WALK_ON); 2163 insert_ob_in_map(tmp,op->map,tmp,INS_NO_MERGE | INS_NO_WALK_ON);
2027 } 2164 }
2028 */ 2165 */
2029 2166
2030 /* Do this as a float - otherwise, rounding might very well reduce this to 0 */ 2167 /* Do this as a float - otherwise, rounding might very well reduce this to 0 */
2031 effect = (float)dam * 3.0 * (100.0 - op->resist[ATNR_PARALYZE]) / 100; 2168 effect = (float) dam *3.0 * (100.0 - op->resist[ATNR_PARALYZE]) / 100;
2032 2169
2033 if (effect==0) return; 2170 if (effect == 0)
2171 return;
2034 2172
2035 op->speed_left-=FABS(op->speed)*effect; 2173 op->speed_left -= FABS (op->speed) * effect;
2036 /* tmp->stats.food+=(signed short) effect/op->speed; */ 2174 /* tmp->stats.food+=(signed short) effect/op->speed; */
2037 2175
2038 /* max number of ticks to be affected for. */ 2176 /* max number of ticks to be affected for. */
2039 max = (100 - op->resist[ATNR_PARALYZE])/ 2; 2177 max = (100 - op->resist[ATNR_PARALYZE]) / 2;
2040 if (op->speed_left< -(FABS(op->speed)*max)) 2178 if (op->speed_left < -(FABS (op->speed) * max))
2041 op->speed_left = (float) -(FABS(op->speed)*max); 2179 op->speed_left = (float) -(FABS (op->speed) * max);
2042 2180
2043/* tmp->stats.food = (signed short) (max/FABS(op->speed)); */ 2181/* tmp->stats.food = (signed short) (max/FABS(op->speed)); */
2044} 2182}
2045 2183
2046 2184
2047/* Attempts to kill 'op'. hitter is the attack object, dam is 2185/* Attempts to kill 'op'. hitter is the attack object, dam is
2048 * the computed damaged. 2186 * the computed damaged.
2049 */ 2187 */
2188void
2050void deathstrike_player(object *op, object *hitter, int *dam) 2189deathstrike_player (object *op, object *hitter, int *dam)
2051{ 2190{
2052 /* The intention of a death attack is to kill outright things 2191 /* The intention of a death attack is to kill outright things
2053 ** that are a lot weaker than the attacker, have a chance of killing 2192 ** that are a lot weaker than the attacker, have a chance of killing
2054 ** things somewhat weaker than the caster, and no chance of 2193 ** things somewhat weaker than the caster, and no chance of
2055 ** killing something equal or stronger than the attacker. 2194 ** killing something equal or stronger than the attacker.
2056 ** Also, if a deathstrike attack has a slaying, any monster 2195 ** Also, if a deathstrike attack has a slaying, any monster
2057 ** whose name or race matches a comma-delimited list in the slaying 2196 ** whose name or race matches a comma-delimited list in the slaying
2058 ** field of the deathstriking object */ 2197 ** field of the deathstriking object */
2059 2198
2060 int atk_lev, def_lev, kill_lev; 2199 int atk_lev, def_lev, kill_lev;
2061 2200
2062 if(hitter->slaying) 2201 if (hitter->slaying)
2063 if(!( (QUERY_FLAG(op,FLAG_UNDEAD)&&strstr(hitter->slaying,undead_name)) || 2202 if (!((QUERY_FLAG (op, FLAG_UNDEAD) && strstr (hitter->slaying, undead_name)) || (op->race && strstr (hitter->slaying, op->race))))
2064 (op->race&&strstr(hitter->slaying,op->race)))) return; 2203 return;
2065 2204
2066 def_lev = op->level; 2205 def_lev = op->level;
2067 if (def_lev < 1) { 2206 if (def_lev < 1)
2207 {
2068 LOG (llevError, "BUG: arch %s, name %s with level < 1\n", 2208 LOG (llevError, "BUG: arch %s, name %s with level < 1\n", &op->arch->name, &op->name);
2069 &op->arch->name, &op->name);
2070 def_lev = 1; 2209 def_lev = 1;
2071 } 2210 }
2072 atk_lev = (hitter->chosen_skill?hitter->chosen_skill->level:hitter->level) / 2; 2211 atk_lev = (hitter->chosen_skill ? hitter->chosen_skill->level : hitter->level) / 2;
2073 /* LOG(llevDebug,"Deathstrike - attack level %d, defender level %d\n", 2212 /* LOG(llevDebug,"Deathstrike - attack level %d, defender level %d\n",
2074 atk_lev, def_lev); */ 2213 atk_lev, def_lev); */
2075 2214
2076 if(atk_lev >= def_lev ){ 2215 if (atk_lev >= def_lev)
2216 {
2077 kill_lev = random_roll(0, atk_lev-1, hitter, PREFER_HIGH); 2217 kill_lev = random_roll (0, atk_lev - 1, hitter, PREFER_HIGH);
2078 2218
2079 /* Note that the below effectively means the ratio of the atk vs 2219 /* Note that the below effectively means the ratio of the atk vs
2080 * defener level is important - if level 52 character has very little 2220 * defener level is important - if level 52 character has very little
2081 * chance of killing a level 50 monster. This should probably be 2221 * chance of killing a level 50 monster. This should probably be
2082 * redone. 2222 * redone.
2083 */ 2223 */
2084 if(kill_lev >= def_lev) { 2224 if (kill_lev >= def_lev)
2225 {
2085 *dam = op->stats.hp+10; /* take all hp. they can still save for 1/2 */ 2226 *dam = op->stats.hp + 10; /* take all hp. they can still save for 1/2 */
2086 /* I think this doesn't really do much. Because of 2227 /* I think this doesn't really do much. Because of
2087 * integer rounding, this only makes any difference if the 2228 * integer rounding, this only makes any difference if the
2088 * attack level is double the defender level. 2229 * attack level is double the defender level.
2089 */ 2230 */
2090 *dam *= kill_lev / def_lev; 2231 *dam *= kill_lev / def_lev;
2091 } 2232 }
2092 } else { 2233 }
2234 else
2235 {
2093 *dam = 0; /* no harm done */ 2236 *dam = 0; /* no harm done */
2094 } 2237 }
2095} 2238}
2096 2239
2097/* thrown_item_effect() - handles any special effects of thrown 2240/* thrown_item_effect() - handles any special effects of thrown
2098 * items (like attacking living creatures--a potion thrown at a 2241 * items (like attacking living creatures--a potion thrown at a
2099 * monster). 2242 * monster).
2100 */ 2243 */
2244static void
2101static void thrown_item_effect (object *hitter, object *victim) 2245thrown_item_effect (object *hitter, object *victim)
2102{ 2246{
2103 if(!QUERY_FLAG(hitter,FLAG_ALIVE)) { 2247 if (!QUERY_FLAG (hitter, FLAG_ALIVE))
2248 {
2104 /* May not need a switch for just 2 types, but this makes it 2249 /* May not need a switch for just 2 types, but this makes it
2105 * easier for expansion. 2250 * easier for expansion.
2106 */ 2251 */
2107 switch (hitter->type) { 2252 switch (hitter->type)
2253 {
2108 case POTION: 2254 case POTION:
2109 /* should player get a save throw instead of checking magic protection? */ 2255 /* should player get a save throw instead of checking magic protection? */
2110 if(QUERY_FLAG(victim,FLAG_ALIVE)&&!QUERY_FLAG(victim,FLAG_UNDEAD) 2256 if (QUERY_FLAG (victim, FLAG_ALIVE) && !QUERY_FLAG (victim, FLAG_UNDEAD) && (victim->resist[ATNR_MAGIC] < 60))
2111 &&(victim->resist[ATNR_MAGIC]<60)) (void) apply_potion(victim,hitter); 2257 (void) apply_potion (victim, hitter);
2112 break; 2258 break;
2113 2259
2114 case POISON: /* poison drinks */ 2260 case POISON: /* poison drinks */
2115 /* As with potions, should monster get a save? */ 2261 /* As with potions, should monster get a save? */
2116 if(QUERY_FLAG(victim,FLAG_ALIVE)&&!QUERY_FLAG(victim,FLAG_UNDEAD) 2262 if (QUERY_FLAG (victim, FLAG_ALIVE) && !QUERY_FLAG (victim, FLAG_UNDEAD) && (victim->resist[ATNR_POISON] < 60))
2117 &&(victim->resist[ATNR_POISON]<60)) apply_poison(victim,hitter); 2263 apply_poison (victim, hitter);
2118 break; 2264 break;
2119 2265
2120 /* Removed case statements that did nothing. 2266 /* Removed case statements that did nothing.
2121 * food may be poisonous, but monster must be willing to eat it, 2267 * food may be poisonous, but monster must be willing to eat it,
2122 * so we don't handle it here. 2268 * so we don't handle it here.
2123 * Containers should perhaps break open, but that code was disabled. 2269 * Containers should perhaps break open, but that code was disabled.
2124 */ 2270 */
2125 } 2271 }
2126 } 2272 }
2127} 2273}
2128 2274
2129/* adj_attackroll() - adjustments to attacks by various conditions */ 2275/* adj_attackroll() - adjustments to attacks by various conditions */
2130 2276
2277int
2131int adj_attackroll (object *hitter, object *target) { 2278adj_attackroll (object *hitter, object *target)
2279{
2132 object *attacker = hitter; 2280 object *attacker = hitter;
2133 int adjust=0; 2281 int adjust = 0;
2134 2282
2135 /* safety */ 2283 /* safety */
2136 if(!target||!hitter||!hitter->map||!target->map||!on_same_map(hitter,target)) { 2284 if (!target || !hitter || !hitter->map || !target->map || !on_same_map (hitter, target))
2285 {
2137 LOG (llevError, "BUG: adj_attackroll(): hitter and target not on same " 2286 LOG (llevError, "BUG: adj_attackroll(): hitter and target not on same " "map\n");
2138 "map\n"); 2287 return 0;
2288 }
2289
2290 /* aimed missiles use the owning object's sight */
2291 if (is_aimed_missile (hitter))
2292 {
2293 if ((attacker = hitter->owner) == NULL)
2294 attacker = hitter;
2295 /* A player who saves but hasn't quit still could have objects
2296 * owned by him - need to handle that case to avoid crashes.
2297 */
2298 if (QUERY_FLAG (attacker, FLAG_REMOVED))
2299 attacker = hitter;
2300 }
2301 else if (!QUERY_FLAG (hitter, FLAG_ALIVE))
2139 return 0; 2302 return 0;
2140 }
2141 2303
2142 /* aimed missiles use the owning object's sight */
2143 if(is_aimed_missile(hitter)) {
2144 if ((attacker = get_owner(hitter))==NULL) attacker = hitter;
2145 /* A player who saves but hasn't quit still could have objects
2146 * owned by him - need to handle that case to avoid crashes.
2147 */
2148 if (QUERY_FLAG(attacker, FLAG_REMOVED)) attacker = hitter;
2149 }
2150 else if(!QUERY_FLAG(hitter,FLAG_ALIVE))
2151 return 0;
2152
2153 /* determine the condtions under which we make an attack. 2304 /* determine the condtions under which we make an attack.
2154 * Add more cases, as the need occurs. */ 2305 * Add more cases, as the need occurs. */
2155 2306
2156 if(!can_see_enemy(attacker,target)) { 2307 if (!can_see_enemy (attacker, target))
2308 {
2157 /* target is unseen */ 2309 /* target is unseen */
2158 if(target->invisible || QUERY_FLAG(attacker,FLAG_BLIND)) 2310 if (target->invisible || QUERY_FLAG (attacker, FLAG_BLIND))
2159 adjust -= 10; 2311 adjust -= 10;
2160 /* dark map penalty for the hitter (lacks infravision if we got here). */ 2312 /* dark map penalty for the hitter (lacks infravision if we got here). */
2161 else if(target->map&&target->map->darkness>0&&!stand_in_light(target)) 2313 else if (target->map && target->map->darkness > 0 && !stand_in_light (target))
2162 adjust -= target->map->darkness; 2314 adjust -= target->map->darkness;
2163 } 2315 }
2164 2316
2165 if(QUERY_FLAG(attacker,FLAG_SCARED)) 2317 if (QUERY_FLAG (attacker, FLAG_SCARED))
2166 adjust -= 3; 2318 adjust -= 3;
2167 2319
2168 if(QUERY_FLAG(target,FLAG_UNAGGRESSIVE)) 2320 if (QUERY_FLAG (target, FLAG_UNAGGRESSIVE))
2169 adjust += 1; 2321 adjust += 1;
2170 2322
2171 if(QUERY_FLAG(target,FLAG_SCARED)) 2323 if (QUERY_FLAG (target, FLAG_SCARED))
2172 adjust += 1; 2324 adjust += 1;
2173 2325
2174 if(QUERY_FLAG(attacker,FLAG_CONFUSED)) 2326 if (QUERY_FLAG (attacker, FLAG_CONFUSED))
2175 adjust -= 3; 2327 adjust -= 3;
2176 2328
2177 /* if we attack at a different 'altitude' its harder */ 2329 /* if we attack at a different 'altitude' its harder */
2178 if((attacker->move_type & target->move_type)==0) 2330 if ((attacker->move_type & target->move_type) == 0)
2179 adjust -= 2; 2331 adjust -= 2;
2180 2332
2181#if 0 2333#if 0
2182 /* slower attacks are less likely to succeed. We should use a 2334 /* slower attacks are less likely to succeed. We should use a
2183 * comparison between attacker/target speeds BUT, players have 2335 * comparison between attacker/target speeds BUT, players have
2184 * a generally faster speed, so this will wind up being a HUGE 2336 * a generally faster speed, so this will wind up being a HUGE
2185 * disadantage for the monsters! Too bad, because missiles which 2337 * disadantage for the monsters! Too bad, because missiles which
2186 * fly fast should have a better chance of hitting a slower target. 2338 * fly fast should have a better chance of hitting a slower target.
2187 */ 2339 */
2188 if(hitter->speed<target->speed) 2340 if (hitter->speed < target->speed)
2189 adjust += ((float) hitter->speed-target->speed); 2341 adjust += ((float) hitter->speed - target->speed);
2190#endif 2342#endif
2191 2343
2192#if 0 2344#if 0
2193 LOG(llevDebug,"adj_attackroll() returns %d (%d)\n",adjust,attacker->count); 2345 LOG (llevDebug, "adj_attackroll() returns %d (%d)\n", adjust, attacker->count);
2194#endif 2346#endif
2195 2347
2196 return adjust; 2348 return adjust;
2197} 2349}
2198 2350
2199 2351
2200/* determine if the object is an 'aimed' missile */ 2352/* determine if the object is an 'aimed' missile */
2353int
2201int is_aimed_missile ( object *op) { 2354is_aimed_missile (object *op)
2355{
2202 2356
2203 /* I broke what used to be one big if into a few nested 2357 /* I broke what used to be one big if into a few nested
2204 * ones so that figuring out the logic is at least possible. 2358 * ones so that figuring out the logic is at least possible.
2205 */ 2359 */
2206 if (op && (op->move_type & MOVE_FLYING)) { 2360 if (op && (op->move_type & MOVE_FLYING))
2361 {
2207 if (op->type==ARROW || op->type==THROWN_OBJ) 2362 if (op->type == ARROW || op->type == THROWN_OBJ)
2208 return 1; 2363 return 1;
2209 else if (op->type==SPELL_EFFECT && (op->subtype == SP_BULLET || 2364 else if (op->type == SPELL_EFFECT && (op->subtype == SP_BULLET || op->subtype == SP_EXPLOSION))
2210 op->subtype == SP_EXPLOSION))
2211 return 1; 2365 return 1;
2212 } 2366 }
2213 return 0; 2367 return 0;
2214} 2368}
2215

Diff Legend

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