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.219 by root, Wed Apr 23 21:09:10 2008 UTC vs.
Revision 1.284 by root, Sat Jun 27 08:35:03 2009 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,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team 4 * Copyright (©) 2005,2006,2007,2008,2009 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
32#include <bitset> 32#include <bitset>
33 33
34UUID UUID::cur; 34UUID UUID::cur;
35static uint64_t seq_next_save; 35static uint64_t seq_next_save;
36static const uint64 UUID_GAP = 1<<19; 36static const uint64 UUID_GAP = 1<<19;
37uint32_t mapspace::smellcount = 10000;
37 38
38objectvec objects; 39objectvec objects;
39activevec actives; 40activevec actives;
40 41
41short freearr_x[SIZEOFFREE] = { 42short freearr_x[SIZEOFFREE] = {
139 140
140/* Returns TRUE if every key_values in wants has a partner with the same value in has. */ 141/* Returns TRUE if every key_values in wants has a partner with the same value in has. */
141static bool 142static bool
142compare_ob_value_lists_one (const object *wants, const object *has) 143compare_ob_value_lists_one (const object *wants, const object *has)
143{ 144{
144 key_value *wants_field;
145
146 /* n-squared behaviour (see get_ob_key_link()), but I'm hoping both 145 /* n-squared behaviour (see kv_get), but I'm hoping both
147 * objects with lists are rare, and lists stay short. If not, use a 146 * objects with lists are rare, and lists stay short. If not, use a
148 * different structure or at least keep the lists sorted... 147 * different structure or at least keep the lists sorted...
149 */ 148 */
150 149
151 /* For each field in wants, */ 150 /* For each field in wants, */
152 for (wants_field = wants->key_values; wants_field; wants_field = wants_field->next) 151 for (key_value *kv = wants->key_values; kv; kv = kv->next)
153 { 152 if (has->kv_get (kv->key) != kv->value)
154 key_value *has_field; 153 return false;
155
156 /* Look for a field in has with the same key. */
157 has_field = get_ob_key_link (has, wants_field->key);
158
159 if (!has_field)
160 return 0; /* No field with that name. */
161
162 /* Found the matching field. */
163 if (has_field->value != wants_field->value)
164 return 0; /* Values don't match, so this half of the comparison is false. */
165
166 /* If we get here, we found a match. Now for the next field in wants. */
167 }
168 154
169 /* If we get here, every field in wants has a matching field in has. */ 155 /* If we get here, every field in wants has a matching field in has. */
170 return 1; 156 return true;
171} 157}
172 158
173/* Returns TRUE if ob1 has the same key_values as ob2. */ 159/* Returns TRUE if ob1 has the same key_values as ob2. */
174static bool 160static bool
175compare_ob_value_lists (const object *ob1, const object *ob2) 161compare_ob_value_lists (const object *ob1, const object *ob2)
176{ 162{
177 /* However, there may be fields in has which aren't partnered in wants, 163 /* However, there may be fields in has which aren't partnered in wants,
178 * so we need to run the comparison *twice*. :( 164 * so we need to run the comparison *twice*. :(
179 */ 165 */
180 return compare_ob_value_lists_one (ob1, ob2) && compare_ob_value_lists_one (ob2, ob1); 166 return compare_ob_value_lists_one (ob1, ob2)
167 && compare_ob_value_lists_one (ob2, ob1);
181} 168}
182 169
183/* Function examines the 2 objects given to it, and returns true if 170/* Function examines the 2 objects given to it, and returns true if
184 * they can be merged together. 171 * they can be merged together.
185 * 172 *
200 || ob1->speed != ob2->speed 187 || ob1->speed != ob2->speed
201 || ob1->value != ob2->value 188 || ob1->value != ob2->value
202 || ob1->name != ob2->name) 189 || ob1->name != ob2->name)
203 return 0; 190 return 0;
204 191
205 /* Do not merge objects if nrof would overflow. First part checks 192 /* Do not merge objects if nrof would overflow, assume nrof
206 * for unsigned overflow (2c), second part checks whether the result 193 * is always 0 .. 2**31-1 */
207 * would fit into a 32 bit signed int, which is often used to hold 194 if (ob1->nrof > 0x7fffffff - ob2->nrof)
208 * nrof values.
209 */
210 if (~ob1->nrof < ob2->nrof || ob1->nrof + ob2->nrof > (1UL << 31))
211 return 0; 195 return 0;
212 196
213 /* If the objects have been identified, set the BEEN_APPLIED flag. 197 /* If the objects have been identified, set the BEEN_APPLIED flag.
214 * This is to the comparison of the flags below will be OK. We 198 * This is to the comparison of the flags below will be OK. We
215 * just can't ignore the been applied or identified flags, as they 199 * just can't ignore the been applied or identified flags, as they
220 SET_FLAG (ob1, FLAG_BEEN_APPLIED); 204 SET_FLAG (ob1, FLAG_BEEN_APPLIED);
221 205
222 if (QUERY_FLAG (ob2, FLAG_IDENTIFIED)) 206 if (QUERY_FLAG (ob2, FLAG_IDENTIFIED))
223 SET_FLAG (ob2, FLAG_BEEN_APPLIED); 207 SET_FLAG (ob2, FLAG_BEEN_APPLIED);
224 208
225 if (ob1->arch->name != ob2->arch->name 209 if (ob1->arch->archname != ob2->arch->archname
226 || ob1->name != ob2->name 210 || ob1->name != ob2->name
227 || ob1->title != ob2->title 211 || ob1->title != ob2->title
228 || ob1->msg != ob2->msg 212 || ob1->msg != ob2->msg
229 || ob1->weight != ob2->weight 213 || ob1->weight != ob2->weight
230 || ob1->attacktype != ob2->attacktype 214 || ob1->attacktype != ob2->attacktype
231 || ob1->magic != ob2->magic 215 || ob1->magic != ob2->magic
232 || ob1->slaying != ob2->slaying 216 || ob1->slaying != ob2->slaying
233 || ob1->skill != ob2->skill 217 || ob1->skill != ob2->skill
234 || ob1->value != ob2->value 218 || ob1->value != ob2->value
235 || ob1->animation_id != ob2->animation_id 219 || ob1->animation_id != ob2->animation_id
220 || (ob1->face != ob2->face && !ob1->animation_id) // face and animation are dependent on each other
236 || ob1->client_type != ob2->client_type 221 || ob1->client_type != ob2->client_type
237 || ob1->materialname != ob2->materialname 222 || ob1->materialname != ob2->materialname
238 || ob1->lore != ob2->lore 223 || ob1->lore != ob2->lore
239 || ob1->subtype != ob2->subtype 224 || ob1->subtype != ob2->subtype
240 || ob1->move_type != ob2->move_type 225 || ob1->move_type != ob2->move_type
248 || memcmp (&ob1->stats , &ob2->stats , sizeof (ob1->stats))) 233 || memcmp (&ob1->stats , &ob2->stats , sizeof (ob1->stats)))
249 return 0; 234 return 0;
250 235
251 if ((ob1->flag ^ ob2->flag) 236 if ((ob1->flag ^ ob2->flag)
252 .reset (FLAG_INV_LOCKED) 237 .reset (FLAG_INV_LOCKED)
253 .reset (FLAG_CLIENT_SENT)
254 .reset (FLAG_REMOVED) 238 .reset (FLAG_REMOVED)
255 .any ()) 239 .any ())
256 return 0; 240 return 0;
257 241
258 /* This is really a spellbook check - we should in general 242 /* This is really a spellbook check - we should in general
334 318
335// find player who can see this object 319// find player who can see this object
336object * 320object *
337object::visible_to () const 321object::visible_to () const
338{ 322{
339 if (!flag [FLAG_REMOVED]) 323 if (client_visible () && !flag [FLAG_REMOVED])
340 { 324 {
341 // see if we are in a container of sorts 325 // see if we are in a container of sorts
342 if (env) 326 if (env)
343 { 327 {
344 // the player inventory itself is always visible 328 // the player inventory itself is always visible
345 if (env->type == PLAYER) 329 if (env->is_player ())
346 return env; 330 return env;
347 331
348 // else a player could have our env open 332 // else a player could have our env open
349 object *envest = env->outer_env (); 333 object *envest = env->outer_env ();
350 334
358 else 342 else
359 { 343 {
360 // maybe there is a player standing on the same mapspace 344 // maybe there is a player standing on the same mapspace
361 // this will catch the case where "this" is a player 345 // this will catch the case where "this" is a player
362 if (object *pl = ms ().player ()) 346 if (object *pl = ms ().player ())
347 if ((!pl->container && pl->contr->ns && !pl->contr->ns->update_look)
348 || this == pl->container)
363 return pl; 349 return pl;
364 } 350 }
365 } 351 }
366 352
367 return 0; 353 return 0;
368} 354}
369 355
370// adjust weight per container type ("of holding") 356// adjust weight per container type ("of holding")
371static sint32 357static sint32
372weight_adjust (object *op, sint32 weight) 358weight_adjust_for (object *op, sint32 weight)
373{ 359{
374 return op->type == CONTAINER 360 return op->type == CONTAINER
375 ? lerp (weight, 0, 100, 0, 100 - op->stats.Str) 361 ? lerp (weight, 0, 100, 0, 100 - op->stats.Str)
376 : weight; 362 : weight;
377} 363}
383static void 369static void
384adjust_weight (object *op, sint32 weight) 370adjust_weight (object *op, sint32 weight)
385{ 371{
386 while (op) 372 while (op)
387 { 373 {
374 // adjust by actual difference to account for rounding errors
375 // i.e. (w2 - w1) / f != w2 / f - w1 / f and the latter is correct
388 weight = weight_adjust (op, weight); 376 weight = weight_adjust_for (op, op->carrying)
377 - weight_adjust_for (op, op->carrying - weight);
389 378
390 if (!weight) 379 if (!weight)
391 return; 380 return;
392 381
393 op->carrying += weight; 382 op->carrying += weight;
416 op->update_weight (); 405 op->update_weight ();
417 406
418 sum += op->total_weight (); 407 sum += op->total_weight ();
419 } 408 }
420 409
421 sum = weight_adjust (this, sum); 410 sum = weight_adjust_for (this, sum);
422 411
423 if (sum != carrying) 412 if (sum != carrying)
424 { 413 {
425 carrying = sum; 414 carrying = sum;
426 415
488 */ 477 */
489object * 478object *
490find_object_name (const char *str) 479find_object_name (const char *str)
491{ 480{
492 shstr_cmp str_ (str); 481 shstr_cmp str_ (str);
493 object *op;
494 482
483 if (str_)
495 for_all_objects (op) 484 for_all_objects (op)
496 if (op->name == str_) 485 if (op->name == str_)
497 break; 486 return op;
498 487
499 return op; 488 return 0;
500} 489}
501 490
502/* 491/*
503 * Sets the owner and sets the skill and exp pointers to owner's current 492 * Sets the owner and sets the skill and exp pointers to owner's current
504 * skill and experience objects. 493 * skill and experience objects.
602 } 591 }
603 592
604 op->key_values = 0; 593 op->key_values = 0;
605} 594}
606 595
607object & 596/*
608object::operator =(const object &src) 597 * copy_to first frees everything allocated by the dst object,
598 * and then copies the contents of itself into the second
599 * object, allocating what needs to be allocated. Basically, any
600 * data that is malloc'd needs to be re-malloc/copied. Otherwise,
601 * if the first object is freed, the pointers in the new object
602 * will point at garbage.
603 */
604void
605object::copy_to (object *dst)
609{ 606{
610 bool is_freed = flag [FLAG_FREED]; 607 dst->remove ();
611 bool is_removed = flag [FLAG_REMOVED];
612
613 *(object_copy *)this = src; 608 *(object_copy *)dst = *this;
614
615 flag [FLAG_FREED] = is_freed;
616 flag [FLAG_REMOVED] = is_removed; 609 dst->flag [FLAG_REMOVED] = true;
617 610
618 /* Copy over key_values, if any. */ 611 /* Copy over key_values, if any. */
619 if (src.key_values) 612 if (key_values)
620 { 613 {
621 key_value *tail = 0; 614 key_value *tail = 0;
622 key_values = 0; 615 dst->key_values = 0;
623 616
624 for (key_value *i = src.key_values; i; i = i->next) 617 for (key_value *i = key_values; i; i = i->next)
625 { 618 {
626 key_value *new_link = new key_value; 619 key_value *new_link = new key_value;
627 620
628 new_link->next = 0; 621 new_link->next = 0;
629 new_link->key = i->key; 622 new_link->key = i->key;
630 new_link->value = i->value; 623 new_link->value = i->value;
631 624
632 /* Try and be clever here, too. */ 625 /* Try and be clever here, too. */
633 if (!key_values) 626 if (!dst->key_values)
634 { 627 {
635 key_values = new_link; 628 dst->key_values = new_link;
636 tail = new_link; 629 tail = new_link;
637 } 630 }
638 else 631 else
639 { 632 {
640 tail->next = new_link; 633 tail->next = new_link;
641 tail = new_link; 634 tail = new_link;
642 } 635 }
643 } 636 }
644 } 637 }
645}
646
647/*
648 * copy_to first frees everything allocated by the dst object,
649 * and then copies the contents of itself into the second
650 * object, allocating what needs to be allocated. Basically, any
651 * data that is malloc'd needs to be re-malloc/copied. Otherwise,
652 * if the first object is freed, the pointers in the new object
653 * will point at garbage.
654 */
655void
656object::copy_to (object *dst)
657{
658 *dst = *this;
659 638
660 if (speed < 0) 639 if (speed < 0)
661 dst->speed_left -= rndm (); 640 dst->speed_left -= rndm ();
662 641
663 dst->set_speed (dst->speed); 642 dst->activate ();
664} 643}
665 644
666void 645void
667object::instantiate () 646object::instantiate ()
668{ 647{
685object * 664object *
686object::clone () 665object::clone ()
687{ 666{
688 object *neu = create (); 667 object *neu = create ();
689 copy_to (neu); 668 copy_to (neu);
669 neu->map = map; // not copied by copy_to
690 return neu; 670 return neu;
691} 671}
692 672
693/* 673/*
694 * If an object with the IS_TURNABLE() flag needs to be turned due 674 * If an object with the IS_TURNABLE() flag needs to be turned due
745 * UP_OBJ_FACE: only the objects face has changed. 725 * UP_OBJ_FACE: only the objects face has changed.
746 */ 726 */
747void 727void
748update_object (object *op, int action) 728update_object (object *op, int action)
749{ 729{
750 if (op == NULL) 730 if (!op)
751 { 731 {
752 /* this should never happen */ 732 /* this should never happen */
753 LOG (llevDebug, "update_object() called for NULL object.\n"); 733 LOG (llevError | logBacktrace, "update_object() called for NULL object.\n");
754 return; 734 return;
755 } 735 }
756 736
757 if (op->env) 737 if (!op->is_on_map ())
758 { 738 {
759 /* Animation is currently handled by client, so nothing 739 /* Animation is currently handled by client, so nothing
760 * to do in this case. 740 * to do in this case.
761 */ 741 */
762 return; 742 return;
763 } 743 }
764
765 /* If the map is saving, don't do anything as everything is
766 * going to get freed anyways.
767 */
768 if (!op->map || op->map->in_memory == MAP_SAVING)
769 return;
770 744
771 /* make sure the object is within map boundaries */ 745 /* make sure the object is within map boundaries */
772 if (op->x < 0 || op->x >= op->map->width || op->y < 0 || op->y >= op->map->height) 746 if (op->x < 0 || op->x >= op->map->width || op->y < 0 || op->y >= op->map->height)
773 { 747 {
774 LOG (llevError, "update_object() called for object out of map!\n"); 748 LOG (llevError, "update_object() called for object out of map!\n");
785 else if (action == UP_OBJ_INSERT) 759 else if (action == UP_OBJ_INSERT)
786 { 760 {
787 // this is likely overkill, TODO: revisit (schmorp) 761 // this is likely overkill, TODO: revisit (schmorp)
788 if ((QUERY_FLAG (op, FLAG_BLOCKSVIEW) && !(m.flags_ & P_BLOCKSVIEW)) 762 if ((QUERY_FLAG (op, FLAG_BLOCKSVIEW) && !(m.flags_ & P_BLOCKSVIEW))
789 || (QUERY_FLAG (op, FLAG_NO_MAGIC) && !(m.flags_ & P_NO_MAGIC)) 763 || (QUERY_FLAG (op, FLAG_NO_MAGIC) && !(m.flags_ & P_NO_MAGIC))
790 || (op->type == PLAYER && !(m.flags_ & P_PLAYER)) 764 || (op->is_player () && !(m.flags_ & P_PLAYER))
791 || (op->type == SAFE_GROUND && !(m.flags_ & P_SAFE)) 765 || (op->type == SAFE_GROUND && !(m.flags_ & P_SAFE))
792 || (QUERY_FLAG (op, FLAG_ALIVE) && !(m.flags_ & P_IS_ALIVE)) 766 || (QUERY_FLAG (op, FLAG_ALIVE) && !(m.flags_ & P_IS_ALIVE))
793 || (QUERY_FLAG (op, FLAG_DAMNED) && !(m.flags_ & P_NO_CLERIC)) 767 || (QUERY_FLAG (op, FLAG_DAMNED) && !(m.flags_ & P_NO_CLERIC))
794 || (m.move_on | op->move_on ) != m.move_on 768 || (m.move_on | op->move_on ) != m.move_on
795 || (m.move_off | op->move_off ) != m.move_off 769 || (m.move_off | op->move_off ) != m.move_off
796 || (m.move_slow | op->move_slow) != m.move_slow 770 || (m.move_slow | op->move_slow) != m.move_slow
797 /* This isn't perfect, but I don't expect a lot of objects to 771 /* This isn't perfect, but I don't expect a lot of objects to
798 * to have move_allow right now. 772 * have move_allow right now.
799 */ 773 */
800 || ((m.move_block | op->move_block) & ~op->move_allow) != m.move_block 774 || ((m.move_block | op->move_block) & ~op->move_allow) != m.move_block
801 || 1) // the above is not strong enough a test to skip updating. los maybe? TODO (Schmorp) 775 || 1) // the above is not strong enough a test to skip updating. los maybe? TODO (Schmorp)
802 m.flags_ = 0; 776 m.invalidate ();
803 } 777 }
804 /* if the object is being removed, we can't make intelligent 778 /* if the object is being removed, we can't make intelligent
805 * decisions, because remove_ob can't really pass the object 779 * decisions, because remove_ob can't really pass the object
806 * that is being removed. 780 * that is being removed.
807 */ 781 */
808 else if (action == UP_OBJ_CHANGE || action == UP_OBJ_REMOVE) 782 else if (action == UP_OBJ_CHANGE || action == UP_OBJ_REMOVE)
809 m.flags_ = 0; 783 m.invalidate ();
810 else if (action == UP_OBJ_FACE) 784 else if (action == UP_OBJ_FACE)
811 /* Nothing to do for that case */ ; 785 /* Nothing to do for that case */ ;
812 else 786 else
813 LOG (llevError, "update_object called with invalid action: %d\n", action); 787 LOG (llevError, "update_object called with invalid action: %d\n", action);
814 788
818 792
819object::object () 793object::object ()
820{ 794{
821 SET_FLAG (this, FLAG_REMOVED); 795 SET_FLAG (this, FLAG_REMOVED);
822 796
823 expmul = 1.0; 797 //expmul = 1.0; declared const for the time being
824 face = blank_face; 798 face = blank_face;
825} 799}
826 800
827object::~object () 801object::~object ()
828{ 802{
856object::activate () 830object::activate ()
857{ 831{
858 /* If already on active list, don't do anything */ 832 /* If already on active list, don't do anything */
859 if (active) 833 if (active)
860 return; 834 return;
835
836 if (has_active_speed () && flag [FLAG_FREED]) LOG (llevError | logBacktrace, "BUG: tried to activate freed object %s\n", debug_desc ());//D
837 if (has_active_speed () && flag [FLAG_DEBUG]) LOG (llevError | logBacktrace, "BUG: tried to activate DEBUG object %s\n", debug_desc ());//D temp
861 838
862 if (has_active_speed ()) 839 if (has_active_speed ())
863 actives.insert (this); 840 actives.insert (this);
864} 841}
865 842
929 * drop on that space. 906 * drop on that space.
930 */ 907 */
931 if (!drop_to_ground 908 if (!drop_to_ground
932 || !map 909 || !map
933 || map->in_memory != MAP_ACTIVE 910 || map->in_memory != MAP_ACTIVE
934 || map->nodrop 911 || map->no_drop
935 || ms ().move_block == MOVE_ALL) 912 || ms ().move_block == MOVE_ALL)
936 { 913 {
937 while (inv) 914 while (inv)
938 {
939 inv->destroy_inv (false);
940 inv->destroy (); 915 inv->destroy ();
941 }
942 } 916 }
943 else 917 else
944 { /* Put objects in inventory onto this space */ 918 { /* Put objects in inventory onto this space */
945 while (inv) 919 while (inv)
946 { 920 {
950 || op->flag [FLAG_NO_DROP] 924 || op->flag [FLAG_NO_DROP]
951 || op->type == RUNE 925 || op->type == RUNE
952 || op->type == TRAP 926 || op->type == TRAP
953 || op->flag [FLAG_IS_A_TEMPLATE] 927 || op->flag [FLAG_IS_A_TEMPLATE]
954 || op->flag [FLAG_DESTROY_ON_DEATH]) 928 || op->flag [FLAG_DESTROY_ON_DEATH])
955 op->destroy (true); 929 op->destroy ();
956 else 930 else
957 map->insert (op, x, y); 931 map->insert (op, x, y);
958 } 932 }
959 } 933 }
960} 934}
964 object *op = new object; 938 object *op = new object;
965 op->link (); 939 op->link ();
966 return op; 940 return op;
967} 941}
968 942
943static struct freed_map : maptile
944{
945 freed_map ()
946 {
947 path = "<freed objects map>";
948 name = "/internal/freed_objects_map";
949 width = 3;
950 height = 3;
951 no_drop = 1;
952 no_reset = 1;
953
954 alloc ();
955 in_memory = MAP_ACTIVE;
956 }
957
958 ~freed_map ()
959 {
960 destroy ();
961 }
962} freed_map; // freed objects are moved here to avoid crashes
963
969void 964void
970object::do_destroy () 965object::do_destroy ()
971{ 966{
972 if (flag [FLAG_IS_LINKED]) 967 if (flag [FLAG_IS_LINKED])
973 remove_button_link (this); 968 remove_link ();
974 969
975 if (flag [FLAG_FRIENDLY]) 970 if (flag [FLAG_FRIENDLY])
976 remove_friendly_object (this); 971 remove_friendly_object (this);
977 972
978 remove (); 973 remove ();
983 unlink (); 978 unlink ();
984 979
985 flag [FLAG_FREED] = 1; 980 flag [FLAG_FREED] = 1;
986 981
987 // hack to ensure that freed objects still have a valid map 982 // hack to ensure that freed objects still have a valid map
988 {
989 static maptile *freed_map; // freed objects are moved here to avoid crashes
990
991 if (!freed_map)
992 {
993 freed_map = new maptile;
994
995 freed_map->path = "<freed objects map>";
996 freed_map->name = "/internal/freed_objects_map";
997 freed_map->width = 3;
998 freed_map->height = 3;
999 freed_map->nodrop = 1;
1000
1001 freed_map->alloc ();
1002 freed_map->in_memory = MAP_ACTIVE;
1003 }
1004
1005 map = freed_map; 983 map = &freed_map;
1006 x = 1; 984 x = 1;
1007 y = 1; 985 y = 1;
1008 }
1009 986
1010 if (more) 987 if (more)
1011 { 988 {
1012 more->destroy (); 989 more->destroy ();
1013 more = 0; 990 more = 0;
1021 attacked_by = 0; 998 attacked_by = 0;
1022 current_weapon = 0; 999 current_weapon = 0;
1023} 1000}
1024 1001
1025void 1002void
1026object::destroy (bool destroy_inventory) 1003object::destroy ()
1027{ 1004{
1028 if (destroyed ()) 1005 if (destroyed ())
1029 return; 1006 return;
1030 1007
1031 if (!is_head () && !head->destroyed ()) 1008 if (!is_head () && !head->destroyed ())
1032 { 1009 {
1033 LOG (llevError | logBacktrace, "tried to destroy the tail of an object"); 1010 LOG (llevError | logBacktrace, "tried to destroy the tail of an object");
1034 head->destroy (destroy_inventory); 1011 head->destroy ();
1012 return;
1035 } 1013 }
1036 1014
1037 destroy_inv (!destroy_inventory); 1015 destroy_inv (false);
1038 1016
1039 if (is_head ()) 1017 if (is_head ())
1040 if (sound_destroy) 1018 if (sound_destroy)
1041 play_sound (sound_destroy); 1019 play_sound (sound_destroy);
1042 else if (flag [FLAG_MONSTER]) 1020 else if (flag [FLAG_MONSTER])
1061 if (flag [FLAG_REMOVED]) 1039 if (flag [FLAG_REMOVED])
1062 return; 1040 return;
1063 1041
1064 INVOKE_OBJECT (REMOVE, this); 1042 INVOKE_OBJECT (REMOVE, this);
1065 1043
1066 if (object *pl = visible_to ())
1067 esrv_del_item (pl->contr, count);
1068
1069 flag [FLAG_REMOVED] = true; 1044 flag [FLAG_REMOVED] = true;
1070 1045
1071 if (more) 1046 if (more)
1072 more->remove (); 1047 more->remove ();
1073 1048
1075 * In this case, the object to be removed is in someones 1050 * In this case, the object to be removed is in someones
1076 * inventory. 1051 * inventory.
1077 */ 1052 */
1078 if (env) 1053 if (env)
1079 { 1054 {
1055 flag [FLAG_REMOVED] = false; // hack around the issue of visible_to checking flag_removed
1056 if (object *pl = visible_to ())
1057 esrv_del_item (pl->contr, count);
1058 flag [FLAG_REMOVED] = true; // hack around the issue of visible_to checking flag_removed
1059
1080 adjust_weight (env, -total_weight ()); 1060 adjust_weight (env, -total_weight ());
1081 1061
1082 *(above ? &above->below : &env->inv) = below; 1062 object *pl = in_player ();
1083
1084 if (below)
1085 below->above = above;
1086 1063
1087 /* we set up values so that it could be inserted into 1064 /* we set up values so that it could be inserted into
1088 * the map, but we don't actually do that - it is up 1065 * the map, but we don't actually do that - it is up
1089 * to the caller to decide what we want to do. 1066 * to the caller to decide what we want to do.
1090 */ 1067 */
1091 map = env->map; 1068 map = env->map;
1092 x = env->x; 1069 x = env->x;
1093 y = env->y; 1070 y = env->y;
1071
1072 // make sure cmov optimisation is applicable
1073 *(above ? &above->below : &env->inv) = below;
1074 *(below ? &below->above : &above ) = above; // &above is just a dummy
1075
1094 above = 0; 1076 above = 0;
1095 below = 0; 1077 below = 0;
1096 env = 0; 1078 env = 0;
1097 1079
1098 /* NO_FIX_PLAYER is set when a great many changes are being 1080 /* NO_FIX_PLAYER is set when a great many changes are being
1099 * made to players inventory. If set, avoiding the call 1081 * made to players inventory. If set, avoiding the call
1100 * to save cpu time. 1082 * to save cpu time.
1101 */ 1083 */
1102 if ((otmp = in_player ()) && otmp->contr && !QUERY_FLAG (otmp, FLAG_NO_FIX_PLAYER)) 1084 if (pl)
1085 if (pl->is_player () && (glow_radius || !QUERY_FLAG (pl, FLAG_NO_FIX_PLAYER)))
1086 {
1103 otmp->update_stats (); 1087 pl->update_stats ();
1088
1089 if (glow_radius && pl->is_on_map ())
1090 update_all_los (pl->map, pl->x, pl->y);
1091 }
1104 } 1092 }
1105 else if (map) 1093 else if (map)
1106 { 1094 {
1107 if (type == PLAYER)
1108 {
1109 // leaving a spot always closes any open container on the ground
1110 if (container && !container->env)
1111 // this causes spurious floorbox updates, but it ensures
1112 // that the CLOSE event is being sent.
1113 close_container ();
1114
1115 --map->players;
1116 map->touch ();
1117 }
1118
1119 map->dirty = true; 1095 map->dirty = true;
1120 mapspace &ms = this->ms (); 1096 mapspace &ms = this->ms ();
1121 1097
1098 if (object *pl = ms.player ())
1099 {
1100 if (is_player ())
1101 {
1102 if (!flag [FLAG_WIZPASS])
1103 ms.smell = ++mapspace::smellcount; // remember the smell of the player
1104
1105 // leaving a spot always closes any open container on the ground
1106 if (container && !container->env)
1107 // this causes spurious floorbox updates, but it ensures
1108 // that the CLOSE event is being sent.
1109 close_container ();
1110
1111 --map->players;
1112 map->touch ();
1113 }
1114 else if (pl->container == this)
1115 {
1116 // removing a container should close it
1117 close_container ();
1118 }
1119
1120 esrv_del_item (pl->contr, count);
1121 }
1122
1122 /* link the object above us */ 1123 /* link the object above us */
1123 if (above) 1124 // re-link, make sure compiler can easily use cmove
1124 above->below = below; 1125 *(above ? &above->below : &ms.top) = below;
1125 else 1126 *(below ? &below->above : &ms.bot) = above;
1126 ms.top = below; /* we were top, set new top */
1127
1128 /* Relink the object below us, if there is one */
1129 if (below)
1130 below->above = above;
1131 else
1132 {
1133 /* Nothing below, which means we need to relink map object for this space
1134 * use translated coordinates in case some oddness with map tiling is
1135 * evident
1136 */
1137 if (GET_MAP_OB (map, x, y) != this)
1138 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 ());
1139
1140 ms.bot = above; /* goes on above it. */
1141 }
1142 1127
1143 above = 0; 1128 above = 0;
1144 below = 0; 1129 below = 0;
1130
1131 ms.invalidate ();
1145 1132
1146 if (map->in_memory == MAP_SAVING) 1133 if (map->in_memory == MAP_SAVING)
1147 return; 1134 return;
1148 1135
1149 int check_walk_off = !flag [FLAG_NO_APPLY]; 1136 int check_walk_off = !flag [FLAG_NO_APPLY];
1156 * appropriately. 1143 * appropriately.
1157 */ 1144 */
1158 pl->close_container (); 1145 pl->close_container ();
1159 1146
1160 //TODO: the floorbox prev/next might need updating 1147 //TODO: the floorbox prev/next might need updating
1161 esrv_del_item (pl->contr, count); 1148 //esrv_del_item (pl->contr, count);
1149 //TODO: update floorbox to preserve ordering
1150 if (pl->contr->ns)
1151 pl->contr->ns->floorbox_update ();
1162 } 1152 }
1163 1153
1164 for (tmp = ms.bot; tmp; tmp = tmp->above) 1154 for (tmp = ms.bot; tmp; tmp = tmp->above)
1165 { 1155 {
1166 /* No point updating the players look faces if he is the object 1156 /* No point updating the players look faces if he is the object
1179 } 1169 }
1180 1170
1181 last = tmp; 1171 last = tmp;
1182 } 1172 }
1183 1173
1184 /* last == NULL if there are no objects on this space */ 1174 if (affects_los ())
1185 //TODO: this makes little sense, why only update the topmost object?
1186 if (!last)
1187 map->at (x, y).flags_ = 0;
1188 else
1189 update_object (last, UP_OBJ_REMOVE);
1190
1191 if (flag [FLAG_BLOCKSVIEW] || glow_radius)
1192 update_all_los (map, x, y); 1175 update_all_los (map, x, y);
1193 } 1176 }
1194} 1177}
1195 1178
1196/* 1179/*
1220 esrv_update_item (UPD_NROF, pl, top); 1203 esrv_update_item (UPD_NROF, pl, top);
1221 1204
1222 op->weight = 0; // cancel the addition above 1205 op->weight = 0; // cancel the addition above
1223 op->carrying = 0; // must be 0 already 1206 op->carrying = 0; // must be 0 already
1224 1207
1225 op->destroy (1); 1208 op->destroy ();
1226 1209
1227 return top; 1210 return top;
1228 } 1211 }
1229 1212
1230 return 0; 1213 return 0;
1258 * job preparing multi-part monsters. 1241 * job preparing multi-part monsters.
1259 */ 1242 */
1260object * 1243object *
1261insert_ob_in_map_at (object *op, maptile *m, object *originator, int flag, int x, int y) 1244insert_ob_in_map_at (object *op, maptile *m, object *originator, int flag, int x, int y)
1262{ 1245{
1246 op->remove ();
1247
1263 for (object *tmp = op->head_ (); tmp; tmp = tmp->more) 1248 for (object *tmp = op->head_ (); tmp; tmp = tmp->more)
1264 { 1249 {
1265 tmp->x = x + tmp->arch->x; 1250 tmp->x = x + tmp->arch->x;
1266 tmp->y = y + tmp->arch->y; 1251 tmp->y = y + tmp->arch->y;
1267 } 1252 }
1290 * just 'op' otherwise 1275 * just 'op' otherwise
1291 */ 1276 */
1292object * 1277object *
1293insert_ob_in_map (object *op, maptile *m, object *originator, int flag) 1278insert_ob_in_map (object *op, maptile *m, object *originator, int flag)
1294{ 1279{
1295 assert (!op->flag [FLAG_FREED]);
1296
1297 op->remove (); 1280 op->remove ();
1281
1282 if (m == &freed_map)//D TODO: remove soon
1283 {//D
1284 LOG (llevError | logBacktrace, "tries to insret object on freed objects map: %s", op->debug_desc ());//D
1285 }//D
1298 1286
1299 /* Ideally, the caller figures this out. However, it complicates a lot 1287 /* Ideally, the caller figures this out. However, it complicates a lot
1300 * of areas of callers (eg, anything that uses find_free_spot would now 1288 * of areas of callers (eg, anything that uses find_free_spot would now
1301 * need extra work 1289 * need extra work
1302 */ 1290 */
1291 maptile *newmap = m;
1303 if (!xy_normalise (m, op->x, op->y)) 1292 if (!xy_normalise (newmap, op->x, op->y))
1304 { 1293 {
1305 op->destroy (1); 1294 op->head_ ()->destroy ();// remove head_ once all tail object destroyers found
1306 return 0; 1295 return 0;
1307 } 1296 }
1308 1297
1309 if (object *more = op->more) 1298 if (object *more = op->more)
1310 if (!insert_ob_in_map (more, m, originator, flag)) 1299 if (!insert_ob_in_map (more, m, originator, flag))
1311 return 0; 1300 return 0;
1312 1301
1313 CLEAR_FLAG (op, FLAG_REMOVED); 1302 op->flag [FLAG_REMOVED] = false;
1314 1303 op->env = 0;
1315 op->map = m; 1304 op->map = newmap;
1305
1316 mapspace &ms = op->ms (); 1306 mapspace &ms = op->ms ();
1317 1307
1318 /* this has to be done after we translate the coordinates. 1308 /* this has to be done after we translate the coordinates.
1319 */ 1309 */
1320 if (op->nrof && !(flag & INS_NO_MERGE)) 1310 if (op->nrof && !(flag & INS_NO_MERGE))
1321 for (object *tmp = ms.bot; tmp; tmp = tmp->above) 1311 for (object *tmp = ms.bot; tmp; tmp = tmp->above)
1322 if (object::can_merge (op, tmp)) 1312 if (object::can_merge (op, tmp))
1323 { 1313 {
1324 // TODO: we atcually want to update tmp, not op, 1314 // TODO: we actually want to update tmp, not op,
1325 // but some caller surely breaks when we return tmp 1315 // but some caller surely breaks when we return tmp
1326 // from here :/ 1316 // from here :/
1327 op->nrof += tmp->nrof; 1317 op->nrof += tmp->nrof;
1328 tmp->destroy (1); 1318 tmp->destroy ();
1329 } 1319 }
1330 1320
1331 CLEAR_FLAG (op, FLAG_APPLIED); /* hack for fixing F_APPLIED in items of dead people */ 1321 CLEAR_FLAG (op, FLAG_APPLIED); /* hack for fixing F_APPLIED in items of dead people */
1332 CLEAR_FLAG (op, FLAG_INV_LOCKED); 1322 CLEAR_FLAG (op, FLAG_INV_LOCKED);
1333 1323
1340 { 1330 {
1341 LOG (llevError, "insert_ob_in_map called with INS_BELOW_ORIGINATOR when originator not on same space!\n"); 1331 LOG (llevError, "insert_ob_in_map called with INS_BELOW_ORIGINATOR when originator not on same space!\n");
1342 abort (); 1332 abort ();
1343 } 1333 }
1344 1334
1335 if (!originator->is_on_map ())
1336 {
1337 LOG (llevError, "insert_ob_in_map(%s) called with INS_BELOW_ORIGINATOR when originator '%s' not on map",
1338 op->debug_desc (), originator->debug_desc ());
1339 abort ();
1340 }
1341
1345 op->above = originator; 1342 op->above = originator;
1346 op->below = originator->below; 1343 op->below = originator->below;
1347
1348 if (op->below)
1349 op->below->above = op;
1350 else
1351 ms.bot = op;
1352
1353 /* since *below* originator, no need to update top */
1354 originator->below = op; 1344 originator->below = op;
1345
1346 *(op->below ? &op->below->above : &ms.bot) = op;
1355 } 1347 }
1356 else 1348 else
1357 { 1349 {
1358 object *top, *floor = NULL; 1350 object *floor = 0;
1359 1351 object *top = ms.top;
1360 top = ms.bot;
1361 1352
1362 /* If there are other objects, then */ 1353 /* If there are other objects, then */
1363 if (top) 1354 if (top)
1364 { 1355 {
1365 object *last = 0;
1366
1367 /* 1356 /*
1368 * If there are multiple objects on this space, we do some trickier handling. 1357 * If there are multiple objects on this space, we do some trickier handling.
1369 * We've already dealt with merging if appropriate. 1358 * We've already dealt with merging if appropriate.
1370 * Generally, we want to put the new object on top. But if 1359 * Generally, we want to put the new object on top. But if
1371 * flag contains INS_ABOVE_FLOOR_ONLY, once we find the last 1360 * flag contains INS_ABOVE_FLOOR_ONLY, once we find the last
1374 * once we get to them. This reduces the need to traverse over all of 1363 * once we get to them. This reduces the need to traverse over all of
1375 * them when adding another one - this saves quite a bit of cpu time 1364 * them when adding another one - this saves quite a bit of cpu time
1376 * when lots of spells are cast in one area. Currently, it is presumed 1365 * when lots of spells are cast in one area. Currently, it is presumed
1377 * that flying non pickable objects are spell objects. 1366 * that flying non pickable objects are spell objects.
1378 */ 1367 */
1379 for (top = ms.bot; top; top = top->above) 1368 for (object *tmp = ms.bot; tmp; tmp = tmp->above)
1380 { 1369 {
1381 if (QUERY_FLAG (top, FLAG_IS_FLOOR) || QUERY_FLAG (top, FLAG_OVERLAY_FLOOR)) 1370 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR) || QUERY_FLAG (tmp, FLAG_OVERLAY_FLOOR))
1382 floor = top; 1371 floor = tmp;
1383 1372
1384 if (QUERY_FLAG (top, FLAG_NO_PICK) && (top->move_type & (MOVE_FLY_LOW | MOVE_FLY_HIGH)) && !QUERY_FLAG (top, FLAG_IS_FLOOR)) 1373 if (QUERY_FLAG (tmp, FLAG_NO_PICK) && (tmp->move_type & (MOVE_FLY_LOW | MOVE_FLY_HIGH)) && !QUERY_FLAG (tmp, FLAG_IS_FLOOR))
1385 { 1374 {
1386 /* We insert above top, so we want this object below this */ 1375 /* We insert above top, so we want this object below this */
1387 top = top->below; 1376 top = tmp->below;
1388 break; 1377 break;
1389 } 1378 }
1390 1379
1391 last = top; 1380 top = tmp;
1392 } 1381 }
1393
1394 /* Don't want top to be NULL, so set it to the last valid object */
1395 top = last;
1396 1382
1397 /* We let update_position deal with figuring out what the space 1383 /* We let update_position deal with figuring out what the space
1398 * looks like instead of lots of conditions here. 1384 * looks like instead of lots of conditions here.
1399 * makes things faster, and effectively the same result. 1385 * makes things faster, and effectively the same result.
1400 */ 1386 */
1407 */ 1393 */
1408 if (!(flag & INS_ON_TOP) 1394 if (!(flag & INS_ON_TOP)
1409 && ms.flags () & P_BLOCKSVIEW 1395 && ms.flags () & P_BLOCKSVIEW
1410 && (op->face && !faces [op->face].visibility)) 1396 && (op->face && !faces [op->face].visibility))
1411 { 1397 {
1398 object *last;
1399
1412 for (last = top; last != floor; last = last->below) 1400 for (last = top; last != floor; last = last->below)
1413 if (QUERY_FLAG (last, FLAG_BLOCKSVIEW) && (last->type != EXIT)) 1401 if (QUERY_FLAG (last, FLAG_BLOCKSVIEW) && (last->type != EXIT))
1414 break; 1402 break;
1415 1403
1416 /* Check to see if we found the object that blocks view, 1404 /* Check to see if we found the object that blocks view,
1424 } /* If objects on this space */ 1412 } /* If objects on this space */
1425 1413
1426 if (flag & INS_ABOVE_FLOOR_ONLY) 1414 if (flag & INS_ABOVE_FLOOR_ONLY)
1427 top = floor; 1415 top = floor;
1428 1416
1429 /* Top is the object that our object (op) is going to get inserted above. 1417 // insert object above top, or bottom-most if top = 0
1430 */
1431
1432 /* First object on this space */
1433 if (!top) 1418 if (!top)
1434 { 1419 {
1420 op->below = 0;
1435 op->above = ms.bot; 1421 op->above = ms.bot;
1436
1437 if (op->above)
1438 op->above->below = op;
1439
1440 op->below = 0;
1441 ms.bot = op; 1422 ms.bot = op;
1423
1424 *(op->above ? &op->above->below : &ms.top) = op;
1442 } 1425 }
1443 else 1426 else
1444 { /* get inserted into the stack above top */ 1427 {
1445 op->above = top->above; 1428 op->above = top->above;
1446
1447 if (op->above)
1448 op->above->below = op; 1429 top->above = op;
1449 1430
1450 op->below = top; 1431 op->below = top;
1451 top->above = op; 1432 *(op->above ? &op->above->below : &ms.top) = op;
1452 } 1433 }
1434 }
1453 1435
1454 if (!op->above) 1436 if (op->is_player ())
1455 ms.top = op;
1456 } /* else not INS_BELOW_ORIGINATOR */
1457
1458 if (op->type == PLAYER)
1459 { 1437 {
1460 op->contr->do_los = 1; 1438 op->contr->do_los = 1;
1461 ++op->map->players; 1439 ++op->map->players;
1462 op->map->touch (); 1440 op->map->touch ();
1463 } 1441 }
1464 1442
1465 op->map->dirty = true; 1443 op->map->dirty = true;
1466 1444
1467 if (object *pl = ms.player ()) 1445 if (object *pl = ms.player ())
1468 //TODO: the floorbox prev/next might need updating 1446 //TODO: the floorbox prev/next might need updating
1469 esrv_send_item (pl, op); 1447 //esrv_send_item (pl, op);
1448 //TODO: update floorbox to preserve ordering
1449 if (pl->contr->ns)
1450 pl->contr->ns->floorbox_update ();
1470 1451
1471 /* If this object glows, it may affect lighting conditions that are 1452 /* If this object glows, it may affect lighting conditions that are
1472 * visible to others on this map. But update_all_los is really 1453 * visible to others on this map. But update_all_los is really
1473 * an inefficient way to do this, as it means los for all players 1454 * an inefficient way to do this, as it means los for all players
1474 * on the map will get recalculated. The players could very well 1455 * on the map will get recalculated. The players could very well
1475 * be far away from this change and not affected in any way - 1456 * be far away from this change and not affected in any way -
1476 * this should get redone to only look for players within range, 1457 * this should get redone to only look for players within range,
1477 * or just updating the P_UPTODATE for spaces within this area 1458 * or just updating the P_UPTODATE for spaces within this area
1478 * of effect may be sufficient. 1459 * of effect may be sufficient.
1479 */ 1460 */
1480 if (op->map->darkness && (op->glow_radius != 0)) 1461 if (op->affects_los ())
1462 {
1463 op->ms ().invalidate ();
1481 update_all_los (op->map, op->x, op->y); 1464 update_all_los (op->map, op->x, op->y);
1465 }
1482 1466
1483 /* updates flags (blocked, alive, no magic, etc) for this map space */ 1467 /* updates flags (blocked, alive, no magic, etc) for this map space */
1484 update_object (op, UP_OBJ_INSERT); 1468 update_object (op, UP_OBJ_INSERT);
1485 1469
1486 INVOKE_OBJECT (INSERT, op); 1470 INVOKE_OBJECT (INSERT, op);
1514/* this function inserts an object in the map, but if it 1498/* this function inserts an object in the map, but if it
1515 * finds an object of its own type, it'll remove that one first. 1499 * finds an object of its own type, it'll remove that one first.
1516 * op is the object to insert it under: supplies x and the map. 1500 * op is the object to insert it under: supplies x and the map.
1517 */ 1501 */
1518void 1502void
1519replace_insert_ob_in_map (const char *arch_string, object *op) 1503replace_insert_ob_in_map (shstr_tmp archname, object *op)
1520{ 1504{
1521 /* first search for itself and remove any old instances */ 1505 /* first search for itself and remove any old instances */
1522 1506
1523 for (object *tmp = op->ms ().bot; tmp; tmp = tmp->above) 1507 for (object *tmp = op->ms ().bot; tmp; tmp = tmp->above)
1524 if (!strcmp (tmp->arch->archname, arch_string)) /* same archetype */ 1508 if (tmp->arch->archname == archname) /* same archetype */
1525 tmp->destroy (1); 1509 tmp->destroy ();
1526 1510
1527 object *tmp = arch_to_object (archetype::find (arch_string)); 1511 object *tmp = arch_to_object (archetype::find (archname));
1528 1512
1529 tmp->x = op->x; 1513 tmp->x = op->x;
1530 tmp->y = op->y; 1514 tmp->y = op->y;
1531 1515
1532 insert_ob_in_map (tmp, op->map, op, 0); 1516 insert_ob_in_map (tmp, op->map, op, 0);
1554 if (!nr) 1538 if (!nr)
1555 return true; 1539 return true;
1556 1540
1557 nr = min (nr, nrof); 1541 nr = min (nr, nrof);
1558 1542
1543 if (nrof > nr)
1544 {
1559 nrof -= nr; 1545 nrof -= nr;
1560
1561 if (nrof)
1562 {
1563 adjust_weight (env, -weight * nr); // carrying == 0 1546 adjust_weight (env, -weight * max (1, nr)); // carrying == 0
1564 1547
1565 if (object *pl = visible_to ()) 1548 if (object *pl = visible_to ())
1566 esrv_update_item (UPD_NROF, pl, this); 1549 esrv_update_item (UPD_NROF, pl, this);
1567 1550
1568 return true; 1551 return true;
1569 } 1552 }
1570 else 1553 else
1571 { 1554 {
1572 destroy (1); 1555 destroy ();
1573 return false; 1556 return false;
1574 } 1557 }
1575} 1558}
1576 1559
1577/* 1560/*
1594 } 1577 }
1595 else 1578 else
1596 { 1579 {
1597 decrease (nr); 1580 decrease (nr);
1598 1581
1599 object *op = object_create_clone (this); 1582 object *op = deep_clone ();
1600 op->nrof = nr; 1583 op->nrof = nr;
1601 return op; 1584 return op;
1602 } 1585 }
1603} 1586}
1604 1587
1654 if (object *pl = tmp->visible_to ()) 1637 if (object *pl = tmp->visible_to ())
1655 esrv_update_item (UPD_NROF, pl, tmp); 1638 esrv_update_item (UPD_NROF, pl, tmp);
1656 1639
1657 adjust_weight (this, op->total_weight ()); 1640 adjust_weight (this, op->total_weight ());
1658 1641
1659 op->destroy (1); 1642 op->destroy ();
1660 op = tmp; 1643 op = tmp;
1661 goto inserted; 1644 goto inserted;
1662 } 1645 }
1663 1646
1664 op->owner = 0; // it's his/hers now. period. 1647 op->owner = 0; // it's his/hers now. period.
1682 1665
1683 adjust_weight (this, op->total_weight ()); 1666 adjust_weight (this, op->total_weight ());
1684 1667
1685inserted: 1668inserted:
1686 /* reset the light list and los of the players on the map */ 1669 /* reset the light list and los of the players on the map */
1687 if (op->glow_radius && map && map->darkness) 1670 if (op->glow_radius && is_on_map ())
1671 {
1672 update_stats ();
1688 update_all_los (map, x, y); 1673 update_all_los (map, x, y);
1689 1674 }
1675 else if (is_player () && !flag [FLAG_NO_FIX_PLAYER])
1690 // if this is a player's inventory, update stats 1676 // if this is a player's inventory, update stats
1691 if (type == PLAYER && !flag [FLAG_NO_FIX_PLAYER])
1692 update_stats (); 1677 update_stats ();
1693 1678
1694 INVOKE_OBJECT (INSERT, this); 1679 INVOKE_OBJECT (INSERT, this);
1695 1680
1696 return op; 1681 return op;
1780 { 1765 {
1781 1766
1782 float 1767 float
1783 diff = tmp->move_slow_penalty * fabs (op->speed); 1768 diff = tmp->move_slow_penalty * fabs (op->speed);
1784 1769
1785 if (op->type == PLAYER) 1770 if (op->is_player ())
1786 if ((QUERY_FLAG (tmp, FLAG_IS_HILLY) && find_skill_by_number (op, SK_CLIMBING)) || 1771 if ((QUERY_FLAG (tmp, FLAG_IS_HILLY) && find_skill_by_number (op, SK_CLIMBING)) ||
1787 (QUERY_FLAG (tmp, FLAG_IS_WOODED) && find_skill_by_number (op, SK_WOODSMAN))) 1772 (QUERY_FLAG (tmp, FLAG_IS_WOODED) && find_skill_by_number (op, SK_WOODSMAN)))
1788 diff /= 4.0; 1773 diff /= 4.0;
1789 1774
1790 op->speed_left -= diff; 1775 op->speed_left -= diff;
1825 LOG (llevError, "Present_arch called outside map.\n"); 1810 LOG (llevError, "Present_arch called outside map.\n");
1826 return NULL; 1811 return NULL;
1827 } 1812 }
1828 1813
1829 for (object *tmp = m->at (x, y).bot; tmp; tmp = tmp->above) 1814 for (object *tmp = m->at (x, y).bot; tmp; tmp = tmp->above)
1830 if (tmp->arch == at) 1815 if (tmp->arch->archname == at->archname)
1831 return tmp; 1816 return tmp;
1832 1817
1833 return NULL; 1818 return NULL;
1834} 1819}
1835 1820
1899 * The first matching object is returned, or NULL if none. 1884 * The first matching object is returned, or NULL if none.
1900 */ 1885 */
1901object * 1886object *
1902present_arch_in_ob (const archetype *at, const object *op) 1887present_arch_in_ob (const archetype *at, const object *op)
1903{ 1888{
1904 for (object *tmp = op->inv; tmp != NULL; tmp = tmp->below) 1889 for (object *tmp = op->inv; tmp; tmp = tmp->below)
1905 if (tmp->arch == at) 1890 if (tmp->arch->archname == at->archname)
1906 return tmp; 1891 return tmp;
1907 1892
1908 return NULL; 1893 return NULL;
1909} 1894}
1910 1895
1998 * head of the object should correspond for the entire object. 1983 * head of the object should correspond for the entire object.
1999 */ 1984 */
2000 if (OB_TYPE_MOVE_BLOCK (ob, ms.move_block)) 1985 if (OB_TYPE_MOVE_BLOCK (ob, ms.move_block))
2001 continue; 1986 continue;
2002 1987
2003 if (ob->blocked (m, pos.x, pos.y)) 1988 if (ob->blocked (pos.m, pos.x, pos.y))
2004 continue; 1989 continue;
2005 1990
2006 altern [index++] = i; 1991 altern [index++] = i;
2007 } 1992 }
2008 1993
2076 * there is capable of. 2061 * there is capable of.
2077 */ 2062 */
2078int 2063int
2079find_dir (maptile *m, int x, int y, object *exclude) 2064find_dir (maptile *m, int x, int y, object *exclude)
2080{ 2065{
2081 int i, max = SIZEOFFREE, mflags; 2066 int max = SIZEOFFREE, mflags;
2082
2083 sint16 nx, ny;
2084 object *tmp;
2085 maptile *mp;
2086
2087 MoveType blocked, move_type; 2067 MoveType move_type;
2088 2068
2089 if (exclude && exclude->head_ () != exclude) 2069 if (exclude && exclude->head_ () != exclude)
2090 { 2070 {
2091 exclude = exclude->head; 2071 exclude = exclude->head;
2092 move_type = exclude->move_type; 2072 move_type = exclude->move_type;
2095 { 2075 {
2096 /* If we don't have anything, presume it can use all movement types. */ 2076 /* If we don't have anything, presume it can use all movement types. */
2097 move_type = MOVE_ALL; 2077 move_type = MOVE_ALL;
2098 } 2078 }
2099 2079
2100 for (i = 1; i < max; i++) 2080 for (int i = 1; i < max; i++)
2101 { 2081 {
2102 mp = m; 2082 mapxy pos (m, x, y);
2103 nx = x + freearr_x[i]; 2083 pos.move (i);
2104 ny = y + freearr_y[i];
2105 2084
2106 mflags = get_map_flags (m, &mp, nx, ny, &nx, &ny); 2085 if (!pos.normalise ())
2107
2108 if (mflags & P_OUT_OF_MAP)
2109 max = maxfree[i]; 2086 max = maxfree[i];
2110 else 2087 else
2111 { 2088 {
2112 mapspace &ms = mp->at (nx, ny); 2089 mapspace &ms = *pos;
2113 2090
2114 blocked = ms.move_block;
2115
2116 if ((move_type & blocked) == move_type) 2091 if ((move_type & ms.move_block) == move_type)
2117 max = maxfree[i]; 2092 max = maxfree [i];
2118 else if (mflags & P_IS_ALIVE) 2093 else if (ms.flags () & P_IS_ALIVE)
2119 { 2094 {
2120 for (tmp = ms.bot; tmp; tmp = tmp->above) 2095 for (object *tmp = ms.bot; tmp; tmp = tmp->above)
2121 if ((tmp->flag [FLAG_MONSTER] || tmp->type == PLAYER) 2096 if ((tmp->flag [FLAG_MONSTER] || tmp->is_player ())
2122 && (tmp != exclude || (tmp->head_ () != tmp && tmp->head_ () != exclude))) 2097 && (tmp != exclude || (tmp->head_ () != tmp && tmp->head_ () != exclude)))
2123 break;
2124
2125 if (tmp)
2126 return freedir[i]; 2098 return freedir [i];
2127 } 2099 }
2128 } 2100 }
2129 } 2101 }
2130 2102
2131 return 0; 2103 return 0;
2206 * This basically means that if direction is 15, then it could either go 2178 * This basically means that if direction is 15, then it could either go
2207 * direction 4, 14, or 16 to get back to where we are. 2179 * direction 4, 14, or 16 to get back to where we are.
2208 * Moved from spell_util.c to object.c with the other related direction 2180 * Moved from spell_util.c to object.c with the other related direction
2209 * functions. 2181 * functions.
2210 */ 2182 */
2211int reduction_dir[SIZEOFFREE][3] = { 2183const int reduction_dir[SIZEOFFREE][3] = {
2212 {0, 0, 0}, /* 0 */ 2184 {0, 0, 0}, /* 0 */
2213 {0, 0, 0}, /* 1 */ 2185 {0, 0, 0}, /* 1 */
2214 {0, 0, 0}, /* 2 */ 2186 {0, 0, 0}, /* 2 */
2215 {0, 0, 0}, /* 3 */ 2187 {0, 0, 0}, /* 3 */
2216 {0, 0, 0}, /* 4 */ 2188 {0, 0, 0}, /* 4 */
2312int 2284int
2313can_pick (const object *who, const object *item) 2285can_pick (const object *who, const object *item)
2314{ 2286{
2315 return /*QUERY_FLAG(who,FLAG_WIZ)|| */ 2287 return /*QUERY_FLAG(who,FLAG_WIZ)|| */
2316 (item->weight > 0 && !QUERY_FLAG (item, FLAG_NO_PICK) && 2288 (item->weight > 0 && !QUERY_FLAG (item, FLAG_NO_PICK) &&
2317 !QUERY_FLAG (item, FLAG_ALIVE) && !item->invisible && (who->type == PLAYER || item->weight < who->weight / 3)); 2289 !QUERY_FLAG (item, FLAG_ALIVE) && !item->invisible && (who->is_player () || item->weight < who->weight / 3));
2318} 2290}
2319 2291
2320/* 2292/*
2321 * create clone from object to another 2293 * create clone from object to another
2322 */ 2294 */
2323object * 2295object *
2324object_create_clone (object *asrc) 2296object::deep_clone ()
2325{ 2297{
2326 object *dst = 0, *tmp, *src, *prev, *item; 2298 assert (("deep_clone called on non-head object", is_head ()));
2327 2299
2328 if (!asrc) 2300 object *dst = clone ();
2329 return 0;
2330 2301
2331 src = asrc->head_ (); 2302 object *prev = dst;
2332
2333 prev = 0;
2334 for (object *part = src; part; part = part->more) 2303 for (object *part = this->more; part; part = part->more)
2335 { 2304 {
2336 tmp = part->clone (); 2305 object *tmp = part->clone ();
2337 tmp->x -= src->x;
2338 tmp->y -= src->y;
2339
2340 if (!part->head)
2341 {
2342 dst = tmp;
2343 tmp->head = 0;
2344 }
2345 else
2346 tmp->head = dst; 2306 tmp->head = dst;
2347
2348 tmp->more = 0;
2349
2350 if (prev)
2351 prev->more = tmp; 2307 prev->more = tmp;
2352
2353 prev = tmp; 2308 prev = tmp;
2354 } 2309 }
2355 2310
2356 for (item = src->inv; item; item = item->below) 2311 for (object *item = inv; item; item = item->below)
2357 insert_ob_in_ob (object_create_clone (item), dst); 2312 insert_ob_in_ob (item->deep_clone (), dst);
2358 2313
2359 return dst; 2314 return dst;
2360} 2315}
2361 2316
2362/* This returns the first object in who's inventory that 2317/* This returns the first object in who's inventory that
2371 return tmp; 2326 return tmp;
2372 2327
2373 return 0; 2328 return 0;
2374} 2329}
2375 2330
2376/* If ob has a field named key, return the link from the list, 2331shstr_tmp
2377 * otherwise return NULL. 2332object::kv_get (shstr_tmp key) const
2378 *
2379 * key must be a passed in shared string - otherwise, this won't
2380 * do the desired thing.
2381 */
2382key_value *
2383get_ob_key_link (const object *ob, const char *key)
2384{ 2333{
2385 for (key_value *link = ob->key_values; link; link = link->next) 2334 for (key_value *kv = key_values; kv; kv = kv->next)
2386 if (link->key == key) 2335 if (kv->key == key)
2387 return link;
2388
2389 return 0;
2390}
2391
2392/*
2393 * Returns the value of op has an extra_field for key, or NULL.
2394 *
2395 * The argument doesn't need to be a shared string.
2396 *
2397 * The returned string is shared.
2398 */
2399const char *
2400get_ob_key_value (const object *op, const char *const key)
2401{
2402 key_value *link;
2403 shstr_cmp canonical_key (key);
2404
2405 if (!canonical_key)
2406 {
2407 /* 1. There being a field named key on any object
2408 * implies there'd be a shared string to find.
2409 * 2. Since there isn't, no object has this field.
2410 * 3. Therefore, *this* object doesn't have this field.
2411 */
2412 return 0;
2413 }
2414
2415 /* This is copied from get_ob_key_link() above -
2416 * only 4 lines, and saves the function call overhead.
2417 */
2418 for (link = op->key_values; link; link = link->next)
2419 if (link->key == canonical_key)
2420 return link->value; 2336 return kv->value;
2421 2337
2422 return 0; 2338 return shstr ();
2423} 2339}
2424 2340
2425/* 2341void
2426 * Updates the canonical_key in op to value. 2342object::kv_set (shstr_tmp key, shstr_tmp value)
2427 *
2428 * canonical_key is a shared string (value doesn't have to be).
2429 *
2430 * Unless add_key is TRUE, it won't add fields, only change the value of existing
2431 * keys.
2432 *
2433 * Returns TRUE on success.
2434 */
2435int
2436set_ob_key_value_s (object *op, const shstr & canonical_key, const char *value, int add_key)
2437{ 2343{
2438 key_value *field = NULL, *last = NULL; 2344 for (key_value *kv = key_values; kv; kv = kv->next)
2439 2345 if (kv->key == key)
2440 for (field = op->key_values; field != NULL; field = field->next)
2441 {
2442 if (field->key != canonical_key)
2443 { 2346 {
2444 last = field; 2347 kv->value = value;
2445 continue; 2348 return;
2446 } 2349 }
2447 2350
2448 if (value) 2351 key_value *kv = new key_value;
2449 field->value = value; 2352
2450 else 2353 kv->next = key_values;
2354 kv->key = key;
2355 kv->value = value;
2356
2357 key_values = kv;
2358}
2359
2360void
2361object::kv_del (shstr_tmp key)
2362{
2363 for (key_value **kvp = &key_values; *kvp; kvp = &(*kvp)->next)
2364 if ((*kvp)->key == key)
2451 { 2365 {
2452 /* Basically, if the archetype has this key set, 2366 key_value *kv = *kvp;
2453 * we need to store the null value so when we save 2367 *kvp = (*kvp)->next;
2454 * it, we save the empty value so that when we load, 2368 delete kv;
2455 * we get this value back again. 2369 return;
2456 */
2457 if (get_ob_key_link (op->arch, canonical_key))
2458 field->value = 0;
2459 else
2460 {
2461 if (last)
2462 last->next = field->next;
2463 else
2464 op->key_values = field->next;
2465
2466 delete field;
2467 }
2468 } 2370 }
2469 return TRUE;
2470 }
2471 /* IF we get here, key doesn't exist */
2472
2473 /* No field, we'll have to add it. */
2474
2475 if (!add_key)
2476 return FALSE;
2477
2478 /* There isn't any good reason to store a null
2479 * value in the key/value list. If the archetype has
2480 * this key, then we should also have it, so shouldn't
2481 * be here. If user wants to store empty strings,
2482 * should pass in ""
2483 */
2484 if (value == NULL)
2485 return TRUE;
2486
2487 field = new key_value;
2488
2489 field->key = canonical_key;
2490 field->value = value;
2491 /* Usual prepend-addition. */
2492 field->next = op->key_values;
2493 op->key_values = field;
2494
2495 return TRUE;
2496}
2497
2498/*
2499 * Updates the key in op to value.
2500 *
2501 * If add_key is FALSE, this will only update existing keys,
2502 * and not add new ones.
2503 * In general, should be little reason FALSE is ever passed in for add_key
2504 *
2505 * Returns TRUE on success.
2506 */
2507int
2508set_ob_key_value (object *op, const char *key, const char *value, int add_key)
2509{
2510 shstr key_ (key);
2511
2512 return set_ob_key_value_s (op, key_, value, add_key);
2513} 2371}
2514 2372
2515object::depth_iterator::depth_iterator (object *container) 2373object::depth_iterator::depth_iterator (object *container)
2516: iterator_base (container) 2374: iterator_base (container)
2517{ 2375{
2567{ 2425{
2568 char flagdesc[512]; 2426 char flagdesc[512];
2569 char info2[256 * 4]; 2427 char info2[256 * 4];
2570 char *p = info; 2428 char *p = info;
2571 2429
2572 p += snprintf (p, 512, "{cnt:%d,uuid:%s,name:\"%s\"%s%s,flags:[%s],type:%d}", 2430 p += snprintf (p, 512, "{cnt:%d,uuid:%s,name:\"%s\"%s%s%s,flags:[%s],type:%d}",
2573 count, 2431 count,
2574 uuid.c_str (), 2432 uuid.c_str (),
2575 &name, 2433 &name,
2576 title ? "\",title:\"" : "", 2434 title ? ",title:\"" : "",
2577 title ? (const char *)title : "", 2435 title ? (const char *)title : "",
2436 title ? "\"" : "",
2578 flag_desc (flagdesc, 512), type); 2437 flag_desc (flagdesc, 512), type);
2579 2438
2580 if (!flag[FLAG_REMOVED] && env) 2439 if (!flag[FLAG_REMOVED] && env)
2581 p += snprintf (p, 256, "(in %s)", env->debug_desc (info2)); 2440 p += snprintf (p, 256, "(in %s)", env->debug_desc (info2));
2582 2441
2615object::open_container (object *new_container) 2474object::open_container (object *new_container)
2616{ 2475{
2617 if (container == new_container) 2476 if (container == new_container)
2618 return; 2477 return;
2619 2478
2620 if (object *old_container = container) 2479 object *old_container = container;
2480
2481 if (old_container)
2621 { 2482 {
2622 if (INVOKE_OBJECT (CLOSE, old_container, ARG_OBJECT (this))) 2483 if (INVOKE_OBJECT (CLOSE, old_container, ARG_OBJECT (this)))
2623 return; 2484 return;
2624 2485
2625#if 0 2486#if 0
2627 if (object *closer = old_container->inv) 2488 if (object *closer = old_container->inv)
2628 if (closer->type == CLOSE_CON) 2489 if (closer->type == CLOSE_CON)
2629 closer->destroy (); 2490 closer->destroy ();
2630#endif 2491#endif
2631 2492
2493 // make sure the container is available
2494 esrv_send_item (this, old_container);
2495
2632 old_container->flag [FLAG_APPLIED] = false; 2496 old_container->flag [FLAG_APPLIED] = false;
2633 container = 0; 2497 container = 0;
2634 2498
2499 // client needs item update to make it work, client bug requires this to be separate
2635 esrv_update_item (UPD_FLAGS, this, old_container); 2500 esrv_update_item (UPD_FLAGS, this, old_container);
2501
2636 new_draw_info_format (NDI_UNIQUE, 0, this, "You close %s.", query_name (old_container)); 2502 new_draw_info_format (NDI_UNIQUE, 0, this, "You close %s.", old_container->query_name ());
2637 play_sound (sound_find ("chest_close")); 2503 play_sound (sound_find ("chest_close"));
2638 } 2504 }
2639 2505
2640 if (new_container) 2506 if (new_container)
2641 { 2507 {
2651 closer->flag [FLAG_NO_MAP_SAVE] = 1; 2517 closer->flag [FLAG_NO_MAP_SAVE] = 1;
2652 new_container->insert (closer); 2518 new_container->insert (closer);
2653 } 2519 }
2654#endif 2520#endif
2655 2521
2656 new_draw_info_format (NDI_UNIQUE, 0, this, "You open %s.", query_name (new_container)); 2522 new_draw_info_format (NDI_UNIQUE, 0, this, "You open %s.", new_container->query_name ());
2523
2524 // make sure the container is available, client bug requires this to be separate
2525 esrv_send_item (this, new_container);
2657 2526
2658 new_container->flag [FLAG_APPLIED] = true; 2527 new_container->flag [FLAG_APPLIED] = true;
2659 container = new_container; 2528 container = new_container;
2660 2529
2530 // client needs flag change
2661 esrv_update_item (UPD_FLAGS, this, new_container); 2531 esrv_update_item (UPD_FLAGS, this, new_container);
2662 esrv_send_inventory (this, new_container); 2532 esrv_send_inventory (this, new_container);
2663 play_sound (sound_find ("chest_open")); 2533 play_sound (sound_find ("chest_open"));
2664 } 2534 }
2535// else if (!old_container->env && contr && contr->ns)
2536// contr->ns->floorbox_reset ();
2665} 2537}
2666 2538
2667object * 2539object *
2668object::force_find (const shstr name) 2540object::force_find (shstr_tmp name)
2669{ 2541{
2670 /* cycle through his inventory to look for the MARK we want to 2542 /* cycle through his inventory to look for the MARK we want to
2671 * place 2543 * place
2672 */ 2544 */
2673 for (object *tmp = inv; tmp; tmp = tmp->below) 2545 for (object *tmp = inv; tmp; tmp = tmp->below)
2675 return splay (tmp); 2547 return splay (tmp);
2676 2548
2677 return 0; 2549 return 0;
2678} 2550}
2679 2551
2680void 2552object *
2681object::force_add (const shstr name, int duration) 2553object::force_add (shstr_tmp name, int duration)
2682{ 2554{
2683 if (object *force = force_find (name)) 2555 if (object *force = force_find (name))
2684 force->destroy (); 2556 force->destroy ();
2685 2557
2686 object *force = get_archetype (FORCE_NAME); 2558 object *force = get_archetype (FORCE_NAME);
2691 2563
2692 force->set_speed (duration ? 1.f / duration : 0.f); 2564 force->set_speed (duration ? 1.f / duration : 0.f);
2693 force->flag [FLAG_IS_USED_UP] = true; 2565 force->flag [FLAG_IS_USED_UP] = true;
2694 force->flag [FLAG_APPLIED] = true; 2566 force->flag [FLAG_APPLIED] = true;
2695 2567
2696 insert (force); 2568 return insert (force);
2697} 2569}
2698 2570
2699void 2571void
2700object::play_sound (faceidx sound) 2572object::play_sound (faceidx sound) const
2701{ 2573{
2702 if (!sound) 2574 if (!sound)
2703 return; 2575 return;
2704 2576
2705 if (flag [FLAG_REMOVED]) 2577 if (is_on_map ())
2578 map->play_sound (sound, x, y);
2579 else if (object *pl = in_player ())
2580 pl->contr->play_sound (sound);
2581}
2582
2583void
2584object::say_msg (const char *msg) const
2585{
2586 if (is_on_map ())
2587 map->say_msg (msg, x, y);
2588 else if (object *pl = in_player ())
2589 pl->contr->play_sound (sound);
2590}
2591
2592void
2593object::make_noise ()
2594{
2595 // we do not model noise in the map, so instead put
2596 // a temporary light into the noise source
2597 // could use the map instead, but that's less reliable for our
2598 // goal, which is to make invisibility a bit harder to exploit
2599
2600 // currently only works sensibly for players
2601 if (!is_player ())
2706 return; 2602 return;
2707 2603
2708 if (env) 2604 // find old force, or create new one
2709 { 2605 object *force = force_find (shstr_noise_force);
2710 if (object *pl = in_player ()) 2606
2711 pl->contr->play_sound (sound); 2607 if (force)
2712 } 2608 force->speed_left = -1.f; // patch old speed up
2713 else 2609 else
2714 map->play_sound (sound, x, y); 2610 {
2715} 2611 force = archetype::get (shstr_noise_force);
2716 2612
2613 force->slaying = shstr_noise_force;
2614 force->stats.food = 1;
2615 force->speed_left = -1.f;
2616
2617 force->set_speed (1.f / 4.f);
2618 force->flag [FLAG_IS_USED_UP] = true;
2619 force->flag [FLAG_APPLIED] = true;
2620
2621 insert (force);
2622 }
2623}
2624

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines