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

Comparing deliantra/server/common/object.C (file contents):
Revision 1.17 by root, Mon Sep 4 17:27:13 2006 UTC vs.
Revision 1.58 by pippijn, Mon Dec 4 17:48:35 2006 UTC

1/*
2 * static char *rcsid_object_c =
3 * "$Id: object.C,v 1.17 2006/09/04 17:27:13 root Exp $";
4 */
5
6/* 1/*
7 CrossFire, A Multiplayer game for X-windows 2 CrossFire, A Multiplayer game for X-windows
8 3
9 Copyright (C) 2001 Mark Wedel & Crossfire Development Team 4 Copyright (C) 2001 Mark Wedel & Crossfire Development Team
10 Copyright (C) 1992 Frank Tore Johansen 5 Copyright (C) 1992 Frank Tore Johansen
… …
21 16
22 You should have received a copy of the GNU General Public License 17 You should have received a copy of the GNU General Public License
23 along with this program; if not, write to the Free Software 18 along with this program; if not, write to the Free Software
24 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 20
26 The authors can be reached via e-mail at crossfire-devel@real-time.com 21 The authors can be reached via e-mail at <crossfire@schmorp.de>
27*/ 22*/
28 23
29/* Eneq(@csd.uu.se): Added weight-modifiers in environment of objects. 24/* Eneq(@csd.uu.se): Added weight-modifiers in environment of objects.
30 sub/add_weight will transcend the environment updating the carrying 25 sub/add_weight will transcend the environment updating the carrying
31 variable. */ 26 variable. */
32#include <global.h> 27#include <global.h>
33#ifndef WIN32 /* ---win32 exclude headers */
34#include <stdio.h> 28#include <stdio.h>
35#include <sys/types.h> 29#include <sys/types.h>
36#include <sys/uio.h> 30#include <sys/uio.h>
37#endif /* win32 */
38#include <object.h> 31#include <object.h>
39#include <funcpoint.h> 32#include <funcpoint.h>
40#include <skills.h>
41#include <loader.h> 33#include <loader.h>
34
42int nrofallocobjects = 0; 35int nrofallocobjects = 0;
36static UUID uuid;
37const uint64 UUID_SKIP = 1<<19;
43 38
44object *objects; /* Pointer to the list of used objects */
45object *active_objects; /* List of active objects that need to be processed */ 39object *active_objects; /* List of active objects that need to be processed */
46 40
47short freearr_x[SIZEOFFREE]= 41short freearr_x[SIZEOFFREE] = { 0, 0, 1, 1, 1, 0, -1, -1, -1, 0, 1, 2, 2, 2, 2, 2, 1, 0, -1, -2, -2, -2, -2, -2, -1,
48 {0,0,1,1,1,0,-1,-1,-1,0,1,2,2,2,2,2,1,0,-1,-2,-2,-2,-2,-2,-1,
49 0,1,2,3,3,3,3,3,3,3,2,1,0,-1,-2,-3,-3,-3,-3,-3,-3,-3,-2,-1}; 42 0, 1, 2, 3, 3, 3, 3, 3, 3, 3, 2, 1, 0, -1, -2, -3, -3, -3, -3, -3, -3, -3, -2, -1
50short freearr_y[SIZEOFFREE]= 43};
51 {0,-1,-1,0,1,1,1,0,-1,-2,-2,-2,-1,0,1,2,2,2,2,2,1,0,-1,-2,-2, 44short freearr_y[SIZEOFFREE] = { 0, -1, -1, 0, 1, 1, 1, 0, -1, -2, -2, -2, -1, 0, 1, 2, 2, 2, 2, 2, 1, 0, -1, -2, -2,
52 -3,-3,-3,-3,-2,-1,0,1,2,3,3,3,3,3,3,3,2,1,0,-1,-2,-3,-3,-3}; 45 -3, -3, -3, -3, -2, -1, 0, 1, 2, 3, 3, 3, 3, 3, 3, 3, 2, 1, 0, -1, -2, -3, -3, -3
53int maxfree[SIZEOFFREE]= 46};
54 {0,9,10,13,14,17,18,21,22,25,26,27,30,31,32,33,36,37,39,39,42,43,44,45, 47int maxfree[SIZEOFFREE] = { 0, 9, 10, 13, 14, 17, 18, 21, 22, 25, 26, 27, 30, 31, 32, 33, 36, 37, 39, 39, 42, 43, 44, 45,
55 48,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49}; 48 48, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49
49};
56int freedir[SIZEOFFREE]= { 50int freedir[SIZEOFFREE] = {
57 0,1,2,3,4,5,6,7,8,1,2,2,2,3,4,4,4,5,6,6,6,7,8,8,8, 51 0, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 2, 2, 3, 4, 4, 4, 5, 6, 6, 6, 7, 8, 8, 8,
58 1,2,2,2,2,2,3,4,4,4,4,4,5,6,6,6,6,6,7,8,8,8,8,8}; 52 1, 2, 2, 2, 2, 2, 3, 4, 4, 4, 4, 4, 5, 6, 6, 6, 6, 6, 7, 8, 8, 8, 8, 8
53};
59 54
55static void
56write_uuid (void)
57{
58 char filename1[MAX_BUF], filename2[MAX_BUF];
59
60 sprintf (filename1, "%s/uuid", settings.localdir);
61 sprintf (filename2, "%s/uuid~", settings.localdir);
62
63 FILE *fp;
64
65 if (!(fp = fopen (filename2, "w")))
66 {
67 LOG (llevError, "ERROR: cannot open %s for writing, unable to write UUID!\n", filename2);
68 return;
69 }
70
71 fprintf (fp, "<1,%llx>\n", (unsigned long long)uuid.seq + UUID_SKIP * 2);
72 fclose (fp);
73 rename (filename2, filename1);
74}
75
76static void
77read_uuid (void)
78{
79 char filename[MAX_BUF];
80
81 sprintf (filename, "%s/uuid", settings.localdir);
82
83 FILE *fp;
84
85 if (!(fp = fopen (filename, "r")))
86 {
87 if (errno == ENOENT)
88 {
89 LOG (llevInfo, "RESET uid to 1\n");
90 uuid.seq = 0;
91 write_uuid ();
92 return;
93 }
94
95 LOG (llevError, "FATAL: cannot open %s for reading!\n", filename);
96 _exit (1);
97 }
98
99 int version;
100 unsigned long long uid;
101 if (2 != fscanf (fp, "<%d,%llx>\n", &version, &uid) || version != 1)
102 {
103 LOG (llevError, "FATAL: error reading uid from %s!\n", filename);
104 _exit (1);
105 }
106
107 uuid.seq = uid;
108 write_uuid ();
109 LOG (llevDebug, "read UID: %lld\n", uid);
110 fclose (fp);
111}
112
113UUID
114gen_uuid ()
115{
116 UUID uid;
117
118 uid.seq = ++uuid.seq;
119
120 if (!(uuid.seq & (UUID_SKIP - 1)))
121 write_uuid ();
122
123 return uid;
124}
125
126void
127init_uuid ()
128{
129 read_uuid ();
130}
60 131
61/* Returns TRUE if every key_values in wants has a partner with the same value in has. */ 132/* Returns TRUE if every key_values in wants has a partner with the same value in has. */
133static int
62static int compare_ob_value_lists_one(const object * wants, const object * has) { 134compare_ob_value_lists_one (const object *wants, const object *has)
135{
63 key_value * wants_field; 136 key_value *wants_field;
64 137
65 /* n-squared behaviour (see get_ob_key_link()), but I'm hoping both 138 /* n-squared behaviour (see get_ob_key_link()), but I'm hoping both
66 * objects with lists are rare, and lists stay short. If not, use a 139 * objects with lists are rare, and lists stay short. If not, use a
67 * different structure or at least keep the lists sorted... 140 * different structure or at least keep the lists sorted...
68 */ 141 */
69 142
70 /* For each field in wants, */ 143 /* For each field in wants, */
71 for (wants_field = wants->key_values; wants_field != NULL; wants_field = wants_field->next) { 144 for (wants_field = wants->key_values; wants_field != NULL; wants_field = wants_field->next)
145 {
72 key_value * has_field; 146 key_value *has_field;
73 147
74 /* Look for a field in has with the same key. */ 148 /* Look for a field in has with the same key. */
75 has_field = get_ob_key_link(has, wants_field->key); 149 has_field = get_ob_key_link (has, wants_field->key);
150
151 if (has_field == NULL)
76 152 {
77 if (has_field == NULL) {
78 /* No field with that name. */ 153 /* No field with that name. */
79 return FALSE; 154 return FALSE;
80 }
81 155 }
156
82 /* Found the matching field. */ 157 /* Found the matching field. */
83 if (has_field->value != wants_field->value) { 158 if (has_field->value != wants_field->value)
159 {
84 /* Values don't match, so this half of the comparison is false. */ 160 /* Values don't match, so this half of the comparison is false. */
85 return FALSE; 161 return FALSE;
86 } 162 }
87 163
88 /* If we get here, we found a match. Now for the next field in wants. */ 164 /* If we get here, we found a match. Now for the next field in wants. */
89 }
90 165 }
166
91 /* If we get here, every field in wants has a matching field in has. */ 167 /* If we get here, every field in wants has a matching field in has. */
92 return TRUE; 168 return TRUE;
93} 169}
94 170
95/* Returns TRUE if ob1 has the same key_values as ob2. */ 171/* Returns TRUE if ob1 has the same key_values as ob2. */
172static int
96static int compare_ob_value_lists(const object * ob1, const object * ob2) { 173compare_ob_value_lists (const object *ob1, const object *ob2)
174{
97 /* However, there may be fields in has which aren't partnered in wants, 175 /* However, there may be fields in has which aren't partnered in wants,
98 * so we need to run the comparison *twice*. :( 176 * so we need to run the comparison *twice*. :(
99 */ 177 */
100 return compare_ob_value_lists_one(ob1, ob2) && compare_ob_value_lists_one(ob2, ob1); 178 return compare_ob_value_lists_one (ob1, ob2) && compare_ob_value_lists_one (ob2, ob1);
101} 179}
102 180
103/* Function examines the 2 objects given to it, and returns true if 181/* Function examines the 2 objects given to it, and returns true if
104 * they can be merged together. 182 * they can be merged together.
105 * 183 *
… …
111 * 189 *
112 * Improvements made with merge: Better checking on potion, and also 190 * Improvements made with merge: Better checking on potion, and also
113 * check weight 191 * check weight
114 */ 192 */
115 193
116bool
117object::can_merge (object *ob1, object *ob2) 194bool object::can_merge (object *ob1, object *ob2)
118{ 195{
119 /* A couple quicksanity checks */ 196 /* A couple quicksanity checks */
120 if ((ob1 == ob2) || (ob1->type != ob2->type)) 197 if ((ob1 == ob2) || (ob1->type != ob2->type))
121 return 0; 198 return 0;
122 199
… …
170 (ob1->subtype != ob2->subtype) || 247 (ob1->subtype != ob2->subtype) ||
171 (ob1->move_type != ob2->move_type) || 248 (ob1->move_type != ob2->move_type) ||
172 (ob1->move_block != ob2->move_block) || 249 (ob1->move_block != ob2->move_block) ||
173 (ob1->move_allow != ob2->move_allow) || 250 (ob1->move_allow != ob2->move_allow) ||
174 (ob1->move_on != ob2->move_on) || 251 (ob1->move_on != ob2->move_on) ||
175 (ob1->move_off != ob2->move_off) || 252 (ob1->move_off != ob2->move_off) || (ob1->move_slow != ob2->move_slow) || (ob1->move_slow_penalty != ob2->move_slow_penalty))
176 (ob1->move_slow != ob2->move_slow) ||
177 (ob1->move_slow_penalty != ob2->move_slow_penalty))
178 return 0; 253 return 0;
179 254
180 /* This is really a spellbook check - really, we should 255 /* This is really a spellbook check - really, we should
181 * check all objects in the inventory. 256 * check all objects in the inventory.
182 */ 257 */
183 if (ob1->inv || ob2->inv) 258 if (ob1->inv || ob2->inv)
184 { 259 {
185 /* if one object has inventory but the other doesn't, not equiv */ 260 /* if one object has inventory but the other doesn't, not equiv */
186 if ((ob1->inv && !ob2->inv) || (ob2->inv && !ob1->inv)) 261 if ((ob1->inv && !ob2->inv) || (ob2->inv && !ob1->inv))
187 return 0; 262 return 0;
188 263
189 /* Now check to see if the two inventory objects could merge */ 264 /* Now check to see if the two inventory objects could merge */
190 if (!CAN_MERGE (ob1->inv, ob2->inv)) 265 if (!CAN_MERGE (ob1->inv, ob2->inv))
191 return 0; 266 return 0;
192 267
193 /* inventory ok - still need to check rest of this object to see 268 /* inventory ok - still need to check rest of this object to see
194 * if it is valid. 269 * if it is valid.
195 */ 270 */
196 } 271 }
… …
204 279
205 /* Note sure why the following is the case - either the object has to 280 /* Note sure why the following is the case - either the object has to
206 * be animated or have a very low speed. Is this an attempted monster 281 * be animated or have a very low speed. Is this an attempted monster
207 * check? 282 * check?
208 */ 283 */
209 if (!QUERY_FLAG (ob1, FLAG_ANIMATE) 284 if (!QUERY_FLAG (ob1, FLAG_ANIMATE) && FABS ((ob1)->speed) > MIN_ACTIVE_SPEED)
210 && FABS ((ob1)->speed) > MIN_ACTIVE_SPEED)
211 return 0; 285 return 0;
212 286
213 switch (ob1->type) 287 switch (ob1->type)
214 { 288 {
215 case SCROLL: 289 case SCROLL:
216 if (ob1->level != ob2->level) 290 if (ob1->level != ob2->level)
217 return 0; 291 return 0;
218 break; 292 break;
219 } 293 }
220 294
221 if (ob1->key_values != NULL || ob2->key_values != NULL) 295 if (ob1->key_values != NULL || ob2->key_values != NULL)
222 { 296 {
223 /* At least one of these has key_values. */ 297 /* At least one of these has key_values. */
224 if ((ob1->key_values == NULL) != (ob2->key_values == NULL)) 298 if ((ob1->key_values == NULL) != (ob2->key_values == NULL))
225 /* One has fields, but the other one doesn't. */ 299 /* One has fields, but the other one doesn't. */
226 return 0; 300 return 0;
227 else if (!compare_ob_value_lists (ob1, ob2)) 301 else if (!compare_ob_value_lists (ob1, ob2))
228 return 0; 302 return 0;
229 } 303 }
230 304
231 //TODO: generate an event or call into perl for additional checks 305 //TODO: generate an event or call into perl for additional checks
232 if (ob1->self || ob2->self) 306 if (ob1->self || ob2->self)
233 { 307 {
234 ob1->optimise (); 308 ob1->optimise ();
235 ob2->optimise (); 309 ob2->optimise ();
236 310
237 if (ob1->self || ob2->self) 311 if (ob1->self || ob2->self)
238 return 0; 312 return 0;
239 } 313 }
240 314
241 /* Everything passes, must be OK. */ 315 /* Everything passes, must be OK. */
242 return 1; 316 return 1;
243} 317}
318
244/* 319/*
245 * sum_weight() is a recursive function which calculates the weight 320 * sum_weight() is a recursive function which calculates the weight
246 * an object is carrying. It goes through in figures out how much 321 * an object is carrying. It goes through in figures out how much
247 * containers are carrying, and sums it up. 322 * containers are carrying, and sums it up.
248 */ 323 */
249signed long sum_weight(object *op) { 324long
325sum_weight (object *op)
326{
250 signed long sum; 327 long sum;
251 object *inv; 328 object *inv;
329
252 for(sum = 0, inv = op->inv; inv != NULL; inv = inv->below) { 330 for (sum = 0, inv = op->inv; inv != NULL; inv = inv->below)
331 {
253 if (inv->inv) 332 if (inv->inv)
254 sum_weight(inv); 333 sum_weight (inv);
255 sum += inv->carrying + inv->weight * (inv->nrof ? inv->nrof : 1); 334 sum += inv->carrying + inv->weight * (inv->nrof ? inv->nrof : 1);
256 } 335 }
336
257 if (op->type == CONTAINER && op->stats.Str) 337 if (op->type == CONTAINER && op->stats.Str)
258 sum = (sum * (100 - op->stats.Str))/100; 338 sum = (sum * (100 - op->stats.Str)) / 100;
339
259 if(op->carrying != sum) 340 if (op->carrying != sum)
260 op->carrying = sum; 341 op->carrying = sum;
342
261 return sum; 343 return sum;
262} 344}
263 345
264/** 346/**
265 * Return the outermost environment object for a given object. 347 * Return the outermost environment object for a given object.
266 */ 348 */
267 349
350object *
268object *object_get_env_recursive (object *op) { 351object_get_env_recursive (object *op)
352{
269 while (op->env != NULL) 353 while (op->env != NULL)
270 op = op->env; 354 op = op->env;
271 return op; 355 return op;
272} 356}
273 357
274/* 358/*
275 * Eneq(@csd.uu.se): Since we can have items buried in a character we need 359 * Eneq(@csd.uu.se): Since we can have items buried in a character we need
276 * a better check. We basically keeping traversing up until we can't 360 * a better check. We basically keeping traversing up until we can't
277 * or find a player. 361 * or find a player.
278 */ 362 */
279 363
364object *
280object *is_player_inv (object *op) { 365is_player_inv (object *op)
366{
281 for (;op!=NULL&&op->type!=PLAYER; op=op->env) 367 for (; op != NULL && op->type != PLAYER; op = op->env)
282 if (op->env==op) 368 if (op->env == op)
283 op->env = NULL; 369 op->env = NULL;
284 return op; 370 return op;
285} 371}
286 372
287/* 373/*
288 * Used by: Crossedit: dump. Server DM commands: dumpbelow, dump. 374 * Used by: Crossedit: dump. Server DM commands: dumpbelow, dump.
289 * Some error messages. 375 * Some error messages.
290 * The result of the dump is stored in the static global errmsg array. 376 * The result of the dump is stored in the static global errmsg array.
291 */ 377 */
292 378
293void dump_object2(object *op) { 379char *
294errmsg[0] = 0;
295return;
296 //TODO//D#d#
297#if 0
298 char *cp;
299/* object *tmp;*/
300
301 if(op->arch!=NULL) {
302 strcat(errmsg,"arch ");
303 strcat(errmsg,op->arch->name?op->arch->name:"(null)");
304 strcat(errmsg,"\n");
305 if((cp=get_ob_diff(op,&empty_archetype->clone))!=NULL)
306 strcat(errmsg,cp);
307#if 0
308 /* Don't dump player diffs - they are too long, mostly meaningless, and
309 * will overflow the buffer.
310 * Changed so that we don't dump inventory either. This may
311 * also overflow the buffer.
312 */
313 if(op->type!=PLAYER && (cp=get_ob_diff(op,&empty_archetype->clone))!=NULL)
314 strcat(errmsg,cp);
315 for (tmp=op->inv; tmp; tmp=tmp->below)
316 dump_object2(tmp);
317#endif
318 strcat(errmsg,"end\n");
319 } else {
320 strcat(errmsg,"Object ");
321 if (op->name==NULL) strcat(errmsg, "(null)");
322 else strcat(errmsg,op->name);
323 strcat(errmsg,"\n");
324#if 0
325 if((cp=get_ob_diff(op,&empty_archetype->clone))!=NULL)
326 strcat(errmsg,cp);
327 for (tmp=op->inv; tmp; tmp=tmp->below)
328 dump_object2(tmp);
329#endif
330 strcat(errmsg,"end\n");
331 }
332#endif
333}
334
335/*
336 * Dumps an object. Returns output in the static global errmsg array.
337 */
338
339void dump_object(object *op) { 380dump_object (object *op)
340 if(op==NULL) { 381{
341 strcpy(errmsg,"[NULL pointer]"); 382 if (!op)
342 return; 383 return strdup ("[NULLOBJ]");
343 }
344 errmsg[0]='\0';
345 dump_object2(op);
346}
347 384
348void dump_all_objects(void) { 385 object_freezer freezer;
349 object *op; 386 save_object (freezer, op, 3);
350 for(op=objects;op!=NULL;op=op->next) { 387 return freezer.as_string ();
351 dump_object(op);
352 fprintf(logfile, "Object %d\n:%s\n", op->count, errmsg);
353 }
354} 388}
355 389
356/* 390/*
357 * get_nearest_part(multi-object, object 2) returns the part of the 391 * get_nearest_part(multi-object, object 2) returns the part of the
358 * multi-object 1 which is closest to the second object. 392 * multi-object 1 which is closest to the second object.
359 * If it's not a multi-object, it is returned. 393 * If it's not a multi-object, it is returned.
360 */ 394 */
361 395
396object *
362object *get_nearest_part(object *op, const object *pl) { 397get_nearest_part (object *op, const object *pl)
398{
363 object *tmp,*closest; 399 object *tmp, *closest;
364 int last_dist,i; 400 int last_dist, i;
401
365 if(op->more==NULL) 402 if (op->more == NULL)
366 return op; 403 return op;
367 for(last_dist=distance(op,pl),closest=op,tmp=op->more;tmp!=NULL;tmp=tmp->more) 404 for (last_dist = distance (op, pl), closest = op, tmp = op->more; tmp != NULL; tmp = tmp->more)
368 if((i=distance(tmp,pl))<last_dist) 405 if ((i = distance (tmp, pl)) < last_dist)
369 closest=tmp,last_dist=i; 406 closest = tmp, last_dist = i;
370 return closest; 407 return closest;
371} 408}
372 409
373/* 410/*
374 * Returns the object which has the count-variable equal to the argument. 411 * Returns the object which has the count-variable equal to the argument.
375 */ 412 */
376 413
414object *
377object *find_object(tag_t i) { 415find_object (tag_t i)
378 object *op; 416{
379 for(op=objects;op!=NULL;op=op->next) 417 for (object *op = object::first; op; op = op->next)
380 if(op->count==i) 418 if (op->count == i)
381 break; 419 return op;
420
382 return op; 421 return 0;
383} 422}
384 423
385/* 424/*
386 * Returns the first object which has a name equal to the argument. 425 * Returns the first object which has a name equal to the argument.
387 * Used only by the patch command, but not all that useful. 426 * Used only by the patch command, but not all that useful.
388 * Enables features like "patch <name-of-other-player> food 999" 427 * Enables features like "patch <name-of-other-player> food 999"
389 */ 428 */
390 429
430object *
391object *find_object_name(const char *str) { 431find_object_name (const char *str)
392 const char *name = shstr::find (str); 432{
433 shstr_cmp str_ (str);
393 object *op; 434 object *op;
435
394 for(op=objects;op!=NULL;op=op->next) 436 for (op = object::first; op != NULL; op = op->next)
395 if(&op->name == name) 437 if (op->name == str_)
396 break; 438 break;
397 439
398 return op; 440 return op;
399} 441}
400 442
443void
401void free_all_object_data () 444free_all_object_data ()
402{ 445{
403 LOG (llevDebug, "%d allocated objects\n", nrofallocobjects); 446 LOG (llevDebug, "%d allocated objects\n", nrofallocobjects);
404}
405
406/*
407 * Returns the object which this object marks as being the owner.
408 * A id-scheme is used to avoid pointing to objects which have been
409 * freed and are now reused. If this is detected, the owner is
410 * set to NULL, and NULL is returned.
411 * Changed 2004-02-12 - if the player is setting at the play again
412 * prompt, he is removed, and we don't want to treat him as an owner of
413 * anything, so check removed flag. I don't expect that this should break
414 * anything - once an object is removed, it is basically dead anyways.
415 */
416
417object *get_owner(object *op) {
418 if(op->owner==NULL)
419 return NULL;
420
421 if (!QUERY_FLAG(op->owner,FLAG_FREED) && !QUERY_FLAG(op->owner, FLAG_REMOVED) &&
422 op->owner->count==op->ownercount)
423 return op->owner;
424
425 op->owner=NULL;
426 op->ownercount=0;
427 return NULL;
428}
429
430void clear_owner(object *op)
431{
432 if (!op) return;
433
434 if (op->owner && op->ownercount == op->owner->count)
435 op->owner->refcount--;
436
437 op->owner = NULL;
438 op->ownercount = 0;
439} 447}
440 448
441/* 449/*
442 * Sets the owner and sets the skill and exp pointers to owner's current 450 * Sets the owner and sets the skill and exp pointers to owner's current
443 * skill and experience objects. 451 * skill and experience objects.
444 */ 452 */
445void set_owner (object *op, object *owner) 453void
454object::set_owner (object *owner)
446{ 455{
447 if(owner==NULL||op==NULL) 456 if (!owner)
448 return; 457 return;
449 458
450 /* next line added to allow objects which own objects */ 459 /* next line added to allow objects which own objects */
451 /* Add a check for ownercounts in here, as I got into an endless loop 460 /* Add a check for ownercounts in here, as I got into an endless loop
452 * with the fireball owning a poison cloud which then owned the 461 * with the fireball owning a poison cloud which then owned the
453 * fireball. I believe that was caused by one of the objects getting 462 * fireball. I believe that was caused by one of the objects getting
454 * freed and then another object replacing it. Since the ownercounts 463 * freed and then another object replacing it. Since the ownercounts
455 * didn't match, this check is valid and I believe that cause is valid. 464 * didn't match, this check is valid and I believe that cause is valid.
456 */ 465 */
457 while (owner->owner && owner!=owner->owner && 466 while (owner->owner)
458 owner->ownercount==owner->owner->count) owner=owner->owner; 467 owner = owner->owner;
459 468
460 /* IF the owner still has an owner, we did not resolve to a final owner.
461 * so lets not add to that.
462 */
463 if (owner->owner) return;
464
465 op->owner=owner; 469 this->owner = owner;
466
467 op->ownercount=owner->count;
468 owner->refcount++;
469
470}
471
472/* Set the owner to clone's current owner and set the skill and experience
473 * objects to clone's objects (typically those objects that where the owner's
474 * current skill and experience objects at the time when clone's owner was
475 * set - not the owner's current skill and experience objects).
476 *
477 * Use this function if player created an object (e.g. fire bullet, swarm
478 * spell), and this object creates further objects whose kills should be
479 * accounted for the player's original skill, even if player has changed
480 * skills meanwhile.
481 */
482void copy_owner (object *op, object *clone)
483{
484 object *owner = get_owner (clone);
485 if (owner == NULL) {
486 /* players don't have owners - they own themselves. Update
487 * as appropriate.
488 */
489 if (clone->type == PLAYER) owner=clone;
490 else return;
491 }
492 set_owner(op, owner);
493
494} 470}
495 471
496/* Zero the key_values on op, decrementing the shared-string 472/* Zero the key_values on op, decrementing the shared-string
497 * refcounts and freeing the links. 473 * refcounts and freeing the links.
498 */ 474 */
475static void
499static void free_key_values(object * op) 476free_key_values (object *op)
500{ 477{
501 for (key_value *i = op->key_values; i != 0; ) 478 for (key_value *i = op->key_values; i != 0;)
502 { 479 {
503 key_value *next = i->next; 480 key_value *next = i->next;
504 delete i; 481 delete i;
482
505 i = next; 483 i = next;
506 } 484 }
507 485
508 op->key_values = 0; 486 op->key_values = 0;
509} 487}
510 488
511void object::clear () 489void object::clear ()
512{ 490{
513 attachable_base::clear (); 491 attachable_base::clear ();
514 492
515 free_key_values (this); 493 free_key_values (this);
516 494
517 name = 0; 495 owner = 0;
496 name = 0;
518 name_pl = 0; 497 name_pl = 0;
519 title = 0; 498 title = 0;
520 race = 0; 499 race = 0;
521 slaying = 0; 500 slaying = 0;
522 skill = 0; 501 skill = 0;
523 msg = 0; 502 msg = 0;
524 lore = 0; 503 lore = 0;
525 custom_name = 0; 504 custom_name = 0;
526 materialname = 0; 505 materialname = 0;
506 contr = 0;
507 below = 0;
508 above = 0;
509 inv = 0;
510 container = 0;
511 env = 0;
512 more = 0;
513 head = 0;
514 map = 0;
515 active_next = 0;
516 active_prev = 0;
527 517
528 memset (static_cast<object_pod *>(this), 0, sizeof (object_pod)); 518 memset (static_cast<object_pod *>(this), 0, sizeof (object_pod));
529 519
530 SET_FLAG (this, FLAG_REMOVED); 520 SET_FLAG (this, FLAG_REMOVED);
521
522 /* What is not cleared is next, prev, and count */
523
524 expmul = 1.0;
525 face = blank_face;
526
527 if (settings.casting_time)
528 casting_time = -1;
531} 529}
532 530
533void object::clone (object *destination) 531void object::clone (object *destination)
534{ 532{
535 *(object_copy *)destination = *(object_copy *)this; 533 *(object_copy *)destination = *this;
536 *(object_pod *)destination = *(object_pod *)this; 534 *(object_pod *)destination = *this;
537 535
538 if (self || cb) 536 if (self || cb)
539 INVOKE_OBJECT (CLONE, this, ARG_OBJECT (destination)); 537 INVOKE_OBJECT (CLONE, this, ARG_OBJECT (destination));
540}
541
542/*
543 * clear_object() frees everything allocated by an object, and also
544 * clears all variables and flags to default settings.
545 */
546
547void clear_object (object *op)
548{
549 op->clear ();
550
551 op->contr = NULL;
552 op->below = NULL;
553 op->above = NULL;
554 op->inv = NULL;
555 op->container=NULL;
556 op->env=NULL;
557 op->more=NULL;
558 op->head=NULL;
559 op->map=NULL;
560 op->refcount=0;
561 op->active_next = NULL;
562 op->active_prev = NULL;
563 /* What is not cleared is next, prev, and count */
564
565 op->expmul = 1.0;
566 op->face = blank_face;
567 op->attacked_by_count = -1;
568
569 if (settings.casting_time)
570 op->casting_time = -1;
571} 538}
572 539
573/* 540/*
574 * copy object first frees everything allocated by the second object, 541 * copy object first frees everything allocated by the second object,
575 * and then copies the contends of the first object into the second 542 * and then copies the contends of the first object into the second
576 * object, allocating what needs to be allocated. Basically, any 543 * object, allocating what needs to be allocated. Basically, any
577 * data that is malloc'd needs to be re-malloc/copied. Otherwise, 544 * data that is malloc'd needs to be re-malloc/copied. Otherwise,
578 * if the first object is freed, the pointers in the new object 545 * if the first object is freed, the pointers in the new object
579 * will point at garbage. 546 * will point at garbage.
580 */ 547 */
581 548void
582void copy_object (object *op2, object *op) 549copy_object (object *op2, object *op)
583{ 550{
584 bool is_freed = QUERY_FLAG (op, FLAG_FREED); 551 bool is_freed = QUERY_FLAG (op, FLAG_FREED);
585 bool is_removed = QUERY_FLAG (op, FLAG_REMOVED); 552 bool is_removed = QUERY_FLAG (op, FLAG_REMOVED);
586 553
587 op2->clone (op); 554 op2->clone (op);
588 555
556 if (is_freed)
589 if (is_freed) SET_FLAG (op, FLAG_FREED); 557 SET_FLAG (op, FLAG_FREED);
558 if (is_removed)
590 if (is_removed) SET_FLAG (op, FLAG_REMOVED); 559 SET_FLAG (op, FLAG_REMOVED);
591 560
592 if (op2->speed < 0) 561 if (op2->speed < 0)
593 op->speed_left = op2->speed_left - RANDOM() % 200 / 100.0; 562 op->speed_left = op2->speed_left - RANDOM () % 200 / 100.0;
594 563
595 /* Copy over key_values, if any. */ 564 /* Copy over key_values, if any. */
596 if (op2->key_values != NULL) 565 if (op2->key_values)
597 { 566 {
598 key_value *tail = NULL; 567 key_value *tail = 0;
599 key_value *i; 568 key_value *i;
600 569
601 op->key_values = NULL; 570 op->key_values = 0;
602 571
603 for (i = op2->key_values; i != NULL; i = i->next) 572 for (i = op2->key_values; i; i = i->next)
604 { 573 {
605 key_value *new_link = new key_value; 574 key_value *new_link = new key_value;
606 575
607 new_link->next = NULL; 576 new_link->next = 0;
608 new_link->key = i->key; 577 new_link->key = i->key;
609 new_link->value = i->value; 578 new_link->value = i->value;
610 579
611 /* Try and be clever here, too. */ 580 /* Try and be clever here, too. */
612 if (op->key_values == NULL) 581 if (!op->key_values)
613 { 582 {
614 op->key_values = new_link; 583 op->key_values = new_link;
615 tail = new_link; 584 tail = new_link;
616 } 585 }
617 else 586 else
… …
624 593
625 update_ob_speed (op); 594 update_ob_speed (op);
626} 595}
627 596
628/* 597/*
629 * get_object() grabs an object from the list of unused objects, makes
630 * sure it is initialised, and returns it.
631 * If there are no free objects, expand_objects() is called to get more.
632 */
633
634object *get_object ()
635{
636 object *op = new object;
637
638 op->count = ++ob_count;
639
640 op->active_next = 0;
641 op->active_prev = 0;
642
643 op->next = objects;
644 op->prev = 0;
645
646 if (objects)
647 objects->prev = op;
648
649 objects = op;
650
651 SET_FLAG (op, FLAG_REMOVED);
652
653 op->expmul = 1.0;
654 op->face = blank_face;
655 op->attacked_by_count = -1;
656
657 return op;
658}
659
660/*
661 * If an object with the IS_TURNABLE() flag needs to be turned due 598 * If an object with the IS_TURNABLE() flag needs to be turned due
662 * to the closest player being on the other side, this function can 599 * to the closest player being on the other side, this function can
663 * be called to update the face variable, _and_ how it looks on the map. 600 * be called to update the face variable, _and_ how it looks on the map.
664 */ 601 */
665 602
603void
666void update_turn_face(object *op) { 604update_turn_face (object *op)
605{
667 if(!QUERY_FLAG(op,FLAG_IS_TURNABLE)||op->arch==NULL) 606 if (!QUERY_FLAG (op, FLAG_IS_TURNABLE) || op->arch == NULL)
668 return; 607 return;
669 SET_ANIMATION(op, op->direction); 608 SET_ANIMATION (op, op->direction);
670 update_object(op,UP_OBJ_FACE); 609 update_object (op, UP_OBJ_FACE);
671} 610}
672 611
673/* 612/*
674 * Updates the speed of an object. If the speed changes from 0 to another 613 * Updates the speed of an object. If the speed changes from 0 to another
675 * value, or vice versa, then add/remove the object from the active list. 614 * value, or vice versa, then add/remove the object from the active list.
676 * This function needs to be called whenever the speed of an object changes. 615 * This function needs to be called whenever the speed of an object changes.
677 */ 616 */
678 617void
679void update_ob_speed(object *op) { 618update_ob_speed (object *op)
619{
680 extern int arch_init; 620 extern int arch_init;
681 621
682 /* No reason putting the archetypes objects on the speed list, 622 /* No reason putting the archetypes objects on the speed list,
683 * since they never really need to be updated. 623 * since they never really need to be updated.
684 */ 624 */
685 625
686 if (QUERY_FLAG(op, FLAG_FREED) && op->speed) { 626 if (QUERY_FLAG (op, FLAG_FREED) && op->speed)
627 {
687 LOG(llevError,"Object %s is freed but has speed.\n", &op->name); 628 LOG (llevError, "Object %s is freed but has speed.\n", &op->name);
688#ifdef MANY_CORES 629#ifdef MANY_CORES
689 abort(); 630 abort ();
690#else 631#else
691 op->speed = 0; 632 op->speed = 0;
692#endif 633#endif
693 } 634 }
635
694 if (arch_init) { 636 if (arch_init)
637 return;
638
639 if (FABS (op->speed) > MIN_ACTIVE_SPEED)
640 {
641 /* If already on active list, don't do anything */
642 if (op->active_next || op->active_prev || op == active_objects)
695 return; 643 return;
696 }
697 if (FABS(op->speed)>MIN_ACTIVE_SPEED) {
698 /* If already on active list, don't do anything */
699 if (op->active_next || op->active_prev || op==active_objects)
700 return;
701 644
702 /* process_events() expects us to insert the object at the beginning 645 /* process_events() expects us to insert the object at the beginning
703 * of the list. */ 646 * of the list. */
704 op->active_next = active_objects; 647 op->active_next = active_objects;
648
705 if (op->active_next!=NULL) 649 if (op->active_next != NULL)
706 op->active_next->active_prev = op; 650 op->active_next->active_prev = op;
651
707 active_objects = op; 652 active_objects = op;
653 }
654 else
708 } 655 {
709 else {
710 /* If not on the active list, nothing needs to be done */ 656 /* If not on the active list, nothing needs to be done */
711 if (!op->active_next && !op->active_prev && op!=active_objects) 657 if (!op->active_next && !op->active_prev && op != active_objects)
712 return; 658 return;
713 659
714 if (op->active_prev==NULL) { 660 if (op->active_prev == NULL)
661 {
715 active_objects = op->active_next; 662 active_objects = op->active_next;
663
716 if (op->active_next!=NULL) 664 if (op->active_next != NULL)
717 op->active_next->active_prev = NULL; 665 op->active_next->active_prev = NULL;
666 }
667 else
718 } 668 {
719 else {
720 op->active_prev->active_next = op->active_next; 669 op->active_prev->active_next = op->active_next;
670
721 if (op->active_next) 671 if (op->active_next)
722 op->active_next->active_prev = op->active_prev; 672 op->active_next->active_prev = op->active_prev;
723 } 673 }
674
724 op->active_next = NULL; 675 op->active_next = NULL;
725 op->active_prev = NULL; 676 op->active_prev = NULL;
726 } 677 }
727} 678}
728 679
729/* This function removes object 'op' from the list of active 680/* This function removes object 'op' from the list of active
730 * objects. 681 * objects.
… …
732 * reference maps where you don't want an object that isn't 683 * reference maps where you don't want an object that isn't
733 * in play chewing up cpu time getting processed. 684 * in play chewing up cpu time getting processed.
734 * The reverse of this is to call update_ob_speed, which 685 * The reverse of this is to call update_ob_speed, which
735 * will do the right thing based on the speed of the object. 686 * will do the right thing based on the speed of the object.
736 */ 687 */
688void
737void remove_from_active_list(object *op) 689remove_from_active_list (object *op)
738{ 690{
739 /* If not on the active list, nothing needs to be done */ 691 /* If not on the active list, nothing needs to be done */
740 if (!op->active_next && !op->active_prev && op!=active_objects) 692 if (!op->active_next && !op->active_prev && op != active_objects)
741 return; 693 return;
742 694
743 if (op->active_prev==NULL) { 695 if (op->active_prev == NULL)
696 {
744 active_objects = op->active_next; 697 active_objects = op->active_next;
745 if (op->active_next!=NULL) 698 if (op->active_next != NULL)
746 op->active_next->active_prev = NULL; 699 op->active_next->active_prev = NULL;
700 }
701 else
747 } 702 {
748 else {
749 op->active_prev->active_next = op->active_next; 703 op->active_prev->active_next = op->active_next;
750 if (op->active_next) 704 if (op->active_next)
751 op->active_next->active_prev = op->active_prev; 705 op->active_next->active_prev = op->active_prev;
752 } 706 }
753 op->active_next = NULL; 707 op->active_next = NULL;
754 op->active_prev = NULL; 708 op->active_prev = NULL;
755} 709}
756 710
757/* 711/*
758 * update_object() updates the array which represents the map. 712 * update_object() updates the array which represents the map.
759 * It takes into account invisible objects (and represent squares covered 713 * It takes into account invisible objects (and represent squares covered
… …
774 * UP_OBJ_CHANGE: object has somehow changed. In this case, we always update 728 * UP_OBJ_CHANGE: object has somehow changed. In this case, we always update
775 * as that is easier than trying to look at what may have changed. 729 * as that is easier than trying to look at what may have changed.
776 * UP_OBJ_FACE: only the objects face has changed. 730 * UP_OBJ_FACE: only the objects face has changed.
777 */ 731 */
778 732
733void
779void update_object(object *op, int action) { 734update_object (object *op, int action)
735{
780 int update_now=0, flags; 736 int update_now = 0, flags;
781 MoveType move_on, move_off, move_block, move_slow; 737 MoveType move_on, move_off, move_block, move_slow;
782 738
783 if (op == NULL) { 739 if (op == NULL)
740 {
784 /* this should never happen */ 741 /* this should never happen */
785 LOG(llevDebug,"update_object() called for NULL object.\n"); 742 LOG (llevDebug, "update_object() called for NULL object.\n");
786 return; 743 return;
787 }
788 744 }
745
789 if(op->env!=NULL) { 746 if (op->env != NULL)
747 {
790 /* Animation is currently handled by client, so nothing 748 /* Animation is currently handled by client, so nothing
791 * to do in this case. 749 * to do in this case.
792 */ 750 */
793 return; 751 return;
794 } 752 }
795 753
796 /* If the map is saving, don't do anything as everything is 754 /* If the map is saving, don't do anything as everything is
797 * going to get freed anyways. 755 * going to get freed anyways.
798 */ 756 */
799 if (!op->map || op->map->in_memory == MAP_SAVING) return; 757 if (!op->map || op->map->in_memory == MAP_SAVING)
800 758 return;
759
801 /* make sure the object is within map boundaries */ 760 /* make sure the object is within map boundaries */
802 if (op->x < 0 || op->x >= MAP_WIDTH(op->map) || 761 if (op->x < 0 || op->x >= MAP_WIDTH (op->map) || op->y < 0 || op->y >= MAP_HEIGHT (op->map))
803 op->y < 0 || op->y >= MAP_HEIGHT(op->map)) { 762 {
804 LOG(llevError,"update_object() called for object out of map!\n"); 763 LOG (llevError, "update_object() called for object out of map!\n");
805#ifdef MANY_CORES 764#ifdef MANY_CORES
806 abort(); 765 abort ();
807#endif 766#endif
808 return; 767 return;
809 }
810 768 }
769
811 flags = GET_MAP_FLAGS(op->map, op->x, op->y); 770 flags = GET_MAP_FLAGS (op->map, op->x, op->y);
812 SET_MAP_FLAGS(op->map, op->x, op->y, flags | P_NEED_UPDATE); 771 SET_MAP_FLAGS (op->map, op->x, op->y, flags | P_NEED_UPDATE);
813 move_slow = GET_MAP_MOVE_SLOW(op->map, op->x, op->y); 772 move_slow = GET_MAP_MOVE_SLOW (op->map, op->x, op->y);
814 move_on = GET_MAP_MOVE_ON(op->map, op->x, op->y); 773 move_on = GET_MAP_MOVE_ON (op->map, op->x, op->y);
815 move_block = GET_MAP_MOVE_BLOCK(op->map, op->x, op->y); 774 move_block = GET_MAP_MOVE_BLOCK (op->map, op->x, op->y);
816 move_off = GET_MAP_MOVE_OFF(op->map, op->x, op->y); 775 move_off = GET_MAP_MOVE_OFF (op->map, op->x, op->y);
817 776
818 if (action == UP_OBJ_INSERT) { 777 if (action == UP_OBJ_INSERT)
778 {
819 if (QUERY_FLAG(op, FLAG_BLOCKSVIEW) && !(flags & P_BLOCKSVIEW)) 779 if (QUERY_FLAG (op, FLAG_BLOCKSVIEW) && !(flags & P_BLOCKSVIEW))
820 update_now=1; 780 update_now = 1;
821 781
822 if (QUERY_FLAG(op, FLAG_NO_MAGIC) && !(flags & P_NO_MAGIC)) 782 if (QUERY_FLAG (op, FLAG_NO_MAGIC) && !(flags & P_NO_MAGIC))
823 update_now=1; 783 update_now = 1;
824 784
825 if (QUERY_FLAG(op, FLAG_DAMNED) && !(flags & P_NO_CLERIC)) 785 if (QUERY_FLAG (op, FLAG_DAMNED) && !(flags & P_NO_CLERIC))
826 update_now=1; 786 update_now = 1;
827 787
828 if (QUERY_FLAG(op, FLAG_ALIVE) && !(flags & P_IS_ALIVE)) 788 if (QUERY_FLAG (op, FLAG_ALIVE) && !(flags & P_IS_ALIVE))
829 update_now=1; 789 update_now = 1;
830 790
791 if (op->type == SAFE_GROUND && !(flags & P_SAFE))
792 update_now = 1;
793
831 if ((move_on | op->move_on) != move_on) update_now=1; 794 if ((move_on | op->move_on) != move_on)
795 update_now = 1;
796
832 if ((move_off | op->move_off) != move_off) update_now=1; 797 if ((move_off | op->move_off) != move_off)
798 update_now = 1;
799
833 /* This isn't perfect, but I don't expect a lot of objects to 800 /* This isn't perfect, but I don't expect a lot of objects to
834 * to have move_allow right now. 801 * to have move_allow right now.
835 */ 802 */
836 if (((move_block | op->move_block) & ~op->move_allow) != move_block) 803 if (((move_block | op->move_block) & ~op->move_allow) != move_block)
837 update_now=1; 804 update_now = 1;
805
838 if ((move_slow | op->move_slow) != move_slow) update_now=1; 806 if ((move_slow | op->move_slow) != move_slow)
807 update_now = 1;
839 } 808 }
840 /* if the object is being removed, we can't make intelligent 809 /* if the object is being removed, we can't make intelligent
841 * decisions, because remove_ob can't really pass the object 810 * decisions, because remove_ob can't really pass the object
842 * that is being removed. 811 * that is being removed.
843 */ 812 */
844 else if (action == UP_OBJ_CHANGE || action == UP_OBJ_REMOVE) { 813 else if (action == UP_OBJ_CHANGE || action == UP_OBJ_REMOVE)
845 update_now=1; 814 update_now = 1;
846 } else if (action == UP_OBJ_FACE) { 815 else if (action == UP_OBJ_FACE)
847 /* Nothing to do for that case */ 816 /* Nothing to do for that case */ ;
848 }
849 else { 817 else
850 LOG(llevError,"update_object called with invalid action: %d\n", action); 818 LOG (llevError, "update_object called with invalid action: %d\n", action);
851 }
852 819
853 if (update_now) { 820 if (update_now)
821 {
854 SET_MAP_FLAGS(op->map, op->x, op->y, flags | P_NO_ERROR | P_NEED_UPDATE); 822 SET_MAP_FLAGS (op->map, op->x, op->y, flags | P_NO_ERROR | P_NEED_UPDATE);
855 update_position(op->map, op->x, op->y); 823 update_position (op->map, op->x, op->y);
856 } 824 }
857 825
858 if(op->more!=NULL) 826 if (op->more != NULL)
859 update_object(op->more, action); 827 update_object (op->more, action);
860} 828}
861 829
830object::vector object::mortals;
831object::vector object::objects; // not yet used
832object *object::first;
833
834void object::free_mortals ()
835{
836 for (AUTODECL (i, mortals.begin ()); i != mortals.end ();)
837 if ((*i)->refcnt)
838 ++i; // further delay freeing
839 else
840 {
841 delete *i;
842 mortals.erase (i);
843 }
844}
845
846object::object ()
847{
848 SET_FLAG (this, FLAG_REMOVED);
849
850 expmul = 1.0;
851 face = blank_face;
852}
853
854object::~object ()
855{
856 free_key_values (this);
857}
858
859void object::link ()
860{
861 count = ++ob_count;
862 uuid = gen_uuid ();
863
864 prev = 0;
865 next = object::first;
866
867 if (object::first)
868 object::first->prev = this;
869
870 object::first = this;
871}
872
873void object::unlink ()
874{
875 if (this == object::first)
876 object::first = next;
877
878 /* Remove this object from the list of used objects */
879 if (prev) prev->next = next;
880 if (next) next->prev = prev;
881
882 prev = 0;
883 next = 0;
884}
885
886object *object::create ()
887{
888 object *op = new object;
889 op->link ();
890 return op;
891}
862 892
863/* 893/*
864 * free_object() frees everything allocated by an object, removes 894 * free_object() frees everything allocated by an object, removes
865 * it from the list of used objects, and puts it on the list of 895 * it from the list of used objects, and puts it on the list of
866 * free objects. The IS_FREED() flag is set in the object. 896 * free objects. The IS_FREED() flag is set in the object.
867 * The object must have been removed by remove_ob() first for 897 * The object must have been removed by remove_ob() first for
868 * this function to succeed. 898 * this function to succeed.
869 * 899 *
870 * If free_inventory is set, free inventory as well. Else drop items in 900 * If destroy_inventory is set, free inventory as well. Else drop items in
871 * inventory to the ground. 901 * inventory to the ground.
872 */ 902 */
873 903void object::destroy (bool destroy_inventory)
874void
875free_object (object * ob)
876{ 904{
877 free_object2 (ob, 0);
878}
879
880void
881free_object2 (object * ob, int free_inventory)
882{
883 object *tmp, *op;
884
885 if (!QUERY_FLAG (ob, FLAG_REMOVED)) 905 if (QUERY_FLAG (this, FLAG_FREED))
886 { 906 return;
887 LOG (llevDebug, "Free object called with non removed object\n");
888 dump_object (ob);
889#ifdef MANY_CORES
890 abort ();
891#endif
892 }
893 907
894 if (QUERY_FLAG (ob, FLAG_FRIENDLY)) 908 if (QUERY_FLAG (this, FLAG_FRIENDLY))
895 {
896 LOG (llevMonster, "Warning: tried to free friendly object.\n");
897 remove_friendly_object (ob); 909 remove_friendly_object (this);
898 }
899 910
900 if (QUERY_FLAG (ob, FLAG_FREED)) 911 if (!QUERY_FLAG (this, FLAG_REMOVED))
901 { 912 remove_ob (this);
902 dump_object (ob); 913
903 LOG (llevError, "Trying to free freed object.\n%s\n", errmsg); 914 SET_FLAG (this, FLAG_FREED);
904 return; 915
916 if (more)
905 } 917 {
906 918 more->destroy (destroy_inventory);
907 if (ob->more != NULL) 919 more = 0;
908 { 920 }
909 free_object2 (ob->more, free_inventory);
910 ob->more = NULL;
911 }
912 921
913 if (ob->inv) 922 if (inv)
914 { 923 {
915 /* Only if the space blocks everything do we not process - 924 /* Only if the space blocks everything do we not process -
916 * if some form of movement is allowed, let objects 925 * if some form of movement is allowed, let objects
917 * drop on that space. 926 * drop on that space.
918 */ 927 */
919 if (free_inventory || ob->map == NULL 928 if (destroy_inventory || !map || map->in_memory != MAP_IN_MEMORY || GET_MAP_MOVE_BLOCK (map, x, y) == MOVE_ALL)
920 || ob->map->in_memory != MAP_IN_MEMORY 929 {
921 || (GET_MAP_MOVE_BLOCK (ob->map, ob->x, ob->y) == MOVE_ALL)) 930 object *op = inv;
922 {
923 op = ob->inv;
924 931
925 while (op != NULL) 932 while (op)
926 { 933 {
927 tmp = op->below; 934 object *tmp = op->below;
928 remove_ob (op); 935 op->destroy (destroy_inventory);
929 free_object2 (op, free_inventory);
930 op = tmp; 936 op = tmp;
931 } 937 }
932 } 938 }
933 else 939 else
934 { /* Put objects in inventory onto this space */ 940 { /* Put objects in inventory onto this space */
935 op = ob->inv; 941 object *op = inv;
936 942
937 while (op != NULL) 943 while (op)
938 { 944 {
939 tmp = op->below; 945 object *tmp = op->below;
946
940 remove_ob (op); 947 remove_ob (op);
941 948
942 if (QUERY_FLAG (op, FLAG_STARTEQUIP) 949 if (QUERY_FLAG (op, FLAG_STARTEQUIP)
943 || QUERY_FLAG (op, FLAG_NO_DROP) || op->type == RUNE 950 || QUERY_FLAG (op, FLAG_NO_DROP) || op->type == RUNE || op->type == TRAP || QUERY_FLAG (op, FLAG_IS_A_TEMPLATE))
944 || op->type == TRAP || QUERY_FLAG (op, FLAG_IS_A_TEMPLATE)) 951 free_object (op);
945 free_object (op); 952 else
946 else 953 {
947 { 954 op->x = x;
948 op->x = ob->x; 955 op->y = y;
949 op->y = ob->y;
950 insert_ob_in_map (op, ob->map, NULL, 0); /* Insert in same map as the envir */ 956 insert_ob_in_map (op, map, 0, 0); /* Insert in same map as the envir */
951 } 957 }
952 958
953 op = tmp; 959 op = tmp;
960 }
961 }
954 } 962 }
955 } 963
964 // hack to ensure that freed objects still have a valid map
965 {
966 static maptile *freed_map; // freed objects are moved here to avoid crashes
967
968 if (!freed_map)
969 {
970 freed_map = new maptile;
971
972 freed_map->name = "/internal/freed_objects_map";
973 freed_map->width = 3;
974 freed_map->height = 3;
975
976 freed_map->allocate ();
956 } 977 }
978
979 map = freed_map;
980 x = 1;
981 y = 1;
982 }
983
984 // clear those pointers that likely might have circular references to us
985 owner = 0;
986 enemy = 0;
987 attacked_by = 0;
988
989 // only relevant for players(?), but make sure of it anyways
990 contr = 0;
957 991
958 /* Remove object from the active list */ 992 /* Remove object from the active list */
959 ob->speed = 0; 993 speed = 0;
960 update_ob_speed (ob); 994 update_ob_speed (this);
961 995
962 SET_FLAG (ob, FLAG_FREED); 996 unlink ();
963 ob->count = 0;
964 997
965 /* Remove this object from the list of used objects */ 998 mortals.push_back (this);
966 if (ob->prev == NULL)
967 {
968 objects = ob->next;
969
970 if (objects != NULL)
971 objects->prev = NULL;
972 }
973 else
974 {
975 ob->prev->next = ob->next;
976
977 if (ob->next != NULL)
978 ob->next->prev = ob->prev;
979 }
980
981 free_key_values (ob);
982
983 /* Now link it with the free_objects list: */
984 ob->prev = 0;
985 ob->next = 0;
986
987 delete ob;
988} 999}
989 1000
990/* 1001/*
991 * sub_weight() recursively (outwards) subtracts a number from the 1002 * sub_weight() recursively (outwards) subtracts a number from the
992 * weight of an object (and what is carried by it's environment(s)). 1003 * weight of an object (and what is carried by it's environment(s)).
993 */ 1004 */
994 1005
1006void
995void sub_weight (object *op, signed long weight) { 1007sub_weight (object *op, signed long weight)
1008{
996 while (op != NULL) { 1009 while (op != NULL)
1010 {
997 if (op->type == CONTAINER) { 1011 if (op->type == CONTAINER)
998 weight=(signed long)(weight*(100-op->stats.Str)/100); 1012 weight = (signed long) (weight * (100 - op->stats.Str) / 100);
999 } 1013
1000 op->carrying-=weight; 1014 op->carrying -= weight;
1001 op = op->env; 1015 op = op->env;
1002 } 1016 }
1003} 1017}
1004 1018
1005/* remove_ob(op): 1019/* remove_ob(op):
1006 * This function removes the object op from the linked list of objects 1020 * This function removes the object op from the linked list of objects
1007 * which it is currently tied to. When this function is done, the 1021 * which it is currently tied to. When this function is done, the
… …
1009 * environment, the x and y coordinates will be updated to 1023 * environment, the x and y coordinates will be updated to
1010 * the previous environment. 1024 * the previous environment.
1011 * Beware: This function is called from the editor as well! 1025 * Beware: This function is called from the editor as well!
1012 */ 1026 */
1013 1027
1028void
1014void remove_ob(object *op) { 1029remove_ob (object *op)
1030{
1015 object *tmp,*last=NULL; 1031 object *tmp, *last = 0;
1016 object *otmp; 1032 object *otmp;
1017 tag_t tag; 1033
1018 int check_walk_off; 1034 int check_walk_off;
1019 mapstruct *m; 1035 maptile *m;
1036
1020 sint16 x,y; 1037 sint16 x, y;
1021
1022 1038
1023 if(QUERY_FLAG(op,FLAG_REMOVED)) { 1039 if (QUERY_FLAG (op, FLAG_REMOVED))
1024 dump_object(op); 1040 return;
1025 LOG(llevError,"Trying to remove removed object.\n%s\n",errmsg);
1026 1041
1027 /* Changed it to always dump core in this case. As has been learned
1028 * in the past, trying to recover from errors almost always
1029 * make things worse, and this is a real error here - something
1030 * that should not happen.
1031 * Yes, if this was a mission critical app, trying to do something
1032 * to recover may make sense, but that is because failure of the app
1033 * may have other disastrous problems. Cf runs out of a script
1034 * so is easily enough restarted without any real problems.
1035 * MSW 2001-07-01
1036 */
1037 abort();
1038 }
1039 if(op->more!=NULL)
1040 remove_ob(op->more);
1041
1042 SET_FLAG(op, FLAG_REMOVED); 1042 SET_FLAG (op, FLAG_REMOVED);
1043 1043
1044 if (op->more != NULL)
1045 remove_ob (op->more);
1046
1044 /* 1047 /*
1045 * In this case, the object to be removed is in someones 1048 * In this case, the object to be removed is in someones
1046 * inventory. 1049 * inventory.
1047 */ 1050 */
1048 if(op->env!=NULL) { 1051 if (op->env != NULL)
1052 {
1049 if(op->nrof) 1053 if (op->nrof)
1050 sub_weight(op->env, op->weight*op->nrof); 1054 sub_weight (op->env, op->weight * op->nrof);
1051 else 1055 else
1052 sub_weight(op->env, op->weight+op->carrying); 1056 sub_weight (op->env, op->weight + op->carrying);
1053 1057
1054 /* NO_FIX_PLAYER is set when a great many changes are being 1058 /* NO_FIX_PLAYER is set when a great many changes are being
1055 * made to players inventory. If set, avoiding the call 1059 * made to players inventory. If set, avoiding the call
1056 * to save cpu time. 1060 * to save cpu time.
1057 */ 1061 */
1058 if ((otmp=is_player_inv(op->env))!=NULL && otmp->contr && 1062 if ((otmp = is_player_inv (op->env)) != NULL && otmp->contr && !QUERY_FLAG (otmp, FLAG_NO_FIX_PLAYER))
1059 !QUERY_FLAG(otmp,FLAG_NO_FIX_PLAYER))
1060 fix_player(otmp); 1063 fix_player (otmp);
1061 1064
1062 if(op->above!=NULL) 1065 if (op->above != NULL)
1063 op->above->below=op->below; 1066 op->above->below = op->below;
1064 else 1067 else
1065 op->env->inv=op->below; 1068 op->env->inv = op->below;
1066 1069
1067 if(op->below!=NULL) 1070 if (op->below != NULL)
1068 op->below->above=op->above; 1071 op->below->above = op->above;
1069 1072
1070 /* we set up values so that it could be inserted into 1073 /* we set up values so that it could be inserted into
1071 * the map, but we don't actually do that - it is up 1074 * the map, but we don't actually do that - it is up
1072 * to the caller to decide what we want to do. 1075 * to the caller to decide what we want to do.
1073 */ 1076 */
1074 op->x=op->env->x,op->y=op->env->y; 1077 op->x = op->env->x, op->y = op->env->y;
1075 op->map=op->env->map; 1078 op->map = op->env->map;
1076 op->above=NULL,op->below=NULL; 1079 op->above = NULL, op->below = NULL;
1077 op->env=NULL; 1080 op->env = NULL;
1081 }
1082 else if (op->map)
1083 {
1084 x = op->x;
1085 y = op->y;
1086 m = get_map_from_coord (op->map, &x, &y);
1087
1088 if (!m)
1089 {
1090 LOG (llevError, "remove_ob called when object was on map but appears to not be within valid coordinates? %s (%d,%d)\n",
1091 op->map->path, op->x, op->y);
1092 /* in old days, we used to set x and y to 0 and continue.
1093 * it seems if we get into this case, something is probablye
1094 * screwed up and should be fixed.
1095 */
1096 abort ();
1097 }
1098
1099 if (op->map != m)
1100 LOG (llevDebug, "remove_ob: Object not really on map it claimed to be on? %s != %s, %d,%d != %d,%d\n",
1101 op->map->path, m->path, op->x, op->y, x, y);
1102
1103 /* Re did the following section of code - it looks like it had
1104 * lots of logic for things we no longer care about
1105 */
1106
1107 /* link the object above us */
1108 if (op->above)
1109 op->above->below = op->below;
1110 else
1111 SET_MAP_TOP (m, x, y, op->below); /* we were top, set new top */
1112
1113 /* Relink the object below us, if there is one */
1114 if (op->below)
1115 op->below->above = op->above;
1116 else
1117 {
1118 /* Nothing below, which means we need to relink map object for this space
1119 * use translated coordinates in case some oddness with map tiling is
1120 * evident
1121 */
1122 if (GET_MAP_OB (m, x, y) != op)
1123 {
1124 char *dump = dump_object (op);
1125 LOG (llevError,
1126 "remove_ob: GET_MAP_OB does not return object to be removed even though it appears to be on the bottom?\n%s\n", dump);
1127 free (dump);
1128 dump = dump_object (GET_MAP_OB (m, x, y));
1129 LOG (llevError, "%s\n", dump);
1130 free (dump);
1131 }
1132
1133 SET_MAP_OB (m, x, y, op->above); /* goes on above it. */
1134 }
1135
1136 op->above = 0;
1137 op->below = 0;
1138
1139 if (op->map->in_memory == MAP_SAVING)
1078 return; 1140 return;
1079 }
1080 1141
1081 /* If we get here, we are removing it from a map */
1082 if (op->map == NULL) return;
1083
1084 x = op->x;
1085 y = op->y;
1086 m = get_map_from_coord(op->map, &x, &y);
1087
1088 if (!m) {
1089 LOG(llevError,"remove_ob called when object was on map but appears to not be within valid coordinates? %s (%d,%d)\n",
1090 op->map->path, op->x, op->y);
1091 /* in old days, we used to set x and y to 0 and continue.
1092 * it seems if we get into this case, something is probablye
1093 * screwed up and should be fixed.
1094 */
1095 abort();
1096 }
1097 if (op->map != m) {
1098 LOG(llevDebug,"remove_ob: Object not really on map it claimed to be on? %s != %s, %d,%d != %d,%d\n",
1099 op->map->path, m->path, op->x, op->y, x, y);
1100 }
1101
1102 /* Re did the following section of code - it looks like it had
1103 * lots of logic for things we no longer care about
1104 */
1105
1106 /* link the object above us */
1107 if (op->above)
1108 op->above->below=op->below;
1109 else
1110 SET_MAP_TOP(m,x,y,op->below); /* we were top, set new top */
1111
1112 /* Relink the object below us, if there is one */
1113 if(op->below) {
1114 op->below->above=op->above;
1115 } else {
1116 /* Nothing below, which means we need to relink map object for this space
1117 * use translated coordinates in case some oddness with map tiling is
1118 * evident
1119 */
1120 if(GET_MAP_OB(m,x,y)!=op) {
1121 dump_object(op);
1122 LOG(llevError,"remove_ob: GET_MAP_OB does not return object to be removed even though it appears to be on the bottom?\n%s\n", errmsg);
1123 dump_object(GET_MAP_OB(m,x,y));
1124 LOG(llevError,"%s\n",errmsg);
1125 }
1126 SET_MAP_OB(m,x,y,op->above); /* goes on above it. */
1127 }
1128 op->above=NULL;
1129 op->below=NULL;
1130
1131 if (op->map->in_memory == MAP_SAVING)
1132 return;
1133
1134 tag = op->count;
1135 check_walk_off = ! QUERY_FLAG (op, FLAG_NO_APPLY); 1142 check_walk_off = !QUERY_FLAG (op, FLAG_NO_APPLY);
1143
1136 for(tmp=GET_MAP_OB(m,x,y);tmp!=NULL;tmp=tmp->above) { 1144 for (tmp = GET_MAP_OB (m, x, y); tmp != NULL; tmp = tmp->above)
1145 {
1137 /* No point updating the players look faces if he is the object 1146 /* No point updating the players look faces if he is the object
1138 * being removed. 1147 * being removed.
1139 */ 1148 */
1140 1149
1141 if(tmp->type==PLAYER && tmp!=op) { 1150 if (tmp->type == PLAYER && tmp != op)
1151 {
1142 /* If a container that the player is currently using somehow gets 1152 /* If a container that the player is currently using somehow gets
1143 * removed (most likely destroyed), update the player view 1153 * removed (most likely destroyed), update the player view
1144 * appropriately. 1154 * appropriately.
1145 */ 1155 */
1146 if (tmp->container==op) { 1156 if (tmp->container == op)
1157 {
1147 CLEAR_FLAG(op, FLAG_APPLIED); 1158 CLEAR_FLAG (op, FLAG_APPLIED);
1148 tmp->container=NULL; 1159 tmp->container = NULL;
1160 }
1161
1162 tmp->contr->socket.update_look = 1;
1149 } 1163 }
1150 tmp->contr->socket.update_look=1; 1164
1151 }
1152 /* See if player moving off should effect something */ 1165 /* See if player moving off should effect something */
1166 if (check_walk_off
1153 if (check_walk_off && ((op->move_type & tmp->move_off) && 1167 && ((op->move_type & tmp->move_off)
1154 (op->move_type & ~tmp->move_off & ~tmp->move_block)==0)) { 1168 && (op->move_type & ~tmp->move_off & ~tmp->move_block) == 0))
1155 1169 {
1156 move_apply(tmp, op, NULL); 1170 move_apply (tmp, op, NULL);
1171
1157 if (was_destroyed (op, tag)) { 1172 if (op->destroyed ())
1158 LOG (llevError, "BUG: remove_ob(): name %s, archname %s destroyed " 1173 LOG (llevError, "BUG: remove_ob(): name %s, destroyed leaving object\n", tmp->debug_desc ());
1159 "leaving object\n", &tmp->name, &tmp->arch->name);
1160 } 1174 }
1161 }
1162 1175
1163 /* Eneq(@csd.uu.se): Fixed this to skip tmp->above=tmp */ 1176 /* Eneq(@csd.uu.se): Fixed this to skip tmp->above=tmp */
1164 1177
1165 if(tmp->above == tmp) 1178 if (tmp->above == tmp)
1166 tmp->above = NULL; 1179 tmp->above = NULL;
1180
1167 last=tmp; 1181 last = tmp;
1168 } 1182 }
1183
1169 /* last == NULL of there are no objects on this space */ 1184 /* last == NULL of there are no objects on this space */
1170 if (last==NULL) { 1185 if (last == NULL)
1186 {
1171 /* set P_NEED_UPDATE, otherwise update_position will complain. In theory, 1187 /* set P_NEED_UPDATE, otherwise update_position will complain. In theory,
1172 * we could preserve the flags (GET_MAP_FLAGS), but update_position figures 1188 * we could preserve the flags (GET_MAP_FLAGS), but update_position figures
1173 * those out anyways, and if there are any flags set right now, they won't 1189 * those out anyways, and if there are any flags set right now, they won't
1174 * be correct anyways. 1190 * be correct anyways.
1175 */ 1191 */
1176 SET_MAP_FLAGS(op->map, op->x, op->y, P_NEED_UPDATE); 1192 SET_MAP_FLAGS (op->map, op->x, op->y, P_NEED_UPDATE);
1177 update_position(op->map, op->x, op->y); 1193 update_position (op->map, op->x, op->y);
1178 } 1194 }
1179 else 1195 else
1180 update_object(last, UP_OBJ_REMOVE); 1196 update_object (last, UP_OBJ_REMOVE);
1181 1197
1182 if(QUERY_FLAG(op,FLAG_BLOCKSVIEW)|| (op->glow_radius != 0)) 1198 if (QUERY_FLAG (op, FLAG_BLOCKSVIEW) || (op->glow_radius != 0))
1183 update_all_los(op->map, op->x, op->y); 1199 update_all_los (op->map, op->x, op->y);
1184 1200 }
1185} 1201}
1186 1202
1187/* 1203/*
1188 * merge_ob(op,top): 1204 * merge_ob(op,top):
1189 * 1205 *
1190 * This function goes through all objects below and including top, and 1206 * This function goes through all objects below and including top, and
1191 * merges op to the first matching object. 1207 * merges op to the first matching object.
1192 * If top is NULL, it is calculated. 1208 * If top is NULL, it is calculated.
1193 * Returns pointer to object if it succeded in the merge, otherwise NULL 1209 * Returns pointer to object if it succeded in the merge, otherwise NULL
1194 */ 1210 */
1195 1211object *
1196object *merge_ob(object *op, object *top) { 1212merge_ob (object *op, object *top)
1213{
1197 if(!op->nrof) 1214 if (!op->nrof)
1198 return 0; 1215 return 0;
1216
1199 if(top==NULL) 1217 if (top == NULL)
1200 for(top=op;top!=NULL&&top->above!=NULL;top=top->above); 1218 for (top = op; top != NULL && top->above != NULL; top = top->above);
1219
1201 for(;top!=NULL;top=top->below) { 1220 for (; top != NULL; top = top->below)
1221 {
1202 if(top==op) 1222 if (top == op)
1203 continue; 1223 continue;
1204 if (CAN_MERGE(op,top)) 1224 if (CAN_MERGE (op, top))
1205 { 1225 {
1206 top->nrof+=op->nrof; 1226 top->nrof += op->nrof;
1227
1207/* CLEAR_FLAG(top,FLAG_STARTEQUIP);*/ 1228/* CLEAR_FLAG(top,FLAG_STARTEQUIP);*/
1208 op->weight = 0; /* Don't want any adjustements now */ 1229 op->weight = 0; /* Don't want any adjustements now */
1209 remove_ob(op); 1230 remove_ob (op);
1210 free_object(op); 1231 free_object (op);
1211 return top; 1232 return top;
1212 } 1233 }
1213 } 1234 }
1235
1214 return NULL; 1236 return 0;
1215} 1237}
1216 1238
1217/* 1239/*
1218 * same as insert_ob_in_map except it handle separate coordinates and do a clean 1240 * same as insert_ob_in_map except it handle separate coordinates and do a clean
1219 * job preparing multi-part monsters 1241 * job preparing multi-part monsters
1220 */ 1242 */
1243object *
1221object *insert_ob_in_map_at(object *op, mapstruct *m, object *originator, int flag, int x, int y){ 1244insert_ob_in_map_at (object *op, maptile *m, object *originator, int flag, int x, int y)
1245{
1222 object* tmp; 1246 object *tmp;
1247
1223 if (op->head) 1248 if (op->head)
1224 op=op->head; 1249 op = op->head;
1250
1225 for (tmp=op;tmp;tmp=tmp->more){ 1251 for (tmp = op; tmp; tmp = tmp->more)
1252 {
1226 tmp->x=x+tmp->arch->clone.x; 1253 tmp->x = x + tmp->arch->clone.x;
1227 tmp->y=y+tmp->arch->clone.y; 1254 tmp->y = y + tmp->arch->clone.y;
1228 } 1255 }
1256
1229 return insert_ob_in_map (op, m, originator, flag); 1257 return insert_ob_in_map (op, m, originator, flag);
1230} 1258}
1231 1259
1232/* 1260/*
1233 * insert_ob_in_map (op, map, originator, flag): 1261 * insert_ob_in_map (op, map, originator, flag):
1234 * This function inserts the object in the two-way linked list 1262 * This function inserts the object in the two-way linked list
… …
1248 * new object if 'op' was merged with other object 1276 * new object if 'op' was merged with other object
1249 * NULL if 'op' was destroyed 1277 * NULL if 'op' was destroyed
1250 * just 'op' otherwise 1278 * just 'op' otherwise
1251 */ 1279 */
1252 1280
1281object *
1253object *insert_ob_in_map (object *op, mapstruct *m, object *originator, int flag) 1282insert_ob_in_map (object *op, maptile *m, object *originator, int flag)
1254{ 1283{
1255 object *tmp, *top, *floor=NULL; 1284 object *tmp, *top, *floor = NULL;
1256 sint16 x,y; 1285 sint16 x, y;
1257 1286
1258 if (QUERY_FLAG (op, FLAG_FREED)) { 1287 if (QUERY_FLAG (op, FLAG_FREED))
1288 {
1259 LOG (llevError, "Trying to insert freed object!\n"); 1289 LOG (llevError, "Trying to insert freed object!\n");
1290 return NULL;
1291 }
1292
1293 if (m == NULL)
1294 {
1295 char *dump = dump_object (op);
1296 LOG (llevError, "Trying to insert in null-map!\n%s\n", dump);
1297 free (dump);
1298 return op;
1299 }
1300
1301 if (out_of_map (m, op->x, op->y))
1302 {
1303 char *dump = dump_object (op);
1304 LOG (llevError, "Trying to insert object outside the map.\n%s\n", dump);
1305#ifdef MANY_CORES
1306 /* Better to catch this here, as otherwise the next use of this object
1307 * is likely to cause a crash. Better to find out where it is getting
1308 * improperly inserted.
1309 */
1310 abort ();
1311#endif
1312 free (dump);
1313 return op;
1314 }
1315
1316 if (!QUERY_FLAG (op, FLAG_REMOVED))
1317 {
1318 char *dump = dump_object (op);
1319 LOG (llevError, "Trying to insert (map) inserted object.\n%s\n", dump);
1320 free (dump);
1321 return op;
1322 }
1323
1324 if (op->more != NULL)
1325 {
1326 /* The part may be on a different map. */
1327
1328 object *more = op->more;
1329
1330 /* We really need the caller to normalize coordinates - if
1331 * we set the map, that doesn't work if the location is within
1332 * a map and this is straddling an edge. So only if coordinate
1333 * is clear wrong do we normalize it.
1334 */
1335 if (OUT_OF_REAL_MAP (more->map, more->x, more->y))
1336 more->map = get_map_from_coord (m, &more->x, &more->y);
1337 else if (!more->map)
1338 {
1339 /* For backwards compatibility - when not dealing with tiled maps,
1340 * more->map should always point to the parent.
1341 */
1342 more->map = m;
1343 }
1344
1345 if (insert_ob_in_map (more, more->map, originator, flag) == NULL)
1346 {
1347 if (!op->head)
1348 LOG (llevError, "BUG: insert_ob_in_map(): inserting op->more killed op\n");
1349
1350 return NULL;
1351 }
1352 }
1353
1354 CLEAR_FLAG (op, FLAG_REMOVED);
1355
1356 /* Ideally, the caller figures this out. However, it complicates a lot
1357 * of areas of callers (eg, anything that uses find_free_spot would now
1358 * need extra work
1359 */
1360 op->map = get_map_from_coord (m, &op->x, &op->y);
1361 x = op->x;
1362 y = op->y;
1363
1364 /* this has to be done after we translate the coordinates.
1365 */
1366 if (op->nrof && !(flag & INS_NO_MERGE))
1367 for (tmp = GET_MAP_OB (op->map, x, y); tmp != NULL; tmp = tmp->above)
1368 if (CAN_MERGE (op, tmp))
1369 {
1370 op->nrof += tmp->nrof;
1371 remove_ob (tmp);
1372 free_object (tmp);
1373 }
1374
1375 CLEAR_FLAG (op, FLAG_APPLIED); /* hack for fixing F_APPLIED in items of dead people */
1376 CLEAR_FLAG (op, FLAG_INV_LOCKED);
1377
1378 if (!QUERY_FLAG (op, FLAG_ALIVE))
1379 CLEAR_FLAG (op, FLAG_NO_STEAL);
1380
1381 if (flag & INS_BELOW_ORIGINATOR)
1382 {
1383 if (originator->map != op->map || originator->x != op->x || originator->y != op->y)
1384 {
1385 LOG (llevError, "insert_ob_in_map called with INS_BELOW_ORIGINATOR when originator not on same space!\n");
1386 abort ();
1387 }
1388
1389 op->above = originator;
1390 op->below = originator->below;
1391
1392 if (op->below)
1393 op->below->above = op;
1394 else
1395 SET_MAP_OB (op->map, op->x, op->y, op);
1396
1397 /* since *below* originator, no need to update top */
1398 originator->below = op;
1399 }
1400 else
1401 {
1402 /* If there are other objects, then */
1403 if ((!(flag & INS_MAP_LOAD)) && ((top = GET_MAP_OB (op->map, op->x, op->y)) != NULL))
1404 {
1405 object *last = NULL;
1406
1407 /*
1408 * If there are multiple objects on this space, we do some trickier handling.
1409 * We've already dealt with merging if appropriate.
1410 * Generally, we want to put the new object on top. But if
1411 * flag contains INS_ABOVE_FLOOR_ONLY, once we find the last
1412 * floor, we want to insert above that and no further.
1413 * Also, if there are spell objects on this space, we stop processing
1414 * once we get to them. This reduces the need to traverse over all of
1415 * them when adding another one - this saves quite a bit of cpu time
1416 * when lots of spells are cast in one area. Currently, it is presumed
1417 * that flying non pickable objects are spell objects.
1418 */
1419
1420 while (top != NULL)
1421 {
1422 if (QUERY_FLAG (top, FLAG_IS_FLOOR) || QUERY_FLAG (top, FLAG_OVERLAY_FLOOR))
1423 floor = top;
1424
1425 if (QUERY_FLAG (top, FLAG_NO_PICK) && (top->move_type & (MOVE_FLY_LOW | MOVE_FLY_HIGH)) && !QUERY_FLAG (top, FLAG_IS_FLOOR))
1426 {
1427 /* We insert above top, so we want this object below this */
1428 top = top->below;
1429 break;
1430 }
1431
1432 last = top;
1433 top = top->above;
1434 }
1435
1436 /* Don't want top to be NULL, so set it to the last valid object */
1437 top = last;
1438
1439 /* We let update_position deal with figuring out what the space
1440 * looks like instead of lots of conditions here.
1441 * makes things faster, and effectively the same result.
1442 */
1443
1444 /* Have object 'fall below' other objects that block view.
1445 * Unless those objects are exits, type 66
1446 * If INS_ON_TOP is used, don't do this processing
1447 * Need to find the object that in fact blocks view, otherwise
1448 * stacking is a bit odd.
1449 */
1450 if (!(flag & INS_ON_TOP) &&
1451 (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_BLOCKSVIEW) && (op->face && !op->face->visibility))
1452 {
1453 for (last = top; last != floor; last = last->below)
1454 if (QUERY_FLAG (last, FLAG_BLOCKSVIEW) && (last->type != EXIT))
1455 break;
1456 /* Check to see if we found the object that blocks view,
1457 * and make sure we have a below pointer for it so that
1458 * we can get inserted below this one, which requires we
1459 * set top to the object below us.
1460 */
1461 if (last && last->below && last != floor)
1462 top = last->below;
1463 }
1464 } /* If objects on this space */
1465
1466 if (flag & INS_MAP_LOAD)
1467 top = GET_MAP_TOP (op->map, op->x, op->y);
1468
1469 if (flag & INS_ABOVE_FLOOR_ONLY)
1470 top = floor;
1471
1472 /* Top is the object that our object (op) is going to get inserted above.
1473 */
1474
1475 /* First object on this space */
1476 if (!top)
1477 {
1478 op->above = GET_MAP_OB (op->map, op->x, op->y);
1479
1480 if (op->above)
1481 op->above->below = op;
1482
1483 op->below = NULL;
1484 SET_MAP_OB (op->map, op->x, op->y, op);
1485 }
1486 else
1487 { /* get inserted into the stack above top */
1488 op->above = top->above;
1489
1490 if (op->above)
1491 op->above->below = op;
1492
1493 op->below = top;
1494 top->above = op;
1495 }
1496
1497 if (op->above == NULL)
1498 SET_MAP_TOP (op->map, op->x, op->y, op);
1499 } /* else not INS_BELOW_ORIGINATOR */
1500
1501 if (op->type == PLAYER)
1502 op->contr->do_los = 1;
1503
1504 /* If we have a floor, we know the player, if any, will be above
1505 * it, so save a few ticks and start from there.
1506 */
1507 if (!(flag & INS_MAP_LOAD))
1508 for (tmp = floor ? floor : GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)
1509 if (tmp->type == PLAYER)
1510 tmp->contr->socket.update_look = 1;
1511
1512 /* If this object glows, it may affect lighting conditions that are
1513 * visible to others on this map. But update_all_los is really
1514 * an inefficient way to do this, as it means los for all players
1515 * on the map will get recalculated. The players could very well
1516 * be far away from this change and not affected in any way -
1517 * this should get redone to only look for players within range,
1518 * or just updating the P_NEED_UPDATE for spaces within this area
1519 * of effect may be sufficient.
1520 */
1521 if (MAP_DARKNESS (op->map) && (op->glow_radius != 0))
1522 update_all_los (op->map, op->x, op->y);
1523
1524 /* updates flags (blocked, alive, no magic, etc) for this map space */
1525 update_object (op, UP_OBJ_INSERT);
1526
1527 /* Don't know if moving this to the end will break anything. However,
1528 * we want to have update_look set above before calling this.
1529 *
1530 * check_move_on() must be after this because code called from
1531 * check_move_on() depends on correct map flags (so functions like
1532 * blocked() and wall() work properly), and these flags are updated by
1533 * update_object().
1534 */
1535
1536 /* if this is not the head or flag has been passed, don't check walk on status */
1537 if (!(flag & INS_NO_WALK_ON) && !op->head)
1538 {
1539 if (check_move_on (op, originator))
1260 return NULL; 1540 return NULL;
1261 }
1262 if(m==NULL) {
1263 dump_object(op);
1264 LOG(llevError,"Trying to insert in null-map!\n%s\n",errmsg);
1265 return op;
1266 }
1267 if(out_of_map(m,op->x,op->y)) {
1268 dump_object(op);
1269 LOG(llevError,"Trying to insert object outside the map.\n%s\n", errmsg);
1270#ifdef MANY_CORES
1271 /* Better to catch this here, as otherwise the next use of this object
1272 * is likely to cause a crash. Better to find out where it is getting
1273 * improperly inserted.
1274 */
1275 abort();
1276#endif
1277 return op;
1278 }
1279 if(!QUERY_FLAG(op,FLAG_REMOVED)) {
1280 dump_object(op);
1281 LOG(llevError,"Trying to insert (map) inserted object.\n%s\n", errmsg);
1282 return op;
1283 }
1284 if(op->more!=NULL) {
1285 /* The part may be on a different map. */
1286 1541
1287 object *more = op->more;
1288
1289 /* We really need the caller to normalize coordinates - if
1290 * we set the map, that doesn't work if the location is within
1291 * a map and this is straddling an edge. So only if coordinate
1292 * is clear wrong do we normalize it.
1293 */
1294 if (OUT_OF_REAL_MAP(more->map, more->x, more->y)) {
1295 more->map = get_map_from_coord(m, &more->x, &more->y);
1296 } else if (!more->map) {
1297 /* For backwards compatibility - when not dealing with tiled maps,
1298 * more->map should always point to the parent.
1299 */
1300 more->map = m;
1301 }
1302
1303 if (insert_ob_in_map(more, more->map, originator, flag) == NULL) {
1304 if ( ! op->head)
1305 LOG (llevError, "BUG: insert_ob_in_map(): inserting op->more killed op\n");
1306 return NULL;
1307 }
1308 }
1309 CLEAR_FLAG(op,FLAG_REMOVED);
1310
1311 /* Ideally, the caller figures this out. However, it complicates a lot
1312 * of areas of callers (eg, anything that uses find_free_spot would now
1313 * need extra work
1314 */
1315 op->map=get_map_from_coord(m, &op->x, &op->y);
1316 x = op->x;
1317 y = op->y;
1318
1319 /* this has to be done after we translate the coordinates.
1320 */
1321 if(op->nrof && !(flag & INS_NO_MERGE)) {
1322 for(tmp=GET_MAP_OB(op->map,x,y);tmp!=NULL;tmp=tmp->above)
1323 if (CAN_MERGE(op,tmp)) {
1324 op->nrof+=tmp->nrof;
1325 remove_ob(tmp);
1326 free_object(tmp);
1327 }
1328 }
1329
1330 CLEAR_FLAG(op,FLAG_APPLIED); /* hack for fixing F_APPLIED in items of dead people */
1331 CLEAR_FLAG(op, FLAG_INV_LOCKED);
1332 if (!QUERY_FLAG(op, FLAG_ALIVE))
1333 CLEAR_FLAG(op, FLAG_NO_STEAL);
1334
1335 if (flag & INS_BELOW_ORIGINATOR) {
1336 if (originator->map != op->map || originator->x != op->x ||
1337 originator->y != op->y) {
1338 LOG(llevError,"insert_ob_in_map called with INS_BELOW_ORIGINATOR when originator not on same space!\n");
1339 abort();
1340 }
1341 op->above = originator;
1342 op->below = originator->below;
1343 if (op->below) op->below->above = op;
1344 else SET_MAP_OB(op->map, op->x, op->y, op);
1345 /* since *below* originator, no need to update top */
1346 originator->below = op;
1347 } else {
1348 /* If there are other objects, then */
1349 if((! (flag & INS_MAP_LOAD)) && ((top=GET_MAP_OB(op->map,op->x,op->y))!=NULL)) {
1350 object *last=NULL;
1351 /*
1352 * If there are multiple objects on this space, we do some trickier handling.
1353 * We've already dealt with merging if appropriate.
1354 * Generally, we want to put the new object on top. But if
1355 * flag contains INS_ABOVE_FLOOR_ONLY, once we find the last
1356 * floor, we want to insert above that and no further.
1357 * Also, if there are spell objects on this space, we stop processing
1358 * once we get to them. This reduces the need to traverse over all of
1359 * them when adding another one - this saves quite a bit of cpu time
1360 * when lots of spells are cast in one area. Currently, it is presumed
1361 * that flying non pickable objects are spell objects.
1362 */
1363
1364 while (top != NULL) {
1365 if (QUERY_FLAG(top, FLAG_IS_FLOOR) ||
1366 QUERY_FLAG(top, FLAG_OVERLAY_FLOOR)) floor = top;
1367 if (QUERY_FLAG(top, FLAG_NO_PICK)
1368 && (top->move_type & (MOVE_FLY_LOW |MOVE_FLY_HIGH))
1369 && !QUERY_FLAG(top, FLAG_IS_FLOOR))
1370 {
1371 /* We insert above top, so we want this object below this */
1372 top=top->below;
1373 break;
1374 }
1375 last = top;
1376 top = top->above;
1377 }
1378 /* Don't want top to be NULL, so set it to the last valid object */
1379 top = last;
1380
1381 /* We let update_position deal with figuring out what the space
1382 * looks like instead of lots of conditions here.
1383 * makes things faster, and effectively the same result.
1384 */
1385
1386 /* Have object 'fall below' other objects that block view.
1387 * Unless those objects are exits, type 66
1388 * If INS_ON_TOP is used, don't do this processing
1389 * Need to find the object that in fact blocks view, otherwise
1390 * stacking is a bit odd.
1391 */
1392 if (!(flag & INS_ON_TOP) &&
1393 (get_map_flags(op->map, NULL, op->x, op->y, NULL, NULL) & P_BLOCKSVIEW) &&
1394 (op->face && !op->face->visibility)) {
1395 for (last=top; last != floor; last=last->below)
1396 if (QUERY_FLAG(last, FLAG_BLOCKSVIEW)&&(last->type != EXIT)) break;
1397 /* Check to see if we found the object that blocks view,
1398 * and make sure we have a below pointer for it so that
1399 * we can get inserted below this one, which requires we
1400 * set top to the object below us.
1401 */
1402 if (last && last->below && last != floor) top=last->below;
1403 }
1404 } /* If objects on this space */
1405 if (flag & INS_MAP_LOAD)
1406 top = GET_MAP_TOP(op->map,op->x,op->y);
1407 if (flag & INS_ABOVE_FLOOR_ONLY) top = floor;
1408
1409 /* Top is the object that our object (op) is going to get inserted above.
1410 */
1411
1412 /* First object on this space */
1413 if (!top) {
1414 op->above = GET_MAP_OB(op->map, op->x, op->y);
1415 if (op->above) op->above->below = op;
1416 op->below = NULL;
1417 SET_MAP_OB(op->map, op->x, op->y, op);
1418 } else { /* get inserted into the stack above top */
1419 op->above = top->above;
1420 if (op->above) op->above->below = op;
1421 op->below = top;
1422 top->above = op;
1423 }
1424 if (op->above==NULL)
1425 SET_MAP_TOP(op->map,op->x, op->y, op);
1426 } /* else not INS_BELOW_ORIGINATOR */
1427
1428 if(op->type==PLAYER)
1429 op->contr->do_los=1;
1430
1431 /* If we have a floor, we know the player, if any, will be above
1432 * it, so save a few ticks and start from there.
1433 */
1434 if (!(flag & INS_MAP_LOAD))
1435 for(tmp=floor?floor:GET_MAP_OB(op->map,op->x,op->y);tmp!=NULL;tmp=tmp->above) {
1436 if (tmp->type == PLAYER)
1437 tmp->contr->socket.update_look=1;
1438 }
1439
1440 /* If this object glows, it may affect lighting conditions that are
1441 * visible to others on this map. But update_all_los is really
1442 * an inefficient way to do this, as it means los for all players
1443 * on the map will get recalculated. The players could very well
1444 * be far away from this change and not affected in any way -
1445 * this should get redone to only look for players within range,
1446 * or just updating the P_NEED_UPDATE for spaces within this area
1447 * of effect may be sufficient.
1448 */
1449 if(MAP_DARKNESS(op->map) && (op->glow_radius != 0))
1450 update_all_los(op->map, op->x, op->y);
1451
1452
1453 /* updates flags (blocked, alive, no magic, etc) for this map space */
1454 update_object(op,UP_OBJ_INSERT);
1455
1456
1457 /* Don't know if moving this to the end will break anything. However,
1458 * we want to have update_look set above before calling this.
1459 *
1460 * check_move_on() must be after this because code called from
1461 * check_move_on() depends on correct map flags (so functions like
1462 * blocked() and wall() work properly), and these flags are updated by
1463 * update_object().
1464 */
1465
1466 /* if this is not the head or flag has been passed, don't check walk on status */
1467
1468 if (!(flag & INS_NO_WALK_ON) && !op->head) {
1469 if (check_move_on(op, originator))
1470 return NULL;
1471
1472 /* If we are a multi part object, lets work our way through the check 1542 /* If we are a multi part object, lets work our way through the check
1473 * walk on's. 1543 * walk on's.
1474 */ 1544 */
1475 for (tmp=op->more; tmp!=NULL; tmp=tmp->more) 1545 for (tmp = op->more; tmp != NULL; tmp = tmp->more)
1476 if (check_move_on (tmp, originator)) 1546 if (check_move_on (tmp, originator))
1477 return NULL; 1547 return NULL;
1478 } 1548 }
1549
1479 return op; 1550 return op;
1480} 1551}
1481 1552
1482/* this function inserts an object in the map, but if it 1553/* this function inserts an object in the map, but if it
1483 * finds an object of its own type, it'll remove that one first. 1554 * finds an object of its own type, it'll remove that one first.
1484 * op is the object to insert it under: supplies x and the map. 1555 * op is the object to insert it under: supplies x and the map.
1485 */ 1556 */
1557void
1486void replace_insert_ob_in_map(const char *arch_string, object *op) { 1558replace_insert_ob_in_map (const char *arch_string, object *op)
1559{
1487 object *tmp; 1560 object *
1488 object *tmp1; 1561 tmp;
1562 object *
1563 tmp1;
1489 1564
1490 /* first search for itself and remove any old instances */ 1565 /* first search for itself and remove any old instances */
1491 1566
1492 for(tmp=GET_MAP_OB(op->map,op->x,op->y); tmp!=NULL; tmp=tmp->above) { 1567 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)
1568 {
1493 if(!strcmp(tmp->arch->name,arch_string)) /* same archetype */ { 1569 if (!strcmp (tmp->arch->name, arch_string)) /* same archetype */
1570 {
1494 remove_ob(tmp); 1571 remove_ob (tmp);
1495 free_object(tmp); 1572 free_object (tmp);
1496 } 1573 }
1497 } 1574 }
1498 1575
1499 tmp1=arch_to_object(find_archetype(arch_string)); 1576 tmp1 = arch_to_object (archetype::find (arch_string));
1500 1577
1501 1578 tmp1->x = op->x;
1502 tmp1->x = op->x; tmp1->y = op->y; 1579 tmp1->y = op->y;
1503 insert_ob_in_map(tmp1,op->map,op,0); 1580 insert_ob_in_map (tmp1, op->map, op, 0);
1504} 1581}
1505 1582
1506/* 1583/*
1507 * get_split_ob(ob,nr) splits up ob into two parts. The part which 1584 * get_split_ob(ob,nr) splits up ob into two parts. The part which
1508 * is returned contains nr objects, and the remaining parts contains 1585 * is returned contains nr objects, and the remaining parts contains
1509 * the rest (or is removed and freed if that number is 0). 1586 * the rest (or is removed and freed if that number is 0).
1510 * On failure, NULL is returned, and the reason put into the 1587 * On failure, NULL is returned, and the reason put into the
1511 * global static errmsg array. 1588 * global static errmsg array.
1512 */ 1589 */
1513 1590
1591object *
1514object *get_split_ob(object *orig_ob, uint32 nr) { 1592get_split_ob (object *orig_ob, uint32 nr)
1515 object *newob; 1593{
1594 object *
1595 newob;
1596 int
1516 int is_removed = (QUERY_FLAG (orig_ob, FLAG_REMOVED) != 0); 1597 is_removed = (QUERY_FLAG (orig_ob, FLAG_REMOVED) != 0);
1517 1598
1518 if(orig_ob->nrof<nr) { 1599 if (orig_ob->nrof < nr)
1519 sprintf(errmsg,"There are only %d %ss.", 1600 {
1520 orig_ob->nrof?orig_ob->nrof:1, &orig_ob->name); 1601 sprintf (errmsg, "There are only %d %ss.", orig_ob->nrof ? orig_ob->nrof : 1, &orig_ob->name);
1521 return NULL; 1602 return NULL;
1522 } 1603 }
1604
1523 newob = object_create_clone(orig_ob); 1605 newob = object_create_clone (orig_ob);
1606
1524 if((orig_ob->nrof-=nr)<1) { 1607 if ((orig_ob->nrof -= nr) < 1)
1608 {
1525 if ( ! is_removed) 1609 if (!is_removed)
1526 remove_ob(orig_ob); 1610 remove_ob (orig_ob);
1527 free_object2(orig_ob, 1); 1611 free_object2 (orig_ob, 1);
1528 } 1612 }
1529 else if ( ! is_removed) { 1613 else if (!is_removed)
1614 {
1530 if(orig_ob->env!=NULL) 1615 if (orig_ob->env != NULL)
1531 sub_weight (orig_ob->env,orig_ob->weight*nr); 1616 sub_weight (orig_ob->env, orig_ob->weight * nr);
1532 if (orig_ob->env == NULL && orig_ob->map->in_memory!=MAP_IN_MEMORY) { 1617 if (orig_ob->env == NULL && orig_ob->map->in_memory != MAP_IN_MEMORY)
1618 {
1533 strcpy(errmsg, "Tried to split object whose map is not in memory."); 1619 strcpy (errmsg, "Tried to split object whose map is not in memory.");
1534 LOG(llevDebug,
1535 "Error, Tried to split object whose map is not in memory.\n"); 1620 LOG (llevDebug, "Error, Tried to split object whose map is not in memory.\n");
1536 return NULL; 1621 return NULL;
1537 } 1622 }
1538 } 1623 }
1624
1539 newob->nrof=nr; 1625 newob->nrof = nr;
1540 1626
1541 return newob; 1627 return newob;
1542} 1628}
1543 1629
1544/* 1630/*
1545 * decrease_ob_nr(object, number) decreases a specified number from 1631 * decrease_ob_nr(object, number) decreases a specified number from
1546 * the amount of an object. If the amount reaches 0, the object 1632 * the amount of an object. If the amount reaches 0, the object
1547 * is subsequently removed and freed. 1633 * is subsequently removed and freed.
1548 * 1634 *
1549 * Return value: 'op' if something is left, NULL if the amount reached 0 1635 * Return value: 'op' if something is left, NULL if the amount reached 0
1550 */ 1636 */
1551 1637
1638object *
1552object *decrease_ob_nr (object *op, uint32 i) 1639decrease_ob_nr (object *op, uint32 i)
1553{ 1640{
1554 object *tmp; 1641 object *tmp;
1555 player *pl; 1642 player *pl;
1556 1643
1557 if (i == 0) /* objects with op->nrof require this check */ 1644 if (i == 0) /* objects with op->nrof require this check */
1558 return op; 1645 return op;
1559 1646
1560 if (i > op->nrof) 1647 if (i > op->nrof)
1561 i = op->nrof; 1648 i = op->nrof;
1562 1649
1563 if (QUERY_FLAG (op, FLAG_REMOVED)) 1650 if (QUERY_FLAG (op, FLAG_REMOVED))
1651 op->nrof -= i;
1652 else if (op->env != NULL)
1653 {
1654 /* is this object in the players inventory, or sub container
1655 * therein?
1656 */
1657 tmp = is_player_inv (op->env);
1658 /* nope. Is this a container the player has opened?
1659 * If so, set tmp to that player.
1660 * IMO, searching through all the players will mostly
1661 * likely be quicker than following op->env to the map,
1662 * and then searching the map for a player.
1663 */
1664 if (!tmp)
1665 {
1666 for (pl = first_player; pl; pl = pl->next)
1667 if (pl->ob->container == op->env)
1668 break;
1669 if (pl)
1670 tmp = pl->ob;
1671 else
1672 tmp = NULL;
1673 }
1674
1675 if (i < op->nrof)
1676 {
1677 sub_weight (op->env, op->weight * i);
1678 op->nrof -= i;
1679 if (tmp)
1680 {
1681 esrv_send_item (tmp, op);
1682 }
1683 }
1684 else
1685 {
1686 remove_ob (op);
1687 op->nrof = 0;
1688 if (tmp)
1689 {
1690 esrv_del_item (tmp->contr, op->count);
1691 }
1692 }
1564 { 1693 }
1694 else
1695 {
1696 object *above = op->above;
1697
1698 if (i < op->nrof)
1565 op->nrof -= i; 1699 op->nrof -= i;
1566 } 1700 else
1567 else if (op->env != NULL)
1568 {
1569 /* is this object in the players inventory, or sub container
1570 * therein?
1571 */
1572 tmp = is_player_inv (op->env);
1573 /* nope. Is this a container the player has opened?
1574 * If so, set tmp to that player.
1575 * IMO, searching through all the players will mostly
1576 * likely be quicker than following op->env to the map,
1577 * and then searching the map for a player.
1578 */
1579 if (!tmp) {
1580 for (pl=first_player; pl; pl=pl->next)
1581 if (pl->ob->container == op->env) break;
1582 if (pl) tmp=pl->ob;
1583 else tmp=NULL;
1584 } 1701 {
1585
1586 if (i < op->nrof) {
1587 sub_weight (op->env, op->weight * i);
1588 op->nrof -= i;
1589 if (tmp) {
1590 esrv_send_item(tmp, op);
1591 }
1592 } else {
1593 remove_ob (op); 1702 remove_ob (op);
1594 op->nrof = 0; 1703 op->nrof = 0;
1595 if (tmp) {
1596 esrv_del_item(tmp->contr, op->count);
1597 } 1704 }
1598 }
1599 }
1600 else
1601 {
1602 object *above = op->above;
1603 1705
1604 if (i < op->nrof) {
1605 op->nrof -= i;
1606 } else {
1607 remove_ob (op);
1608 op->nrof = 0;
1609 }
1610 /* Since we just removed op, op->above is null */ 1706 /* Since we just removed op, op->above is null */
1611 for (tmp = above; tmp != NULL; tmp = tmp->above) 1707 for (tmp = above; tmp != NULL; tmp = tmp->above)
1612 if (tmp->type == PLAYER) { 1708 if (tmp->type == PLAYER)
1709 {
1613 if (op->nrof) 1710 if (op->nrof)
1614 esrv_send_item(tmp, op); 1711 esrv_send_item (tmp, op);
1615 else 1712 else
1616 esrv_del_item(tmp->contr, op->count); 1713 esrv_del_item (tmp->contr, op->count);
1617 } 1714 }
1618 } 1715 }
1619 1716
1620 if (op->nrof) { 1717 if (op->nrof)
1621 return op; 1718 return op;
1622 } else { 1719 else
1720 {
1623 free_object (op); 1721 free_object (op);
1624 return NULL; 1722 return NULL;
1625 } 1723 }
1626} 1724}
1627 1725
1628/* 1726/*
1629 * add_weight(object, weight) adds the specified weight to an object, 1727 * add_weight(object, weight) adds the specified weight to an object,
1630 * and also updates how much the environment(s) is/are carrying. 1728 * and also updates how much the environment(s) is/are carrying.
1631 */ 1729 */
1632 1730
1731void
1633void add_weight (object *op, signed long weight) { 1732add_weight (object *op, signed long weight)
1733{
1634 while (op!=NULL) { 1734 while (op != NULL)
1735 {
1635 if (op->type == CONTAINER) { 1736 if (op->type == CONTAINER)
1636 weight=(signed long)(weight*(100-op->stats.Str)/100); 1737 weight = (signed long) (weight * (100 - op->stats.Str) / 100);
1637 } 1738
1638 op->carrying+=weight; 1739 op->carrying += weight;
1639 op=op->env; 1740 op = op->env;
1640 } 1741 }
1641} 1742}
1642 1743
1643/* 1744/*
1644 * insert_ob_in_ob(op,environment): 1745 * insert_ob_in_ob(op,environment):
1645 * This function inserts the object op in the linked list 1746 * This function inserts the object op in the linked list
… …
1652 * 1753 *
1653 * The function returns now pointer to inserted item, and return value can 1754 * The function returns now pointer to inserted item, and return value can
1654 * be != op, if items are merged. -Tero 1755 * be != op, if items are merged. -Tero
1655 */ 1756 */
1656 1757
1758object *
1657object *insert_ob_in_ob(object *op,object *where) { 1759insert_ob_in_ob (object *op, object *where)
1658 object *tmp, *otmp; 1760{
1761 object *
1762 tmp, *
1763 otmp;
1659 1764
1660 if(!QUERY_FLAG(op,FLAG_REMOVED)) { 1765 if (!QUERY_FLAG (op, FLAG_REMOVED))
1661 dump_object(op); 1766 {
1767 char *dump = dump_object (op);
1662 LOG(llevError,"Trying to insert (ob) inserted object.\n%s\n", errmsg); 1768 LOG (llevError, "Trying to insert (ob) inserted object.\n%s\n", dump);
1769 free (dump);
1663 return op; 1770 return op;
1664 } 1771 }
1772
1665 if(where==NULL) { 1773 if (where == NULL)
1666 dump_object(op); 1774 {
1775 char *dump = dump_object (op);
1667 LOG(llevError,"Trying to put object in NULL.\n%s\n", errmsg); 1776 LOG (llevError, "Trying to put object in NULL.\n%s\n", dump);
1777 free (dump);
1668 return op; 1778 return op;
1669 } 1779 }
1780
1670 if (where->head) { 1781 if (where->head)
1671 LOG(llevDebug, 1782 {
1672 "Warning: Tried to insert object wrong part of multipart object.\n"); 1783 LOG (llevDebug, "Warning: Tried to insert object wrong part of multipart object.\n");
1673 where = where->head; 1784 where = where->head;
1674 } 1785 }
1786
1675 if (op->more) { 1787 if (op->more)
1788 {
1676 LOG(llevError, "Tried to insert multipart object %s (%d)\n", 1789 LOG (llevError, "Tried to insert multipart object %s (%d)\n", &op->name, op->count);
1677 &op->name, op->count);
1678 return op; 1790 return op;
1679 } 1791 }
1792
1680 CLEAR_FLAG(op, FLAG_OBJ_ORIGINAL); 1793 CLEAR_FLAG (op, FLAG_OBJ_ORIGINAL);
1681 CLEAR_FLAG(op, FLAG_REMOVED); 1794 CLEAR_FLAG (op, FLAG_REMOVED);
1682 if(op->nrof) { 1795 if (op->nrof)
1796 {
1683 for(tmp=where->inv;tmp!=NULL;tmp=tmp->below) 1797 for (tmp = where->inv; tmp != NULL; tmp = tmp->below)
1684 if ( CAN_MERGE(tmp,op) ) { 1798 if (CAN_MERGE (tmp, op))
1799 {
1685 /* return the original object and remove inserted object 1800 /* return the original object and remove inserted object
1686 (client needs the original object) */ 1801 (client needs the original object) */
1687 tmp->nrof += op->nrof; 1802 tmp->nrof += op->nrof;
1688 /* Weight handling gets pretty funky. Since we are adding to 1803 /* Weight handling gets pretty funky. Since we are adding to
1689 * tmp->nrof, we need to increase the weight. 1804 * tmp->nrof, we need to increase the weight.
1690 */ 1805 */
1691 add_weight (where, op->weight*op->nrof); 1806 add_weight (where, op->weight * op->nrof);
1692 SET_FLAG(op, FLAG_REMOVED); 1807 SET_FLAG (op, FLAG_REMOVED);
1693 free_object(op); /* free the inserted object */ 1808 free_object (op); /* free the inserted object */
1694 op = tmp; 1809 op = tmp;
1695 remove_ob (op); /* and fix old object's links */ 1810 remove_ob (op); /* and fix old object's links */
1696 CLEAR_FLAG(op, FLAG_REMOVED); 1811 CLEAR_FLAG (op, FLAG_REMOVED);
1697 break; 1812 break;
1698 } 1813 }
1699 1814
1700 /* I assume combined objects have no inventory 1815 /* I assume combined objects have no inventory
1701 * We add the weight - this object could have just been removed 1816 * We add the weight - this object could have just been removed
1702 * (if it was possible to merge). calling remove_ob will subtract 1817 * (if it was possible to merge). calling remove_ob will subtract
1703 * the weight, so we need to add it in again, since we actually do 1818 * the weight, so we need to add it in again, since we actually do
1704 * the linking below 1819 * the linking below
1705 */ 1820 */
1706 add_weight (where, op->weight*op->nrof); 1821 add_weight (where, op->weight * op->nrof);
1822 }
1707 } else 1823 else
1708 add_weight (where, (op->weight+op->carrying)); 1824 add_weight (where, (op->weight + op->carrying));
1709 1825
1710 otmp=is_player_inv(where); 1826 otmp = is_player_inv (where);
1711 if (otmp&&otmp->contr!=NULL) { 1827 if (otmp && otmp->contr != NULL)
1828 {
1712 if (!QUERY_FLAG(otmp,FLAG_NO_FIX_PLAYER)) 1829 if (!QUERY_FLAG (otmp, FLAG_NO_FIX_PLAYER))
1713 fix_player(otmp); 1830 fix_player (otmp);
1714 } 1831 }
1715 1832
1716 op->map=NULL; 1833 op->map = NULL;
1717 op->env=where; 1834 op->env = where;
1718 op->above=NULL; 1835 op->above = NULL;
1719 op->below=NULL; 1836 op->below = NULL;
1720 op->x=0,op->y=0; 1837 op->x = 0, op->y = 0;
1721 1838
1722 /* reset the light list and los of the players on the map */ 1839 /* reset the light list and los of the players on the map */
1723 if((op->glow_radius!=0)&&where->map) 1840 if ((op->glow_radius != 0) && where->map)
1724 { 1841 {
1725#ifdef DEBUG_LIGHTS 1842#ifdef DEBUG_LIGHTS
1726 LOG(llevDebug, " insert_ob_in_ob(): got %s to insert in map/op\n", 1843 LOG (llevDebug, " insert_ob_in_ob(): got %s to insert in map/op\n", op->name);
1727 op->name);
1728#endif /* DEBUG_LIGHTS */ 1844#endif /* DEBUG_LIGHTS */
1845 if (MAP_DARKNESS (where->map))
1729 if (MAP_DARKNESS(where->map)) update_all_los(where->map, where->x, where->y); 1846 update_all_los (where->map, where->x, where->y);
1730 } 1847 }
1731 1848
1732 /* Client has no idea of ordering so lets not bother ordering it here. 1849 /* Client has no idea of ordering so lets not bother ordering it here.
1733 * It sure simplifies this function... 1850 * It sure simplifies this function...
1734 */ 1851 */
1735 if (where->inv==NULL) 1852 if (where->inv == NULL)
1736 where->inv=op; 1853 where->inv = op;
1737 else { 1854 else
1855 {
1738 op->below = where->inv; 1856 op->below = where->inv;
1739 op->below->above = op; 1857 op->below->above = op;
1740 where->inv = op; 1858 where->inv = op;
1741 } 1859 }
1742 return op; 1860 return op;
1743} 1861}
1744 1862
1745/* 1863/*
1746 * Checks if any objects has a move_type that matches objects 1864 * Checks if any objects has a move_type that matches objects
… …
1761 * MSW 2001-07-08: Check all objects on space, not just those below 1879 * MSW 2001-07-08: Check all objects on space, not just those below
1762 * object being inserted. insert_ob_in_map may not put new objects 1880 * object being inserted. insert_ob_in_map may not put new objects
1763 * on top. 1881 * on top.
1764 */ 1882 */
1765 1883
1884int
1766int check_move_on (object *op, object *originator) 1885check_move_on (object *op, object *originator)
1767{ 1886{
1768 object *tmp; 1887 object *tmp;
1769 tag_t tag;
1770 mapstruct *m=op->map; 1888 maptile *m = op->map;
1771 int x=op->x, y=op->y; 1889 int x = op->x, y = op->y;
1890
1772 MoveType move_on, move_slow, move_block; 1891 MoveType move_on, move_slow, move_block;
1773 1892
1774 if(QUERY_FLAG(op,FLAG_NO_APPLY)) 1893 if (QUERY_FLAG (op, FLAG_NO_APPLY))
1775 return 0; 1894 return 0;
1776 1895
1777 tag = op->count;
1778
1779 move_on = GET_MAP_MOVE_ON(op->map, op->x, op->y); 1896 move_on = GET_MAP_MOVE_ON (op->map, op->x, op->y);
1780 move_slow = GET_MAP_MOVE_SLOW(op->map, op->x, op->y); 1897 move_slow = GET_MAP_MOVE_SLOW (op->map, op->x, op->y);
1781 move_block = GET_MAP_MOVE_BLOCK(op->map, op->x, op->y); 1898 move_block = GET_MAP_MOVE_BLOCK (op->map, op->x, op->y);
1782 1899
1783 /* if nothing on this space will slow op down or be applied, 1900 /* if nothing on this space will slow op down or be applied,
1784 * no need to do checking below. have to make sure move_type 1901 * no need to do checking below. have to make sure move_type
1785 * is set, as lots of objects don't have it set - we treat that 1902 * is set, as lots of objects don't have it set - we treat that
1786 * as walking. 1903 * as walking.
1787 */ 1904 */
1788 if (op->move_type && !(op->move_type & move_on) && !(op->move_type & move_slow)) 1905 if (op->move_type && !(op->move_type & move_on) && !(op->move_type & move_slow))
1789 return 0; 1906 return 0;
1790 1907
1791 /* This is basically inverse logic of that below - basically, 1908 /* This is basically inverse logic of that below - basically,
1792 * if the object can avoid the move on or slow move, they do so, 1909 * if the object can avoid the move on or slow move, they do so,
1793 * but can't do it if the alternate movement they are using is 1910 * but can't do it if the alternate movement they are using is
1794 * blocked. Logic on this seems confusing, but does seem correct. 1911 * blocked. Logic on this seems confusing, but does seem correct.
1795 */ 1912 */
1796 if ((op->move_type & ~move_on & ~move_block) != 0 && 1913 if ((op->move_type & ~move_on & ~move_block) != 0 && (op->move_type & ~move_slow & ~move_block) != 0)
1797 (op->move_type & ~move_slow & ~move_block) != 0) return 0; 1914 return 0;
1798 1915
1799 /* The objects have to be checked from top to bottom. 1916 /* The objects have to be checked from top to bottom.
1800 * Hence, we first go to the top: 1917 * Hence, we first go to the top:
1801 */ 1918 */
1802 1919
1803 for (tmp=GET_MAP_OB(op->map, op->x, op->y); tmp!=NULL && 1920 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL && tmp->above != NULL; tmp = tmp->above)
1804 tmp->above!=NULL; tmp=tmp->above) { 1921 {
1805 /* Trim the search when we find the first other spell effect 1922 /* Trim the search when we find the first other spell effect
1806 * this helps performance so that if a space has 50 spell objects, 1923 * this helps performance so that if a space has 50 spell objects,
1807 * we don't need to check all of them. 1924 * we don't need to check all of them.
1808 */ 1925 */
1809 if ((tmp->move_type & MOVE_FLY_LOW) && QUERY_FLAG(tmp, FLAG_NO_PICK)) break; 1926 if ((tmp->move_type & MOVE_FLY_LOW) && QUERY_FLAG (tmp, FLAG_NO_PICK))
1927 break;
1928 }
1929
1930 for (; tmp; tmp = tmp->below)
1810 } 1931 {
1811 for(;tmp!=NULL; tmp=tmp->below) { 1932 if (tmp == op)
1812 if (tmp == op) continue; /* Can't apply yourself */ 1933 continue; /* Can't apply yourself */
1813 1934
1814 /* Check to see if one of the movement types should be slowed down. 1935 /* Check to see if one of the movement types should be slowed down.
1815 * Second check makes sure that the movement types not being slowed 1936 * Second check makes sure that the movement types not being slowed
1816 * (~slow_move) is not blocked on this space - just because the 1937 * (~slow_move) is not blocked on this space - just because the
1817 * space doesn't slow down swimming (for example), if you can't actually 1938 * space doesn't slow down swimming (for example), if you can't actually
1818 * swim on that space, can't use it to avoid the penalty. 1939 * swim on that space, can't use it to avoid the penalty.
1819 */ 1940 */
1820 if (!QUERY_FLAG(op, FLAG_WIZPASS)) { 1941 if (!QUERY_FLAG (op, FLAG_WIZPASS))
1942 {
1821 if ((!op->move_type && tmp->move_slow & MOVE_WALK) || 1943 if ((!op->move_type && tmp->move_slow & MOVE_WALK) ||
1822 ((op->move_type & tmp->move_slow) &&
1823 (op->move_type & ~tmp->move_slow & ~tmp->move_block) == 0)) { 1944 ((op->move_type & tmp->move_slow) && (op->move_type & ~tmp->move_slow & ~tmp->move_block) == 0))
1945 {
1824 1946
1825 float diff; 1947 float
1826
1827 diff = tmp->move_slow_penalty*FABS(op->speed); 1948 diff = tmp->move_slow_penalty * FABS (op->speed);
1949
1828 if (op->type == PLAYER) { 1950 if (op->type == PLAYER)
1829 if ((QUERY_FLAG(tmp, FLAG_IS_HILLY) && find_skill_by_number(op, SK_CLIMBING)) || 1951 if ((QUERY_FLAG (tmp, FLAG_IS_HILLY) && find_skill_by_number (op, SK_CLIMBING)) ||
1830 (QUERY_FLAG(tmp, FLAG_IS_WOODED) && find_skill_by_number(op, SK_WOODSMAN))) { 1952 (QUERY_FLAG (tmp, FLAG_IS_WOODED) && find_skill_by_number (op, SK_WOODSMAN)))
1831 diff /= 4.0; 1953 diff /= 4.0;
1832 } 1954
1833 }
1834 op->speed_left -= diff; 1955 op->speed_left -= diff;
1835 } 1956 }
1836 } 1957 }
1837 1958
1838 /* Basically same logic as above, except now for actual apply. */ 1959 /* Basically same logic as above, except now for actual apply. */
1839 if ((!op->move_type && tmp->move_on & MOVE_WALK) || 1960 if ((!op->move_type && tmp->move_on & MOVE_WALK) ||
1840 ((op->move_type & tmp->move_on) &&
1841 (op->move_type & ~tmp->move_on & ~tmp->move_block)==0)) { 1961 ((op->move_type & tmp->move_on) && (op->move_type & ~tmp->move_on & ~tmp->move_block) == 0))
1842 1962 {
1843 move_apply(tmp, op, originator); 1963 move_apply (tmp, op, originator);
1964
1844 if (was_destroyed (op, tag)) 1965 if (op->destroyed ())
1845 return 1; 1966 return 1;
1846 1967
1847 /* what the person/creature stepped onto has moved the object 1968 /* what the person/creature stepped onto has moved the object
1848 * someplace new. Don't process any further - if we did, 1969 * someplace new. Don't process any further - if we did,
1849 * have a feeling strange problems would result. 1970 * have a feeling strange problems would result.
1850 */ 1971 */
1851 if (op->map != m || op->x != x || op->y != y) return 0; 1972 if (op->map != m || op->x != x || op->y != y)
1973 return 0;
1852 } 1974 }
1853 } 1975 }
1976
1854 return 0; 1977 return 0;
1855} 1978}
1856 1979
1857/* 1980/*
1858 * present_arch(arch, map, x, y) searches for any objects with 1981 * present_arch(arch, map, x, y) searches for any objects with
1859 * a matching archetype at the given map and coordinates. 1982 * a matching archetype at the given map and coordinates.
1860 * The first matching object is returned, or NULL if none. 1983 * The first matching object is returned, or NULL if none.
1861 */ 1984 */
1862 1985
1986object *
1863object *present_arch(const archetype *at, mapstruct *m, int x, int y) { 1987present_arch (const archetype *at, maptile *m, int x, int y)
1988{
1864 object *tmp; 1989 object *
1990 tmp;
1991
1865 if(m==NULL || out_of_map(m,x,y)) { 1992 if (m == NULL || out_of_map (m, x, y))
1993 {
1866 LOG(llevError,"Present_arch called outside map.\n"); 1994 LOG (llevError, "Present_arch called outside map.\n");
1867 return NULL; 1995 return NULL;
1868 } 1996 }
1869 for(tmp=GET_MAP_OB(m,x,y); tmp != NULL; tmp = tmp->above) 1997 for (tmp = GET_MAP_OB (m, x, y); tmp != NULL; tmp = tmp->above)
1870 if(tmp->arch == at) 1998 if (tmp->arch == at)
1871 return tmp; 1999 return tmp;
1872 return NULL; 2000 return NULL;
1873} 2001}
1874 2002
1875/* 2003/*
1876 * present(type, map, x, y) searches for any objects with 2004 * present(type, map, x, y) searches for any objects with
1877 * a matching type variable at the given map and coordinates. 2005 * a matching type variable at the given map and coordinates.
1878 * The first matching object is returned, or NULL if none. 2006 * The first matching object is returned, or NULL if none.
1879 */ 2007 */
1880 2008
2009object *
1881object *present(unsigned char type,mapstruct *m, int x,int y) { 2010present (unsigned char type, maptile *m, int x, int y)
2011{
1882 object *tmp; 2012 object *
2013 tmp;
2014
1883 if(out_of_map(m,x,y)) { 2015 if (out_of_map (m, x, y))
2016 {
1884 LOG(llevError,"Present called outside map.\n"); 2017 LOG (llevError, "Present called outside map.\n");
1885 return NULL; 2018 return NULL;
1886 } 2019 }
1887 for(tmp=GET_MAP_OB(m,x,y);tmp!=NULL;tmp=tmp->above) 2020 for (tmp = GET_MAP_OB (m, x, y); tmp != NULL; tmp = tmp->above)
1888 if(tmp->type==type) 2021 if (tmp->type == type)
1889 return tmp; 2022 return tmp;
1890 return NULL; 2023 return NULL;
1891} 2024}
1892 2025
1893/* 2026/*
1894 * present_in_ob(type, object) searches for any objects with 2027 * present_in_ob(type, object) searches for any objects with
1895 * a matching type variable in the inventory of the given object. 2028 * a matching type variable in the inventory of the given object.
1896 * The first matching object is returned, or NULL if none. 2029 * The first matching object is returned, or NULL if none.
1897 */ 2030 */
1898 2031
2032object *
1899object *present_in_ob(unsigned char type, const object *op) { 2033present_in_ob (unsigned char type, const object *op)
2034{
1900 object *tmp; 2035 object *
2036 tmp;
2037
1901 for(tmp=op->inv;tmp!=NULL;tmp=tmp->below) 2038 for (tmp = op->inv; tmp != NULL; tmp = tmp->below)
1902 if(tmp->type==type) 2039 if (tmp->type == type)
1903 return tmp; 2040 return tmp;
1904 return NULL; 2041 return NULL;
1905} 2042}
1906 2043
1907/* 2044/*
… …
1917 * the object name, not the archetype name. this is so that the 2054 * the object name, not the archetype name. this is so that the
1918 * spell code can use one object type (force), but change it's name 2055 * spell code can use one object type (force), but change it's name
1919 * to be unique. 2056 * to be unique.
1920 */ 2057 */
1921 2058
2059object *
1922object *present_in_ob_by_name(int type, const char *str, const object *op) { 2060present_in_ob_by_name (int type, const char *str, const object *op)
2061{
1923 object *tmp; 2062 object *
2063 tmp;
1924 2064
1925 for(tmp=op->inv; tmp!=NULL; tmp=tmp->below) { 2065 for (tmp = op->inv; tmp != NULL; tmp = tmp->below)
2066 {
1926 if ((type==-1 || tmp->type==type) && (!strcmp(str, tmp->name))) 2067 if ((type == -1 || tmp->type == type) && (!strcmp (str, tmp->name)))
1927 return tmp; 2068 return tmp;
1928 } 2069 }
1929 return NULL; 2070 return NULL;
1930} 2071}
1931 2072
1932/* 2073/*
1933 * present_arch_in_ob(archetype, object) searches for any objects with 2074 * present_arch_in_ob(archetype, object) searches for any objects with
1934 * a matching archetype in the inventory of the given object. 2075 * a matching archetype in the inventory of the given object.
1935 * The first matching object is returned, or NULL if none. 2076 * The first matching object is returned, or NULL if none.
1936 */ 2077 */
1937 2078
2079object *
1938object *present_arch_in_ob(const archetype *at, const object *op) { 2080present_arch_in_ob (const archetype *at, const object *op)
2081{
1939 object *tmp; 2082 object *
2083 tmp;
2084
1940 for(tmp=op->inv;tmp!=NULL;tmp=tmp->below) 2085 for (tmp = op->inv; tmp != NULL; tmp = tmp->below)
1941 if( tmp->arch == at) 2086 if (tmp->arch == at)
1942 return tmp; 2087 return tmp;
1943 return NULL; 2088 return NULL;
1944} 2089}
1945 2090
1946/* 2091/*
1947 * activate recursively a flag on an object inventory 2092 * activate recursively a flag on an object inventory
1948 */ 2093 */
2094void
1949void flag_inv(object*op, int flag){ 2095flag_inv (object *op, int flag)
2096{
1950 object *tmp; 2097 object *
2098 tmp;
2099
1951 if(op->inv) 2100 if (op->inv)
1952 for(tmp = op->inv; tmp != NULL; tmp = tmp->below){ 2101 for (tmp = op->inv; tmp != NULL; tmp = tmp->below)
2102 {
1953 SET_FLAG(tmp, flag); 2103 SET_FLAG (tmp, flag);
1954 flag_inv(tmp,flag); 2104 flag_inv (tmp, flag);
1955 } 2105 }
1956}/* 2106} /*
1957 * desactivate recursively a flag on an object inventory 2107 * desactivate recursively a flag on an object inventory
1958 */ 2108 */
2109void
1959void unflag_inv(object*op, int flag){ 2110unflag_inv (object *op, int flag)
2111{
1960 object *tmp; 2112 object *
2113 tmp;
2114
1961 if(op->inv) 2115 if (op->inv)
1962 for(tmp = op->inv; tmp != NULL; tmp = tmp->below){ 2116 for (tmp = op->inv; tmp != NULL; tmp = tmp->below)
2117 {
1963 CLEAR_FLAG(tmp, flag); 2118 CLEAR_FLAG (tmp, flag);
1964 unflag_inv(tmp,flag); 2119 unflag_inv (tmp, flag);
1965 } 2120 }
1966} 2121}
1967 2122
1968/* 2123/*
1969 * set_cheat(object) sets the cheat flag (WAS_WIZ) in the object and in 2124 * set_cheat(object) sets the cheat flag (WAS_WIZ) in the object and in
1970 * all it's inventory (recursively). 2125 * all it's inventory (recursively).
1971 * If checksums are used, a player will get set_cheat called for 2126 * If checksums are used, a player will get set_cheat called for
1972 * him/her-self and all object carried by a call to this function. 2127 * him/her-self and all object carried by a call to this function.
1973 */ 2128 */
1974 2129
2130void
1975void set_cheat(object *op) { 2131set_cheat (object *op)
2132{
1976 SET_FLAG(op, FLAG_WAS_WIZ); 2133 SET_FLAG (op, FLAG_WAS_WIZ);
1977 flag_inv(op, FLAG_WAS_WIZ); 2134 flag_inv (op, FLAG_WAS_WIZ);
1978} 2135}
1979 2136
1980/* 2137/*
1981 * find_free_spot(object, map, x, y, start, stop) will search for 2138 * find_free_spot(object, map, x, y, start, stop) will search for
1982 * a spot at the given map and coordinates which will be able to contain 2139 * a spot at the given map and coordinates which will be able to contain
… …
1997 * to know if the space in question will block the object. We can't use 2154 * to know if the space in question will block the object. We can't use
1998 * the archetype because that isn't correct if the monster has been 2155 * the archetype because that isn't correct if the monster has been
1999 * customized, changed states, etc. 2156 * customized, changed states, etc.
2000 */ 2157 */
2001 2158
2159int
2002int find_free_spot(const object *ob, mapstruct *m,int x,int y,int start,int stop) { 2160find_free_spot (const object *ob, maptile *m, int x, int y, int start, int stop)
2161{
2162 int
2163 i,
2003 int i,index=0, flag; 2164 index = 0, flag;
2165 static int
2004 static int altern[SIZEOFFREE]; 2166 altern[SIZEOFFREE];
2005 2167
2006 for(i=start;i<stop;i++) { 2168 for (i = start; i < stop; i++)
2169 {
2007 flag = ob_blocked(ob,m,x+freearr_x[i],y+freearr_y[i]); 2170 flag = ob_blocked (ob, m, x + freearr_x[i], y + freearr_y[i]);
2008 if(!flag) 2171 if (!flag)
2009 altern[index++]=i; 2172 altern[index++] = i;
2010 2173
2011 /* Basically, if we find a wall on a space, we cut down the search size. 2174 /* Basically, if we find a wall on a space, we cut down the search size.
2012 * In this way, we won't return spaces that are on another side of a wall. 2175 * In this way, we won't return spaces that are on another side of a wall.
2013 * This mostly work, but it cuts down the search size in all directions - 2176 * This mostly work, but it cuts down the search size in all directions -
2014 * if the space being examined only has a wall to the north and empty 2177 * if the space being examined only has a wall to the north and empty
2015 * spaces in all the other directions, this will reduce the search space 2178 * spaces in all the other directions, this will reduce the search space
2016 * to only the spaces immediately surrounding the target area, and 2179 * to only the spaces immediately surrounding the target area, and
2017 * won't look 2 spaces south of the target space. 2180 * won't look 2 spaces south of the target space.
2018 */ 2181 */
2019 else if ((flag & AB_NO_PASS) && maxfree[i]<stop) 2182 else if ((flag & AB_NO_PASS) && maxfree[i] < stop)
2020 stop=maxfree[i]; 2183 stop = maxfree[i];
2021 } 2184 }
2022 if(!index) return -1; 2185 if (!index)
2186 return -1;
2023 return altern[RANDOM()%index]; 2187 return altern[RANDOM () % index];
2024} 2188}
2025 2189
2026/* 2190/*
2027 * find_first_free_spot(archetype, mapstruct, x, y) works like 2191 * find_first_free_spot(archetype, maptile, x, y) works like
2028 * find_free_spot(), but it will search max number of squares. 2192 * find_free_spot(), but it will search max number of squares.
2029 * But it will return the first available spot, not a random choice. 2193 * But it will return the first available spot, not a random choice.
2030 * Changed 0.93.2: Have it return -1 if there is no free spot available. 2194 * Changed 0.93.2: Have it return -1 if there is no free spot available.
2031 */ 2195 */
2032 2196
2197int
2033int find_first_free_spot(const object *ob, mapstruct *m,int x,int y) { 2198find_first_free_spot (const object *ob, maptile *m, int x, int y)
2199{
2200 int
2034 int i; 2201 i;
2202
2035 for(i=0;i<SIZEOFFREE;i++) { 2203 for (i = 0; i < SIZEOFFREE; i++)
2204 {
2036 if(!ob_blocked(ob,m,x+freearr_x[i],y+freearr_y[i])) 2205 if (!ob_blocked (ob, m, x + freearr_x[i], y + freearr_y[i]))
2037 return i; 2206 return i;
2038 } 2207 }
2039 return -1; 2208 return -1;
2040} 2209}
2041 2210
2042/* 2211/*
2043 * The function permute(arr, begin, end) randomly reorders the array 2212 * The function permute(arr, begin, end) randomly reorders the array
2044 * arr[begin..end-1]. 2213 * arr[begin..end-1].
2045 */ 2214 */
2215static void
2046static void permute(int *arr, int begin, int end) 2216permute (int *arr, int begin, int end)
2047{ 2217{
2048 int i, j, tmp, len; 2218 int
2219 i,
2220 j,
2221 tmp,
2222 len;
2049 2223
2050 len = end-begin; 2224 len = end - begin;
2051 for(i = begin; i < end; i++) 2225 for (i = begin; i < end; i++)
2052 { 2226 {
2053 j = begin+RANDOM()%len; 2227 j = begin + RANDOM () % len;
2054 2228
2055 tmp = arr[i]; 2229 tmp = arr[i];
2056 arr[i] = arr[j]; 2230 arr[i] = arr[j];
2057 arr[j] = tmp; 2231 arr[j] = tmp;
2058 } 2232 }
2059} 2233}
2060 2234
2061/* new function to make monster searching more efficient, and effective! 2235/* new function to make monster searching more efficient, and effective!
2062 * This basically returns a randomized array (in the passed pointer) of 2236 * This basically returns a randomized array (in the passed pointer) of
2063 * the spaces to find monsters. In this way, it won't always look for 2237 * the spaces to find monsters. In this way, it won't always look for
2064 * monsters to the north first. However, the size of the array passed 2238 * monsters to the north first. However, the size of the array passed
2065 * covers all the spaces, so within that size, all the spaces within 2239 * covers all the spaces, so within that size, all the spaces within
2066 * the 3x3 area will be searched, just not in a predictable order. 2240 * the 3x3 area will be searched, just not in a predictable order.
2067 */ 2241 */
2242void
2068void get_search_arr(int *search_arr) 2243get_search_arr (int *search_arr)
2069{ 2244{
2245 int
2070 int i; 2246 i;
2071 2247
2072 for(i = 0; i < SIZEOFFREE; i++) 2248 for (i = 0; i < SIZEOFFREE; i++)
2073 { 2249 {
2074 search_arr[i] = i; 2250 search_arr[i] = i;
2075 } 2251 }
2076 2252
2077 permute(search_arr, 1, SIZEOFFREE1+1); 2253 permute (search_arr, 1, SIZEOFFREE1 + 1);
2078 permute(search_arr, SIZEOFFREE1+1, SIZEOFFREE2+1); 2254 permute (search_arr, SIZEOFFREE1 + 1, SIZEOFFREE2 + 1);
2079 permute(search_arr, SIZEOFFREE2+1, SIZEOFFREE); 2255 permute (search_arr, SIZEOFFREE2 + 1, SIZEOFFREE);
2080} 2256}
2081 2257
2082/* 2258/*
2083 * find_dir(map, x, y, exclude) will search some close squares in the 2259 * find_dir(map, x, y, exclude) will search some close squares in the
2084 * given map at the given coordinates for live objects. 2260 * given map at the given coordinates for live objects.
… …
2090 * is actually want is going to try and move there. We need this info 2266 * is actually want is going to try and move there. We need this info
2091 * because we have to know what movement the thing looking to move 2267 * because we have to know what movement the thing looking to move
2092 * there is capable of. 2268 * there is capable of.
2093 */ 2269 */
2094 2270
2271int
2095int find_dir(mapstruct *m, int x, int y, object *exclude) { 2272find_dir (maptile *m, int x, int y, object *exclude)
2273{
2274 int
2275 i,
2096 int i,max=SIZEOFFREE, mflags; 2276 max = SIZEOFFREE, mflags;
2277
2097 sint16 nx, ny; 2278 sint16 nx, ny;
2098 object *tmp; 2279 object *
2099 mapstruct *mp; 2280 tmp;
2281 maptile *
2282 mp;
2283
2100 MoveType blocked, move_type; 2284 MoveType blocked, move_type;
2101 2285
2102 if (exclude && exclude->head) { 2286 if (exclude && exclude->head)
2287 {
2103 exclude = exclude->head; 2288 exclude = exclude->head;
2104 move_type = exclude->move_type; 2289 move_type = exclude->move_type;
2105 } else { 2290 }
2291 else
2292 {
2106 /* If we don't have anything, presume it can use all movement types. */ 2293 /* If we don't have anything, presume it can use all movement types. */
2107 move_type=MOVE_ALL; 2294 move_type = MOVE_ALL;
2295 }
2296
2297 for (i = 1; i < max; i++)
2108 } 2298 {
2109
2110 for(i=1;i<max;i++) {
2111 mp = m; 2299 mp = m;
2112 nx = x + freearr_x[i]; 2300 nx = x + freearr_x[i];
2113 ny = y + freearr_y[i]; 2301 ny = y + freearr_y[i];
2114 2302
2115 mflags = get_map_flags(m, &mp, nx, ny, &nx, &ny); 2303 mflags = get_map_flags (m, &mp, nx, ny, &nx, &ny);
2116 if (mflags & P_OUT_OF_MAP) { 2304 if (mflags & P_OUT_OF_MAP)
2305 {
2117 max = maxfree[i]; 2306 max = maxfree[i];
2307 }
2118 } else { 2308 else
2309 {
2119 blocked = GET_MAP_MOVE_BLOCK(mp, nx, ny); 2310 blocked = GET_MAP_MOVE_BLOCK (mp, nx, ny);
2120 2311
2121 if ((move_type & blocked) == move_type) { 2312 if ((move_type & blocked) == move_type)
2313 {
2122 max=maxfree[i]; 2314 max = maxfree[i];
2315 }
2123 } else if (mflags & P_IS_ALIVE) { 2316 else if (mflags & P_IS_ALIVE)
2317 {
2124 for (tmp=GET_MAP_OB(mp,nx,ny); tmp!= NULL; tmp=tmp->above) { 2318 for (tmp = GET_MAP_OB (mp, nx, ny); tmp != NULL; tmp = tmp->above)
2125 if ((QUERY_FLAG(tmp,FLAG_MONSTER) || tmp->type==PLAYER) && 2319 {
2126 (tmp != exclude ||(tmp->head && tmp->head != exclude))) { 2320 if ((QUERY_FLAG (tmp, FLAG_MONSTER) || tmp->type == PLAYER) && (tmp != exclude || (tmp->head && tmp->head != exclude)))
2321 {
2127 break; 2322 break;
2128 } 2323 }
2129 } 2324 }
2130 if(tmp) { 2325 if (tmp)
2326 {
2131 return freedir[i]; 2327 return freedir[i];
2132 } 2328 }
2133 } 2329 }
2134 } 2330 }
2135 } 2331 }
2136 return 0; 2332 return 0;
2137} 2333}
2138 2334
2139/* 2335/*
2140 * distance(object 1, object 2) will return the square of the 2336 * distance(object 1, object 2) will return the square of the
2141 * distance between the two given objects. 2337 * distance between the two given objects.
2142 */ 2338 */
2143 2339
2340int
2144int distance(const object *ob1, const object *ob2) { 2341distance (const object *ob1, const object *ob2)
2342{
2145 int i; 2343 int
2146 i= (ob1->x - ob2->x)*(ob1->x - ob2->x)+ 2344 i;
2147 (ob1->y - ob2->y)*(ob1->y - ob2->y); 2345
2346 i = (ob1->x - ob2->x) * (ob1->x - ob2->x) + (ob1->y - ob2->y) * (ob1->y - ob2->y);
2148 return i; 2347 return i;
2149} 2348}
2150 2349
2151/* 2350/*
2152 * find_dir_2(delta-x,delta-y) will return a direction in which 2351 * find_dir_2(delta-x,delta-y) will return a direction in which
2153 * an object which has subtracted the x and y coordinates of another 2352 * an object which has subtracted the x and y coordinates of another
2154 * object, needs to travel toward it. 2353 * object, needs to travel toward it.
2155 */ 2354 */
2156 2355
2356int
2157int find_dir_2(int x, int y) { 2357find_dir_2 (int x, int y)
2358{
2158 int q; 2359 int
2360 q;
2159 2361
2160 if(y) 2362 if (y)
2161 q=x*100/y; 2363 q = x * 100 / y;
2162 else if (x) 2364 else if (x)
2163 q= -300*x; 2365 q = -300 * x;
2164 else 2366 else
2165 return 0; 2367 return 0;
2166 2368
2167 if(y>0) { 2369 if (y > 0)
2370 {
2168 if(q < -242) 2371 if (q < -242)
2169 return 3 ; 2372 return 3;
2170 if (q < -41) 2373 if (q < -41)
2171 return 2 ; 2374 return 2;
2172 if (q < 41) 2375 if (q < 41)
2173 return 1 ; 2376 return 1;
2174 if (q < 242) 2377 if (q < 242)
2175 return 8 ; 2378 return 8;
2176 return 7 ; 2379 return 7;
2177 } 2380 }
2178 2381
2179 if (q < -242) 2382 if (q < -242)
2180 return 7 ; 2383 return 7;
2181 if (q < -41) 2384 if (q < -41)
2182 return 6 ; 2385 return 6;
2183 if (q < 41) 2386 if (q < 41)
2184 return 5 ; 2387 return 5;
2185 if (q < 242) 2388 if (q < 242)
2186 return 4 ; 2389 return 4;
2187 2390
2188 return 3 ; 2391 return 3;
2189} 2392}
2190 2393
2191/* 2394/*
2192 * absdir(int): Returns a number between 1 and 8, which represent 2395 * absdir(int): Returns a number between 1 and 8, which represent
2193 * the "absolute" direction of a number (it actually takes care of 2396 * the "absolute" direction of a number (it actually takes care of
2194 * "overflow" in previous calculations of a direction). 2397 * "overflow" in previous calculations of a direction).
2195 */ 2398 */
2196 2399
2400int
2197int absdir(int d) { 2401absdir (int d)
2198 while(d<1) d+=8; 2402{
2199 while(d>8) d-=8; 2403 while (d < 1)
2404 d += 8;
2405 while (d > 8)
2406 d -= 8;
2200 return d; 2407 return d;
2201} 2408}
2202 2409
2203/* 2410/*
2204 * dirdiff(dir1, dir2) returns how many 45-degrees differences there is 2411 * dirdiff(dir1, dir2) returns how many 45-degrees differences there is
2205 * between two directions (which are expected to be absolute (see absdir()) 2412 * between two directions (which are expected to be absolute (see absdir())
2206 */ 2413 */
2207 2414
2415int
2208int dirdiff(int dir1, int dir2) { 2416dirdiff (int dir1, int dir2)
2417{
2209 int d; 2418 int
2419 d;
2420
2210 d = abs(dir1 - dir2); 2421 d = abs (dir1 - dir2);
2211 if(d>4) 2422 if (d > 4)
2212 d = 8 - d; 2423 d = 8 - d;
2213 return d; 2424 return d;
2214} 2425}
2215 2426
2216/* peterm: 2427/* peterm:
… …
2221 * direction 4, 14, or 16 to get back to where we are. 2432 * direction 4, 14, or 16 to get back to where we are.
2222 * Moved from spell_util.c to object.c with the other related direction 2433 * Moved from spell_util.c to object.c with the other related direction
2223 * functions. 2434 * functions.
2224 */ 2435 */
2225 2436
2437int
2226int reduction_dir[SIZEOFFREE][3] = { 2438 reduction_dir[SIZEOFFREE][3] = {
2227 {0,0,0}, /* 0 */ 2439 {0, 0, 0}, /* 0 */
2228 {0,0,0}, /* 1 */ 2440 {0, 0, 0}, /* 1 */
2229 {0,0,0}, /* 2 */ 2441 {0, 0, 0}, /* 2 */
2230 {0,0,0}, /* 3 */ 2442 {0, 0, 0}, /* 3 */
2231 {0,0,0}, /* 4 */ 2443 {0, 0, 0}, /* 4 */
2232 {0,0,0}, /* 5 */ 2444 {0, 0, 0}, /* 5 */
2233 {0,0,0}, /* 6 */ 2445 {0, 0, 0}, /* 6 */
2234 {0,0,0}, /* 7 */ 2446 {0, 0, 0}, /* 7 */
2235 {0,0,0}, /* 8 */ 2447 {0, 0, 0}, /* 8 */
2236 {8,1,2}, /* 9 */ 2448 {8, 1, 2}, /* 9 */
2237 {1,2,-1}, /* 10 */ 2449 {1, 2, -1}, /* 10 */
2238 {2,10,12}, /* 11 */ 2450 {2, 10, 12}, /* 11 */
2239 {2,3,-1}, /* 12 */ 2451 {2, 3, -1}, /* 12 */
2240 {2,3,4}, /* 13 */ 2452 {2, 3, 4}, /* 13 */
2241 {3,4,-1}, /* 14 */ 2453 {3, 4, -1}, /* 14 */
2242 {4,14,16}, /* 15 */ 2454 {4, 14, 16}, /* 15 */
2243 {5,4,-1}, /* 16 */ 2455 {5, 4, -1}, /* 16 */
2244 {4,5,6}, /* 17 */ 2456 {4, 5, 6}, /* 17 */
2245 {6,5,-1}, /* 18 */ 2457 {6, 5, -1}, /* 18 */
2246 {6,20,18}, /* 19 */ 2458 {6, 20, 18}, /* 19 */
2247 {7,6,-1}, /* 20 */ 2459 {7, 6, -1}, /* 20 */
2248 {6,7,8}, /* 21 */ 2460 {6, 7, 8}, /* 21 */
2249 {7,8,-1}, /* 22 */ 2461 {7, 8, -1}, /* 22 */
2250 {8,22,24}, /* 23 */ 2462 {8, 22, 24}, /* 23 */
2251 {8,1,-1}, /* 24 */ 2463 {8, 1, -1}, /* 24 */
2252 {24,9,10}, /* 25 */ 2464 {24, 9, 10}, /* 25 */
2253 {9,10,-1}, /* 26 */ 2465 {9, 10, -1}, /* 26 */
2254 {10,11,-1}, /* 27 */ 2466 {10, 11, -1}, /* 27 */
2255 {27,11,29}, /* 28 */ 2467 {27, 11, 29}, /* 28 */
2256 {11,12,-1}, /* 29 */ 2468 {11, 12, -1}, /* 29 */
2257 {12,13,-1}, /* 30 */ 2469 {12, 13, -1}, /* 30 */
2258 {12,13,14}, /* 31 */ 2470 {12, 13, 14}, /* 31 */
2259 {13,14,-1}, /* 32 */ 2471 {13, 14, -1}, /* 32 */
2260 {14,15,-1}, /* 33 */ 2472 {14, 15, -1}, /* 33 */
2261 {33,15,35}, /* 34 */ 2473 {33, 15, 35}, /* 34 */
2262 {16,15,-1}, /* 35 */ 2474 {16, 15, -1}, /* 35 */
2263 {17,16,-1}, /* 36 */ 2475 {17, 16, -1}, /* 36 */
2264 {18,17,16}, /* 37 */ 2476 {18, 17, 16}, /* 37 */
2265 {18,17,-1}, /* 38 */ 2477 {18, 17, -1}, /* 38 */
2266 {18,19,-1}, /* 39 */ 2478 {18, 19, -1}, /* 39 */
2267 {41,19,39}, /* 40 */ 2479 {41, 19, 39}, /* 40 */
2268 {19,20,-1}, /* 41 */ 2480 {19, 20, -1}, /* 41 */
2269 {20,21,-1}, /* 42 */ 2481 {20, 21, -1}, /* 42 */
2270 {20,21,22}, /* 43 */ 2482 {20, 21, 22}, /* 43 */
2271 {21,22,-1}, /* 44 */ 2483 {21, 22, -1}, /* 44 */
2272 {23,22,-1}, /* 45 */ 2484 {23, 22, -1}, /* 45 */
2273 {45,47,23}, /* 46 */ 2485 {45, 47, 23}, /* 46 */
2274 {23,24,-1}, /* 47 */ 2486 {23, 24, -1}, /* 47 */
2275 {24,9,-1}}; /* 48 */ 2487 {24, 9, -1}
2488}; /* 48 */
2276 2489
2277/* Recursive routine to step back and see if we can 2490/* Recursive routine to step back and see if we can
2278 * find a path to that monster that we found. If not, 2491 * find a path to that monster that we found. If not,
2279 * we don't bother going toward it. Returns 1 if we 2492 * we don't bother going toward it. Returns 1 if we
2280 * can see a direct way to get it 2493 * can see a direct way to get it
2281 * Modified to be map tile aware -.MSW 2494 * Modified to be map tile aware -.MSW
2282 */ 2495 */
2283
2284 2496
2497
2498int
2285int can_see_monsterP(mapstruct *m, int x, int y,int dir) { 2499can_see_monsterP (maptile *m, int x, int y, int dir)
2500{
2286 sint16 dx, dy; 2501 sint16 dx, dy;
2502 int
2287 int mflags; 2503 mflags;
2288 2504
2505 if (dir < 0)
2289 if(dir<0) return 0; /* exit condition: invalid direction */ 2506 return 0; /* exit condition: invalid direction */
2290 2507
2291 dx = x + freearr_x[dir]; 2508 dx = x + freearr_x[dir];
2292 dy = y + freearr_y[dir]; 2509 dy = y + freearr_y[dir];
2293 2510
2294 mflags = get_map_flags(m, &m, dx, dy, &dx, &dy); 2511 mflags = get_map_flags (m, &m, dx, dy, &dx, &dy);
2295 2512
2296 /* This functional arguably was incorrect before - it was 2513 /* This functional arguably was incorrect before - it was
2297 * checking for P_WALL - that was basically seeing if 2514 * checking for P_WALL - that was basically seeing if
2298 * we could move to the monster - this is being more 2515 * we could move to the monster - this is being more
2299 * literal on if we can see it. To know if we can actually 2516 * literal on if we can see it. To know if we can actually
2300 * move to the monster, we'd need the monster passed in or 2517 * move to the monster, we'd need the monster passed in or
2301 * at least its move type. 2518 * at least its move type.
2302 */ 2519 */
2303 if (mflags & (P_OUT_OF_MAP | P_BLOCKSVIEW)) return 0; 2520 if (mflags & (P_OUT_OF_MAP | P_BLOCKSVIEW))
2521 return 0;
2304 2522
2305 /* yes, can see. */ 2523 /* yes, can see. */
2306 if(dir < 9) return 1; 2524 if (dir < 9)
2525 return 1;
2307 return can_see_monsterP(m, x, y, reduction_dir[dir][0]) | 2526 return can_see_monsterP (m, x, y, reduction_dir[dir][0]) |
2308 can_see_monsterP(m,x,y, reduction_dir[dir][1]) | 2527 can_see_monsterP (m, x, y, reduction_dir[dir][1]) | can_see_monsterP (m, x, y, reduction_dir[dir][2]);
2309 can_see_monsterP(m,x,y, reduction_dir[dir][2]);
2310} 2528}
2311 2529
2312 2530
2313 2531
2314/* 2532/*
2315 * can_pick(picker, item): finds out if an object is possible to be 2533 * can_pick(picker, item): finds out if an object is possible to be
2316 * picked up by the picker. Returnes 1 if it can be 2534 * picked up by the picker. Returnes 1 if it can be
2317 * picked up, otherwise 0. 2535 * picked up, otherwise 0.
2318 * 2536 *
… …
2320 * core dumps if they do. 2538 * core dumps if they do.
2321 * 2539 *
2322 * Add a check so we can't pick up invisible objects (0.93.8) 2540 * Add a check so we can't pick up invisible objects (0.93.8)
2323 */ 2541 */
2324 2542
2543int
2325int can_pick(const object *who, const object *item) { 2544can_pick (const object *who, const object *item)
2545{
2326 return /*QUERY_FLAG(who,FLAG_WIZ)||*/ 2546 return /*QUERY_FLAG(who,FLAG_WIZ)|| */
2327 (item->weight>0&&!QUERY_FLAG(item,FLAG_NO_PICK)&& 2547 (item->weight > 0 && !QUERY_FLAG (item, FLAG_NO_PICK) &&
2328 !QUERY_FLAG(item,FLAG_ALIVE)&&!item->invisible && 2548 !QUERY_FLAG (item, FLAG_ALIVE) && !item->invisible && (who->type == PLAYER || item->weight < who->weight / 3));
2329 (who->type==PLAYER||item->weight<who->weight/3));
2330} 2549}
2331 2550
2332 2551
2333/* 2552/*
2334 * create clone from object to another 2553 * create clone from object to another
2335 */ 2554 */
2555object *
2336object *object_create_clone (object *asrc) { 2556object_create_clone (object *asrc)
2557{
2558 object *
2337 object *dst = NULL,*tmp,*src,*part,*prev, *item; 2559 dst = NULL, *tmp, *src, *part, *prev, *item;
2338 2560
2561 if (!asrc)
2339 if(!asrc) return NULL; 2562 return NULL;
2340 src = asrc; 2563 src = asrc;
2341 if(src->head) 2564 if (src->head)
2342 src = src->head; 2565 src = src->head;
2343 2566
2344 prev = NULL; 2567 prev = NULL;
2345 for(part = src; part; part = part->more) { 2568 for (part = src; part; part = part->more)
2569 {
2346 tmp = get_object(); 2570 tmp = get_object ();
2347 copy_object(part,tmp); 2571 copy_object (part, tmp);
2348 tmp->x -= src->x; 2572 tmp->x -= src->x;
2349 tmp->y -= src->y; 2573 tmp->y -= src->y;
2350 if(!part->head) { 2574 if (!part->head)
2575 {
2351 dst = tmp; 2576 dst = tmp;
2352 tmp->head = NULL; 2577 tmp->head = NULL;
2578 }
2353 } else { 2579 else
2580 {
2354 tmp->head = dst; 2581 tmp->head = dst;
2355 } 2582 }
2356 tmp->more = NULL; 2583 tmp->more = NULL;
2357 if(prev) 2584 if (prev)
2358 prev->more = tmp; 2585 prev->more = tmp;
2359 prev = tmp; 2586 prev = tmp;
2360 } 2587 }
2361 /*** copy inventory ***/ 2588
2362 for(item = src->inv; item; item = item->below) { 2589 for (item = src->inv; item; item = item->below)
2363 (void) insert_ob_in_ob(object_create_clone(item),dst); 2590 insert_ob_in_ob (object_create_clone (item), dst);
2364 }
2365 2591
2366 return dst; 2592 return dst;
2367}
2368
2369/* return true if the object was destroyed, 0 otherwise */
2370int was_destroyed (const object *op, tag_t old_tag)
2371{
2372 /* checking for FLAG_FREED isn't necessary, but makes this function more
2373 * robust */
2374 return op->count != old_tag || QUERY_FLAG (op, FLAG_FREED);
2375} 2593}
2376 2594
2377/* GROS - Creates an object using a string representing its content. */ 2595/* GROS - Creates an object using a string representing its content. */
2378/* Basically, we save the content of the string to a temp file, then call */ 2596/* Basically, we save the content of the string to a temp file, then call */
2379/* load_object on it. I admit it is a highly inefficient way to make things, */ 2597/* load_object on it. I admit it is a highly inefficient way to make things, */
2380/* but it was simple to make and allows reusing the load_object function. */ 2598/* but it was simple to make and allows reusing the load_object function. */
2381/* Remember not to use load_object_str in a time-critical situation. */ 2599/* Remember not to use load_object_str in a time-critical situation. */
2382/* Also remember that multiparts objects are not supported for now. */ 2600/* Also remember that multiparts objects are not supported for now. */
2383 2601
2602object *
2384object* load_object_str(const char *obstr) 2603load_object_str (const char *obstr)
2385{ 2604{
2386 object *op; 2605 object *op;
2387 char filename[MAX_BUF]; 2606 char filename[MAX_BUF];
2607
2388 sprintf(filename,"%s/cfloadobstr2044",settings.tmpdir); 2608 sprintf (filename, "%s/cfloadobstr2044", settings.tmpdir);
2389 2609
2390 FILE *tempfile=fopen(filename,"w"); 2610 FILE *tempfile = fopen (filename, "w");
2611
2391 if (tempfile == NULL) 2612 if (tempfile == NULL)
2392 { 2613 {
2393 LOG(llevError,"Error - Unable to access load object temp file\n"); 2614 LOG (llevError, "Error - Unable to access load object temp file\n");
2394 return NULL; 2615 return NULL;
2395 }; 2616 }
2617
2396 fprintf(tempfile,obstr); 2618 fprintf (tempfile, obstr);
2397 fclose(tempfile); 2619 fclose (tempfile);
2398 2620
2399 op=get_object(); 2621 op = get_object ();
2400 2622
2401 object_thawer thawer (filename); 2623 object_thawer thawer (filename);
2402 2624
2403 if (thawer) 2625 if (thawer)
2404 load_object(thawer,op,0); 2626 load_object (thawer, op, 0);
2405 2627
2406 LOG(llevDebug," load str completed, object=%s\n", &op->name); 2628 LOG (llevDebug, " load str completed, object=%s\n", &op->name);
2407 CLEAR_FLAG(op,FLAG_REMOVED); 2629 CLEAR_FLAG (op, FLAG_REMOVED);
2408 2630
2409 return op; 2631 return op;
2410} 2632}
2411 2633
2412/* This returns the first object in who's inventory that 2634/* This returns the first object in who's inventory that
2413 * has the same type and subtype match. 2635 * has the same type and subtype match.
2414 * returns NULL if no match. 2636 * returns NULL if no match.
2415 */ 2637 */
2638object *
2416object *find_obj_by_type_subtype(const object *who, int type, int subtype) 2639find_obj_by_type_subtype (const object *who, int type, int subtype)
2417{ 2640{
2418 object *tmp; 2641 object *tmp;
2419 2642
2420 for (tmp=who->inv; tmp; tmp=tmp->below) 2643 for (tmp = who->inv; tmp; tmp = tmp->below)
2421 if (tmp->type == type && tmp->subtype == subtype) return tmp; 2644 if (tmp->type == type && tmp->subtype == subtype)
2645 return tmp;
2422 2646
2423 return NULL; 2647 return NULL;
2424} 2648}
2425 2649
2426/* If ob has a field named key, return the link from the list, 2650/* If ob has a field named key, return the link from the list,
2427 * otherwise return NULL. 2651 * otherwise return NULL.
2428 * 2652 *
2429 * key must be a passed in shared string - otherwise, this won't 2653 * key must be a passed in shared string - otherwise, this won't
2430 * do the desired thing. 2654 * do the desired thing.
2431 */ 2655 */
2656key_value *
2432key_value * get_ob_key_link(const object * ob, const char * key) { 2657get_ob_key_link (const object *ob, const char *key)
2658{
2433 key_value * link; 2659 key_value *link;
2434 2660
2435 for (link = ob->key_values; link != NULL; link = link->next) { 2661 for (link = ob->key_values; link != NULL; link = link->next)
2436 if (link->key == key) { 2662 if (link->key == key)
2437 return link; 2663 return link;
2438 } 2664
2439 }
2440
2441 return NULL; 2665 return NULL;
2442} 2666}
2443 2667
2444/* 2668/*
2445 * Returns the value of op has an extra_field for key, or NULL. 2669 * Returns the value of op has an extra_field for key, or NULL.
2446 * 2670 *
2447 * The argument doesn't need to be a shared string. 2671 * The argument doesn't need to be a shared string.
2448 * 2672 *
2449 * The returned string is shared. 2673 * The returned string is shared.
2450 */ 2674 */
2675const char *
2451const char * get_ob_key_value(const object * op, const char * const key) { 2676get_ob_key_value (const object *op, const char *const key)
2677{
2452 key_value * link; 2678 key_value *link;
2453 const char * canonical_key; 2679 shstr_cmp canonical_key (key);
2680
2681 if (!canonical_key)
2454 2682 {
2455 canonical_key = shstr::find (key);
2456
2457 if (canonical_key == NULL) {
2458 /* 1. There being a field named key on any object 2683 /* 1. There being a field named key on any object
2459 * implies there'd be a shared string to find. 2684 * implies there'd be a shared string to find.
2460 * 2. Since there isn't, no object has this field. 2685 * 2. Since there isn't, no object has this field.
2461 * 3. Therefore, *this* object doesn't have this field. 2686 * 3. Therefore, *this* object doesn't have this field.
2462 */ 2687 */
2463 return NULL; 2688 return 0;
2464 } 2689 }
2465 2690
2466 /* This is copied from get_ob_key_link() above - 2691 /* This is copied from get_ob_key_link() above -
2467 * only 4 lines, and saves the function call overhead. 2692 * only 4 lines, and saves the function call overhead.
2468 */ 2693 */
2469 for (link = op->key_values; link != NULL; link = link->next) { 2694 for (link = op->key_values; link; link = link->next)
2470 if (link->key == canonical_key) { 2695 if (link->key == canonical_key)
2471 return link->value; 2696 return link->value;
2472 } 2697
2473 } 2698 return 0;
2474 return NULL;
2475} 2699}
2476 2700
2477 2701
2478/* 2702/*
2479 * Updates the canonical_key in op to value. 2703 * Updates the canonical_key in op to value.
… …
2483 * Unless add_key is TRUE, it won't add fields, only change the value of existing 2707 * Unless add_key is TRUE, it won't add fields, only change the value of existing
2484 * keys. 2708 * keys.
2485 * 2709 *
2486 * Returns TRUE on success. 2710 * Returns TRUE on success.
2487 */ 2711 */
2712int
2488int set_ob_key_value_s(object * op, const shstr &canonical_key, const char * value, int add_key) { 2713set_ob_key_value_s (object *op, const shstr & canonical_key, const char *value, int add_key)
2714{
2715 key_value *
2489 key_value * field = NULL, *last=NULL; 2716 field = NULL, *last = NULL;
2490 2717
2491 for (field=op->key_values; field != NULL; field=field->next) { 2718 for (field = op->key_values; field != NULL; field = field->next)
2719 {
2492 if (field->key != canonical_key) { 2720 if (field->key != canonical_key)
2721 {
2493 last = field; 2722 last = field;
2494 continue; 2723 continue;
2495 } 2724 }
2496 2725
2497 if (value) 2726 if (value)
2498 field->value = value; 2727 field->value = value;
2499 else { 2728 else
2729 {
2500 /* Basically, if the archetype has this key set, 2730 /* Basically, if the archetype has this key set,
2501 * we need to store the null value so when we save 2731 * we need to store the null value so when we save
2502 * it, we save the empty value so that when we load, 2732 * it, we save the empty value so that when we load,
2503 * we get this value back again. 2733 * we get this value back again.
2504 */ 2734 */
2505 if (get_ob_key_link (&op->arch->clone, canonical_key)) 2735 if (get_ob_key_link (&op->arch->clone, canonical_key))
2506 field->value = 0; 2736 field->value = 0;
2737 else
2738 {
2739 if (last)
2740 last->next = field->next;
2507 else 2741 else
2508 {
2509 if (last) last->next = field->next;
2510 else op->key_values = field->next; 2742 op->key_values = field->next;
2511 2743
2512 delete field; 2744 delete field;
2513 } 2745 }
2514 } 2746 }
2515 return TRUE; 2747 return TRUE;
2516 } 2748 }
2517 /* IF we get here, key doesn't exist */ 2749 /* IF we get here, key doesn't exist */
2518 2750
2519 /* No field, we'll have to add it. */ 2751 /* No field, we'll have to add it. */
2752
2753 if (!add_key)
2520 2754 {
2521 if (!add_key) {
2522 return FALSE; 2755 return FALSE;
2523 } 2756 }
2524 /* There isn't any good reason to store a null 2757 /* There isn't any good reason to store a null
2525 * value in the key/value list. If the archetype has 2758 * value in the key/value list. If the archetype has
2526 * this key, then we should also have it, so shouldn't 2759 * this key, then we should also have it, so shouldn't
2527 * be here. If user wants to store empty strings, 2760 * be here. If user wants to store empty strings,
2528 * should pass in "" 2761 * should pass in ""
2529 */ 2762 */
2530 if (value == NULL) return TRUE; 2763 if (value == NULL)
2531
2532 field = new key_value;
2533
2534 field->key = canonical_key;
2535 field->value = value;
2536 /* Usual prepend-addition. */
2537 field->next = op->key_values;
2538 op->key_values = field;
2539
2540 return TRUE; 2764 return TRUE;
2765
2766 field = new key_value;
2767
2768 field->key = canonical_key;
2769 field->value = value;
2770 /* Usual prepend-addition. */
2771 field->next = op->key_values;
2772 op->key_values = field;
2773
2774 return TRUE;
2541} 2775}
2542 2776
2543/* 2777/*
2544 * Updates the key in op to value. 2778 * Updates the key in op to value.
2545 * 2779 *
… …
2547 * and not add new ones. 2781 * and not add new ones.
2548 * In general, should be little reason FALSE is ever passed in for add_key 2782 * In general, should be little reason FALSE is ever passed in for add_key
2549 * 2783 *
2550 * Returns TRUE on success. 2784 * Returns TRUE on success.
2551 */ 2785 */
2786int
2552int set_ob_key_value(object * op, const char *key, const char * value, int add_key) 2787set_ob_key_value (object *op, const char *key, const char *value, int add_key)
2553{ 2788{
2554 shstr key_ (key); 2789 shstr key_ (key);
2790
2555 return set_ob_key_value_s (op, key_, value, add_key); 2791 return set_ob_key_value_s (op, key_, value, add_key);
2556} 2792}
2793
2794object::depth_iterator::depth_iterator (object *container)
2795: iterator_base (container)
2796{
2797 while (item->inv)
2798 item = item->inv;
2799}
2800
2801void
2802object::depth_iterator::next ()
2803{
2804 if (item->below)
2805 {
2806 item = item->below;
2807
2808 while (item->inv)
2809 item = item->inv;
2810 }
2811 else
2812 item = item->env;
2813}
2814
2815// return a suitable string describing an objetc in enough detail to find it
2816const char *
2817object::debug_desc (char *info) const
2818{
2819 char info2[256 * 3];
2820 char *p = info;
2821
2822 p += snprintf (p, 256, "%d=\"%s%s%s\"",
2823 count,
2824 &name,
2825 title ? " " : "",
2826 title ? (const char *)title : "");
2827
2828 if (env)
2829 p += snprintf (p, 256, "(in %s)", env->debug_desc (info2));
2830
2831 if (map)
2832 p += snprintf (p, 256, "(on %s@%d+%d)", map->path, x, y);
2833
2834 return info;
2835}
2836
2837const char *
2838object::debug_desc () const
2839{
2840 static char info[256 * 3];
2841 return debug_desc (info);
2842}
2843

Diff Legend

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