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.71 by root, Wed Nov 16 23:42:03 2016 UTC

1/* 1/*
2 CrossFire, A Multiplayer game for X-windows 2 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
3 3 *
4 * Copyright (©) 2005,2006,2007,2008,2009,2010,2011,2012,2013,2014,2015,2016 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
4 Copyright (C) 2002 Mark Wedel & Crossfire Development Team 5 * Copyright (©) 2002 Mark Wedel & Crossfire Development Team
5 Copyright (C) 1992 Frank Tore Johansen 6 * Copyright (©) 1992 Frank Tore Johansen
6 7 *
7 This program is free software; you can redistribute it and/or modify 8 * Deliantra is free software: you can redistribute it and/or modify it under
8 it under the terms of the GNU General Public License as published by 9 * the terms of the Affero GNU General Public License as published by the
9 the Free Software Foundation; either version 2 of the License, or 10 * Free Software Foundation, either version 3 of the License, or (at your
10 (at your option) any later version. 11 * 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 Affero GNU General Public License
18 along with this program; if not, write to the Free Software 19 * and the GNU General Public License along with this program. If not, see
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 * <http://www.gnu.org/licenses/>.
20 21 *
21 The authors can be reached via e-mail at <crossfire@schmorp.de> 22 * The authors can be reached via e-mail to <support@deliantra.net>
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 *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 object *owner = pet->owner;
50 { 48
51 /* If the owner has turned on the pet, make the pet 49 if (!owner)
52 * unfriendly.
53 */
54 if ((check_enemy (owner, rv)) == pet)
55 {
56 CLEAR_FLAG (pet, FLAG_FRIENDLY);
57 remove_friendly_object (pet);
58 pet->attack_movement &= ~PETMOVE;
59 return owner;
60 }
61 } 50 {
62 else
63 {
64 /* else the owner is no longer around, so the 51 /* the owner is no longer around, so the
65 * pet no longer needs to be friendly. 52 * pet no longer needs to be friendly.
66 */ 53 */
67 CLEAR_FLAG (pet, FLAG_FRIENDLY);
68 remove_friendly_object (pet); 54 remove_friendly_object (pet);
69 pet->attack_movement &= ~PETMOVE; 55 pet->attack_movement &= ~PETMOVE;
70 return NULL; 56 return 0;
57 }
58
59 /* If the owner has turned on the pet, make the pet
60 * unfriendly.
61 */
62 if (check_enemy (owner, rv) == pet)
71 } 63 {
64 remove_friendly_object (pet);
65 pet->attack_movement &= ~PETMOVE;
66 return owner;
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 && !pet->flag [FLAG_CONFUSED] && pet->flag [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 // owners sometimes are not on a map but in the inventory of somehting else
112 if (!owner->flag [FLAG_REMOVED] && owner->map)
113 {
114 tmp3 = 0;
115
113 for (i = 0; i < SIZEOFFREE; i++) 116 for (i = 0; i < SIZEOFFREE; i++)
114 { 117 {
115 x = owner->x + freearr_x[search_arr[i]]; 118 x = owner->x + freearr_x[search_arr[i]];
116 y = owner->y + freearr_y[search_arr[i]]; 119 y = owner->y + freearr_y[search_arr[i]];
117 nm = owner->map; 120 nm = owner->map;
118 /* Only look on the space if there is something alive there. */ 121 /* Only look on the space if there is something alive there. */
119 mflags = get_map_flags (nm, &nm, x, y, &x, &y); 122 mflags = get_map_flags (nm, &nm, x, y, &x, &y);
123
120 if (!(mflags & P_OUT_OF_MAP) && mflags & P_IS_ALIVE) 124 if (!(mflags & P_OUT_OF_MAP) && mflags & P_IS_ALIVE)
121 { 125 {
122 for (tmp = get_map_ob (nm, x, y); tmp != NULL; tmp = tmp->above) 126 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 { 127 {
128 object *tmp2 = tmp->head == 0 ? tmp : tmp->head;
131 129
132 if (!can_see_enemy (pet, tmp2)) 130 if (tmp2->flag [FLAG_ALIVE] && ((!tmp2->flag [FLAG_FRIENDLY] &&
131 (tmp2->type != PLAYER)) ||
132 should_arena_attack (pet, owner, tmp2))
133 && !tmp2->flag [FLAG_UNAGGRESSIVE] && tmp2 != pet && tmp2 != owner && can_detect_enemy (pet, tmp2, rv))
133 { 134 {
135
136 if (!can_see_enemy (pet, tmp2))
137 {
134 if (tmp3 != NULL) 138 if (tmp3 != 0)
135 tmp3 = tmp2; 139 tmp3 = tmp2;
136 } 140 }
137 else
138 {
139 pet->enemy = tmp2;
140 if (check_enemy (pet, rv) != NULL)
141 return tmp2;
142 else 141 else
142 {
143 pet->enemy = tmp2;
144 if (check_enemy (pet, rv) != 0)
145 return tmp2;
146 else
143 pet->enemy = NULL; 147 pet->enemy = 0;
144 } 148 }
145 } /* if this is a valid enemy */ 149 } /* if this is a valid enemy */
146 } /* for objects on this space */ 150 } /* for objects on this space */
147 } /* if there is something living on this space */ 151 } /* if there is something living on this space */
148 } /* for loop of spaces around the owner */ 152 } /* for loop of spaces around the owner */
149 153
150 /* fine, we went through the whole loop and didn't find one we could 154 /* fine, we went through the whole loop and didn't find one we could
151 see, take what we have */ 155 see, take what we have */
152 if (tmp3 != NULL) 156 if (tmp3 != 0)
153 { 157 {
154 pet->enemy = tmp3; 158 pet->enemy = tmp3;
155 if (check_enemy (pet, rv) != NULL) 159 if (check_enemy (pet, rv) != 0)
156 return tmp3; 160 return tmp3;
157 else 161 else
158 pet->enemy = NULL; 162 pet->enemy = 0;
163 }
159 } 164 }
160 165
161 /* No threat to owner, check to see if the pet has an attacker */ 166 /* No threat to owner, check to see if the pet has an attacker */
162 if (attacker) 167 if (attacker)
163 { 168 {
164 /* also need to check to make sure it is not freindly */ 169 /* also need to check to make sure it is not freindly */
165 /* or otherwise non-hostile, and is an appropriate target */ 170 /* or otherwise non-hostile, and is an appropriate target */
166 if (!QUERY_FLAG (attacker, FLAG_FRIENDLY) && on_same_map (pet, attacker)) 171 if (!attacker->flag [FLAG_FRIENDLY] && on_same_map (pet, attacker))
167 { 172 {
168 pet->enemy = attacker; 173 pet->enemy = attacker;
169 174
170 if (check_enemy (pet, rv) != NULL) 175 if (check_enemy (pet, rv) != 0)
171 return attacker; 176 return attacker;
172 else 177 else
173 pet->enemy = NULL; 178 pet->enemy = 0;
174 } 179 }
175 } 180 }
176 181
177 /* Don't have an attacker or legal enemy, so look for a new one!. 182 /* 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 183 * 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 184 * 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. 185 * the same as the code that looks around the owner.
181 */ 186 */
182 if (owner->type == PLAYER && owner->contr->petmode != pet_defend) 187 if (owner->type == PLAYER && owner->contr->petmode != pet_defend)
183 { 188 {
184 tmp3 = NULL; 189 tmp3 = 0;
185 for (i = 0; i < SIZEOFFREE; i++) 190 for (i = 0; i < SIZEOFFREE; i++)
186 { 191 {
187 x = pet->x + freearr_x[search_arr[i]]; 192 x = pet->x + freearr_x[search_arr[i]];
188 y = pet->y + freearr_y[search_arr[i]]; 193 y = pet->y + freearr_y[search_arr[i]];
189 nm = pet->map; 194 nm = pet->map;
190 /* Only look on the space if there is something alive there. */ 195 /* Only look on the space if there is something alive there. */
191 mflags = get_map_flags (nm, &nm, x, y, &x, &y); 196 mflags = get_map_flags (nm, &nm, x, y, &x, &y);
192 if (!(mflags & P_OUT_OF_MAP) && mflags & P_IS_ALIVE) 197 if (!(mflags & P_OUT_OF_MAP) && mflags & P_IS_ALIVE)
193 { 198 {
194 for (tmp = get_map_ob (nm, x, y); tmp != NULL; tmp = tmp->above) 199 for (tmp = GET_MAP_OB (nm, x, y); tmp != 0; tmp = tmp->above)
195 { 200 {
196 object *tmp2 = tmp->head == NULL ? tmp : tmp->head; 201 object *tmp2 = tmp->head == 0 ? tmp : tmp->head;
197 202
198 if (QUERY_FLAG (tmp2, FLAG_ALIVE) && ((!QUERY_FLAG (tmp2, FLAG_FRIENDLY) && 203 if (tmp2->flag [FLAG_ALIVE] && ((!tmp2->flag [FLAG_FRIENDLY] &&
199 (tmp2->type != PLAYER)) || 204 (tmp2->type != PLAYER)) ||
200 should_arena_attack (pet, owner, tmp2)) 205 should_arena_attack (pet, owner, tmp2))
201 && !QUERY_FLAG (tmp2, FLAG_UNAGGRESSIVE) && tmp2 != pet && tmp2 != owner && can_detect_enemy (pet, tmp2, rv)) 206 && !tmp2->flag [FLAG_UNAGGRESSIVE] && tmp2 != pet && tmp2 != owner && can_detect_enemy (pet, tmp2, rv))
202 { 207 {
203 208
204 if (!can_see_enemy (pet, tmp2)) 209 if (!can_see_enemy (pet, tmp2))
205 { 210 {
206 if (tmp3 != NULL) 211 if (tmp3 != 0)
207 tmp3 = tmp2; 212 tmp3 = tmp2;
208 } 213 }
209 else 214 else
210 { 215 {
211 pet->enemy = tmp2; 216 pet->enemy = tmp2;
212 if (check_enemy (pet, rv) != NULL) 217 if (check_enemy (pet, rv) != 0)
213 return tmp2; 218 return tmp2;
214 else 219 else
215 pet->enemy = NULL; 220 pet->enemy = 0;
216 } 221 }
217 } /* make sure we can get to the bugger */ 222 } /* make sure we can get to the bugger */
218 } /* for objects on this space */ 223 } /* for objects on this space */
219 } /* if there is something living on this space */ 224 } /* if there is something living on this space */
220 } /* for loop of spaces around the pet */ 225 } /* for loop of spaces around the pet */
226
227 /* fine, we went through the whole loop and didn't find one we could
228 see, take what we have */
229 if (tmp3 != 0)
230 {
231 pet->enemy = tmp3;
232 if (check_enemy (pet, rv) != 0)
233 return tmp3;
234 else
235 pet->enemy = 0;
236 }
221 } /* pet in defence mode */ 237 } /* pet in defence mode */
222 238
223 /* fine, we went through the whole loop and didn't find one we could 239 object *enemy = check_enemy (pet, rv);
224 see, take what we have */ 240 // we have a summoned pet here and the owners enemy isn't set or can't
225 if (tmp3 != NULL) 241 // be reached => search for a player around us and set it as our new enemy!!
226 { 242 if (!enemy && pet->owner && pet->owner->type != PLAYER)
227 pet->enemy = tmp3; 243 enemy = get_nearest_player (pet);
228 if (check_enemy (pet, rv) != NULL)
229 return tmp3;
230 else
231 pet->enemy = NULL;
232 }
233 244
234 /* Didn't find anything - return the owner's enemy or NULL */ 245 /* Didn't find anything - return the owner's enemy or 0 */
235 return check_enemy (pet, rv); 246 return enemy;
236} 247}
237 248
238void 249void
239terminate_all_pets (object *owner) 250terminate_all_pets (object *owner)
240{ 251{
241 objectlink *obl, *next; 252 objectlink *obl, *next;
242 253
243 for (obl = first_friendly_object; obl != NULL; obl = next) 254 for (obl = first_friendly_object; obl; obl = next)
244 { 255 {
245 object *ob = obl->ob; 256 object *ob = obl->ob;
246
247 next = obl->next; 257 next = obl->next;
258
248 if (get_owner (ob) == owner) 259 if (ob->owner == owner)
249 { 260 ob->drop_and_destroy ();
250 if (!QUERY_FLAG (ob, FLAG_REMOVED))
251 remove_ob (ob);
252 remove_friendly_object (ob);
253 free_object (ob);
254 }
255 } 261 }
256} 262}
257 263
258/* 264/*
259 * Unfortunately, sometimes, the owner of a pet is in the 265 * Unfortunately, sometimes, the owner of a pet is in the
260 * process of entering a new map when this is called. 266 * process of entering a new map when this is called.
261 * Thus the map isn't loaded yet, and we have to remove
262 * the pet...
263 * Interesting enough, we don't use the passed map structure in 267 * Interesting enough, we don't use the passed map structure in
264 * this function. 268 * this function.
265 */ 269 */
266
267void 270void
268remove_all_pets (mapstruct *map) 271move_all_pets ()
269{ 272{
270 objectlink *obl, *next; 273 objectlink *obl, *next;
271 object *owner; 274 object *owner;
272 275
273 for (obl = first_friendly_object; obl != NULL; obl = next) 276 for (obl = first_friendly_object; obl; obl = next)
274 { 277 {
275 next = obl->next; 278 next = obl->next;
276 if (obl->ob->type != PLAYER && QUERY_FLAG (obl->ob, FLAG_FRIENDLY) && 279
277 (owner = get_owner (obl->ob)) != NULL && !on_same_map (owner, obl->ob)) 280 if (obl->ob->type != PLAYER
281 && obl->ob->flag [FLAG_FRIENDLY]
282 && (owner = obl->ob->owner)
283 && !on_same_map (owner, obl->ob))
278 { 284 {
279 /* follow owner checks map status for us */ 285 /* follow owner checks map status for us */
280 follow_owner (obl->ob, owner); 286 follow_owner (obl->ob, owner);
281 } 287 }
282 } 288 }
283} 289}
284 290
285int 291int
286follow_owner (object *ob, object *owner) 292follow_owner (object *ob, object *owner)
287{ 293{
288 object *tmp; 294 if (owner->flag [FLAG_REMOVED])
289 int dir; 295 return 0; // do nothing if the owner is removed
290 296 else if (!owner->map || owner->map->state != MAP_ACTIVE)
291 if (!QUERY_FLAG (ob, FLAG_REMOVED)) 297 LOG (llevError, "owner '%s' of the pet '%s' not on a map in memory!?\n", &owner->name, &ob->name);
292 remove_ob (ob); 298 else
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 {
299 if (owner->map->in_memory != MAP_IN_MEMORY)
300 {
301 LOG (llevError, "Owner of the pet not on a map in memory!?\n");
302 goto fail;
303 }
304
305 dir = find_free_spot (ob, owner->map, owner->x, owner->y, 1, SIZEOFFREE); 300 int dir = find_free_spot (ob, owner->map, owner->x, owner->y, 1, SIZEOFFREE);
306 301
307 if (dir == -1) 302 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 } 303 {
321 } 304 owner->map->insert (ob, owner->x + freearr_x[dir], owner->y + freearr_y[dir]);
322 insert_ob_in_map (ob, ob->map, NULL, 0); 305
323 if (owner->type == PLAYER) /* Uh, I hope this is always true... */ 306 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"); 307 new_draw_info (NDI_UNIQUE, 0, owner, "Your pet magically appears next to you");
325 308
326 return 0; 309 return 0;
310 }
311 }
327 312
328fail: 313 ob->drop_and_destroy ();
329 remove_friendly_object (ob);
330 free_object (ob);
331 314
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->drop_and_destroy ();
347 remove_friendly_object (ob);
348 free_object (ob);
349 LOG (llevMonster, "Pet: no owner, leaving.\n"); 330 LOG (llevTrace, "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 }
342
359 /* Calculate Direction */ 343 /* Calculate Direction */
360 if (owner->type == PLAYER && owner->contr->petmode == pet_sad) 344 if (owner->type == PLAYER && owner->contr->petmode == pet_sad)
361 { 345 {
362 /* in S&D mode, if we have no enemy, run randomly about. */ 346 /* in S&D mode, if we have no enemy, run randomly about. */
363 for (i = 0; i < 15; i++) 347 for (i = 0; i < 15; i++)
… …
372 continue; 356 continue;
373 else 357 else
374 break; 358 break;
375 } 359 }
376 } 360 }
377 else 361 else if (!owner->flag [FLAG_REMOVED]) // only get vector to owner when owner not removed
378 { 362 {
379 struct rv_vector rv; 363 struct rv_vector rv;
380 364
381 get_rangevector (ob, ob->owner, &rv, 0); 365 get_rangevector (ob, ob->owner, &rv, 0);
382 dir = rv.direction; 366 dir = rv.direction;
383 } 367 }
368
384 ob->direction = dir; 369 ob->direction = dir;
385 370
386 tag = ob->count;
387 /* move_ob returns 0 if the object couldn't move. If that is the 371 /* move_ob returns 0 if the object couldn't move. If that is the
388 * case, lets do some other work. 372 * case, lets do some other work.
389 */ 373 */
390 if (!(move_ob (ob, dir, ob))) 374 if (!(ob->move (dir)))
391 { 375 {
392 object *part; 376 object *part;
393 377
394 /* the failed move_ob above may destroy the pet, so check here */ 378 /* the failed move_ob above may destroy the pet, so check here */
395 if (was_destroyed (ob, tag)) 379 if (ob->destroyed ())
396 return; 380 return;
397 381
398 for (part = ob; part != NULL; part = part->more) 382 for (part = ob; part != NULL; part = part->more)
399 { 383 {
400 dx = part->x + freearr_x[dir]; 384 dx = part->x + freearr_x[dir];
401 dy = part->y + freearr_y[dir]; 385 dy = part->y + freearr_y[dir];
402 m = get_map_from_coord (part->map, &dx, &dy); 386 m = get_map_from_coord (part->map, &dx, &dy);
403 if (!m) 387 if (!m)
404 continue; 388 continue;
405 389
406 for (ob2 = get_map_ob (m, dx, dy); ob2 != NULL; ob2 = ob2->above) 390 for (ob2 = GET_MAP_OB (m, dx, dy); ob2 != NULL; ob2 = ob2->above)
407 { 391 {
408 object *new_ob; 392 object *new_ob;
409 393
410 new_ob = ob2->head ? ob2->head : ob2; 394 new_ob = ob2->head ? ob2->head : ob2;
395
411 if (new_ob == ob) 396 if (new_ob == ob)
412 break; 397 break;
398
413 if (new_ob == ob->owner) 399 if (new_ob == ob->owner)
414 return; 400 return;
401
415 if (get_owner (new_ob) == ob->owner) 402 if (new_ob->owner == ob->owner)
416 break; 403 break;
417 404
418 /* Hmm. Did we try to move into an enemy monster? If so, 405 /* Hmm. Did we try to move into an enemy monster? If so,
419 * make it our enemy. 406 * make it our enemy.
420 */ 407 */
421 if (QUERY_FLAG (new_ob, FLAG_ALIVE) && !QUERY_FLAG (ob, FLAG_UNAGGRESSIVE) 408 if (new_ob->flag [FLAG_ALIVE] && !ob->flag [FLAG_UNAGGRESSIVE]
422 && !QUERY_FLAG (new_ob, FLAG_UNAGGRESSIVE) && !QUERY_FLAG (new_ob, FLAG_FRIENDLY)) 409 && !new_ob->flag [FLAG_UNAGGRESSIVE] && !new_ob->flag [FLAG_FRIENDLY])
423 { 410 {
424 411
425 ob->enemy = new_ob; 412 ob->enemy = new_ob;
426 if (new_ob->enemy == NULL) 413 if (new_ob->enemy == NULL)
427 new_ob->enemy = ob; 414 new_ob->enemy = ob;
… …
433 return; 420 return;
434 } 421 }
435 } 422 }
436 } 423 }
437 /* Try a different course */ 424 /* Try a different course */
438 dir = absdir (dir + 4 - (RANDOM () % 5) - (RANDOM () % 5)); 425 dir = absdir (dir + 4 - (rndm (5)) - (rndm (5)));
439 (void) move_ob (ob, dir, ob); 426 ob->move (dir);
440 } 427 }
441 return;
442} 428}
443 429
444/**************************************************************************** 430/****************************************************************************
445 * 431 *
446 * GOLEM SPELL CODE 432 * GOLEM SPELL CODE
… …
451 * proper for map insertion. 437 * proper for map insertion.
452 * at is the archetype, op is the caster of the spell, dir is the 438 * at is the archetype, op is the caster of the spell, dir is the
453 * direction the monster should be placed in. 439 * direction the monster should be placed in.
454 * is_golem is to note that this is a golem spell. 440 * is_golem is to note that this is a golem spell.
455 */ 441 */
456object * 442static object *
457fix_summon_pet (archetype *at, object *op, int dir, int is_golem) 443fix_summon_pet (archetype *at, object *op, int dir, int is_golem)
458{ 444{
459 archetype *atmp;
460 object *tmp = NULL, *prev = NULL, *head = NULL; 445 object *tmp = NULL, *prev = NULL, *head = NULL;
461 446
462 for (atmp = at; atmp != NULL; atmp = atmp->more) 447 for (archetype *atmp = at; atmp; atmp = (archetype *)atmp->more)
463 { 448 {
464 tmp = arch_to_object (atmp); 449 tmp = atmp->instance ();
450
465 if (atmp == at) 451 if (atmp == at)
466 { 452 {
467 if (!is_golem) 453 if (!is_golem)
468 SET_FLAG (tmp, FLAG_MONSTER); 454 tmp->set_flag (FLAG_MONSTER);
455
469 set_owner (tmp, op); 456 tmp->set_owner (op);
457
470 if (op->type == PLAYER) 458 if (op->type == PLAYER)
471 { 459 {
472 tmp->stats.exp = 0; 460 tmp->stats.exp = 0;
473 add_friendly_object (tmp); 461 add_friendly_object (tmp);
474 SET_FLAG (tmp, FLAG_FRIENDLY);
475 if (is_golem) 462 if (is_golem)
476 CLEAR_FLAG (tmp, FLAG_MONSTER); 463 tmp->clr_flag (FLAG_MONSTER);
477 } 464 }
478 else 465 else
479 { 466 {
480 if (QUERY_FLAG (op, FLAG_FRIENDLY)) 467 if (op->flag [FLAG_FRIENDLY])
481 { 468 {
482 object *owner = get_owner (op); 469 object *owner = op->owner;
483 470
484 if (owner != NULL) 471 if (owner)
485 { /* For now, we transfer ownership */ 472 { /* For now, we transfer ownership */
486 set_owner (tmp, owner); 473 tmp->set_owner (owner);
487 tmp->attack_movement = PETMOVE; 474 tmp->attack_movement = PETMOVE;
488 add_friendly_object (tmp); 475 add_friendly_object (tmp);
489 SET_FLAG (tmp, FLAG_FRIENDLY);
490 } 476 }
491 } 477 }
492 } 478 }
479
493 if (op->type != PLAYER || !is_golem) 480 if (op->type != PLAYER || !is_golem)
494 { 481 {
495 tmp->attack_movement = PETMOVE; 482 tmp->attack_movement = PETMOVE;
496 tmp->speed_left = -1; 483 tmp->speed_left = -1;
497 tmp->type = 0; 484 tmp->type = 0;
… …
499 } 486 }
500 else 487 else
501 tmp->type = GOLEM; 488 tmp->type = GOLEM;
502 489
503 } 490 }
491
504 if (head == NULL) 492 if (!head)
505 head = tmp; 493 head = tmp;
494
506 tmp->x = op->x + freearr_x[dir] + tmp->arch->clone.x; 495 tmp->x = op->x + freearr_x[dir] + tmp->arch->x;
507 tmp->y = op->y + freearr_y[dir] + tmp->arch->clone.y; 496 tmp->y = op->y + freearr_y[dir] + tmp->arch->y;
508 tmp->map = op->map; 497 tmp->map = op->map;
498
509 if (tmp->invisible) 499 if (tmp->invisible)
510 tmp->invisible = 0; 500 tmp->invisible = 0;
501
511 if (head != tmp) 502 if (head != tmp)
512 tmp->head = head, prev->more = tmp; 503 tmp->head = head, prev->more = tmp;
504
513 prev = tmp; 505 prev = tmp;
514 } 506 }
507
515 head->direction = dir; 508 head->direction = dir;
516 509
517 /* need to change some monster attr to prevent problems/crashing */ 510 /* need to change some monster attr to prevent problems/crashing */
518 head->last_heal = 0; 511 head->last_heal = 0;
519 head->last_eat = 0; 512 head->last_eat = 0;
520 head->last_grace = 0; 513 head->last_grace = 0;
521 head->last_sp = 0; 514 head->last_sp = 0;
522 head->other_arch = NULL; 515 head->other_arch = NULL;
523 head->stats.exp = 0; 516 head->stats.exp = 0;
524 CLEAR_FLAG (head, FLAG_CHANGING); 517 head->clr_flag (FLAG_CHANGING);
525 CLEAR_FLAG (head, FLAG_STAND_STILL); 518 head->clr_flag (FLAG_STAND_STILL);
526 CLEAR_FLAG (head, FLAG_GENERATOR); 519 head->clr_flag (FLAG_GENERATOR);
527 CLEAR_FLAG (head, FLAG_SPLITTING); 520 head->clr_flag (FLAG_SPLITTING);
528 if (head->attacktype & AT_GHOSTHIT) 521 if (head->attacktype & AT_GHOSTHIT)
529 head->attacktype = (AT_PHYSICAL | AT_DRAIN); 522 head->attacktype = (AT_PHYSICAL | AT_DRAIN);
530 523
531 return head; 524 return head;
532} 525}
533 526
534/* updated this to allow more than the golem 'head' to attack */ 527/* updated this to allow more than the golem 'head' to attack */
535
536/* op is the golem to be moved. */ 528/* op is the golem to be moved. */
537
538void 529void
539move_golem (object *op) 530move_golem (object *op)
540{ 531{
541 int made_attack = 0; 532 int made_attack = 0;
542 object *tmp; 533 object *tmp;
543 tag_t tag;
544 534
545 if (QUERY_FLAG (op, FLAG_MONSTER)) 535 if (op->flag [FLAG_MONSTER])
546 return; /* Has already been moved */ 536 return; /* Has already been moved */
547 537
548 if (get_owner (op) == NULL) 538 if (!op->owner)
549 { 539 {
550 LOG (llevDebug, "Golem without owner destructed.\n"); 540 LOG (llevDebug, "Golem without owner destructed.\n");
551 remove_ob (op); 541 op->drop_and_destroy ();
552 free_object (op);
553 return; 542 return;
554 } 543 }
544
555 /* It would be nice to have a cleaner way of what message to print 545 /* It would be nice to have a cleaner way of what message to print
556 * when the golem expires than these hard coded entries. 546 * when the golem expires than these hard coded entries.
557 * Note it is intentional that a golems duration is based on its 547 * Note it is intentional that a golems duration is based on its
558 * hp, and not duration 548 * hp, and not duration
559 */ 549 */
560 if (--op->stats.hp < 0) 550 if (--op->stats.hp < 0)
561 { 551 {
562 if (op->msg) 552 if (op->msg)
563 new_draw_info (NDI_UNIQUE, 0, op->owner, op->msg); 553 new_draw_info (NDI_UNIQUE, 0, op->owner, op->msg);
564 op->owner->contr->ranges[range_golem] = NULL; 554
565 op->owner->contr->golem_count = 0; 555 op->drop_and_destroy ();
566 remove_friendly_object (op);
567 remove_ob (op);
568 free_object (op);
569 return; 556 return;
570 } 557 }
571 558
572 /* Do golem attacks/movement for single & multisq golems. 559 /* Do golem attacks/movement for single & multisq golems.
573 * Assuming here that op is the 'head' object. Pass only op to 560 * Assuming here that op is the 'head' object. Pass only op to
574 * move_ob (makes recursive calls to other parts) 561 * ->move (makes recursive calls to other parts)
575 * move_ob returns 0 if the creature was not able to move. 562 * move_ob returns 0 if the creature was not able to move.
576 */ 563 */
577 tag = op->count;
578 if (move_ob (op, op->direction, op)) 564 if (op->move (op->direction, op))
579 return; 565 return;
580 if (was_destroyed (op, tag)) 566
567 if (op->destroyed ())
581 return; 568 return;
582 569
583 for (tmp = op; tmp; tmp = tmp->more) 570 for (tmp = op; tmp; tmp = tmp->more)
584 { 571 {
585 sint16 x = tmp->x + freearr_x[op->direction], y = tmp->y + freearr_y[op->direction]; 572 sint16 x = tmp->x + freearr_x[op->direction], y = tmp->y + freearr_y[op->direction];
586 object *victim; 573 object *victim;
587 mapstruct *m; 574 maptile *m;
588 int mflags; 575 int mflags;
589 576
590 m = op->map; 577 m = op->map;
591 mflags = get_map_flags (m, &m, x, y, &x, &y); 578 mflags = get_map_flags (m, &m, x, y, &x, &y);
592 579
593 if (mflags & P_OUT_OF_MAP) 580 if (mflags & P_OUT_OF_MAP)
594 continue; 581 continue;
595 582
596 for (victim = get_map_ob (op->map, x, y); victim; victim = victim->above) 583 for (victim = GET_MAP_OB (m, x, y); victim; victim = victim->above)
597 if (QUERY_FLAG (victim, FLAG_ALIVE)) 584 if (victim->flag [FLAG_ALIVE])
598 break; 585 break;
599 586
600 /* We used to call will_hit_self to make sure we don't 587 /* 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 588 * hit ourselves, but that didn't work, and I don't really
602 * know if that was more efficient anyways than this. 589 * know if that was more efficient anyways than this.
… …
604 * but since we are not trying to dereferance that pointer, 591 * but since we are not trying to dereferance that pointer,
605 * that isn't a problem. 592 * that isn't a problem.
606 */ 593 */
607 if (victim && victim != op && victim->head != op) 594 if (victim && victim != op && victim->head != op)
608 { 595 {
609
610 /* for golems with race fields, we don't attack 596 /* for golems with race fields, we don't attack
611 * aligned races 597 * aligned races
612 */ 598 */
613 599
614 if (victim->race && op->race && strstr (op->race, victim->race)) 600 if (victim->race && op->race && op->race.contains (victim->race))
615 { 601 {
616 if (op->owner) 602 if (op->owner)
617 new_draw_info_format (NDI_UNIQUE, 0, op->owner, "%s avoids damaging %s.", &op->name, &victim->name); 603 new_draw_info_format (NDI_UNIQUE, 0, op->owner, "%s avoids damaging %s.", &op->name, &victim->name);
618 } 604 }
619 else if (victim == op->owner) 605 else if (victim == op->owner)
… …
626 attack_ob (victim, op); 612 attack_ob (victim, op);
627 made_attack = 1; 613 made_attack = 1;
628 } 614 }
629 } /* If victim */ 615 } /* If victim */
630 } 616 }
617
631 if (made_attack) 618 if (made_attack)
632 update_object (op, UP_OBJ_FACE); 619 update_object (op, UP_OBJ_FACE);
633} 620}
634 621
635/* this is a really stupid function when you get down and 622/* this is a really stupid function when you get down and
… …
641control_golem (object *op, int dir) 628control_golem (object *op, int dir)
642{ 629{
643 op->direction = dir; 630 op->direction = dir;
644} 631}
645 632
646/* summon golem: summons a monster for 'op'. caster is the object 633/* summon golem: summons a monster for 'op'. caster is the object
647 * casting the spell, dir is the direction to place the monster, 634 * casting the spell, dir is the direction to place the monster,
648 * at is the archetype of the monster, and spob is the spell 635 * at is the archetype of the monster, and spob is the spell
649 * object. At this stage, all spob is really used for is to 636 * object. At this stage, all spob is really used for is to
650 * adjust some values in the monster. 637 * adjust some values in the monster.
651 */ 638 */
652int 639int
653summon_golem (object *op, object *caster, int dir, object *spob) 640summon_golem (object *op, object *caster, int dir, object *spob)
654{ 641{
655 object *tmp, *god = NULL; 642 object *tmp, *god = NULL;
656 archetype *at; 643 archetype *at;
657 char buf[MAX_BUF];
658 644
659 /* Because there can be different golem spells, player may want to 645 /* Because there can be different golem spells, player may want to
660 * 'lose' their old golem. 646 * 'lose' their old golem.
661 */ 647 */
662 if (op->type == PLAYER && op->contr->ranges[range_golem] != NULL && op->contr->golem_count == op->contr->ranges[range_golem]->count) 648 if (op->type == PLAYER && op->contr->golem)
663 { 649 {
664 new_draw_info (NDI_UNIQUE, 0, op, "You dismiss your existing golem."); 650 new_draw_info (NDI_UNIQUE, 0, op, "You dismiss your existing golem.");
665 remove_ob (op->contr->ranges[range_golem]); 651 op->contr->golem->drop_and_destroy ();
666 free_object (op->contr->ranges[range_golem]); 652 op->contr->golem = 0;
667 op->contr->ranges[range_golem] = NULL;
668 op->contr->golem_count = (uint32) - 1;
669 } 653 }
670 654
671 if (spob->other_arch) 655 if (spob->other_arch)
672 at = spob->other_arch; 656 at = spob->other_arch;
673 else if (spob->race) 657 else if (spob->race)
… …
693 LOG (llevError, "Spell %s lacks other_arch\n", &spob->name); 677 LOG (llevError, "Spell %s lacks other_arch\n", &spob->name);
694 return 0; 678 return 0;
695 } 679 }
696 680
697 if (!dir) 681 if (!dir)
698 dir = find_free_spot (NULL, op->map, op->x, op->y, 1, SIZEOFFREE1 + 1); 682 dir = find_free_spot (at, op->map, op->x, op->y, 1, SIZEOFFREE1 + 1);
699 683
700 if (dir == -1 || ob_blocked (&at->clone, op->map, op->x + freearr_x[dir], op->y + freearr_y[dir])) 684 if (dir < 0 || at->blocked (op->map, op->x + freearr_x[dir], op->y + freearr_y[dir]))
701 { 685 {
702 new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way."); 686 new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way.");
703 return 0; 687 return 0;
704 } 688 }
689
705 /* basically want to get proper map/coordinates for this object */ 690 /* basically want to get proper map/coordinates for this object */
706 691
707 if (!(tmp = fix_summon_pet (at, op, dir, GOLEM))) 692 if (!(tmp = fix_summon_pet (at, op, dir, GOLEM)))
708 { 693 {
709 new_draw_info (NDI_UNIQUE, 0, op, "Your spell fails."); 694 new_draw_info (NDI_UNIQUE, 0, op, "Your spell fails.");
… …
711 } 696 }
712 697
713 if (op->type == PLAYER) 698 if (op->type == PLAYER)
714 { 699 {
715 tmp->type = GOLEM; 700 tmp->type = GOLEM;
716 set_owner (tmp, op); 701 op->contr->golem = tmp;
702 /* give the player control of the golem */
717 set_spell_skill (op, caster, spob, tmp); 703 set_spell_skill (op, caster, spob, tmp);
718 op->contr->ranges[range_golem] = tmp;
719 op->contr->golem_count = tmp->count;
720 /* give the player control of the golem */
721 op->contr->shoottype = range_golem;
722 }
723 else
724 { 704 }
725 if (QUERY_FLAG (op, FLAG_FRIENDLY))
726 {
727 object *owner = get_owner (op);
728 705
729 if (owner != NULL)
730 { /* For now, we transfer ownership */
731 set_owner (tmp, owner);
732 tmp->attack_movement = PETMOVE;
733 add_friendly_object (tmp);
734 SET_FLAG (tmp, FLAG_FRIENDLY);
735 }
736 }
737
738 SET_FLAG (tmp, FLAG_MONSTER);
739 }
740
741 /* make the speed positive. */
742 tmp->speed = FABS (tmp->speed);
743
744 /* This sets the level dependencies on dam and hp for monsters */ 706 /* This sets the level dependencies on dam and hp for monsters */
745 /* players can't cope with too strong summonings. */ 707 /* players can't cope with too strong summonings. */
746 /* but monsters can. reserve these for players. */ 708 /* but monsters can. reserve these for players. */
747 if (op->type == PLAYER) 709 if (op->type == PLAYER)
748 { 710 {
749 tmp->stats.hp += spob->duration + SP_level_duration_adjust (caster, spob); 711 tmp->stats.hp += spob->duration + SP_level_duration_adjust (caster, spob);
… …
751 if (!spob->stats.dam) 713 if (!spob->stats.dam)
752 tmp->stats.dam += SP_level_dam_adjust (caster, spob); 714 tmp->stats.dam += SP_level_dam_adjust (caster, spob);
753 else 715 else
754 tmp->stats.dam = spob->stats.dam + SP_level_dam_adjust (caster, spob); 716 tmp->stats.dam = spob->stats.dam + SP_level_dam_adjust (caster, spob);
755 717
756 tmp->speed += .02 * SP_level_range_adjust (caster, spob); 718 tmp->set_speed (min (1.f, tmp->speed + .02f * SP_level_range_adjust (caster, spob)));
757 tmp->speed = MIN (tmp->speed, 1.0);
758 719
759 if (spob->attacktype) 720 if (spob->attacktype)
760 tmp->attacktype = spob->attacktype; 721 tmp->attacktype = spob->attacktype;
761 } 722 }
762 723
… …
766 727
767 /* make experience increase in proportion to the strength. 728 /* make experience increase in proportion to the strength.
768 * this is a bit simplistic - we are basically just looking at how 729 * this is a bit simplistic - we are basically just looking at how
769 * often the sp doubles and use that as the ratio. 730 * often the sp doubles and use that as the ratio.
770 */ 731 */
771 tmp->stats.exp *= 1 + (MAX (spob->stats.maxgrace, spob->stats.sp) / caster_level (caster, spob)); 732 tmp->stats.exp *= 1 + max (spob->stats.maxgrace, spob->stats.sp) / casting_level (caster, spob);
772 tmp->speed_left = 0; 733 tmp->speed_left = 0;
773 tmp->direction = dir; 734 tmp->direction = dir;
774 735
775 /* Holy spell - some additional tailoring */ 736 /* Holy spell - some additional tailoring */
776 if (god) 737 if (god)
777 { 738 {
778 object *tmp2;
779
780 sprintf (buf, "%s of %s", &spob->name, &god->name); 739 char *buf = format ("%s of %s", &spob->name, &god->name);
781 buf[0] = toupper (buf[0]); 740 buf[0] = toupper (buf[0]);
782 741
783 for (tmp2 = tmp; tmp2; tmp2 = tmp2->more) 742 for (object *tmp2 = tmp; tmp2; tmp2 = tmp2->more)
784 tmp2->name = buf; 743 tmp2->name = buf;
785 744
786 tmp->attacktype |= god->attacktype; 745 tmp->attacktype |= god->attacktype;
787 memcpy (tmp->resist, god->resist, sizeof (tmp->resist)); 746 memcpy (tmp->resist, god->resist, sizeof (tmp->resist));
788 tmp->race = god->race; 747 tmp->race = god->race;
… …
792 if (!(tmp->attacktype & AT_PHYSICAL)) 751 if (!(tmp->attacktype & AT_PHYSICAL))
793 tmp->attacktype |= AT_PHYSICAL; 752 tmp->attacktype |= AT_PHYSICAL;
794 } 753 }
795 754
796 insert_ob_in_map (tmp, tmp->map, op, 0); 755 insert_ob_in_map (tmp, tmp->map, op, 0);
756
797 return 1; 757 return 1;
798} 758}
799 759
800 760
801/*************************************************************************** 761/***************************************************************************
… …
807/* Returns a monster (chosen at random) that this particular player (and his 767/* Returns a monster (chosen at random) that this particular player (and his
808 * god) find acceptable. This checks level, races allowed by god, etc 768 * god) find acceptable. This checks level, races allowed by god, etc
809 * to determine what is acceptable. 769 * to determine what is acceptable.
810 * This returns NULL if no match was found. 770 * This returns NULL if no match was found.
811 */ 771 */
812 772static object *
813object *
814choose_cult_monster (object *pl, object *god, int summon_level) 773choose_cult_monster (object *pl, object *god, int summon_level)
815{ 774{
816 char buf[MAX_BUF]; 775 char buf[MAX_BUF];
817 const char *race; 776 const char *race;
818 int racenr, mon_nr, i; 777 int racenr, mon_nr, i;
… …
858 /* search for an apprplritate monster on this race list */ 817 /* search for an apprplritate monster on this race list */
859 mon_nr = 0; 818 mon_nr = 0;
860 for (tobl = list->member; tobl; tobl = tobl->next) 819 for (tobl = list->member; tobl; tobl = tobl->next)
861 { 820 {
862 otmp = tobl->ob; 821 otmp = tobl->ob;
863 if (!otmp || !QUERY_FLAG (otmp, FLAG_MONSTER)) 822 if (!otmp || !otmp->flag [FLAG_MONSTER])
864 continue; 823 continue;
865 if (otmp->level <= summon_level) 824 if (otmp->level <= summon_level)
866 mon_nr++; 825 mon_nr++;
867 } 826 }
868 827
… …
872 * a valid entry, assuming nothing is available and quit. 831 * a valid entry, assuming nothing is available and quit.
873 */ 832 */
874 if (!mon_nr) 833 if (!mon_nr)
875 return NULL; 834 return NULL;
876 835
877 mon_nr = rndm (0, mon_nr - 1); 836 mon_nr = rndm (mon_nr - 1);
878 for (tobl = list->member; tobl; tobl = tobl->next) 837 for (tobl = list->member; tobl; tobl = tobl->next)
879 { 838 {
880 otmp = tobl->ob; 839 otmp = tobl->ob;
881 if (!otmp || !QUERY_FLAG (otmp, FLAG_MONSTER)) 840 if (!otmp || !otmp->flag [FLAG_MONSTER])
882 continue; 841 continue;
842
883 if (otmp->level <= summon_level && !mon_nr--) 843 if (otmp->level <= summon_level && !mon_nr--)
884 return otmp; 844 return otmp;
885 } 845 }
846
886 /* This should not happen */ 847 /* This should not happen */
887 LOG (llevDebug, "choose_cult_monster() mon_nr was set, but did not find a monster\n"); 848 LOG (llevDebug, "choose_cult_monster() mon_nr was set, but did not find a monster\n");
888 return NULL; 849 return NULL;
889} 850}
890 851
891int 852int
892summon_object (object *op, object *caster, object *spell_ob, int dir, const char *stringarg) 853summon_object (object *op, object *caster, object *spell_ob, int dir, const char *stringarg)
893{ 854{
894 sint16 x, y, nrof = 1, i; 855 int nrof = 1;
895 archetype *summon_arch; 856 archetype *summon_arch;
896 int ndir; 857 int ndir;
897 858
898 if (spell_ob->other_arch) 859 if (spell_ob->other_arch)
899 summon_arch = spell_ob->other_arch; 860 summon_arch = spell_ob->other_arch;
900 else if (spell_ob->randomitems) 861 else if (spell_ob->randomitems)
901 { 862 {
902 int level = caster_level (caster, spell_ob); 863 int level = casting_level (caster, spell_ob);
903 treasure *tr, *lasttr = NULL; 864 treasure *tr, *lasttr = NULL;
904 865
905 shstr_cmp sparam (stringarg); 866 shstr_cmp sparam (stringarg);
906 867
907 /* In old code, this was a very convoluted for statement, 868 /* In old code, this was a very convoluted for statement,
908 * with all the checks in the 'for' portion itself. Much 869 * with all the checks in the 'for' portion itself. Much
909 * more readable to break some of the conditions out. 870 * more readable to break some of the conditions out.
910 */ 871 */
911 for (tr = spell_ob->randomitems->items; tr; tr = tr->next) 872 for (tr = spell_ob->randomitems->items; tr; tr = tr->next)
912 { 873 {
874 if (!tr->item)
875 continue;
876
913 if (level < tr->magic) 877 if (level < tr->magic)
914 break; 878 break;
915 879
916 lasttr = tr; 880 lasttr = tr;
917 881
918 if (tr->item->name == sparam) 882 if (tr->item->archname == sparam)
919 break;
920
921 if (!tr->next || !tr->next->item)
922 break; 883 break;
923 } 884 }
924 885
925 if (!lasttr) 886 if (!lasttr)
926 { 887 {
… …
928 new_draw_info (NDI_UNIQUE, 0, op, "The spell fails to summon any monsters."); 889 new_draw_info (NDI_UNIQUE, 0, op, "The spell fails to summon any monsters.");
929 return 0; 890 return 0;
930 } 891 }
931 892
932 summon_arch = lasttr->item; 893 summon_arch = lasttr->item;
933 nrof = lasttr->nrof; 894 nrof = lasttr->nrof;
934 } 895 }
935 else if (spell_ob->race && !strcmp (spell_ob->race, "GODCULTMON")) 896 else if (spell_ob->race == shstr_GODCULTMON)
936 { 897 {
937 object *god = find_god (determine_god (op)), *mon, *owner; 898 object *god = find_god (determine_god (op)), *mon, *owner;
938 int summon_level, tries; 899 int summon_level, tries;
939 900
940 if (!god && ((owner = get_owner (op)) != NULL)) 901 if (!god && ((owner = op->owner) != NULL))
941 god = find_god (determine_god (owner)); 902 god = find_god (determine_god (owner));
942 903
943 /* If we can't find a god, can't get what monster to summon */ 904 /* If we can't find a god, can't get what monster to summon */
944 if (!god) 905 if (!god)
945 return 0; 906 return 0;
… …
949 new_draw_info_format (NDI_UNIQUE, 0, op, "%s has no creatures that you may summon!", &god->name); 910 new_draw_info_format (NDI_UNIQUE, 0, op, "%s has no creatures that you may summon!", &god->name);
950 return 0; 911 return 0;
951 } 912 }
952 913
953 /* the summon level */ 914 /* the summon level */
954 summon_level = caster_level (caster, spell_ob); 915 summon_level = casting_level (caster, spell_ob);
955 if (summon_level == 0) 916 if (summon_level == 0)
956 summon_level = 1; 917 summon_level = 1;
957 918
958 tries = 0; 919 tries = 0;
959 do 920 do
… …
968 ndir = dir; 929 ndir = dir;
969 930
970 if (!ndir) 931 if (!ndir)
971 ndir = find_free_spot (mon, op->map, op->x, op->y, 1, SIZEOFFREE); 932 ndir = find_free_spot (mon, op->map, op->x, op->y, 1, SIZEOFFREE);
972 933
973 if (ndir == -1 || ob_blocked (mon, op->map, op->x + freearr_x[ndir], op->y + freearr_y[ndir])) 934 if (ndir < 0 || mon->blocked (op->map, op->x + freearr_x[ndir], op->y + freearr_y[ndir]))
974 { 935 {
975 ndir = -1; 936 ndir = -1;
976 if (++tries == 5) 937 if (++tries == 5)
977 { 938 {
978 new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way."); 939 new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way.");
… …
999 { 960 {
1000 new_draw_info (NDI_UNIQUE, 0, op, "There is no monsters available for summoning."); 961 new_draw_info (NDI_UNIQUE, 0, op, "There is no monsters available for summoning.");
1001 return 0; 962 return 0;
1002 } 963 }
1003 964
1004 for (i = 1; i <= nrof; i++) 965 for (int i = 1; i <= nrof; i++)
1005 { 966 {
1006 archetype *atmp;
1007 object *prev = NULL, *head = NULL, *tmp; 967 object *prev = NULL, *head = NULL, *tmp;
1008 968
1009 if (dir) 969 if (dir)
1010 { 970 {
1011 ndir = dir; 971 ndir = dir;
1012 dir = absdir (dir + 1); 972 dir = absdir (dir + 1);
1013 } 973 }
1014 else 974 else
1015 ndir = find_free_spot (&summon_arch->clone, op->map, op->x, op->y, 1, SIZEOFFREE); 975 ndir = find_free_spot (summon_arch, op->map, op->x, op->y, 1, SIZEOFFREE);
1016 976
1017 if (ndir > 0)
1018 {
1019 x = freearr_x[ndir]; 977 sint16 x = freearr_x [ndir];
1020 y = freearr_y[ndir]; 978 sint16 y = freearr_y [ndir];
1021 }
1022 979
1023 if (ndir == -1 || ob_blocked (&summon_arch->clone, op->map, op->x + x, op->y + y)) 980 if (ndir < 0 || summon_arch->blocked (op->map, op->x + x, op->y + y))
1024 { 981 {
1025 new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way."); 982 new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way.");
1026 if (nrof > 1) 983 if (nrof > 1)
1027 new_draw_info (NDI_UNIQUE, 0, op, "No more pets for this casting."); 984 new_draw_info (NDI_UNIQUE, 0, op, "No more pets for this casting.");
1028 985
1029 return nrof > 1; 986 return nrof > 1;
1030 } 987 }
1031 988
1032 for (atmp = summon_arch; atmp != NULL; atmp = atmp->more) 989 for (archetype *atmp = summon_arch; atmp; atmp = (archetype *)atmp->more)
1033 { 990 {
1034 tmp = arch_to_object (atmp); 991 tmp = atmp->instance ();
1035 if (atmp == summon_arch) 992 if (atmp == summon_arch)
1036 { 993 {
1037 if (QUERY_FLAG (tmp, FLAG_MONSTER)) 994 if (tmp->flag [FLAG_MONSTER])
1038 { 995 {
1039 set_owner (tmp, op); 996 tmp->set_owner (op);
1040 set_spell_skill (op, caster, spell_ob, tmp); 997 set_spell_skill (op, caster, spell_ob, tmp);
1041 tmp->enemy = op->enemy; 998 tmp->enemy = op->enemy;
1042 tmp->type = 0; 999 tmp->type = 0;
1043 CLEAR_FLAG (tmp, FLAG_SLEEP); 1000 tmp->clr_flag (FLAG_SLEEP);
1044 1001
1045 if (op->type == PLAYER || QUERY_FLAG (op, FLAG_FRIENDLY)) 1002 if (op->type == PLAYER || op->flag [FLAG_FRIENDLY])
1046 { 1003 {
1047 /* If this is not set, we make it friendly */ 1004 /* If this is not set, we make it friendly */
1048 if (!QUERY_FLAG (spell_ob, FLAG_MONSTER)) 1005 if (!spell_ob->flag [FLAG_MONSTER])
1049 { 1006 {
1050 SET_FLAG (tmp, FLAG_FRIENDLY);
1051 add_friendly_object (tmp); 1007 add_friendly_object (tmp);
1052 tmp->stats.exp = 0; 1008 tmp->stats.exp = 0;
1053 1009
1054 if (spell_ob->attack_movement) 1010 if (spell_ob->attack_movement)
1055 tmp->attack_movement = spell_ob->attack_movement; 1011 tmp->attack_movement = spell_ob->attack_movement;
1056 1012
1057 if (get_owner (op)) 1013 if (op->owner)
1058 set_owner (tmp, get_owner (op)); 1014 tmp->set_owner (op->owner);
1059 } 1015 }
1060 } 1016 }
1061 } 1017 }
1062 1018
1063 if (tmp->speed > MIN_ACTIVE_SPEED) 1019 if (tmp->has_active_speed ())
1064 tmp->speed_left = -1; 1020 tmp->speed_left = -1;
1065 } 1021 }
1066 1022
1067 if (head == NULL) 1023 if (head == NULL)
1068 head = tmp; 1024 head = tmp;
… …
1071 tmp->head = head; 1027 tmp->head = head;
1072 prev->more = tmp; 1028 prev->more = tmp;
1073 } 1029 }
1074 1030
1075 prev = tmp; 1031 prev = tmp;
1076 tmp->x = op->x + x + tmp->arch->clone.x; 1032 tmp->x = op->x + x + tmp->arch->x;
1077 tmp->y = op->y + y + tmp->arch->clone.y; 1033 tmp->y = op->y + y + tmp->arch->y;
1078 tmp->map = op->map; 1034 tmp->map = op->map;
1079 } 1035 }
1080 1036
1081 head->direction = freedir[ndir]; 1037 head->direction = freedir[ndir];
1082 head->stats.exp = 0; 1038 head->stats.exp = 0;
1083 head = insert_ob_in_map (head, head->map, op, 0); 1039 head = insert_ob_in_map (head, head->map, op, 0);
1084 1040
1085 if (head && head->randomitems) 1041 if (head && head->randomitems)
1086 { 1042 {
1087 object *tmp;
1088
1089 create_treasure (head->randomitems, head, GT_APPLY | GT_STARTEQUIP, 6, 0); 1043 create_treasure (head->randomitems, head, GT_APPLY | GT_STARTEQUIP, 6, 0);
1044
1090 for (tmp = head->inv; tmp; tmp = tmp->below) 1045 for (object *tmp = head->inv; tmp; tmp = tmp->below)
1091 if (!tmp->nrof) 1046 tmp->set_flag (FLAG_DESTROY_ON_DEATH);
1092 SET_FLAG (tmp, FLAG_NO_DROP);
1093 } 1047 }
1094 } /* for i < nrof */ 1048 } /* for i < nrof */
1095 1049
1096 return 1; 1050 return 1;
1097}
1098
1099/* recursively look through the owner property of objects until the real owner
1100is found */
1101object *
1102get_real_owner (object *ob)
1103{
1104 object *realowner = ob;
1105
1106 if (realowner == NULL)
1107 return NULL;
1108
1109 while (get_owner (realowner) != NULL)
1110 {
1111 realowner = get_owner (realowner);
1112 }
1113 return realowner;
1114} 1051}
1115 1052
1116/* determines if checks so pets don't attack players or other pets should be 1053/* determines if checks so pets don't attack players or other pets should be
1117overruled by the arena petmode */ 1054overruled by the arena petmode */
1118int 1055int
… …
1124 if ((target == NULL) || (pet == NULL) || (owner == NULL)) 1061 if ((target == NULL) || (pet == NULL) || (owner == NULL))
1125 return 0; 1062 return 0;
1126 1063
1127 /* get the owners of itself and the target, this is to deal with pets of 1064 /* get the owners of itself and the target, this is to deal with pets of
1128 pets */ 1065 pets */
1129 rowner = get_real_owner (owner); 1066 rowner = owner->outer_owner ();
1130 if (target->type != PLAYER) 1067 towner = target->is_player () ? 0 : target->outer_owner ();
1131 {
1132 towner = get_real_owner (target);
1133 }
1134 else
1135 {
1136 towner = 0;
1137 }
1138 1068
1139 /* if the pet has now owner, exit with error */ 1069 /* if the pet has now owner, exit with error */
1140 if (rowner == NULL) 1070 if (!rowner)
1141 { 1071 {
1142 LOG (llevError, "Pet has no owner.\n"); 1072 LOG (llevError, "Pet has no owner.\n");
1143 return 0; 1073 return 0;
1144 } 1074 }
1145 1075
1146 /* if the target is not a player, and has no owner, we shouldn't be here 1076 /* if the target is not a player, and has no owner, we shouldn't be here
1147 */ 1077 */
1148 if ((towner == NULL) && (target->type != PLAYER)) 1078 if (!towner && !target->is_player ())
1149 { 1079 {
1150 LOG (llevError, "Target is not a player but has no owner. We should not be here.\n"); 1080 LOG (llevError, "Target is not a player but has no owner. We should not be here.\n");
1151 return 0; 1081 return 0;
1152 } 1082 }
1153 1083
1154 /* make sure that the owner is a player */ 1084 /* make sure that the owner is a player */
1155 if (rowner->type != PLAYER) 1085 if (!rowner->is_player ())
1156 return 0; 1086 return 0;
1157 1087
1158 /* abort if the petmode is not arena */ 1088 /* abort if the petmode is not arena */
1159 if (rowner->contr->petmode != pet_arena) 1089 if (rowner->contr->petmode != pet_arena)
1160 return 0; 1090 return 0;
… …
1162 /* abort if the pet, it's owner, or the target is not on battleground */ 1092 /* abort if the pet, it's owner, or the target is not on battleground */
1163 if (!(op_on_battleground (pet, NULL, NULL) && op_on_battleground (owner, NULL, NULL) && op_on_battleground (target, NULL, NULL))) 1093 if (!(op_on_battleground (pet, NULL, NULL) && op_on_battleground (owner, NULL, NULL) && op_on_battleground (target, NULL, NULL)))
1164 return 0; 1094 return 0;
1165 1095
1166 /* if the target is a monster, make sure it's owner is not the same */ 1096 /* if the target is a monster, make sure it's owner is not the same */
1167 if ((target->type != PLAYER) && (rowner == towner)) 1097 if (!target->is_player () && rowner == towner)
1168 return 0; 1098 return 0;
1169 1099
1170 /* check if the target is a player which affects how it will handle 1100 /* check if the target is a player which affects how it will handle
1171 parties */ 1101 parties */
1172 if (target->type != PLAYER) 1102 if (!target->is_player ())
1173 { 1103 {
1174 /* if the target is owned by a player make sure than make sure 1104 /* if the target is owned by a player make sure than make sure
1175 it's not in the same party */ 1105 it's not in the same party */
1176 if ((towner->type == PLAYER) && (rowner->contr->party != NULL)) 1106 if (towner->is_player () && rowner->contr->party)
1177 {
1178 if (rowner->contr->party == towner->contr->party) 1107 if (rowner->contr->party == towner->contr->party)
1179 return 0; 1108 return 0;
1180 }
1181 } 1109 }
1182 else 1110 else
1183 { 1111 {
1184 /* if the target is a player make sure than make sure it's not 1112 /* if the target is a player make sure than make sure it's not
1185 in the same party */ 1113 in the same party */
1186 if (rowner->contr->party != NULL) 1114 if (rowner->contr->party)
1187 {
1188 if (rowner->contr->party == target->contr->party) 1115 if (rowner->contr->party == target->contr->party)
1189 return 0; 1116 return 0;
1190 }
1191 } 1117 }
1192 1118
1193 return 1; 1119 return 1;
1194} 1120}
1121

Diff Legend

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