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.206 by root, Tue Apr 15 14:21:04 2008 UTC vs.
Revision 1.256 by root, Sun Aug 31 05:47:14 2008 UTC

1/* 1/*
2 * This file is part of Deliantra, the Roguelike Realtime MMORPG. 2 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
3 * 3 *
4 * Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Deliantra team 4 * Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5 * Copyright (©) 2001,2007 Mark Wedel & Crossfire Development Team 5 * Copyright (©) 2001,2007 Mark Wedel & Crossfire Development Team
6 * Copyright (©) 1992,2007 Frank Tore Johansen 6 * Copyright (©) 1992,2007 Frank Tore Johansen
7 * 7 *
8 * Deliantra is free software: you can redistribute it and/or modify 8 * Deliantra is free software: you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by 9 * it under the terms of the GNU General Public License as published by
19 * along with this program. If not, see <http://www.gnu.org/licenses/>. 19 * along with this program. If not, see <http://www.gnu.org/licenses/>.
20 * 20 *
21 * The authors can be reached via e-mail to <support@deliantra.net> 21 * The authors can be reached via e-mail to <support@deliantra.net>
22 */ 22 */
23 23
24/* Eneq(@csd.uu.se): Added weight-modifiers in environment of objects.
25 sub/add_weight will transcend the environment updating the carrying
26 variable. */
27#include <global.h> 24#include <global.h>
28#include <stdio.h> 25#include <stdio.h>
29#include <sys/types.h> 26#include <sys/types.h>
30#include <sys/uio.h> 27#include <sys/uio.h>
31#include <object.h> 28#include <object.h>
32#include <funcpoint.h>
33#include <sproto.h> 29#include <sproto.h>
34#include <loader.h> 30#include <loader.h>
35 31
36#include <bitset> 32#include <bitset>
37 33
143 139
144/* Returns TRUE if every key_values in wants has a partner with the same value in has. */ 140/* Returns TRUE if every key_values in wants has a partner with the same value in has. */
145static bool 141static bool
146compare_ob_value_lists_one (const object *wants, const object *has) 142compare_ob_value_lists_one (const object *wants, const object *has)
147{ 143{
148 key_value *wants_field;
149
150 /* n-squared behaviour (see get_ob_key_link()), but I'm hoping both 144 /* n-squared behaviour (see kv_get), but I'm hoping both
151 * objects with lists are rare, and lists stay short. If not, use a 145 * objects with lists are rare, and lists stay short. If not, use a
152 * different structure or at least keep the lists sorted... 146 * different structure or at least keep the lists sorted...
153 */ 147 */
154 148
155 /* For each field in wants, */ 149 /* For each field in wants, */
156 for (wants_field = wants->key_values; wants_field; wants_field = wants_field->next) 150 for (key_value *kv = wants->key_values; kv; kv = kv->next)
157 { 151 if (has->kv_get (kv->key) != kv->value)
158 key_value *has_field; 152 return false;
159
160 /* Look for a field in has with the same key. */
161 has_field = get_ob_key_link (has, wants_field->key);
162
163 if (!has_field)
164 return 0; /* No field with that name. */
165
166 /* Found the matching field. */
167 if (has_field->value != wants_field->value)
168 return 0; /* Values don't match, so this half of the comparison is false. */
169
170 /* If we get here, we found a match. Now for the next field in wants. */
171 }
172 153
173 /* If we get here, every field in wants has a matching field in has. */ 154 /* If we get here, every field in wants has a matching field in has. */
174 return 1; 155 return true;
175} 156}
176 157
177/* Returns TRUE if ob1 has the same key_values as ob2. */ 158/* Returns TRUE if ob1 has the same key_values as ob2. */
178static bool 159static bool
179compare_ob_value_lists (const object *ob1, const object *ob2) 160compare_ob_value_lists (const object *ob1, const object *ob2)
180{ 161{
181 /* However, there may be fields in has which aren't partnered in wants, 162 /* However, there may be fields in has which aren't partnered in wants,
182 * so we need to run the comparison *twice*. :( 163 * so we need to run the comparison *twice*. :(
183 */ 164 */
184 return compare_ob_value_lists_one (ob1, ob2) && compare_ob_value_lists_one (ob2, ob1); 165 return compare_ob_value_lists_one (ob1, ob2)
166 && compare_ob_value_lists_one (ob2, ob1);
185} 167}
186 168
187/* Function examines the 2 objects given to it, and returns true if 169/* Function examines the 2 objects given to it, and returns true if
188 * they can be merged together. 170 * they can be merged together.
189 * 171 *
204 || ob1->speed != ob2->speed 186 || ob1->speed != ob2->speed
205 || ob1->value != ob2->value 187 || ob1->value != ob2->value
206 || ob1->name != ob2->name) 188 || ob1->name != ob2->name)
207 return 0; 189 return 0;
208 190
209 /* Do not merge objects if nrof would overflow. First part checks 191 /* Do not merge objects if nrof would overflow, assume nrof
210 * for unsigned overflow (2c), second part checks wether the result 192 * is always 0 .. 2**31-1 */
211 * would fit into a 32 bit signed int, which is often used to hold 193 if (ob1->nrof > 0x7fffffff - ob2->nrof)
212 * nrof values.
213 */
214 if (~ob1->nrof < ob2->nrof || ob1->nrof + ob2->nrof > (1UL << 31))
215 return 0; 194 return 0;
216 195
217 /* If the objects have been identified, set the BEEN_APPLIED flag. 196 /* If the objects have been identified, set the BEEN_APPLIED flag.
218 * This is to the comparison of the flags below will be OK. We 197 * This is to the comparison of the flags below will be OK. We
219 * just can't ignore the been applied or identified flags, as they 198 * just can't ignore the been applied or identified flags, as they
224 SET_FLAG (ob1, FLAG_BEEN_APPLIED); 203 SET_FLAG (ob1, FLAG_BEEN_APPLIED);
225 204
226 if (QUERY_FLAG (ob2, FLAG_IDENTIFIED)) 205 if (QUERY_FLAG (ob2, FLAG_IDENTIFIED))
227 SET_FLAG (ob2, FLAG_BEEN_APPLIED); 206 SET_FLAG (ob2, FLAG_BEEN_APPLIED);
228 207
229 if ((ob1->flag ^ ob2->flag).reset (FLAG_INV_LOCKED).reset (FLAG_CLIENT_SENT).any () 208 if (ob1->arch->archname != ob2->arch->archname
230 || ob1->arch != ob2->arch
231 || ob1->name != ob2->name 209 || ob1->name != ob2->name
232 || ob1->title != ob2->title 210 || ob1->title != ob2->title
233 || ob1->msg != ob2->msg 211 || ob1->msg != ob2->msg
234 || ob1->weight != ob2->weight 212 || ob1->weight != ob2->weight
235 || memcmp (&ob1->resist, &ob2->resist, sizeof (ob1->resist))
236 || memcmp (&ob1->stats , &ob2->stats , sizeof (ob1->stats) )
237 || ob1->attacktype != ob2->attacktype 213 || ob1->attacktype != ob2->attacktype
238 || ob1->magic != ob2->magic 214 || ob1->magic != ob2->magic
239 || ob1->slaying != ob2->slaying 215 || ob1->slaying != ob2->slaying
240 || ob1->skill != ob2->skill 216 || ob1->skill != ob2->skill
241 || ob1->value != ob2->value 217 || ob1->value != ob2->value
242 || ob1->animation_id != ob2->animation_id 218 || ob1->animation_id != ob2->animation_id
219 || (ob1->face != ob2->face && !ob1->animation_id) // face and animation are dependent on each other
243 || ob1->client_type != ob2->client_type 220 || ob1->client_type != ob2->client_type
244 || ob1->materialname != ob2->materialname 221 || ob1->materialname != ob2->materialname
245 || ob1->lore != ob2->lore 222 || ob1->lore != ob2->lore
246 || ob1->subtype != ob2->subtype 223 || ob1->subtype != ob2->subtype
247 || ob1->move_type != ob2->move_type 224 || ob1->move_type != ob2->move_type
248 || ob1->move_block != ob2->move_block 225 || ob1->move_block != ob2->move_block
249 || ob1->move_allow != ob2->move_allow 226 || ob1->move_allow != ob2->move_allow
250 || ob1->move_on != ob2->move_on 227 || ob1->move_on != ob2->move_on
251 || ob1->move_off != ob2->move_off 228 || ob1->move_off != ob2->move_off
252 || ob1->move_slow != ob2->move_slow 229 || ob1->move_slow != ob2->move_slow
253 || ob1->move_slow_penalty != ob2->move_slow_penalty) 230 || ob1->move_slow_penalty != ob2->move_slow_penalty
231 || memcmp (&ob1->resist, &ob2->resist, sizeof (ob1->resist))
232 || memcmp (&ob1->stats , &ob2->stats , sizeof (ob1->stats)))
233 return 0;
234
235 if ((ob1->flag ^ ob2->flag)
236 .reset (FLAG_INV_LOCKED)
237 .reset (FLAG_REMOVED)
238 .any ())
254 return 0; 239 return 0;
255 240
256 /* This is really a spellbook check - we should in general 241 /* This is really a spellbook check - we should in general
257 * not merge objects with real inventories, as splitting them 242 * not merge objects with real inventories, as splitting them
258 * is hard. 243 * is hard.
297 282
298 if (ob1->key_values || ob2->key_values) 283 if (ob1->key_values || ob2->key_values)
299 { 284 {
300 /* At least one of these has key_values. */ 285 /* At least one of these has key_values. */
301 if ((!ob1->key_values) != (!ob2->key_values)) 286 if ((!ob1->key_values) != (!ob2->key_values))
302 /* One has fields, but the other one doesn't. */ 287 return 0; /* One has fields, but the other one doesn't. */
303 return 0; 288
304 else if (!compare_ob_value_lists (ob1, ob2)) 289 if (!compare_ob_value_lists (ob1, ob2))
305 return 0; 290 return 0;
306 } 291 }
307 292
308 if (ob1->self || ob2->self) 293 if (ob1->self || ob2->self)
309 { 294 {
315 int k1 = ob1->self ? HvTOTALKEYS (ob1->self) : 0; 300 int k1 = ob1->self ? HvTOTALKEYS (ob1->self) : 0;
316 int k2 = ob2->self ? HvTOTALKEYS (ob2->self) : 0; 301 int k2 = ob2->self ? HvTOTALKEYS (ob2->self) : 0;
317 302
318 if (k1 != k2) 303 if (k1 != k2)
319 return 0; 304 return 0;
305
320 else if (k1 == 0) 306 if (k1 == 0)
321 return 1; 307 return 1;
308
322 else if (!cfperl_can_merge (ob1, ob2)) 309 if (!cfperl_can_merge (ob1, ob2))
323 return 0; 310 return 0;
324 } 311 }
325 } 312 }
326 313
327 /* Everything passes, must be OK. */ 314 /* Everything passes, must be OK. */
328 return 1; 315 return 1;
329} 316}
330 317
318// find player who can see this object
319object *
320object::visible_to () const
321{
322 if (client_visible () && !flag [FLAG_REMOVED])
323 {
324 // see if we are in a container of sorts
325 if (env)
326 {
327 // the player inventory itself is always visible
328 if (env->type == PLAYER)
329 return env;
330
331 // else a player could have our env open
332 object *envest = env->outer_env ();
333
334 // the player itself is always on a map, so we will find him here
335 // even if our inv is in a player.
336 if (envest->is_on_map ())
337 if (object *pl = envest->ms ().player ())
338 if (pl->container == env)
339 return pl;
340 }
341 else
342 {
343 // maybe there is a player standing on the same mapspace
344 // this will catch the case where "this" is a player
345 if (object *pl = ms ().player ())
346 if ((!pl->container && pl->contr->ns && !pl->contr->ns->update_look)
347 || this == pl->container)
348 return pl;
349 }
350 }
351
352 return 0;
353}
354
355// adjust weight per container type ("of holding")
356static sint32
357weight_adjust_for (object *op, sint32 weight)
358{
359 return op->type == CONTAINER
360 ? lerp (weight, 0, 100, 0, 100 - op->stats.Str)
361 : weight;
362}
363
331/* 364/*
365 * adjust_weight(object, weight) adds the specified weight to an object,
366 * and also updates how much the environment(s) is/are carrying.
367 */
368static void
369adjust_weight (object *op, sint32 weight)
370{
371 while (op)
372 {
373 // adjust by actual difference to account for rounding errors
374 // i.e. (w2 - w1) / f != w2 / f - w1 / f and the latter is correct
375 weight = weight_adjust_for (op, op->carrying)
376 - weight_adjust_for (op, op->carrying - weight);
377
378 if (!weight)
379 return;
380
381 op->carrying += weight;
382
383 if (object *pl = op->visible_to ())
384 if (pl != op) // player is handled lazily
385 esrv_update_item (UPD_WEIGHT, pl, op);
386
387 op = op->env;
388 }
389}
390
391/*
332 * sum_weight() is a recursive function which calculates the weight 392 * this is a recursive function which calculates the weight
333 * an object is carrying. It goes through in figures out how much 393 * an object is carrying. It goes through op and figures out how much
334 * containers are carrying, and sums it up. 394 * containers are carrying, and sums it up.
335 */ 395 */
336long 396void
337sum_weight (object *op) 397object::update_weight ()
338{ 398{
339 long sum; 399 sint32 sum = 0;
340 object *inv;
341 400
342 for (sum = 0, inv = op->inv; inv; inv = inv->below) 401 for (object *op = inv; op; op = op->below)
343 { 402 {
344 if (inv->inv) 403 if (op->inv)
345 sum_weight (inv); 404 op->update_weight ();
346 405
347 sum += inv->carrying + inv->weight * (inv->nrof ? inv->nrof : 1); 406 sum += op->total_weight ();
407 }
408
409 sum = weight_adjust_for (this, sum);
410
411 if (sum != carrying)
348 } 412 {
349
350 if (op->type == CONTAINER && op->stats.Str)
351 sum = (sum * (100 - op->stats.Str)) / 100;
352
353 if (op->carrying != sum)
354 op->carrying = sum; 413 carrying = sum;
355 414
356 return sum; 415 if (object *pl = visible_to ())
416 if (pl != this) // player is handled lazily
417 esrv_update_item (UPD_WEIGHT, pl, this);
418 }
357} 419}
358 420
359/** 421/*
360 * Return the outermost environment object for a given object. 422 * Used by: Server DM commands: dumpbelow, dump. Some error messages.
361 */
362
363object *
364object_get_env_recursive (object *op)
365{
366 while (op->env != NULL)
367 op = op->env;
368 return op;
369}
370
371/*
372 * Used by: Crossedit: dump. Server DM commands: dumpbelow, dump.
373 * Some error messages.
374 * The result of the dump is stored in the static global errmsg array.
375 */ 423 */
376char * 424char *
377dump_object (object *op) 425dump_object (object *op)
378{ 426{
379 if (!op) 427 if (!op)
393get_nearest_part (object *op, const object *pl) 441get_nearest_part (object *op, const object *pl)
394{ 442{
395 object *tmp, *closest; 443 object *tmp, *closest;
396 int last_dist, i; 444 int last_dist, i;
397 445
398 if (op->more == NULL) 446 if (!op->more)
399 return op; 447 return op;
448
400 for (last_dist = distance (op, pl), closest = op, tmp = op->more; tmp != NULL; tmp = tmp->more) 449 for (last_dist = distance (op, pl), closest = op, tmp = op->more;
450 tmp;
451 tmp = tmp->more)
401 if ((i = distance (tmp, pl)) < last_dist) 452 if ((i = distance (tmp, pl)) < last_dist)
402 closest = tmp, last_dist = i; 453 closest = tmp, last_dist = i;
454
403 return closest; 455 return closest;
404} 456}
405 457
406/* 458/*
407 * Returns the object which has the count-variable equal to the argument. 459 * Returns the object which has the count-variable equal to the argument.
460 * VERRRY slow.
408 */ 461 */
409object * 462object *
410find_object (tag_t i) 463find_object (tag_t i)
411{ 464{
412 for_all_objects (op) 465 for_all_objects (op)
423 */ 476 */
424object * 477object *
425find_object_name (const char *str) 478find_object_name (const char *str)
426{ 479{
427 shstr_cmp str_ (str); 480 shstr_cmp str_ (str);
428 object *op;
429 481
482 if (str_)
430 for_all_objects (op) 483 for_all_objects (op)
431 if (op->name == str_) 484 if (op->name == str_)
432 break; 485 return op;
433 486
434 return op; 487 return 0;
435} 488}
436 489
437/* 490/*
438 * Sets the owner and sets the skill and exp pointers to owner's current 491 * Sets the owner and sets the skill and exp pointers to owner's current
439 * skill and experience objects. 492 * skill and experience objects.
537 } 590 }
538 591
539 op->key_values = 0; 592 op->key_values = 0;
540} 593}
541 594
542object & 595/*
543object::operator =(const object &src) 596 * copy_to first frees everything allocated by the dst object,
597 * and then copies the contents of itself into the second
598 * object, allocating what needs to be allocated. Basically, any
599 * data that is malloc'd needs to be re-malloc/copied. Otherwise,
600 * if the first object is freed, the pointers in the new object
601 * will point at garbage.
602 */
603void
604object::copy_to (object *dst)
544{ 605{
545 bool is_freed = flag [FLAG_FREED]; 606 dst->remove ();
546 bool is_removed = flag [FLAG_REMOVED];
547
548 *(object_copy *)this = src; 607 *(object_copy *)dst = *this;
549
550 flag [FLAG_FREED] = is_freed;
551 flag [FLAG_REMOVED] = is_removed; 608 dst->flag [FLAG_REMOVED] = true;
552 609
553 /* Copy over key_values, if any. */ 610 /* Copy over key_values, if any. */
554 if (src.key_values) 611 if (key_values)
555 { 612 {
556 key_value *tail = 0; 613 key_value *tail = 0;
557 key_values = 0; 614 dst->key_values = 0;
558 615
559 for (key_value *i = src.key_values; i; i = i->next) 616 for (key_value *i = key_values; i; i = i->next)
560 { 617 {
561 key_value *new_link = new key_value; 618 key_value *new_link = new key_value;
562 619
563 new_link->next = 0; 620 new_link->next = 0;
564 new_link->key = i->key; 621 new_link->key = i->key;
565 new_link->value = i->value; 622 new_link->value = i->value;
566 623
567 /* Try and be clever here, too. */ 624 /* Try and be clever here, too. */
568 if (!key_values) 625 if (!dst->key_values)
569 { 626 {
570 key_values = new_link; 627 dst->key_values = new_link;
571 tail = new_link; 628 tail = new_link;
572 } 629 }
573 else 630 else
574 { 631 {
575 tail->next = new_link; 632 tail->next = new_link;
576 tail = new_link; 633 tail = new_link;
577 } 634 }
578 } 635 }
579 } 636 }
580}
581
582/*
583 * copy_to first frees everything allocated by the dst object,
584 * and then copies the contents of itself into the second
585 * object, allocating what needs to be allocated. Basically, any
586 * data that is malloc'd needs to be re-malloc/copied. Otherwise,
587 * if the first object is freed, the pointers in the new object
588 * will point at garbage.
589 */
590void
591object::copy_to (object *dst)
592{
593 *dst = *this;
594 637
595 if (speed < 0) 638 if (speed < 0)
596 dst->speed_left -= rndm (); 639 dst->speed_left -= rndm ();
597 640
598 dst->set_speed (dst->speed); 641 dst->activate ();
599} 642}
600 643
601void 644void
602object::instantiate () 645object::instantiate ()
603{ 646{
620object * 663object *
621object::clone () 664object::clone ()
622{ 665{
623 object *neu = create (); 666 object *neu = create ();
624 copy_to (neu); 667 copy_to (neu);
668 neu->map = map; // not copied by copy_to
625 return neu; 669 return neu;
626} 670}
627 671
628/* 672/*
629 * If an object with the IS_TURNABLE() flag needs to be turned due 673 * If an object with the IS_TURNABLE() flag needs to be turned due
680 * UP_OBJ_FACE: only the objects face has changed. 724 * UP_OBJ_FACE: only the objects face has changed.
681 */ 725 */
682void 726void
683update_object (object *op, int action) 727update_object (object *op, int action)
684{ 728{
685 if (op == NULL) 729 if (!op)
686 { 730 {
687 /* this should never happen */ 731 /* this should never happen */
688 LOG (llevDebug, "update_object() called for NULL object.\n"); 732 LOG (llevError | logBacktrace, "update_object() called for NULL object.\n");
689 return; 733 return;
690 } 734 }
691 735
692 if (op->env) 736 if (!op->is_on_map ())
693 { 737 {
694 /* Animation is currently handled by client, so nothing 738 /* Animation is currently handled by client, so nothing
695 * to do in this case. 739 * to do in this case.
696 */ 740 */
697 return; 741 return;
698 } 742 }
699
700 /* If the map is saving, don't do anything as everything is
701 * going to get freed anyways.
702 */
703 if (!op->map || op->map->in_memory == MAP_SAVING)
704 return;
705 743
706 /* make sure the object is within map boundaries */ 744 /* make sure the object is within map boundaries */
707 if (op->x < 0 || op->x >= op->map->width || op->y < 0 || op->y >= op->map->height) 745 if (op->x < 0 || op->x >= op->map->width || op->y < 0 || op->y >= op->map->height)
708 { 746 {
709 LOG (llevError, "update_object() called for object out of map!\n"); 747 LOG (llevError, "update_object() called for object out of map!\n");
728 || (QUERY_FLAG (op, FLAG_DAMNED) && !(m.flags_ & P_NO_CLERIC)) 766 || (QUERY_FLAG (op, FLAG_DAMNED) && !(m.flags_ & P_NO_CLERIC))
729 || (m.move_on | op->move_on ) != m.move_on 767 || (m.move_on | op->move_on ) != m.move_on
730 || (m.move_off | op->move_off ) != m.move_off 768 || (m.move_off | op->move_off ) != m.move_off
731 || (m.move_slow | op->move_slow) != m.move_slow 769 || (m.move_slow | op->move_slow) != m.move_slow
732 /* This isn't perfect, but I don't expect a lot of objects to 770 /* This isn't perfect, but I don't expect a lot of objects to
733 * to have move_allow right now. 771 * have move_allow right now.
734 */ 772 */
735 || ((m.move_block | op->move_block) & ~op->move_allow) != m.move_block 773 || ((m.move_block | op->move_block) & ~op->move_allow) != m.move_block
736 || 1) // the above is not strong enough a test to skip updating. los maybe? TODO (Schmorp) 774 || 1) // the above is not strong enough a test to skip updating. los maybe? TODO (Schmorp)
737 m.flags_ = 0; 775 m.flags_ = 0;
738 } 776 }
792{ 830{
793 /* If already on active list, don't do anything */ 831 /* If already on active list, don't do anything */
794 if (active) 832 if (active)
795 return; 833 return;
796 834
835 if (has_active_speed () && flag [FLAG_FREED ]) LOG (llevError | logBacktrace, "BUG: tried to activate freed object %s\n", debug_desc ());//D
836
797 if (has_active_speed ()) 837 if (has_active_speed ())
798 actives.insert (this); 838 actives.insert (this);
799} 839}
800 840
801void 841void
852object::destroy_inv (bool drop_to_ground) 892object::destroy_inv (bool drop_to_ground)
853{ 893{
854 // need to check first, because the checks below might segfault 894 // need to check first, because the checks below might segfault
855 // as we might be on an invalid mapspace and crossfire code 895 // as we might be on an invalid mapspace and crossfire code
856 // is too buggy to ensure that the inventory is empty. 896 // is too buggy to ensure that the inventory is empty.
857 // corollary: if you create arrows etc. with stuff in tis inventory, 897 // corollary: if you create arrows etc. with stuff in its inventory,
858 // cf will crash below with off-map x and y 898 // cf will crash below with off-map x and y
859 if (!inv) 899 if (!inv)
860 return; 900 return;
861 901
862 /* Only if the space blocks everything do we not process - 902 /* Only if the space blocks everything do we not process -
864 * drop on that space. 904 * drop on that space.
865 */ 905 */
866 if (!drop_to_ground 906 if (!drop_to_ground
867 || !map 907 || !map
868 || map->in_memory != MAP_ACTIVE 908 || map->in_memory != MAP_ACTIVE
869 || map->nodrop 909 || map->no_drop
870 || ms ().move_block == MOVE_ALL) 910 || ms ().move_block == MOVE_ALL)
871 { 911 {
872 while (inv) 912 while (inv)
873 {
874 inv->destroy_inv (drop_to_ground);
875 inv->destroy (); 913 inv->destroy (true);
876 }
877 } 914 }
878 else 915 else
879 { /* Put objects in inventory onto this space */ 916 { /* Put objects in inventory onto this space */
880 while (inv) 917 while (inv)
881 { 918 {
885 || op->flag [FLAG_NO_DROP] 922 || op->flag [FLAG_NO_DROP]
886 || op->type == RUNE 923 || op->type == RUNE
887 || op->type == TRAP 924 || op->type == TRAP
888 || op->flag [FLAG_IS_A_TEMPLATE] 925 || op->flag [FLAG_IS_A_TEMPLATE]
889 || op->flag [FLAG_DESTROY_ON_DEATH]) 926 || op->flag [FLAG_DESTROY_ON_DEATH])
890 op->destroy (); 927 op->destroy (true);
891 else 928 else
892 map->insert (op, x, y); 929 map->insert (op, x, y);
893 } 930 }
894 } 931 }
895} 932}
899 object *op = new object; 936 object *op = new object;
900 op->link (); 937 op->link ();
901 return op; 938 return op;
902} 939}
903 940
941static struct freed_map : maptile
942{
943 freed_map ()
944 {
945 path = "<freed objects map>";
946 name = "/internal/freed_objects_map";
947 width = 3;
948 height = 3;
949 no_drop = 1;
950 no_reset = 1;
951
952 alloc ();
953 in_memory = MAP_ACTIVE;
954 }
955
956 ~freed_map ()
957 {
958 destroy ();
959 }
960} freed_map; // freed objects are moved here to avoid crashes
961
904void 962void
905object::do_destroy () 963object::do_destroy ()
906{ 964{
907 attachable::do_destroy ();
908
909 if (flag [FLAG_IS_LINKED]) 965 if (flag [FLAG_IS_LINKED])
910 remove_button_link (this); 966 remove_button_link (this);
911 967
912 if (flag [FLAG_FRIENDLY]) 968 if (flag [FLAG_FRIENDLY])
913 remove_friendly_object (this); 969 remove_friendly_object (this);
914 970
915 if (!flag [FLAG_REMOVED])
916 remove (); 971 remove ();
917 972
918 destroy_inv (true); 973 attachable::do_destroy ();
919 974
920 deactivate (); 975 deactivate ();
921 unlink (); 976 unlink ();
922 977
923 flag [FLAG_FREED] = 1; 978 flag [FLAG_FREED] = 1;
924 979
925 // hack to ensure that freed objects still have a valid map 980 // hack to ensure that freed objects still have a valid map
926 {
927 static maptile *freed_map; // freed objects are moved here to avoid crashes
928
929 if (!freed_map)
930 {
931 freed_map = new maptile;
932
933 freed_map->path = "<freed objects map>";
934 freed_map->name = "/internal/freed_objects_map";
935 freed_map->width = 3;
936 freed_map->height = 3;
937 freed_map->nodrop = 1;
938
939 freed_map->alloc ();
940 freed_map->in_memory = MAP_ACTIVE;
941 }
942
943 map = freed_map; 981 map = &freed_map;
944 x = 1; 982 x = 1;
945 y = 1; 983 y = 1;
946 }
947 984
948 if (more) 985 if (more)
949 { 986 {
950 more->destroy (); 987 more->destroy ();
951 more = 0; 988 more = 0;
964object::destroy (bool destroy_inventory) 1001object::destroy (bool destroy_inventory)
965{ 1002{
966 if (destroyed ()) 1003 if (destroyed ())
967 return; 1004 return;
968 1005
1006 if (!is_head () && !head->destroyed ())
1007 {
1008 LOG (llevError | logBacktrace, "tried to destroy the tail of an object");
1009 head->destroy (destroy_inventory);
1010 return;
1011 }
1012
969 if (destroy_inventory) 1013 destroy_inv (!destroy_inventory);
970 destroy_inv (false);
971 1014
972 if (is_head ()) 1015 if (is_head ())
973 if (sound_destroy) 1016 if (sound_destroy)
974 play_sound (sound_destroy); 1017 play_sound (sound_destroy);
975 else if (flag [FLAG_MONSTER]) 1018 else if (flag [FLAG_MONSTER])
976 play_sound (sound_find ("monster_destroy")); // quick hack, too lazy to create a generic mechanism 1019 play_sound (sound_find ("monster_destroy")); // quick hack, too lazy to create a generic mechanism
977 1020
978 attachable::destroy (); 1021 attachable::destroy ();
979}
980
981/*
982 * sub_weight() recursively (outwards) subtracts a number from the
983 * weight of an object (and what is carried by it's environment(s)).
984 */
985void
986sub_weight (object *op, signed long weight)
987{
988 while (op != NULL)
989 {
990 if (op->type == CONTAINER)
991 weight = (signed long) (weight * (100 - op->stats.Str) / 100);
992
993 op->carrying -= weight;
994 op = op->env;
995 }
996} 1022}
997 1023
998/* op->remove (): 1024/* op->remove ():
999 * This function removes the object op from the linked list of objects 1025 * This function removes the object op from the linked list of objects
1000 * which it is currently tied to. When this function is done, the 1026 * which it is currently tied to. When this function is done, the
1006object::do_remove () 1032object::do_remove ()
1007{ 1033{
1008 object *tmp, *last = 0; 1034 object *tmp, *last = 0;
1009 object *otmp; 1035 object *otmp;
1010 1036
1011 if (QUERY_FLAG (this, FLAG_REMOVED)) 1037 if (flag [FLAG_REMOVED])
1012 return; 1038 return;
1013 1039
1014 SET_FLAG (this, FLAG_REMOVED);
1015 INVOKE_OBJECT (REMOVE, this); 1040 INVOKE_OBJECT (REMOVE, this);
1041
1042 flag [FLAG_REMOVED] = true;
1016 1043
1017 if (more) 1044 if (more)
1018 more->remove (); 1045 more->remove ();
1019 1046
1020 /* 1047 /*
1021 * In this case, the object to be removed is in someones 1048 * In this case, the object to be removed is in someones
1022 * inventory. 1049 * inventory.
1023 */ 1050 */
1024 if (env) 1051 if (env)
1025 { 1052 {
1026 if (nrof) 1053 flag [FLAG_REMOVED] = false; // hack around the issue of visible_to checking flag_removed
1027 sub_weight (env, weight * nrof); 1054 if (object *pl = visible_to ())
1028 else 1055 esrv_del_item (pl->contr, count);
1029 sub_weight (env, weight + carrying); 1056 flag [FLAG_REMOVED] = true; // hack around the issue of visible_to checking flag_removed
1057
1058 adjust_weight (env, -total_weight ());
1059
1060 /* we set up values so that it could be inserted into
1061 * the map, but we don't actually do that - it is up
1062 * to the caller to decide what we want to do.
1063 */
1064 map = env->map;
1065 x = env->x;
1066 y = env->y;
1067
1068 // make sure cmov optimisation is applicable
1069 *(above ? &above->below : &env->inv) = below;
1070 *(below ? &below->above : &above ) = above; // &above is just a dummy
1071
1072 above = 0;
1073 below = 0;
1074 env = 0;
1030 1075
1031 /* NO_FIX_PLAYER is set when a great many changes are being 1076 /* NO_FIX_PLAYER is set when a great many changes are being
1032 * made to players inventory. If set, avoiding the call 1077 * made to players inventory. If set, avoiding the call
1033 * to save cpu time. 1078 * to save cpu time.
1034 */ 1079 */
1035 if ((otmp = in_player ()) && otmp->contr && !QUERY_FLAG (otmp, FLAG_NO_FIX_PLAYER)) 1080 if ((otmp = in_player ()) && otmp->contr && !QUERY_FLAG (otmp, FLAG_NO_FIX_PLAYER))
1036 otmp->update_stats (); 1081 otmp->update_stats ();
1037
1038 if (above)
1039 above->below = below;
1040 else
1041 env->inv = below;
1042
1043 if (below)
1044 below->above = above;
1045
1046 /* we set up values so that it could be inserted into
1047 * the map, but we don't actually do that - it is up
1048 * to the caller to decide what we want to do.
1049 */
1050 x = env->x, y = env->y;
1051 map = env->map;
1052 above = 0, below = 0;
1053 env = 0;
1054 } 1082 }
1055 else if (map) 1083 else if (map)
1056 { 1084 {
1057 if (type == PLAYER)
1058 {
1059 // leaving a spot always closes any open container on the ground
1060 if (container && !container->env)
1061 // this causes spurious floorbox updates, but it ensures
1062 // that the CLOSE event is being sent.
1063 close_container ();
1064
1065 --map->players;
1066 map->touch ();
1067 }
1068
1069 map->dirty = true; 1085 map->dirty = true;
1070 mapspace &ms = this->ms (); 1086 mapspace &ms = this->ms ();
1071 1087
1088 if (object *pl = ms.player ())
1089 {
1090 if (type == PLAYER) // this == pl(!)
1091 {
1092 // leaving a spot always closes any open container on the ground
1093 if (container && !container->env)
1094 // this causes spurious floorbox updates, but it ensures
1095 // that the CLOSE event is being sent.
1096 close_container ();
1097
1098 --map->players;
1099 map->touch ();
1100 }
1101 else if (pl->container == this)
1102 {
1103 // removing a container should close it
1104 close_container ();
1105 }
1106
1107 esrv_del_item (pl->contr, count);
1108 }
1109
1072 /* link the object above us */ 1110 /* link the object above us */
1073 if (above) 1111 // re-link, make sure compiler can easily use cmove
1074 above->below = below; 1112 *(above ? &above->below : &ms.top) = below;
1075 else 1113 *(below ? &below->above : &ms.bot) = above;
1076 ms.top = below; /* we were top, set new top */
1077
1078 /* Relink the object below us, if there is one */
1079 if (below)
1080 below->above = above;
1081 else
1082 {
1083 /* Nothing below, which means we need to relink map object for this space
1084 * use translated coordinates in case some oddness with map tiling is
1085 * evident
1086 */
1087 if (GET_MAP_OB (map, x, y) != this)
1088 LOG (llevError, "remove_ob: GET_MAP_OB does not return object to be removed even though it appears to be on the bottom? %s\n", debug_desc ());
1089
1090 ms.bot = above; /* goes on above it. */
1091 }
1092 1114
1093 above = 0; 1115 above = 0;
1094 below = 0; 1116 below = 0;
1117
1118 ms.flags_ = 0;
1095 1119
1096 if (map->in_memory == MAP_SAVING) 1120 if (map->in_memory == MAP_SAVING)
1097 return; 1121 return;
1098 1122
1099 int check_walk_off = !flag [FLAG_NO_APPLY]; 1123 int check_walk_off = !flag [FLAG_NO_APPLY];
1105 * removed (most likely destroyed), update the player view 1129 * removed (most likely destroyed), update the player view
1106 * appropriately. 1130 * appropriately.
1107 */ 1131 */
1108 pl->close_container (); 1132 pl->close_container ();
1109 1133
1134 //TODO: the floorbox prev/next might need updating
1135 //esrv_del_item (pl->contr, count);
1136 //TODO: update floorbox to preserve ordering
1137 if (pl->contr->ns)
1110 pl->contr->ns->floorbox_update (); 1138 pl->contr->ns->floorbox_update ();
1111 } 1139 }
1112 1140
1113 for (tmp = ms.bot; tmp; tmp = tmp->above) 1141 for (tmp = ms.bot; tmp; tmp = tmp->above)
1114 { 1142 {
1115 /* No point updating the players look faces if he is the object 1143 /* No point updating the players look faces if he is the object
1128 } 1156 }
1129 1157
1130 last = tmp; 1158 last = tmp;
1131 } 1159 }
1132 1160
1133 /* last == NULL if there are no objects on this space */
1134 //TODO: this makes little sense, why only update the topmost object?
1135 if (!last)
1136 map->at (x, y).flags_ = 0;
1137 else
1138 update_object (last, UP_OBJ_REMOVE);
1139
1140 if (flag [FLAG_BLOCKSVIEW] || glow_radius) 1161 if (flag [FLAG_BLOCKSVIEW] || glow_radius)
1141 update_all_los (map, x, y); 1162 update_all_los (map, x, y);
1142 } 1163 }
1143} 1164}
1144 1165
1159 if (!top) 1180 if (!top)
1160 for (top = op; top && top->above; top = top->above) 1181 for (top = op; top && top->above; top = top->above)
1161 ; 1182 ;
1162 1183
1163 for (; top; top = top->below) 1184 for (; top; top = top->below)
1164 {
1165 if (top == op)
1166 continue;
1167
1168 if (object::can_merge (op, top)) 1185 if (object::can_merge (op, top))
1169 { 1186 {
1170 top->nrof += op->nrof; 1187 top->nrof += op->nrof;
1171 1188
1172/* CLEAR_FLAG(top,FLAG_STARTEQUIP);*/ 1189 if (object *pl = top->visible_to ())
1173 op->weight = 0; /* Don't want any adjustements now */ 1190 esrv_update_item (UPD_NROF, pl, top);
1191
1192 op->weight = 0; // cancel the addition above
1193 op->carrying = 0; // must be 0 already
1194
1174 op->destroy (); 1195 op->destroy (1);
1196
1175 return top; 1197 return top;
1176 } 1198 }
1177 }
1178 1199
1179 return 0; 1200 return 0;
1180} 1201}
1181 1202
1182void 1203void
1207 * job preparing multi-part monsters. 1228 * job preparing multi-part monsters.
1208 */ 1229 */
1209object * 1230object *
1210insert_ob_in_map_at (object *op, maptile *m, object *originator, int flag, int x, int y) 1231insert_ob_in_map_at (object *op, maptile *m, object *originator, int flag, int x, int y)
1211{ 1232{
1233 op->remove ();
1234
1212 for (object *tmp = op->head_ (); tmp; tmp = tmp->more) 1235 for (object *tmp = op->head_ (); tmp; tmp = tmp->more)
1213 { 1236 {
1214 tmp->x = x + tmp->arch->x; 1237 tmp->x = x + tmp->arch->x;
1215 tmp->y = y + tmp->arch->y; 1238 tmp->y = y + tmp->arch->y;
1216 } 1239 }
1239 * just 'op' otherwise 1262 * just 'op' otherwise
1240 */ 1263 */
1241object * 1264object *
1242insert_ob_in_map (object *op, maptile *m, object *originator, int flag) 1265insert_ob_in_map (object *op, maptile *m, object *originator, int flag)
1243{ 1266{
1244 assert (!op->flag [FLAG_FREED]); 1267 if (op->is_on_map ())
1268 {
1269 LOG (llevError, "insert_ob_in_map called for object already on map");
1270 abort ();
1271 }
1245 1272
1246 object *top, *floor = NULL; 1273 if (op->env)
1247 1274 {
1275 LOG (llevError, "insert_ob_in_map called for object in an inventory (proceeding)");
1248 op->remove (); 1276 op->remove ();
1277 }
1278
1279 if (op->face && !face_info (op->face))//D TODO: remove soon
1280 {//D
1281 LOG (llevError | logBacktrace, "op->face out of bounds: %s", op->debug_desc ());//D
1282 op->face = 1;//D
1283 }//D
1249 1284
1250 /* Ideally, the caller figures this out. However, it complicates a lot 1285 /* Ideally, the caller figures this out. However, it complicates a lot
1251 * of areas of callers (eg, anything that uses find_free_spot would now 1286 * of areas of callers (eg, anything that uses find_free_spot would now
1252 * need extra work 1287 * need extra work
1253 */ 1288 */
1254 if (!xy_normalise (m, op->x, op->y)) 1289 if (!xy_normalise (m, op->x, op->y))
1255 { 1290 {
1256 op->destroy (); 1291 op->head_ ()->destroy (1);// remove head_ once all tail object destroyers found
1257 return 0; 1292 return 0;
1258 } 1293 }
1259 1294
1260 if (object *more = op->more) 1295 if (object *more = op->more)
1261 if (!insert_ob_in_map (more, m, originator, flag)) 1296 if (!insert_ob_in_map (more, m, originator, flag))
1270 */ 1305 */
1271 if (op->nrof && !(flag & INS_NO_MERGE)) 1306 if (op->nrof && !(flag & INS_NO_MERGE))
1272 for (object *tmp = ms.bot; tmp; tmp = tmp->above) 1307 for (object *tmp = ms.bot; tmp; tmp = tmp->above)
1273 if (object::can_merge (op, tmp)) 1308 if (object::can_merge (op, tmp))
1274 { 1309 {
1310 // TODO: we actually want to update tmp, not op,
1311 // but some caller surely breaks when we return tmp
1312 // from here :/
1275 op->nrof += tmp->nrof; 1313 op->nrof += tmp->nrof;
1276 tmp->destroy (); 1314 tmp->destroy (1);
1277 } 1315 }
1278 1316
1279 CLEAR_FLAG (op, FLAG_APPLIED); /* hack for fixing F_APPLIED in items of dead people */ 1317 CLEAR_FLAG (op, FLAG_APPLIED); /* hack for fixing F_APPLIED in items of dead people */
1280 CLEAR_FLAG (op, FLAG_INV_LOCKED); 1318 CLEAR_FLAG (op, FLAG_INV_LOCKED);
1281 1319
1288 { 1326 {
1289 LOG (llevError, "insert_ob_in_map called with INS_BELOW_ORIGINATOR when originator not on same space!\n"); 1327 LOG (llevError, "insert_ob_in_map called with INS_BELOW_ORIGINATOR when originator not on same space!\n");
1290 abort (); 1328 abort ();
1291 } 1329 }
1292 1330
1331 if (!originator->is_on_map ())
1332 LOG (llevDebug | logBacktrace, "insert_ob_in_map(%s) called with INS_BELOW_ORIGINATOR when originator '%s' not on map",
1333 op->debug_desc (), originator->debug_desc ());
1334
1293 op->above = originator; 1335 op->above = originator;
1294 op->below = originator->below; 1336 op->below = originator->below;
1295
1296 if (op->below)
1297 op->below->above = op;
1298 else
1299 ms.bot = op;
1300
1301 /* since *below* originator, no need to update top */
1302 originator->below = op; 1337 originator->below = op;
1338
1339 *(op->below ? &op->below->above : &ms.bot) = op;
1303 } 1340 }
1304 else 1341 else
1305 { 1342 {
1306 top = ms.bot; 1343 object *floor = 0;
1344 object *top = ms.top;
1307 1345
1308 /* If there are other objects, then */ 1346 /* If there are other objects, then */
1309 if (top) 1347 if (top)
1310 { 1348 {
1311 object *last = 0;
1312
1313 /* 1349 /*
1314 * If there are multiple objects on this space, we do some trickier handling. 1350 * If there are multiple objects on this space, we do some trickier handling.
1315 * We've already dealt with merging if appropriate. 1351 * We've already dealt with merging if appropriate.
1316 * Generally, we want to put the new object on top. But if 1352 * Generally, we want to put the new object on top. But if
1317 * flag contains INS_ABOVE_FLOOR_ONLY, once we find the last 1353 * flag contains INS_ABOVE_FLOOR_ONLY, once we find the last
1320 * once we get to them. This reduces the need to traverse over all of 1356 * once we get to them. This reduces the need to traverse over all of
1321 * them when adding another one - this saves quite a bit of cpu time 1357 * them when adding another one - this saves quite a bit of cpu time
1322 * when lots of spells are cast in one area. Currently, it is presumed 1358 * when lots of spells are cast in one area. Currently, it is presumed
1323 * that flying non pickable objects are spell objects. 1359 * that flying non pickable objects are spell objects.
1324 */ 1360 */
1325 for (top = ms.bot; top; top = top->above) 1361 for (object *tmp = ms.bot; tmp; tmp = tmp->above)
1326 { 1362 {
1327 if (QUERY_FLAG (top, FLAG_IS_FLOOR) || QUERY_FLAG (top, FLAG_OVERLAY_FLOOR)) 1363 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR) || QUERY_FLAG (tmp, FLAG_OVERLAY_FLOOR))
1328 floor = top; 1364 floor = tmp;
1329 1365
1330 if (QUERY_FLAG (top, FLAG_NO_PICK) && (top->move_type & (MOVE_FLY_LOW | MOVE_FLY_HIGH)) && !QUERY_FLAG (top, FLAG_IS_FLOOR)) 1366 if (QUERY_FLAG (tmp, FLAG_NO_PICK) && (tmp->move_type & (MOVE_FLY_LOW | MOVE_FLY_HIGH)) && !QUERY_FLAG (tmp, FLAG_IS_FLOOR))
1331 { 1367 {
1332 /* We insert above top, so we want this object below this */ 1368 /* We insert above top, so we want this object below this */
1333 top = top->below; 1369 top = tmp->below;
1334 break; 1370 break;
1335 } 1371 }
1336 1372
1337 last = top; 1373 top = tmp;
1338 } 1374 }
1339
1340 /* Don't want top to be NULL, so set it to the last valid object */
1341 top = last;
1342 1375
1343 /* We let update_position deal with figuring out what the space 1376 /* We let update_position deal with figuring out what the space
1344 * looks like instead of lots of conditions here. 1377 * looks like instead of lots of conditions here.
1345 * makes things faster, and effectively the same result. 1378 * makes things faster, and effectively the same result.
1346 */ 1379 */
1353 */ 1386 */
1354 if (!(flag & INS_ON_TOP) 1387 if (!(flag & INS_ON_TOP)
1355 && ms.flags () & P_BLOCKSVIEW 1388 && ms.flags () & P_BLOCKSVIEW
1356 && (op->face && !faces [op->face].visibility)) 1389 && (op->face && !faces [op->face].visibility))
1357 { 1390 {
1391 object *last;
1392
1358 for (last = top; last != floor; last = last->below) 1393 for (last = top; last != floor; last = last->below)
1359 if (QUERY_FLAG (last, FLAG_BLOCKSVIEW) && (last->type != EXIT)) 1394 if (QUERY_FLAG (last, FLAG_BLOCKSVIEW) && (last->type != EXIT))
1360 break; 1395 break;
1361 1396
1362 /* Check to see if we found the object that blocks view, 1397 /* Check to see if we found the object that blocks view,
1370 } /* If objects on this space */ 1405 } /* If objects on this space */
1371 1406
1372 if (flag & INS_ABOVE_FLOOR_ONLY) 1407 if (flag & INS_ABOVE_FLOOR_ONLY)
1373 top = floor; 1408 top = floor;
1374 1409
1375 /* Top is the object that our object (op) is going to get inserted above. 1410 // insert object above top, or bottom-most if top = 0
1376 */
1377
1378 /* First object on this space */
1379 if (!top) 1411 if (!top)
1380 { 1412 {
1413 op->below = 0;
1381 op->above = ms.bot; 1414 op->above = ms.bot;
1382
1383 if (op->above)
1384 op->above->below = op;
1385
1386 op->below = 0;
1387 ms.bot = op; 1415 ms.bot = op;
1416
1417 *(op->above ? &op->above->below : &ms.top) = op;
1388 } 1418 }
1389 else 1419 else
1390 { /* get inserted into the stack above top */ 1420 {
1391 op->above = top->above; 1421 op->above = top->above;
1392
1393 if (op->above)
1394 op->above->below = op; 1422 top->above = op;
1395 1423
1396 op->below = top; 1424 op->below = top;
1397 top->above = op; 1425 *(op->above ? &op->above->below : &ms.top) = op;
1398 } 1426 }
1399 1427 }
1400 if (!op->above)
1401 ms.top = op;
1402 } /* else not INS_BELOW_ORIGINATOR */
1403 1428
1404 if (op->type == PLAYER) 1429 if (op->type == PLAYER)
1405 { 1430 {
1406 op->contr->do_los = 1; 1431 op->contr->do_los = 1;
1407 ++op->map->players; 1432 ++op->map->players;
1409 } 1434 }
1410 1435
1411 op->map->dirty = true; 1436 op->map->dirty = true;
1412 1437
1413 if (object *pl = ms.player ()) 1438 if (object *pl = ms.player ())
1439 //TODO: the floorbox prev/next might need updating
1440 //esrv_send_item (pl, op);
1441 //TODO: update floorbox to preserve ordering
1442 if (pl->contr->ns)
1414 pl->contr->ns->floorbox_update (); 1443 pl->contr->ns->floorbox_update ();
1415 1444
1416 /* If this object glows, it may affect lighting conditions that are 1445 /* If this object glows, it may affect lighting conditions that are
1417 * visible to others on this map. But update_all_los is really 1446 * visible to others on this map. But update_all_los is really
1418 * an inefficient way to do this, as it means los for all players 1447 * an inefficient way to do this, as it means los for all players
1419 * on the map will get recalculated. The players could very well 1448 * on the map will get recalculated. The players could very well
1461 * op is the object to insert it under: supplies x and the map. 1490 * op is the object to insert it under: supplies x and the map.
1462 */ 1491 */
1463void 1492void
1464replace_insert_ob_in_map (const char *arch_string, object *op) 1493replace_insert_ob_in_map (const char *arch_string, object *op)
1465{ 1494{
1466 object *tmp, *tmp1;
1467
1468 /* first search for itself and remove any old instances */ 1495 /* first search for itself and remove any old instances */
1469 1496
1470 for (tmp = op->ms ().bot; tmp; tmp = tmp->above) 1497 for (object *tmp = op->ms ().bot; tmp; tmp = tmp->above)
1471 if (!strcmp (tmp->arch->archname, arch_string)) /* same archetype */ 1498 if (!strcmp (tmp->arch->archname, arch_string)) /* same archetype */
1472 tmp->destroy (); 1499 tmp->destroy (1);
1473 1500
1474 tmp1 = arch_to_object (archetype::find (arch_string)); 1501 object *tmp = arch_to_object (archetype::find (arch_string));
1475 1502
1476 tmp1->x = op->x; 1503 tmp->x = op->x;
1477 tmp1->y = op->y; 1504 tmp->y = op->y;
1505
1478 insert_ob_in_map (tmp1, op->map, op, 0); 1506 insert_ob_in_map (tmp, op->map, op, 0);
1479} 1507}
1480 1508
1481object * 1509object *
1482object::insert_at (object *where, object *originator, int flags) 1510object::insert_at (object *where, object *originator, int flags)
1483{ 1511{
1486 else 1514 else
1487 return where->map->insert (this, where->x, where->y, originator, flags); 1515 return where->map->insert (this, where->x, where->y, originator, flags);
1488} 1516}
1489 1517
1490/* 1518/*
1491 * get_split_ob(ob,nr) splits up ob into two parts. The part which
1492 * is returned contains nr objects, and the remaining parts contains
1493 * the rest (or is removed and freed if that number is 0).
1494 * On failure, NULL is returned, and the reason put into the
1495 * global static errmsg array.
1496 */
1497object *
1498get_split_ob (object *orig_ob, uint32 nr)
1499{
1500 object *newob;
1501 int is_removed = (QUERY_FLAG (orig_ob, FLAG_REMOVED) != 0);
1502
1503 if (orig_ob->nrof < nr)
1504 {
1505 sprintf (errmsg, "There are only %d %ss.", orig_ob->nrof ? orig_ob->nrof : 1, &orig_ob->name);
1506 return NULL;
1507 }
1508
1509 newob = object_create_clone (orig_ob);
1510
1511 if ((orig_ob->nrof -= nr) < 1)
1512 orig_ob->destroy (1);
1513 else if (!is_removed)
1514 {
1515 if (orig_ob->env != NULL)
1516 sub_weight (orig_ob->env, orig_ob->weight * nr);
1517 if (orig_ob->env == NULL && orig_ob->map->in_memory != MAP_ACTIVE)
1518 {
1519 strcpy (errmsg, "Tried to split object whose map is not in memory.");
1520 LOG (llevDebug, "Error, Tried to split object whose map is not in memory.\n");
1521 return NULL;
1522 }
1523 }
1524
1525 newob->nrof = nr;
1526
1527 return newob;
1528}
1529
1530/*
1531 * decrease_ob_nr(object, number) decreases a specified number from 1519 * decrease(object, number) decreases a specified number from
1532 * the amount of an object. If the amount reaches 0, the object 1520 * the amount of an object. If the amount reaches 0, the object
1533 * is subsequently removed and freed. 1521 * is subsequently removed and freed.
1534 * 1522 *
1535 * Return value: 'op' if something is left, NULL if the amount reached 0 1523 * Return value: 'op' if something is left, NULL if the amount reached 0
1536 */ 1524 */
1525bool
1526object::decrease (sint32 nr)
1527{
1528 if (!nr)
1529 return true;
1530
1531 nr = min (nr, nrof);
1532
1533 if (nrof > nr)
1534 {
1535 nrof -= nr;
1536 adjust_weight (env, -weight * max (1, nr)); // carrying == 0
1537
1538 if (object *pl = visible_to ())
1539 esrv_update_item (UPD_NROF, pl, this);
1540
1541 return true;
1542 }
1543 else
1544 {
1545 destroy ();
1546 return false;
1547 }
1548}
1549
1550/*
1551 * split(ob,nr) splits up ob into two parts. The part which
1552 * is returned contains nr objects, and the remaining parts contains
1553 * the rest (or is removed and returned if that number is 0).
1554 * On failure, NULL is returned.
1555 */
1537object * 1556object *
1538decrease_ob_nr (object *op, uint32 i) 1557object::split (sint32 nr)
1539{ 1558{
1540 object *tmp; 1559 int have = number_of ();
1541 1560
1542 if (i == 0) /* objects with op->nrof require this check */ 1561 if (have < nr)
1543 return op; 1562 return 0;
1544 1563 else if (have == nr)
1545 if (i > op->nrof)
1546 i = op->nrof;
1547
1548 if (QUERY_FLAG (op, FLAG_REMOVED))
1549 op->nrof -= i;
1550 else if (op->env)
1551 { 1564 {
1552 /* is this object in the players inventory, or sub container
1553 * therein?
1554 */
1555 tmp = op->in_player ();
1556 /* nope. Is this a container the player has opened?
1557 * If so, set tmp to that player.
1558 * IMO, searching through all the players will mostly
1559 * likely be quicker than following op->env to the map,
1560 * and then searching the map for a player.
1561 */
1562 if (!tmp)
1563 for_all_players (pl)
1564 if (pl->ob->container == op->env)
1565 {
1566 tmp = pl->ob;
1567 break;
1568 }
1569
1570 if (i < op->nrof)
1571 {
1572 sub_weight (op->env, op->weight * i);
1573 op->nrof -= i;
1574 if (tmp)
1575 esrv_send_item (tmp, op);
1576 }
1577 else
1578 {
1579 op->remove (); 1565 remove ();
1580 op->nrof = 0; 1566 return this;
1581 if (tmp)
1582 esrv_del_item (tmp->contr, op->count);
1583 }
1584 } 1567 }
1585 else 1568 else
1586 { 1569 {
1587 object *above = op->above; 1570 decrease (nr);
1588 1571
1589 if (i < op->nrof) 1572 object *op = deep_clone ();
1590 op->nrof -= i; 1573 op->nrof = nr;
1591 else
1592 {
1593 op->remove ();
1594 op->nrof = 0;
1595 }
1596
1597 /* Since we just removed op, op->above is null */
1598 for (tmp = above; tmp; tmp = tmp->above)
1599 if (tmp->type == PLAYER)
1600 {
1601 if (op->nrof)
1602 esrv_send_item (tmp, op);
1603 else
1604 esrv_del_item (tmp->contr, op->count);
1605 }
1606 }
1607
1608 if (op->nrof)
1609 return op; 1574 return op;
1610 else
1611 {
1612 op->destroy ();
1613 return 0;
1614 }
1615}
1616
1617/*
1618 * add_weight(object, weight) adds the specified weight to an object,
1619 * and also updates how much the environment(s) is/are carrying.
1620 */
1621void
1622add_weight (object *op, signed long weight)
1623{
1624 while (op != NULL)
1625 {
1626 if (op->type == CONTAINER)
1627 weight = (signed long) (weight * (100 - op->stats.Str) / 100);
1628
1629 op->carrying += weight;
1630 op = op->env;
1631 } 1575 }
1632} 1576}
1633 1577
1634object * 1578object *
1635insert_ob_in_ob (object *op, object *where) 1579insert_ob_in_ob (object *op, object *where)
1660 * be != op, if items are merged. -Tero 1604 * be != op, if items are merged. -Tero
1661 */ 1605 */
1662object * 1606object *
1663object::insert (object *op) 1607object::insert (object *op)
1664{ 1608{
1665 if (!QUERY_FLAG (op, FLAG_REMOVED))
1666 op->remove ();
1667
1668 if (op->more) 1609 if (op->more)
1669 { 1610 {
1670 LOG (llevError, "Tried to insert multipart object %s (%d)\n", &op->name, op->count); 1611 LOG (llevError, "Tried to insert multipart object %s (%d)\n", &op->name, op->count);
1671 return op; 1612 return op;
1672 } 1613 }
1673 1614
1674 CLEAR_FLAG (op, FLAG_OBJ_ORIGINAL); 1615 op->remove ();
1675 CLEAR_FLAG (op, FLAG_REMOVED); 1616
1617 op->flag [FLAG_OBJ_ORIGINAL] = 0;
1676 1618
1677 if (op->nrof) 1619 if (op->nrof)
1678 {
1679 for (object *tmp = inv; tmp; tmp = tmp->below) 1620 for (object *tmp = inv; tmp; tmp = tmp->below)
1680 if (object::can_merge (tmp, op)) 1621 if (object::can_merge (tmp, op))
1681 { 1622 {
1682 /* return the original object and remove inserted object 1623 /* return the original object and remove inserted object
1683 (client needs the original object) */ 1624 (client needs the original object) */
1684 tmp->nrof += op->nrof; 1625 tmp->nrof += op->nrof;
1685 /* Weight handling gets pretty funky. Since we are adding to 1626
1686 * tmp->nrof, we need to increase the weight. 1627 if (object *pl = tmp->visible_to ())
1687 */ 1628 esrv_update_item (UPD_NROF, pl, tmp);
1629
1688 add_weight (this, op->weight * op->nrof); 1630 adjust_weight (this, op->total_weight ());
1689 SET_FLAG (op, FLAG_REMOVED); 1631
1690 op->destroy (); /* free the inserted object */ 1632 op->destroy (1);
1691 op = tmp; 1633 op = tmp;
1692 op->remove (); /* and fix old object's links */ 1634 goto inserted;
1693 CLEAR_FLAG (op, FLAG_REMOVED);
1694 break;
1695 } 1635 }
1696 1636
1697 /* I assume combined objects have no inventory
1698 * We add the weight - this object could have just been removed
1699 * (if it was possible to merge). calling remove_ob will subtract
1700 * the weight, so we need to add it in again, since we actually do
1701 * the linking below
1702 */
1703 add_weight (this, op->weight * op->nrof);
1704 }
1705 else
1706 add_weight (this, (op->weight + op->carrying));
1707
1708 if (object *otmp = this->in_player ())
1709 if (otmp->contr && !QUERY_FLAG (otmp, FLAG_NO_FIX_PLAYER))
1710 otmp->update_stats ();
1711
1712 op->owner = 0; // its his/hers now. period. 1637 op->owner = 0; // it's his/hers now. period.
1713 op->map = 0; 1638 op->map = 0;
1639 op->x = 0;
1640 op->y = 0;
1641
1642 op->above = 0;
1643 op->below = inv;
1714 op->env = this; 1644 op->env = this;
1715 op->above = 0;
1716 op->below = 0;
1717 op->x = op->y = 0;
1718 1645
1646 if (inv)
1647 inv->above = op;
1648
1649 inv = op;
1650
1651 op->flag [FLAG_REMOVED] = 0;
1652
1653 if (object *pl = op->visible_to ())
1654 esrv_send_item (pl, op);
1655
1656 adjust_weight (this, op->total_weight ());
1657
1658inserted:
1719 /* reset the light list and los of the players on the map */ 1659 /* reset the light list and los of the players on the map */
1720 if (op->glow_radius && map) 1660 if (op->glow_radius && map && map->darkness)
1721 {
1722#ifdef DEBUG_LIGHTS
1723 LOG (llevDebug, " insert_ob_in_ob(): got %s to insert in map/op\n", op->name);
1724#endif /* DEBUG_LIGHTS */
1725 if (map->darkness)
1726 update_all_los (map, x, y); 1661 update_all_los (map, x, y);
1727 }
1728 1662
1729 /* Client has no idea of ordering so lets not bother ordering it here. 1663 // if this is a player's inventory, update stats
1730 * It sure simplifies this function... 1664 if (type == PLAYER && !flag [FLAG_NO_FIX_PLAYER])
1731 */ 1665 update_stats ();
1732 if (!inv)
1733 inv = op;
1734 else
1735 {
1736 op->below = inv;
1737 op->below->above = op;
1738 inv = op;
1739 }
1740 1666
1741 INVOKE_OBJECT (INSERT, this); 1667 INVOKE_OBJECT (INSERT, this);
1742 1668
1743 return op; 1669 return op;
1744} 1670}
1872 LOG (llevError, "Present_arch called outside map.\n"); 1798 LOG (llevError, "Present_arch called outside map.\n");
1873 return NULL; 1799 return NULL;
1874 } 1800 }
1875 1801
1876 for (object *tmp = m->at (x, y).bot; tmp; tmp = tmp->above) 1802 for (object *tmp = m->at (x, y).bot; tmp; tmp = tmp->above)
1877 if (tmp->arch == at) 1803 if (tmp->arch->archname == at->archname)
1878 return tmp; 1804 return tmp;
1879 1805
1880 return NULL; 1806 return NULL;
1881} 1807}
1882 1808
1946 * The first matching object is returned, or NULL if none. 1872 * The first matching object is returned, or NULL if none.
1947 */ 1873 */
1948object * 1874object *
1949present_arch_in_ob (const archetype *at, const object *op) 1875present_arch_in_ob (const archetype *at, const object *op)
1950{ 1876{
1951 for (object *tmp = op->inv; tmp != NULL; tmp = tmp->below) 1877 for (object *tmp = op->inv; tmp; tmp = tmp->below)
1952 if (tmp->arch == at) 1878 if (tmp->arch->archname == at->archname)
1953 return tmp; 1879 return tmp;
1954 1880
1955 return NULL; 1881 return NULL;
1956} 1882}
1957 1883
2366 2292
2367/* 2293/*
2368 * create clone from object to another 2294 * create clone from object to another
2369 */ 2295 */
2370object * 2296object *
2371object_create_clone (object *asrc) 2297object::deep_clone ()
2372{ 2298{
2373 object *dst = 0, *tmp, *src, *prev, *item; 2299 assert (("deep_clone called on non-head object", is_head ()));
2374 2300
2375 if (!asrc) 2301 object *dst = clone ();
2376 return 0;
2377 2302
2378 src = asrc->head_ (); 2303 object *prev = dst;
2379
2380 prev = 0;
2381 for (object *part = src; part; part = part->more) 2304 for (object *part = this->more; part; part = part->more)
2382 { 2305 {
2383 tmp = part->clone (); 2306 object *tmp = part->clone ();
2384 tmp->x -= src->x;
2385 tmp->y -= src->y;
2386
2387 if (!part->head)
2388 {
2389 dst = tmp;
2390 tmp->head = 0;
2391 }
2392 else
2393 tmp->head = dst; 2307 tmp->head = dst;
2394
2395 tmp->more = 0;
2396
2397 if (prev)
2398 prev->more = tmp; 2308 prev->more = tmp;
2399
2400 prev = tmp; 2309 prev = tmp;
2401 } 2310 }
2402 2311
2403 for (item = src->inv; item; item = item->below) 2312 for (object *item = inv; item; item = item->below)
2404 insert_ob_in_ob (object_create_clone (item), dst); 2313 insert_ob_in_ob (item->deep_clone (), dst);
2405 2314
2406 return dst; 2315 return dst;
2407} 2316}
2408 2317
2409/* This returns the first object in who's inventory that 2318/* This returns the first object in who's inventory that
2418 return tmp; 2327 return tmp;
2419 2328
2420 return 0; 2329 return 0;
2421} 2330}
2422 2331
2423/* If ob has a field named key, return the link from the list, 2332const shstr &
2424 * otherwise return NULL. 2333object::kv_get (const shstr &key) const
2425 *
2426 * key must be a passed in shared string - otherwise, this won't
2427 * do the desired thing.
2428 */
2429key_value *
2430get_ob_key_link (const object *ob, const char *key)
2431{ 2334{
2432 for (key_value *link = ob->key_values; link; link = link->next) 2335 for (key_value *kv = key_values; kv; kv = kv->next)
2433 if (link->key == key) 2336 if (kv->key == key)
2434 return link;
2435
2436 return 0;
2437}
2438
2439/*
2440 * Returns the value of op has an extra_field for key, or NULL.
2441 *
2442 * The argument doesn't need to be a shared string.
2443 *
2444 * The returned string is shared.
2445 */
2446const char *
2447get_ob_key_value (const object *op, const char *const key)
2448{
2449 key_value *link;
2450 shstr_cmp canonical_key (key);
2451
2452 if (!canonical_key)
2453 {
2454 /* 1. There being a field named key on any object
2455 * implies there'd be a shared string to find.
2456 * 2. Since there isn't, no object has this field.
2457 * 3. Therefore, *this* object doesn't have this field.
2458 */
2459 return 0;
2460 }
2461
2462 /* This is copied from get_ob_key_link() above -
2463 * only 4 lines, and saves the function call overhead.
2464 */
2465 for (link = op->key_values; link; link = link->next)
2466 if (link->key == canonical_key)
2467 return link->value; 2337 return kv->value;
2468 2338
2469 return 0; 2339 return shstr_null;
2470} 2340}
2471 2341
2472/* 2342void
2473 * Updates the canonical_key in op to value. 2343object::kv_set (const shstr &key, const shstr &value)
2474 *
2475 * canonical_key is a shared string (value doesn't have to be).
2476 *
2477 * Unless add_key is TRUE, it won't add fields, only change the value of existing
2478 * keys.
2479 *
2480 * Returns TRUE on success.
2481 */
2482int
2483set_ob_key_value_s (object *op, const shstr & canonical_key, const char *value, int add_key)
2484{ 2344{
2485 key_value *field = NULL, *last = NULL; 2345 for (key_value *kv = key_values; kv; kv = kv->next)
2486 2346 if (kv->key == key)
2487 for (field = op->key_values; field != NULL; field = field->next)
2488 {
2489 if (field->key != canonical_key)
2490 { 2347 {
2491 last = field; 2348 kv->value = value;
2492 continue; 2349 return;
2493 } 2350 }
2494 2351
2495 if (value) 2352 key_value *kv = new key_value;
2496 field->value = value; 2353
2497 else 2354 kv->next = key_values;
2355 kv->key = key;
2356 kv->value = value;
2357
2358 key_values = kv;
2359}
2360
2361void
2362object::kv_del (const shstr &key)
2363{
2364 for (key_value **kvp = &key_values; *kvp; kvp = &(*kvp)->next)
2365 if ((*kvp)->key == key)
2498 { 2366 {
2499 /* Basically, if the archetype has this key set, 2367 key_value *kv = *kvp;
2500 * we need to store the null value so when we save 2368 *kvp = (*kvp)->next;
2501 * it, we save the empty value so that when we load, 2369 delete kv;
2502 * we get this value back again. 2370 return;
2503 */
2504 if (get_ob_key_link (op->arch, canonical_key))
2505 field->value = 0;
2506 else
2507 {
2508 if (last)
2509 last->next = field->next;
2510 else
2511 op->key_values = field->next;
2512
2513 delete field;
2514 }
2515 } 2371 }
2516 return TRUE;
2517 }
2518 /* IF we get here, key doesn't exist */
2519
2520 /* No field, we'll have to add it. */
2521
2522 if (!add_key)
2523 return FALSE;
2524
2525 /* There isn't any good reason to store a null
2526 * value in the key/value list. If the archetype has
2527 * this key, then we should also have it, so shouldn't
2528 * be here. If user wants to store empty strings,
2529 * should pass in ""
2530 */
2531 if (value == NULL)
2532 return TRUE;
2533
2534 field = new key_value;
2535
2536 field->key = canonical_key;
2537 field->value = value;
2538 /* Usual prepend-addition. */
2539 field->next = op->key_values;
2540 op->key_values = field;
2541
2542 return TRUE;
2543}
2544
2545/*
2546 * Updates the key in op to value.
2547 *
2548 * If add_key is FALSE, this will only update existing keys,
2549 * and not add new ones.
2550 * In general, should be little reason FALSE is ever passed in for add_key
2551 *
2552 * Returns TRUE on success.
2553 */
2554int
2555set_ob_key_value (object *op, const char *key, const char *value, int add_key)
2556{
2557 shstr key_ (key);
2558
2559 return set_ob_key_value_s (op, key_, value, add_key);
2560} 2372}
2561 2373
2562object::depth_iterator::depth_iterator (object *container) 2374object::depth_iterator::depth_iterator (object *container)
2563: iterator_base (container) 2375: iterator_base (container)
2564{ 2376{
2614{ 2426{
2615 char flagdesc[512]; 2427 char flagdesc[512];
2616 char info2[256 * 4]; 2428 char info2[256 * 4];
2617 char *p = info; 2429 char *p = info;
2618 2430
2619 p += snprintf (p, 512, "{cnt:%d,uuid:%s,name:\"%s\"%s%s,flags:[%s],type:%d}", 2431 p += snprintf (p, 512, "{cnt:%d,uuid:%s,name:\"%s\"%s%s%s,flags:[%s],type:%d}",
2620 count, 2432 count,
2621 uuid.c_str (), 2433 uuid.c_str (),
2622 &name, 2434 &name,
2623 title ? "\",title:\"" : "", 2435 title ? ",title:\"" : "",
2624 title ? (const char *)title : "", 2436 title ? (const char *)title : "",
2437 title ? "\"" : "",
2625 flag_desc (flagdesc, 512), type); 2438 flag_desc (flagdesc, 512), type);
2626 2439
2627 if (!this->flag[FLAG_REMOVED] && env) 2440 if (!flag[FLAG_REMOVED] && env)
2628 p += snprintf (p, 256, "(in %s)", env->debug_desc (info2)); 2441 p += snprintf (p, 256, "(in %s)", env->debug_desc (info2));
2629 2442
2630 if (map) 2443 if (map)
2631 p += snprintf (p, 256, "(on %s@%d+%d)", &map->path, x, y); 2444 p += snprintf (p, 256, "(on %s@%d+%d)", &map->path, x, y);
2632 2445
2662object::open_container (object *new_container) 2475object::open_container (object *new_container)
2663{ 2476{
2664 if (container == new_container) 2477 if (container == new_container)
2665 return; 2478 return;
2666 2479
2667 if (object *old_container = container) 2480 object *old_container = container;
2481
2482 if (old_container)
2668 { 2483 {
2669 if (INVOKE_OBJECT (CLOSE, old_container, ARG_OBJECT (this))) 2484 if (INVOKE_OBJECT (CLOSE, old_container, ARG_OBJECT (this)))
2670 return; 2485 return;
2671 2486
2672#if 0 2487#if 0
2674 if (object *closer = old_container->inv) 2489 if (object *closer = old_container->inv)
2675 if (closer->type == CLOSE_CON) 2490 if (closer->type == CLOSE_CON)
2676 closer->destroy (); 2491 closer->destroy ();
2677#endif 2492#endif
2678 2493
2494 // make sure the container is available
2495 esrv_send_item (this, old_container);
2496
2679 old_container->flag [FLAG_APPLIED] = 0; 2497 old_container->flag [FLAG_APPLIED] = false;
2680 container = 0; 2498 container = 0;
2681 2499
2500 // client needs item update to make it work, client bug requires this to be separate
2682 esrv_update_item (UPD_FLAGS, this, old_container); 2501 esrv_update_item (UPD_FLAGS, this, old_container);
2502
2683 new_draw_info_format (NDI_UNIQUE, 0, this, "You close %s.", query_name (old_container)); 2503 new_draw_info_format (NDI_UNIQUE, 0, this, "You close %s.", query_name (old_container));
2684 play_sound (sound_find ("chest_close")); 2504 play_sound (sound_find ("chest_close"));
2685 } 2505 }
2686 2506
2687 if (new_container) 2507 if (new_container)
2700 } 2520 }
2701#endif 2521#endif
2702 2522
2703 new_draw_info_format (NDI_UNIQUE, 0, this, "You open %s.", query_name (new_container)); 2523 new_draw_info_format (NDI_UNIQUE, 0, this, "You open %s.", query_name (new_container));
2704 2524
2525 // make sure the container is available, client bug requires this to be separate
2526 esrv_send_item (this, new_container);
2527
2705 new_container->flag [FLAG_APPLIED] = 1; 2528 new_container->flag [FLAG_APPLIED] = true;
2706 container = new_container; 2529 container = new_container;
2707 2530
2531 // client needs flag change
2708 esrv_update_item (UPD_FLAGS, this, new_container); 2532 esrv_update_item (UPD_FLAGS, this, new_container);
2709 esrv_send_inventory (this, new_container); 2533 esrv_send_inventory (this, new_container);
2710 play_sound (sound_find ("chest_open")); 2534 play_sound (sound_find ("chest_open"));
2711 } 2535 }
2536// else if (!old_container->env && contr && contr->ns)
2537// contr->ns->floorbox_reset ();
2712} 2538}
2713 2539
2714object * 2540object *
2715object::force_find (const shstr name) 2541object::force_find (const shstr name)
2716{ 2542{
2742 2568
2743 insert (force); 2569 insert (force);
2744} 2570}
2745 2571
2746void 2572void
2747object::play_sound (faceidx sound) const 2573object::play_sound (faceidx sound)
2748{ 2574{
2749 if (!sound) 2575 if (!sound)
2750 return; 2576 return;
2751 2577
2752 if (flag [FLAG_REMOVED]) 2578 if (flag [FLAG_REMOVED])

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines