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

Comparing deliantra/server/server/pets.C (file contents):
Revision 1.9 by root, Thu Sep 14 22:34:04 2006 UTC vs.
Revision 1.29 by root, Tue Apr 24 12:32:16 2007 UTC

1/* 1/*
2 CrossFire, A Multiplayer game for X-windows 2 * CrossFire, A Multiplayer game for X-windows
3 3 *
4 * Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
4 Copyright (C) 2002 Mark Wedel & Crossfire Development Team 5 * Copyright (C) 2002 Mark Wedel & Crossfire Development Team
5 Copyright (C) 1992 Frank Tore Johansen 6 * Copyright (C) 1992 Frank Tore Johansen
6 7 *
7 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
8 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
9 the Free Software Foundation; either version 2 of the License, or 10 * the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version. 11 * (at your option) any later version.
11 12 *
12 This program is distributed in the hope that it will be useful, 13 * This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details. 16 * GNU General Public License for more details.
16 17 *
17 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
18 along with this program; if not, write to the Free Software 19 * along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 21 *
21 The authors can be reached via e-mail at <crossfire@schmorp.de> 22 * The authors can be reached via e-mail at <crossfire@schmorp.de>
22*/ 23 */
23 24
24#include <global.h> 25#include <global.h>
25#ifndef __CEXTRACT__
26# include <sproto.h> 26#include <sproto.h>
27#endif
28 27
29/* given that 'pet' is a friendly object, this function returns a 28/* given that 'pet' is a friendly object, this function returns a
30 * monster the pet should attack, NULL if nothing appropriate is 29 * monster the pet should attack, NULL if nothing appropriate is
31 * found. it basically looks for nasty things around the owner 30 * found. it basically looks for nasty things around the owner
32 * of the pet to attack. 31 * of the pet to attack.
33 * this is now tilemap aware. 32 * this is now tilemap aware.
34 */ 33 */
35
36object * 34object *
37get_pet_enemy (object *pet, rv_vector * rv) 35get_pet_enemy (object *pet, rv_vector * rv)
38{ 36{
39 object *owner, *tmp, *attacker, *tmp3; 37 object *owner, *tmp, *attacker, *tmp3;
40 int i; 38 int i;
41 sint16 x, y; 39 sint16 x, y;
42 mapstruct *nm; 40 maptile *nm;
43 int search_arr[SIZEOFFREE]; 41 int search_arr[SIZEOFFREE];
44 int mflags; 42 int mflags;
45 43
46 attacker = pet->attacked_by; /*pointer to attacking enemy */ 44 attacker = pet->attacked_by; /*pointer to attacking enemy */
47 pet->attacked_by = NULL; /*clear this, since we are dealing with it */ 45 pet->attacked_by = NULL; /*clear this, since we are dealing with it */
48 46
49 if ((owner = get_owner (pet)) != NULL) 47 if (owner = pet->owner)
50 { 48 {
51 /* If the owner has turned on the pet, make the pet 49 /* If the owner has turned on the pet, make the pet
52 * unfriendly. 50 * unfriendly.
53 */ 51 */
54 if ((check_enemy (owner, rv)) == pet) 52 if (check_enemy (owner, rv) == pet)
55 { 53 {
56 CLEAR_FLAG (pet, FLAG_FRIENDLY);
57 remove_friendly_object (pet); 54 remove_friendly_object (pet);
58 pet->attack_movement &= ~PETMOVE; 55 pet->attack_movement &= ~PETMOVE;
59 return owner; 56 return owner;
60 } 57 }
61 } 58 }
62 else 59 else
63 { 60 {
64 /* else the owner is no longer around, so the 61 /* else the owner is no longer around, so the
65 * pet no longer needs to be friendly. 62 * pet no longer needs to be friendly.
66 */ 63 */
67 CLEAR_FLAG (pet, FLAG_FRIENDLY);
68 remove_friendly_object (pet); 64 remove_friendly_object (pet);
69 pet->attack_movement &= ~PETMOVE; 65 pet->attack_movement &= ~PETMOVE;
70 return NULL; 66 return 0;
71 } 67 }
68
72 /* If they are not on the same map, the pet won't be agressive */ 69 /* If they are not on the same map, the pet won't be agressive */
73 if (!on_same_map (pet, owner)) 70 //if (!on_same_map (pet, owner))
74 return NULL; 71 // return 0;
75 72
76 /* See if the pet has an existing enemy. If so, don't start a new one */ 73 /* See if the pet has an existing enemy. If so, don't start a new one */
77 if ((tmp = check_enemy (pet, rv)) != NULL) 74 if (tmp = check_enemy (pet, rv))
78 { 75 {
79 if (tmp == owner && !QUERY_FLAG (pet, FLAG_CONFUSED) && QUERY_FLAG (pet, FLAG_FRIENDLY)) 76 if (tmp == owner && !QUERY_FLAG (pet, FLAG_CONFUSED) && QUERY_FLAG (pet, FLAG_FRIENDLY))
80 /* without this check, you can actually get pets with 77 /* without this check, you can actually get pets with
81 * enemy set to owner! 78 * enemy set to owner!
82 */ 79 */
83 pet->enemy = NULL; 80 pet->enemy = 0;
84 else 81 else
85 return tmp; 82 return tmp;
86 } 83 }
84
87 get_search_arr (search_arr); 85 get_search_arr (search_arr);
88 86
89 if (owner->type == PLAYER && owner->contr->petmode > pet_normal) 87 if (owner->type == PLAYER && owner->contr->petmode > pet_normal)
90 { 88 {
91 if (owner->contr->petmode == pet_sad) 89 if (owner->contr->petmode == pet_sad)
92 { 90 {
93 tmp = find_nearest_living_creature (pet); 91 tmp = find_nearest_living_creature (pet);
94 if (tmp != NULL) 92 if (tmp != 0)
95 { 93 {
96 get_rangevector (pet, tmp, rv, 0); 94 get_rangevector (pet, tmp, rv, 0);
97 if (check_enemy (pet, rv) != NULL) 95 if (check_enemy (pet, rv) != 0)
98 return tmp; 96 return tmp;
99 else 97 else
100 pet->enemy = NULL; 98 pet->enemy = 0;
101 } 99 }
102 /* if we got here we have no enemy */ 100 /* if we got here we have no enemy */
103 /* we return NULL to avoid heading back to the owner */ 101 /* we return 0 to avoid heading back to the owner */
104 pet->enemy = NULL; 102 pet->enemy = 0;
105 return NULL; 103 return 0;
106 } 104 }
107 } 105 }
108 106
109 /* Since the pet has no existing enemy, look for anything nasty 107 /* Since the pet has no existing enemy, look for anything nasty
110 * around the owner that it should go and attack. 108 * around the owner that it should go and attack. (if the owner is
109 * still on a map)
111 */ 110 */
112 tmp3 = NULL; 111 if (!owner->flag [FLAG_REMOVED])
112 {
113 tmp3 = 0;
114
113 for (i = 0; i < SIZEOFFREE; i++) 115 for (i = 0; i < SIZEOFFREE; i++)
114 { 116 {
115 x = owner->x + freearr_x[search_arr[i]]; 117 x = owner->x + freearr_x[search_arr[i]];
116 y = owner->y + freearr_y[search_arr[i]]; 118 y = owner->y + freearr_y[search_arr[i]];
117 nm = owner->map; 119 nm = owner->map;
118 /* Only look on the space if there is something alive there. */ 120 /* Only look on the space if there is something alive there. */
119 mflags = get_map_flags (nm, &nm, x, y, &x, &y); 121 mflags = get_map_flags (nm, &nm, x, y, &x, &y);
122
120 if (!(mflags & P_OUT_OF_MAP) && mflags & P_IS_ALIVE) 123 if (!(mflags & P_OUT_OF_MAP) && mflags & P_IS_ALIVE)
121 { 124 {
122 for (tmp = get_map_ob (nm, x, y); tmp != NULL; tmp = tmp->above) 125 for (tmp = GET_MAP_OB (nm, x, y); tmp != 0; tmp = tmp->above)
123 {
124 object *tmp2 = tmp->head == NULL ? tmp : tmp->head;
125
126 if (QUERY_FLAG (tmp2, FLAG_ALIVE) && ((!QUERY_FLAG (tmp2, FLAG_FRIENDLY) &&
127 (tmp2->type != PLAYER)) ||
128 should_arena_attack (pet, owner, tmp2))
129 && !QUERY_FLAG (tmp2, FLAG_UNAGGRESSIVE) && tmp2 != pet && tmp2 != owner && can_detect_enemy (pet, tmp2, rv))
130 { 126 {
127 object *tmp2 = tmp->head == 0 ? tmp : tmp->head;
131 128
132 if (!can_see_enemy (pet, tmp2)) 129 if (QUERY_FLAG (tmp2, FLAG_ALIVE) && ((!QUERY_FLAG (tmp2, FLAG_FRIENDLY) &&
130 (tmp2->type != PLAYER)) ||
131 should_arena_attack (pet, owner, tmp2))
132 && !QUERY_FLAG (tmp2, FLAG_UNAGGRESSIVE) && tmp2 != pet && tmp2 != owner && can_detect_enemy (pet, tmp2, rv))
133 { 133 {
134
135 if (!can_see_enemy (pet, tmp2))
136 {
134 if (tmp3 != NULL) 137 if (tmp3 != 0)
135 tmp3 = tmp2; 138 tmp3 = tmp2;
136 } 139 }
137 else
138 {
139 pet->enemy = tmp2;
140 if (check_enemy (pet, rv) != NULL)
141 return tmp2;
142 else 140 else
141 {
142 pet->enemy = tmp2;
143 if (check_enemy (pet, rv) != 0)
144 return tmp2;
145 else
143 pet->enemy = NULL; 146 pet->enemy = 0;
144 } 147 }
145 } /* if this is a valid enemy */ 148 } /* if this is a valid enemy */
146 } /* for objects on this space */ 149 } /* for objects on this space */
147 } /* if there is something living on this space */ 150 } /* if there is something living on this space */
148 } /* for loop of spaces around the owner */ 151 } /* for loop of spaces around the owner */
149 152
150 /* fine, we went through the whole loop and didn't find one we could 153 /* fine, we went through the whole loop and didn't find one we could
151 see, take what we have */ 154 see, take what we have */
152 if (tmp3 != NULL) 155 if (tmp3 != 0)
153 { 156 {
154 pet->enemy = tmp3; 157 pet->enemy = tmp3;
155 if (check_enemy (pet, rv) != NULL) 158 if (check_enemy (pet, rv) != 0)
156 return tmp3; 159 return tmp3;
157 else 160 else
158 pet->enemy = NULL; 161 pet->enemy = 0;
162 }
159 } 163 }
160 164
161 /* No threat to owner, check to see if the pet has an attacker */ 165 /* No threat to owner, check to see if the pet has an attacker */
162 if (attacker) 166 if (attacker)
163 { 167 {
… …
165 /* or otherwise non-hostile, and is an appropriate target */ 169 /* or otherwise non-hostile, and is an appropriate target */
166 if (!QUERY_FLAG (attacker, FLAG_FRIENDLY) && on_same_map (pet, attacker)) 170 if (!QUERY_FLAG (attacker, FLAG_FRIENDLY) && on_same_map (pet, attacker))
167 { 171 {
168 pet->enemy = attacker; 172 pet->enemy = attacker;
169 173
170 if (check_enemy (pet, rv) != NULL) 174 if (check_enemy (pet, rv) != 0)
171 return attacker; 175 return attacker;
172 else 176 else
173 pet->enemy = NULL; 177 pet->enemy = 0;
174 } 178 }
175 } 179 }
176 180
177 /* Don't have an attacker or legal enemy, so look for a new one!. 181 /* Don't have an attacker or legal enemy, so look for a new one!.
178 * This looks for one around where the pet is. Thus, you could lead 182 * This looks for one around where the pet is. Thus, you could lead
179 * a pet to danger, then take a few steps back. This code is basically 183 * a pet to danger, then take a few steps back. This code is basically
180 * the same as the code that looks around the owner. 184 * the same as the code that looks around the owner.
181 */ 185 */
182 if (owner->type == PLAYER && owner->contr->petmode != pet_defend) 186 if (owner->type == PLAYER && owner->contr->petmode != pet_defend)
183 { 187 {
184 tmp3 = NULL; 188 tmp3 = 0;
185 for (i = 0; i < SIZEOFFREE; i++) 189 for (i = 0; i < SIZEOFFREE; i++)
186 { 190 {
187 x = pet->x + freearr_x[search_arr[i]]; 191 x = pet->x + freearr_x[search_arr[i]];
188 y = pet->y + freearr_y[search_arr[i]]; 192 y = pet->y + freearr_y[search_arr[i]];
189 nm = pet->map; 193 nm = pet->map;
190 /* Only look on the space if there is something alive there. */ 194 /* Only look on the space if there is something alive there. */
191 mflags = get_map_flags (nm, &nm, x, y, &x, &y); 195 mflags = get_map_flags (nm, &nm, x, y, &x, &y);
192 if (!(mflags & P_OUT_OF_MAP) && mflags & P_IS_ALIVE) 196 if (!(mflags & P_OUT_OF_MAP) && mflags & P_IS_ALIVE)
193 { 197 {
194 for (tmp = get_map_ob (nm, x, y); tmp != NULL; tmp = tmp->above) 198 for (tmp = GET_MAP_OB (nm, x, y); tmp != 0; tmp = tmp->above)
195 { 199 {
196 object *tmp2 = tmp->head == NULL ? tmp : tmp->head; 200 object *tmp2 = tmp->head == 0 ? tmp : tmp->head;
197 201
198 if (QUERY_FLAG (tmp2, FLAG_ALIVE) && ((!QUERY_FLAG (tmp2, FLAG_FRIENDLY) && 202 if (QUERY_FLAG (tmp2, FLAG_ALIVE) && ((!QUERY_FLAG (tmp2, FLAG_FRIENDLY) &&
199 (tmp2->type != PLAYER)) || 203 (tmp2->type != PLAYER)) ||
200 should_arena_attack (pet, owner, tmp2)) 204 should_arena_attack (pet, owner, tmp2))
201 && !QUERY_FLAG (tmp2, FLAG_UNAGGRESSIVE) && tmp2 != pet && tmp2 != owner && can_detect_enemy (pet, tmp2, rv)) 205 && !QUERY_FLAG (tmp2, FLAG_UNAGGRESSIVE) && tmp2 != pet && tmp2 != owner && can_detect_enemy (pet, tmp2, rv))
202 { 206 {
203 207
204 if (!can_see_enemy (pet, tmp2)) 208 if (!can_see_enemy (pet, tmp2))
205 { 209 {
206 if (tmp3 != NULL) 210 if (tmp3 != 0)
207 tmp3 = tmp2; 211 tmp3 = tmp2;
208 } 212 }
209 else 213 else
210 { 214 {
211 pet->enemy = tmp2; 215 pet->enemy = tmp2;
212 if (check_enemy (pet, rv) != NULL) 216 if (check_enemy (pet, rv) != 0)
213 return tmp2; 217 return tmp2;
214 else 218 else
215 pet->enemy = NULL; 219 pet->enemy = 0;
216 } 220 }
217 } /* make sure we can get to the bugger */ 221 } /* make sure we can get to the bugger */
218 } /* for objects on this space */ 222 } /* for objects on this space */
219 } /* if there is something living on this space */ 223 } /* if there is something living on this space */
220 } /* for loop of spaces around the pet */ 224 } /* for loop of spaces around the pet */
225
226 /* fine, we went through the whole loop and didn't find one we could
227 see, take what we have */
228 if (tmp3 != 0)
229 {
230 pet->enemy = tmp3;
231 if (check_enemy (pet, rv) != 0)
232 return tmp3;
233 else
234 pet->enemy = 0;
235 }
221 } /* pet in defence mode */ 236 } /* pet in defence mode */
222 237
223 /* fine, we went through the whole loop and didn't find one we could 238 object *enemy = check_enemy (pet, rv);
224 see, take what we have */ 239 // we have a summoned pet here and the owners enemy isn't set or can't
225 if (tmp3 != NULL) 240 // be reached => search for a player around us and set it as our new enemy!!
226 { 241 if (!enemy && pet->owner && pet->owner->type != PLAYER)
227 pet->enemy = tmp3; 242 enemy = get_nearest_player (pet);
228 if (check_enemy (pet, rv) != NULL)
229 return tmp3;
230 else
231 pet->enemy = NULL;
232 }
233 243
234 /* Didn't find anything - return the owner's enemy or NULL */ 244 /* Didn't find anything - return the owner's enemy or 0 */
235 return check_enemy (pet, rv); 245 return enemy;
236} 246}
237 247
238void 248void
239terminate_all_pets (object *owner) 249terminate_all_pets (object *owner)
240{ 250{
241 objectlink *obl, *next; 251 objectlink *obl, *next;
242 252
243 for (obl = first_friendly_object; obl != NULL; obl = next) 253 for (obl = first_friendly_object; obl; obl = next)
244 { 254 {
245 object *ob = obl->ob; 255 object *ob = obl->ob;
246
247 next = obl->next; 256 next = obl->next;
257
248 if (get_owner (ob) == owner) 258 if (ob->owner == owner)
249 { 259 ob->destroy ();
250 if (!QUERY_FLAG (ob, FLAG_REMOVED))
251 remove_ob (ob);
252 remove_friendly_object (ob);
253 free_object (ob);
254 }
255 } 260 }
256} 261}
257 262
258/* 263/*
259 * Unfortunately, sometimes, the owner of a pet is in the 264 * Unfortunately, sometimes, the owner of a pet is in the
… …
261 * Thus the map isn't loaded yet, and we have to remove 266 * Thus the map isn't loaded yet, and we have to remove
262 * the pet... 267 * the pet...
263 * Interesting enough, we don't use the passed map structure in 268 * Interesting enough, we don't use the passed map structure in
264 * this function. 269 * this function.
265 */ 270 */
266
267void 271void
268remove_all_pets (mapstruct *map) 272remove_all_pets (maptile *map)
269{ 273{
270 objectlink *obl, *next; 274 objectlink *obl, *next;
271 object *owner; 275 object *owner;
272 276
273 for (obl = first_friendly_object; obl != NULL; obl = next) 277 for (obl = first_friendly_object; obl; obl = next)
274 { 278 {
275 next = obl->next; 279 next = obl->next;
276 if (obl->ob->type != PLAYER && QUERY_FLAG (obl->ob, FLAG_FRIENDLY) && 280
277 (owner = get_owner (obl->ob)) != NULL && !on_same_map (owner, obl->ob)) 281 if (obl->ob->type != PLAYER
282 && QUERY_FLAG (obl->ob, FLAG_FRIENDLY)
283 && (owner = obl->ob->owner) != 0
284 && !on_same_map (owner, obl->ob))
278 { 285 {
279 /* follow owner checks map status for us */ 286 /* follow owner checks map status for us */
280 follow_owner (obl->ob, owner); 287 follow_owner (obl->ob, owner);
281 } 288 }
282 } 289 }
283} 290}
284 291
285int 292int
286follow_owner (object *ob, object *owner) 293follow_owner (object *ob, object *owner)
287{ 294{
288 object *tmp; 295 if (owner->flag [FLAG_REMOVED])
289 int dir; 296 return 0; // do nothing if the owner is removed
290
291 if (!QUERY_FLAG (ob, FLAG_REMOVED))
292 remove_ob (ob);
293
294 if (owner->map == NULL)
295 {
296 LOG (llevError, "Can't follow owner (%d): no map.\n", &owner->name);
297 goto fail;
298 }
299 if (owner->map->in_memory != MAP_IN_MEMORY) 297 else if (owner->map->in_memory != MAP_IN_MEMORY)
300 {
301 LOG (llevError, "Owner of the pet not on a map in memory!?\n"); 298 LOG (llevError, "Owner of the pet not on a map in memory!?\n");
302 goto fail; 299 else
303 } 300 {
304
305 dir = find_free_spot (ob, owner->map, owner->x, owner->y, 1, SIZEOFFREE); 301 int dir = find_free_spot (ob, owner->map, owner->x, owner->y, 1, SIZEOFFREE);
306 302
307 if (dir == -1) 303 if (dir >= 0)
308 {
309 LOG (llevMonster, "No space for pet to follow, freeing %s.\n", &ob->name);
310 goto fail;
311 }
312 for (tmp = ob; tmp != NULL; tmp = tmp->more)
313 {
314 tmp->x = owner->x + freearr_x[dir] + (tmp->arch == NULL ? 0 : tmp->arch->clone.x);
315 tmp->y = owner->y + freearr_y[dir] + (tmp->arch == NULL ? 0 : tmp->arch->clone.y);
316 tmp->map = owner->map;
317 if (OUT_OF_REAL_MAP (tmp->map, tmp->x, tmp->y))
318 {
319 tmp->map = get_map_from_coord (tmp->map, &tmp->x, &tmp->y);
320 } 304 {
321 } 305 owner->map->insert (ob, owner->x + freearr_x[dir], owner->y + freearr_y[dir]);
322 insert_ob_in_map (ob, ob->map, NULL, 0); 306
323 if (owner->type == PLAYER) /* Uh, I hope this is always true... */ 307 if (owner->type == PLAYER) /* Uh, I hope this is always true... */
324 new_draw_info (NDI_UNIQUE, 0, owner, "Your pet magically appears next to you"); 308 new_draw_info (NDI_UNIQUE, 0, owner, "Your pet magically appears next to you");
325 309
326 return 0; 310 return 0;
311 }
312 }
327 313
328fail: 314 ob->destroy ();
329 remove_friendly_object (ob);
330 free_object (ob);
331
332 return 1; 315 return 1;
333} 316}
334 317
335void 318void
336pet_move (object *ob) 319pet_move (object *ob)
337{ 320{
338 int dir, tag, i; 321 int dir = 0, i;
339 sint16 dx, dy; 322 sint16 dx, dy;
340 object *ob2, *owner; 323 object *ob2, *owner;
341 mapstruct *m; 324 maptile *m;
342 325
343 /* Check to see if player pulled out */ 326 /* Check to see if player pulled out */
344 if ((owner = get_owner (ob)) == NULL) 327 if ((owner = ob->owner) == NULL)
345 { 328 {
346 remove_ob (ob); /* Will be freed when returning */ 329 ob->destroy ();
347 remove_friendly_object (ob);
348 free_object (ob);
349 LOG (llevMonster, "Pet: no owner, leaving.\n"); 330 LOG (llevMonster, "Pet: no owner, leaving.\n");
350 return; 331 return;
351 } 332 }
352 333
353 /* move monster into the owners map if not in the same map */ 334 /* move monster into the owners map if not in the same map
354 if (!on_same_map (ob, owner)) 335 * except when the owner is removed.
336 */
337 if (!on_same_map (ob, owner) && !owner->flag [FLAG_REMOVED])
355 { 338 {
356 follow_owner (ob, owner); 339 follow_owner (ob, owner);
357 return; 340 return;
358 } 341 }
359 /* Calculate Direction */ 342 /* Calculate Direction */
… …
372 continue; 355 continue;
373 else 356 else
374 break; 357 break;
375 } 358 }
376 } 359 }
377 else 360 else if (!owner->flag [FLAG_REMOVED]) // only get vector to owner when owner not removed
378 { 361 {
379 struct rv_vector rv; 362 struct rv_vector rv;
380 363
381 get_rangevector (ob, ob->owner, &rv, 0); 364 get_rangevector (ob, ob->owner, &rv, 0);
382 dir = rv.direction; 365 dir = rv.direction;
383 } 366 }
384 ob->direction = dir; 367 ob->direction = dir;
385 368
386 tag = ob->count;
387 /* move_ob returns 0 if the object couldn't move. If that is the 369 /* move_ob returns 0 if the object couldn't move. If that is the
388 * case, lets do some other work. 370 * case, lets do some other work.
389 */ 371 */
390 if (!(move_ob (ob, dir, ob))) 372 if (!(move_ob (ob, dir, ob)))
391 { 373 {
392 object *part; 374 object *part;
393 375
394 /* the failed move_ob above may destroy the pet, so check here */ 376 /* the failed move_ob above may destroy the pet, so check here */
395 if (was_destroyed (ob, tag)) 377 if (ob->destroyed ())
396 return; 378 return;
397 379
398 for (part = ob; part != NULL; part = part->more) 380 for (part = ob; part != NULL; part = part->more)
399 { 381 {
400 dx = part->x + freearr_x[dir]; 382 dx = part->x + freearr_x[dir];
401 dy = part->y + freearr_y[dir]; 383 dy = part->y + freearr_y[dir];
402 m = get_map_from_coord (part->map, &dx, &dy); 384 m = get_map_from_coord (part->map, &dx, &dy);
403 if (!m) 385 if (!m)
404 continue; 386 continue;
405 387
406 for (ob2 = get_map_ob (m, dx, dy); ob2 != NULL; ob2 = ob2->above) 388 for (ob2 = GET_MAP_OB (m, dx, dy); ob2 != NULL; ob2 = ob2->above)
407 { 389 {
408 object *new_ob; 390 object *new_ob;
409 391
410 new_ob = ob2->head ? ob2->head : ob2; 392 new_ob = ob2->head ? ob2->head : ob2;
411 if (new_ob == ob) 393 if (new_ob == ob)
412 break; 394 break;
413 if (new_ob == ob->owner) 395 if (new_ob == ob->owner)
414 return; 396 return;
415 if (get_owner (new_ob) == ob->owner) 397 if (new_ob->owner == ob->owner)
416 break; 398 break;
417 399
418 /* Hmm. Did we try to move into an enemy monster? If so, 400 /* Hmm. Did we try to move into an enemy monster? If so,
419 * make it our enemy. 401 * make it our enemy.
420 */ 402 */
… …
433 return; 415 return;
434 } 416 }
435 } 417 }
436 } 418 }
437 /* Try a different course */ 419 /* Try a different course */
438 dir = absdir (dir + 4 - (RANDOM () % 5) - (RANDOM () % 5)); 420 dir = absdir (dir + 4 - (rndm (5)) - (rndm (5)));
439 (void) move_ob (ob, dir, ob); 421 (void) move_ob (ob, dir, ob);
440 } 422 }
441 return; 423 return;
442} 424}
443 425
… …
457fix_summon_pet (archetype *at, object *op, int dir, int is_golem) 439fix_summon_pet (archetype *at, object *op, int dir, int is_golem)
458{ 440{
459 archetype *atmp; 441 archetype *atmp;
460 object *tmp = NULL, *prev = NULL, *head = NULL; 442 object *tmp = NULL, *prev = NULL, *head = NULL;
461 443
462 for (atmp = at; atmp != NULL; atmp = atmp->more) 444 for (atmp = at; atmp; atmp = atmp->more)
463 { 445 {
464 tmp = arch_to_object (atmp); 446 tmp = arch_to_object (atmp);
447
465 if (atmp == at) 448 if (atmp == at)
466 { 449 {
467 if (!is_golem) 450 if (!is_golem)
468 SET_FLAG (tmp, FLAG_MONSTER); 451 SET_FLAG (tmp, FLAG_MONSTER);
452
469 set_owner (tmp, op); 453 tmp->set_owner (op);
470 if (op->type == PLAYER) 454 if (op->type == PLAYER)
471 { 455 {
472 tmp->stats.exp = 0; 456 tmp->stats.exp = 0;
473 add_friendly_object (tmp); 457 add_friendly_object (tmp);
474 SET_FLAG (tmp, FLAG_FRIENDLY);
475 if (is_golem) 458 if (is_golem)
476 CLEAR_FLAG (tmp, FLAG_MONSTER); 459 CLEAR_FLAG (tmp, FLAG_MONSTER);
477 } 460 }
478 else 461 else
479 { 462 {
480 if (QUERY_FLAG (op, FLAG_FRIENDLY)) 463 if (QUERY_FLAG (op, FLAG_FRIENDLY))
481 { 464 {
482 object *owner = get_owner (op); 465 object *owner = op->owner;
483 466
484 if (owner != NULL) 467 if (owner)
485 { /* For now, we transfer ownership */ 468 { /* For now, we transfer ownership */
486 set_owner (tmp, owner); 469 tmp->set_owner (owner);
487 tmp->attack_movement = PETMOVE; 470 tmp->attack_movement = PETMOVE;
488 add_friendly_object (tmp); 471 add_friendly_object (tmp);
489 SET_FLAG (tmp, FLAG_FRIENDLY);
490 } 472 }
491 } 473 }
492 } 474 }
475
493 if (op->type != PLAYER || !is_golem) 476 if (op->type != PLAYER || !is_golem)
494 { 477 {
495 tmp->attack_movement = PETMOVE; 478 tmp->attack_movement = PETMOVE;
496 tmp->speed_left = -1; 479 tmp->speed_left = -1;
497 tmp->type = 0; 480 tmp->type = 0;
… …
499 } 482 }
500 else 483 else
501 tmp->type = GOLEM; 484 tmp->type = GOLEM;
502 485
503 } 486 }
487
504 if (head == NULL) 488 if (!head)
505 head = tmp; 489 head = tmp;
490
506 tmp->x = op->x + freearr_x[dir] + tmp->arch->clone.x; 491 tmp->x = op->x + freearr_x[dir] + tmp->arch->clone.x;
507 tmp->y = op->y + freearr_y[dir] + tmp->arch->clone.y; 492 tmp->y = op->y + freearr_y[dir] + tmp->arch->clone.y;
508 tmp->map = op->map; 493 tmp->map = op->map;
494
509 if (tmp->invisible) 495 if (tmp->invisible)
510 tmp->invisible = 0; 496 tmp->invisible = 0;
497
511 if (head != tmp) 498 if (head != tmp)
512 tmp->head = head, prev->more = tmp; 499 tmp->head = head, prev->more = tmp;
500
513 prev = tmp; 501 prev = tmp;
514 } 502 }
503
515 head->direction = dir; 504 head->direction = dir;
516 505
517 /* need to change some monster attr to prevent problems/crashing */ 506 /* need to change some monster attr to prevent problems/crashing */
518 head->last_heal = 0; 507 head->last_heal = 0;
519 head->last_eat = 0; 508 head->last_eat = 0;
… …
530 519
531 return head; 520 return head;
532} 521}
533 522
534/* updated this to allow more than the golem 'head' to attack */ 523/* updated this to allow more than the golem 'head' to attack */
535
536/* op is the golem to be moved. */ 524/* op is the golem to be moved. */
537
538void 525void
539move_golem (object *op) 526move_golem (object *op)
540{ 527{
541 int made_attack = 0; 528 int made_attack = 0;
542 object *tmp; 529 object *tmp;
543 tag_t tag;
544 530
545 if (QUERY_FLAG (op, FLAG_MONSTER)) 531 if (QUERY_FLAG (op, FLAG_MONSTER))
546 return; /* Has already been moved */ 532 return; /* Has already been moved */
547 533
548 if (get_owner (op) == NULL) 534 if (!op->owner)
549 { 535 {
550 LOG (llevDebug, "Golem without owner destructed.\n"); 536 LOG (llevDebug, "Golem without owner destructed.\n");
551 remove_ob (op); 537 op->remove ();
552 free_object (op); 538 op->destroy ();
553 return; 539 return;
554 } 540 }
541
555 /* It would be nice to have a cleaner way of what message to print 542 /* It would be nice to have a cleaner way of what message to print
556 * when the golem expires than these hard coded entries. 543 * when the golem expires than these hard coded entries.
557 * Note it is intentional that a golems duration is based on its 544 * Note it is intentional that a golems duration is based on its
558 * hp, and not duration 545 * hp, and not duration
559 */ 546 */
560 if (--op->stats.hp < 0) 547 if (--op->stats.hp < 0)
561 { 548 {
562 if (op->msg) 549 if (op->msg)
563 new_draw_info (NDI_UNIQUE, 0, op->owner, op->msg); 550 new_draw_info (NDI_UNIQUE, 0, op->owner, op->msg);
564 op->owner->contr->ranges[range_golem] = NULL; 551
565 op->owner->contr->golem_count = 0; 552 op->destroy ();
566 remove_friendly_object (op);
567 remove_ob (op);
568 free_object (op);
569 return; 553 return;
570 } 554 }
571 555
572 /* Do golem attacks/movement for single & multisq golems. 556 /* Do golem attacks/movement for single & multisq golems.
573 * Assuming here that op is the 'head' object. Pass only op to 557 * Assuming here that op is the 'head' object. Pass only op to
574 * move_ob (makes recursive calls to other parts) 558 * move_ob (makes recursive calls to other parts)
575 * move_ob returns 0 if the creature was not able to move. 559 * move_ob returns 0 if the creature was not able to move.
576 */ 560 */
577 tag = op->count;
578 if (move_ob (op, op->direction, op)) 561 if (move_ob (op, op->direction, op))
579 return; 562 return;
580 if (was_destroyed (op, tag)) 563
564 if (op->destroyed ())
581 return; 565 return;
582 566
583 for (tmp = op; tmp; tmp = tmp->more) 567 for (tmp = op; tmp; tmp = tmp->more)
584 { 568 {
585 sint16 x = tmp->x + freearr_x[op->direction], y = tmp->y + freearr_y[op->direction]; 569 sint16 x = tmp->x + freearr_x[op->direction], y = tmp->y + freearr_y[op->direction];
586 object *victim; 570 object *victim;
587 mapstruct *m; 571 maptile *m;
588 int mflags; 572 int mflags;
589 573
590 m = op->map; 574 m = op->map;
591 mflags = get_map_flags (m, &m, x, y, &x, &y); 575 mflags = get_map_flags (m, &m, x, y, &x, &y);
592 576
593 if (mflags & P_OUT_OF_MAP) 577 if (mflags & P_OUT_OF_MAP)
594 continue; 578 continue;
595 579
596 for (victim = get_map_ob (op->map, x, y); victim; victim = victim->above) 580 for (victim = GET_MAP_OB (op->map, x, y); victim; victim = victim->above)
597 if (QUERY_FLAG (victim, FLAG_ALIVE)) 581 if (QUERY_FLAG (victim, FLAG_ALIVE))
598 break; 582 break;
599 583
600 /* We used to call will_hit_self to make sure we don't 584 /* We used to call will_hit_self to make sure we don't
601 * hit ourselves, but that didn't work, and I don't really 585 * hit ourselves, but that didn't work, and I don't really
… …
604 * but since we are not trying to dereferance that pointer, 588 * but since we are not trying to dereferance that pointer,
605 * that isn't a problem. 589 * that isn't a problem.
606 */ 590 */
607 if (victim && victim != op && victim->head != op) 591 if (victim && victim != op && victim->head != op)
608 { 592 {
609
610 /* for golems with race fields, we don't attack 593 /* for golems with race fields, we don't attack
611 * aligned races 594 * aligned races
612 */ 595 */
613 596
614 if (victim->race && op->race && strstr (op->race, victim->race)) 597 if (victim->race && op->race && strstr (op->race, victim->race))
… …
626 attack_ob (victim, op); 609 attack_ob (victim, op);
627 made_attack = 1; 610 made_attack = 1;
628 } 611 }
629 } /* If victim */ 612 } /* If victim */
630 } 613 }
614
631 if (made_attack) 615 if (made_attack)
632 update_object (op, UP_OBJ_FACE); 616 update_object (op, UP_OBJ_FACE);
633} 617}
634 618
635/* this is a really stupid function when you get down and 619/* this is a really stupid function when you get down and
… …
657 char buf[MAX_BUF]; 641 char buf[MAX_BUF];
658 642
659 /* Because there can be different golem spells, player may want to 643 /* Because there can be different golem spells, player may want to
660 * 'lose' their old golem. 644 * 'lose' their old golem.
661 */ 645 */
662 if (op->type == PLAYER && op->contr->ranges[range_golem] != NULL && op->contr->golem_count == op->contr->ranges[range_golem]->count) 646 if (op->type == PLAYER && op->contr->ranges[range_golem])
663 { 647 {
664 new_draw_info (NDI_UNIQUE, 0, op, "You dismiss your existing golem."); 648 new_draw_info (NDI_UNIQUE, 0, op, "You dismiss your existing golem.");
665 remove_ob (op->contr->ranges[range_golem]); 649 op->contr->ranges[range_golem]->remove ();
666 free_object (op->contr->ranges[range_golem]); 650 op->contr->ranges[range_golem]->destroy ();
667 op->contr->ranges[range_golem] = NULL; 651 op->contr->ranges[range_golem] = 0;
668 op->contr->golem_count = (uint32) - 1;
669 } 652 }
670 653
671 if (spob->other_arch) 654 if (spob->other_arch)
672 at = spob->other_arch; 655 at = spob->other_arch;
673 else if (spob->race) 656 else if (spob->race)
… …
693 LOG (llevError, "Spell %s lacks other_arch\n", &spob->name); 676 LOG (llevError, "Spell %s lacks other_arch\n", &spob->name);
694 return 0; 677 return 0;
695 } 678 }
696 679
697 if (!dir) 680 if (!dir)
698 dir = find_free_spot (NULL, op->map, op->x, op->y, 1, SIZEOFFREE1 + 1); 681 dir = find_free_spot (&at->clone, op->map, op->x, op->y, 1, SIZEOFFREE1 + 1);
699 682
700 if (dir == -1 || ob_blocked (&at->clone, op->map, op->x + freearr_x[dir], op->y + freearr_y[dir])) 683 if (dir < 0 || ob_blocked (&at->clone, op->map, op->x + freearr_x[dir], op->y + freearr_y[dir]))
701 { 684 {
702 new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way."); 685 new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way.");
703 return 0; 686 return 0;
704 } 687 }
688
705 /* basically want to get proper map/coordinates for this object */ 689 /* basically want to get proper map/coordinates for this object */
706 690
707 if (!(tmp = fix_summon_pet (at, op, dir, GOLEM))) 691 if (!(tmp = fix_summon_pet (at, op, dir, GOLEM)))
708 { 692 {
709 new_draw_info (NDI_UNIQUE, 0, op, "Your spell fails."); 693 new_draw_info (NDI_UNIQUE, 0, op, "Your spell fails.");
… …
711 } 695 }
712 696
713 if (op->type == PLAYER) 697 if (op->type == PLAYER)
714 { 698 {
715 tmp->type = GOLEM; 699 tmp->type = GOLEM;
716 set_owner (tmp, op); 700 tmp->set_owner (op);
717 set_spell_skill (op, caster, spob, tmp);
718 op->contr->ranges[range_golem] = tmp; 701 op->contr->ranges[range_golem] = tmp;
719 op->contr->golem_count = tmp->count;
720 /* give the player control of the golem */ 702 /* give the player control of the golem */
721 op->contr->shoottype = range_golem; 703 op->contr->shoottype = range_golem;
704 set_spell_skill (op, caster, spob, tmp);
722 } 705 }
723 else 706 else
724 { 707 {
725 if (QUERY_FLAG (op, FLAG_FRIENDLY)) 708 if (QUERY_FLAG (op, FLAG_FRIENDLY))
726 { 709 {
727 object *owner = get_owner (op); 710 object *owner = op->owner;
728 711
729 if (owner != NULL) 712 if (owner)
730 { /* For now, we transfer ownership */ 713 { /* For now, we transfer ownership */
731 set_owner (tmp, owner); 714 tmp->set_owner (owner);
732 tmp->attack_movement = PETMOVE; 715 tmp->attack_movement = PETMOVE;
733 add_friendly_object (tmp); 716 add_friendly_object (tmp);
734 SET_FLAG (tmp, FLAG_FRIENDLY);
735 } 717 }
736 } 718 }
737 719
738 SET_FLAG (tmp, FLAG_MONSTER); 720 SET_FLAG (tmp, FLAG_MONSTER);
739 } 721 }
… …
908 * with all the checks in the 'for' portion itself. Much 890 * with all the checks in the 'for' portion itself. Much
909 * more readable to break some of the conditions out. 891 * more readable to break some of the conditions out.
910 */ 892 */
911 for (tr = spell_ob->randomitems->items; tr; tr = tr->next) 893 for (tr = spell_ob->randomitems->items; tr; tr = tr->next)
912 { 894 {
895 if (!tr->item)
896 continue;
897
913 if (level < tr->magic) 898 if (level < tr->magic)
914 break; 899 break;
915 900
916 lasttr = tr; 901 lasttr = tr;
917 902
918 if (tr->item->name == sparam) 903 if (tr->item->name == sparam)
919 break;
920
921 if (!tr->next || !tr->next->item)
922 break; 904 break;
923 } 905 }
924 906
925 if (!lasttr) 907 if (!lasttr)
926 { 908 {
… …
928 new_draw_info (NDI_UNIQUE, 0, op, "The spell fails to summon any monsters."); 910 new_draw_info (NDI_UNIQUE, 0, op, "The spell fails to summon any monsters.");
929 return 0; 911 return 0;
930 } 912 }
931 913
932 summon_arch = lasttr->item; 914 summon_arch = lasttr->item;
933 nrof = lasttr->nrof; 915 nrof = lasttr->nrof;
934 } 916 }
935 else if (spell_ob->race && !strcmp (spell_ob->race, "GODCULTMON")) 917 else if (spell_ob->race && !strcmp (spell_ob->race, "GODCULTMON"))
936 { 918 {
937 object *god = find_god (determine_god (op)), *mon, *owner; 919 object *god = find_god (determine_god (op)), *mon, *owner;
938 int summon_level, tries; 920 int summon_level, tries;
939 921
940 if (!god && ((owner = get_owner (op)) != NULL)) 922 if (!god && ((owner = op->owner) != NULL))
941 god = find_god (determine_god (owner)); 923 god = find_god (determine_god (owner));
942 924
943 /* If we can't find a god, can't get what monster to summon */ 925 /* If we can't find a god, can't get what monster to summon */
944 if (!god) 926 if (!god)
945 return 0; 927 return 0;
… …
968 ndir = dir; 950 ndir = dir;
969 951
970 if (!ndir) 952 if (!ndir)
971 ndir = find_free_spot (mon, op->map, op->x, op->y, 1, SIZEOFFREE); 953 ndir = find_free_spot (mon, op->map, op->x, op->y, 1, SIZEOFFREE);
972 954
973 if (ndir == -1 || ob_blocked (mon, op->map, op->x + freearr_x[ndir], op->y + freearr_y[ndir])) 955 if (ndir < 0 || ob_blocked (mon, op->map, op->x + freearr_x[ndir], op->y + freearr_y[ndir]))
974 { 956 {
975 ndir = -1; 957 ndir = -1;
976 if (++tries == 5) 958 if (++tries == 5)
977 { 959 {
978 new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way."); 960 new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way.");
… …
1018 { 1000 {
1019 x = freearr_x[ndir]; 1001 x = freearr_x[ndir];
1020 y = freearr_y[ndir]; 1002 y = freearr_y[ndir];
1021 } 1003 }
1022 1004
1023 if (ndir == -1 || ob_blocked (&summon_arch->clone, op->map, op->x + x, op->y + y)) 1005 if (ndir < 0 || ob_blocked (&summon_arch->clone, op->map, op->x + x, op->y + y))
1024 { 1006 {
1025 new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way."); 1007 new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way.");
1026 if (nrof > 1) 1008 if (nrof > 1)
1027 new_draw_info (NDI_UNIQUE, 0, op, "No more pets for this casting."); 1009 new_draw_info (NDI_UNIQUE, 0, op, "No more pets for this casting.");
1028 1010
… …
1034 tmp = arch_to_object (atmp); 1016 tmp = arch_to_object (atmp);
1035 if (atmp == summon_arch) 1017 if (atmp == summon_arch)
1036 { 1018 {
1037 if (QUERY_FLAG (tmp, FLAG_MONSTER)) 1019 if (QUERY_FLAG (tmp, FLAG_MONSTER))
1038 { 1020 {
1039 set_owner (tmp, op); 1021 tmp->set_owner (op);
1040 set_spell_skill (op, caster, spell_ob, tmp); 1022 set_spell_skill (op, caster, spell_ob, tmp);
1041 tmp->enemy = op->enemy; 1023 tmp->enemy = op->enemy;
1042 tmp->type = 0; 1024 tmp->type = 0;
1043 CLEAR_FLAG (tmp, FLAG_SLEEP); 1025 CLEAR_FLAG (tmp, FLAG_SLEEP);
1044 1026
1045 if (op->type == PLAYER || QUERY_FLAG (op, FLAG_FRIENDLY)) 1027 if (op->type == PLAYER || QUERY_FLAG (op, FLAG_FRIENDLY))
1046 { 1028 {
1047 /* If this is not set, we make it friendly */ 1029 /* If this is not set, we make it friendly */
1048 if (!QUERY_FLAG (spell_ob, FLAG_MONSTER)) 1030 if (!QUERY_FLAG (spell_ob, FLAG_MONSTER))
1049 { 1031 {
1050 SET_FLAG (tmp, FLAG_FRIENDLY);
1051 add_friendly_object (tmp); 1032 add_friendly_object (tmp);
1052 tmp->stats.exp = 0; 1033 tmp->stats.exp = 0;
1053 1034
1054 if (spell_ob->attack_movement) 1035 if (spell_ob->attack_movement)
1055 tmp->attack_movement = spell_ob->attack_movement; 1036 tmp->attack_movement = spell_ob->attack_movement;
1056 1037
1057 if (get_owner (op)) 1038 if (op->owner)
1058 set_owner (tmp, get_owner (op)); 1039 tmp->set_owner (op->owner);
1059 } 1040 }
1060 } 1041 }
1061 } 1042 }
1062 1043
1063 if (tmp->speed > MIN_ACTIVE_SPEED) 1044 if (tmp->speed > MIN_ACTIVE_SPEED)
… …
1082 head->stats.exp = 0; 1063 head->stats.exp = 0;
1083 head = insert_ob_in_map (head, head->map, op, 0); 1064 head = insert_ob_in_map (head, head->map, op, 0);
1084 1065
1085 if (head && head->randomitems) 1066 if (head && head->randomitems)
1086 { 1067 {
1087 object *tmp;
1088
1089 create_treasure (head->randomitems, head, GT_APPLY | GT_STARTEQUIP, 6, 0); 1068 create_treasure (head->randomitems, head, GT_APPLY | GT_STARTEQUIP, 6, 0);
1069
1090 for (tmp = head->inv; tmp; tmp = tmp->below) 1070 for (object *tmp = head->inv; tmp; tmp = tmp->below)
1091 if (!tmp->nrof)
1092 SET_FLAG (tmp, FLAG_NO_DROP); 1071 SET_FLAG (tmp, FLAG_DESTROY_ON_DEATH);
1093 } 1072 }
1094 } /* for i < nrof */ 1073 } /* for i < nrof */
1095 1074
1096 return 1; 1075 return 1;
1097} 1076}
… …
1104 object *realowner = ob; 1083 object *realowner = ob;
1105 1084
1106 if (realowner == NULL) 1085 if (realowner == NULL)
1107 return NULL; 1086 return NULL;
1108 1087
1109 while (get_owner (realowner) != NULL) 1088 while (realowner->owner != NULL)
1110 { 1089 {
1111 realowner = get_owner (realowner); 1090 realowner = realowner->owner;
1112 } 1091 }
1113 return realowner; 1092 return realowner;
1114} 1093}
1115 1094
1116/* determines if checks so pets don't attack players or other pets should be 1095/* determines if checks so pets don't attack players or other pets should be
… …
1125 return 0; 1104 return 0;
1126 1105
1127 /* get the owners of itself and the target, this is to deal with pets of 1106 /* get the owners of itself and the target, this is to deal with pets of
1128 pets */ 1107 pets */
1129 rowner = get_real_owner (owner); 1108 rowner = get_real_owner (owner);
1130 if (target->type != PLAYER) 1109 towner = target->type == PLAYER ? 0 : get_real_owner (target);
1131 {
1132 towner = get_real_owner (target);
1133 }
1134 else
1135 {
1136 towner = 0;
1137 }
1138 1110
1139 /* if the pet has now owner, exit with error */ 1111 /* if the pet has now owner, exit with error */
1140 if (rowner == NULL) 1112 if (!rowner)
1141 { 1113 {
1142 LOG (llevError, "Pet has no owner.\n"); 1114 LOG (llevError, "Pet has no owner.\n");
1143 return 0; 1115 return 0;
1144 } 1116 }
1145 1117

Diff Legend

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