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.21 by root, Sat Sep 9 21:48:28 2006 UTC vs.
Revision 1.54 by root, Fri Nov 17 19:40:53 2006 UTC

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

Diff Legend

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