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.207 by root, Sun Apr 20 23:25:09 2008 UTC vs.
Revision 1.231 by root, Sun May 4 11:12:40 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
28#include <global.h> 24#include <global.h>
29#include <stdio.h> 25#include <stdio.h>
30#include <sys/types.h> 26#include <sys/types.h>
31#include <sys/uio.h> 27#include <sys/uio.h>
32#include <object.h> 28#include <object.h>
33#include <funcpoint.h>
34#include <sproto.h> 29#include <sproto.h>
35#include <loader.h> 30#include <loader.h>
36 31
37#include <bitset> 32#include <bitset>
38 33
… …
144 139
145/* 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. */
146static bool 141static bool
147compare_ob_value_lists_one (const object *wants, const object *has) 142compare_ob_value_lists_one (const object *wants, const object *has)
148{ 143{
149 key_value *wants_field;
150
151 /* 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
152 * 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
153 * different structure or at least keep the lists sorted... 146 * different structure or at least keep the lists sorted...
154 */ 147 */
155 148
156 /* For each field in wants, */ 149 /* For each field in wants, */
157 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)
158 { 151 if (has->kv_get (kv->key) != kv->value)
159 key_value *has_field; 152 return false;
160
161 /* Look for a field in has with the same key. */
162 has_field = get_ob_key_link (has, wants_field->key);
163
164 if (!has_field)
165 return 0; /* No field with that name. */
166
167 /* Found the matching field. */
168 if (has_field->value != wants_field->value)
169 return 0; /* Values don't match, so this half of the comparison is false. */
170
171 /* If we get here, we found a match. Now for the next field in wants. */
172 }
173 153
174 /* 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. */
175 return 1; 155 return true;
176} 156}
177 157
178/* Returns TRUE if ob1 has the same key_values as ob2. */ 158/* Returns TRUE if ob1 has the same key_values as ob2. */
179static bool 159static bool
180compare_ob_value_lists (const object *ob1, const object *ob2) 160compare_ob_value_lists (const object *ob1, const object *ob2)
181{ 161{
182 /* 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,
183 * so we need to run the comparison *twice*. :( 163 * so we need to run the comparison *twice*. :(
184 */ 164 */
185 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);
186} 167}
187 168
188/* 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
189 * they can be merged together. 170 * they can be merged together.
190 * 171 *
… …
206 || ob1->value != ob2->value 187 || ob1->value != ob2->value
207 || ob1->name != ob2->name) 188 || ob1->name != ob2->name)
208 return 0; 189 return 0;
209 190
210 /* Do not merge objects if nrof would overflow. First part checks 191 /* Do not merge objects if nrof would overflow. First part checks
211 * for unsigned overflow (2c), second part checks wether the result 192 * for unsigned overflow (2c), second part checks whether the result
212 * would fit into a 32 bit signed int, which is often used to hold 193 * would fit into a 32 bit signed int, which is often used to hold
213 * nrof values. 194 * nrof values.
214 */ 195 */
215 if (~ob1->nrof < ob2->nrof || ob1->nrof + ob2->nrof > (1UL << 31)) 196 if (~ob1->nrof < ob2->nrof || ob1->nrof + ob2->nrof > (1UL << 31))
216 return 0; 197 return 0;
… …
225 SET_FLAG (ob1, FLAG_BEEN_APPLIED); 206 SET_FLAG (ob1, FLAG_BEEN_APPLIED);
226 207
227 if (QUERY_FLAG (ob2, FLAG_IDENTIFIED)) 208 if (QUERY_FLAG (ob2, FLAG_IDENTIFIED))
228 SET_FLAG (ob2, FLAG_BEEN_APPLIED); 209 SET_FLAG (ob2, FLAG_BEEN_APPLIED);
229 210
230 if ((ob1->flag ^ ob2->flag).reset (FLAG_INV_LOCKED).reset (FLAG_CLIENT_SENT).any () 211 if (ob1->arch->name != ob2->arch->name
231 || ob1->arch != ob2->arch
232 || ob1->name != ob2->name 212 || ob1->name != ob2->name
233 || ob1->title != ob2->title 213 || ob1->title != ob2->title
234 || ob1->msg != ob2->msg 214 || ob1->msg != ob2->msg
235 || ob1->weight != ob2->weight 215 || ob1->weight != ob2->weight
236 || memcmp (&ob1->resist, &ob2->resist, sizeof (ob1->resist))
237 || memcmp (&ob1->stats , &ob2->stats , sizeof (ob1->stats) )
238 || ob1->attacktype != ob2->attacktype 216 || ob1->attacktype != ob2->attacktype
239 || ob1->magic != ob2->magic 217 || ob1->magic != ob2->magic
240 || ob1->slaying != ob2->slaying 218 || ob1->slaying != ob2->slaying
241 || ob1->skill != ob2->skill 219 || ob1->skill != ob2->skill
242 || ob1->value != ob2->value 220 || ob1->value != ob2->value
… …
249 || ob1->move_block != ob2->move_block 227 || ob1->move_block != ob2->move_block
250 || ob1->move_allow != ob2->move_allow 228 || ob1->move_allow != ob2->move_allow
251 || ob1->move_on != ob2->move_on 229 || ob1->move_on != ob2->move_on
252 || ob1->move_off != ob2->move_off 230 || ob1->move_off != ob2->move_off
253 || ob1->move_slow != ob2->move_slow 231 || ob1->move_slow != ob2->move_slow
254 || ob1->move_slow_penalty != ob2->move_slow_penalty) 232 || ob1->move_slow_penalty != ob2->move_slow_penalty
233 || memcmp (&ob1->resist, &ob2->resist, sizeof (ob1->resist))
234 || memcmp (&ob1->stats , &ob2->stats , sizeof (ob1->stats)))
235 return 0;
236
237 if ((ob1->flag ^ ob2->flag)
238 .reset (FLAG_INV_LOCKED)
239 .reset (FLAG_CLIENT_SENT)
240 .reset (FLAG_REMOVED)
241 .any ())
255 return 0; 242 return 0;
256 243
257 /* This is really a spellbook check - we should in general 244 /* This is really a spellbook check - we should in general
258 * not merge objects with real inventories, as splitting them 245 * not merge objects with real inventories, as splitting them
259 * is hard. 246 * is hard.
… …
298 285
299 if (ob1->key_values || ob2->key_values) 286 if (ob1->key_values || ob2->key_values)
300 { 287 {
301 /* At least one of these has key_values. */ 288 /* At least one of these has key_values. */
302 if ((!ob1->key_values) != (!ob2->key_values)) 289 if ((!ob1->key_values) != (!ob2->key_values))
303 /* One has fields, but the other one doesn't. */ 290 return 0; /* One has fields, but the other one doesn't. */
304 return 0; 291
305 else if (!compare_ob_value_lists (ob1, ob2)) 292 if (!compare_ob_value_lists (ob1, ob2))
306 return 0; 293 return 0;
307 } 294 }
308 295
309 if (ob1->self || ob2->self) 296 if (ob1->self || ob2->self)
310 { 297 {
… …
316 int k1 = ob1->self ? HvTOTALKEYS (ob1->self) : 0; 303 int k1 = ob1->self ? HvTOTALKEYS (ob1->self) : 0;
317 int k2 = ob2->self ? HvTOTALKEYS (ob2->self) : 0; 304 int k2 = ob2->self ? HvTOTALKEYS (ob2->self) : 0;
318 305
319 if (k1 != k2) 306 if (k1 != k2)
320 return 0; 307 return 0;
308
321 else if (k1 == 0) 309 if (k1 == 0)
322 return 1; 310 return 1;
311
323 else if (!cfperl_can_merge (ob1, ob2)) 312 if (!cfperl_can_merge (ob1, ob2))
324 return 0; 313 return 0;
325 } 314 }
326 } 315 }
327 316
328 /* Everything passes, must be OK. */ 317 /* Everything passes, must be OK. */
329 return 1; 318 return 1;
330} 319}
331 320
321// find player who can see this object
322object *
323object::visible_to () const
324{
325 if (client_visible () && !flag [FLAG_REMOVED])
326 {
327 // see if we are in a container of sorts
328 if (env)
329 {
330 // the player inventory itself is always visible
331 if (env->type == PLAYER)
332 return env;
333
334 // else a player could have our env open
335 object *envest = env->outer_env ();
336
337 // the player itself is always on a map, so we will find him here
338 // even if our inv is in a player.
339 if (envest->is_on_map ())
340 if (object *pl = envest->ms ().player ())
341 if (pl->container == env)
342 return pl;
343 }
344 else
345 {
346 // maybe there is a player standing on the same mapspace
347 // this will catch the case where "this" is a player
348 if (object *pl = ms ().player ())
349 if (!pl->container || this == pl->container)
350 return pl;
351 }
352 }
353
354 return 0;
355}
356
357// adjust weight per container type ("of holding")
332static sint32 358static sint32
333weight_adjust (object *op, sint32 weight) 359weight_adjust (object *op, sint32 weight)
334{ 360{
335 return op->type == CONTAINER 361 return op->type == CONTAINER
336 ? lerp (weight, 0, 100, 0, 100 - op->stats.Str) 362 ? lerp (weight, 0, 100, 0, 100 - op->stats.Str)
337 : weight; 363 : weight;
338} 364}
339 365
340/* 366/*
341 * add_weight(object, weight) adds the specified weight to an object, 367 * adjust_weight(object, weight) adds the specified weight to an object,
342 * and also updates how much the environment(s) is/are carrying. 368 * and also updates how much the environment(s) is/are carrying.
343 */ 369 */
344static void 370static void
345add_weight (object *op, sint32 weight) 371adjust_weight (object *op, sint32 weight)
346{ 372{
347 while (op) 373 while (op)
348 { 374 {
349 weight = weight_adjust (op, weight); 375 weight = weight_adjust (op, weight);
350 376
377 if (!weight)
378 return;
379
351 op->carrying += weight; 380 op->carrying += weight;
381
382 if (object *pl = op->visible_to ())
383 if (pl != op) // player is handled lazily
384 esrv_update_item (UPD_WEIGHT, pl, op);
385
352 op = op->env; 386 op = op->env;
353 } 387 }
354}
355
356/*
357 * sub_weight() recursively (outwards) subtracts a number from the
358 * weight of an object (and what is carried by it's environment(s)).
359 */
360static void
361sub_weight (object *op, long weight)
362{
363 add_weight (op, -weight);
364} 388}
365 389
366/* 390/*
367 * this is a recursive function which calculates the weight 391 * this is a recursive function which calculates the weight
368 * an object is carrying. It goes through op and figures out how much 392 * an object is carrying. It goes through op and figures out how much
… …
379 op->update_weight (); 403 op->update_weight ();
380 404
381 sum += op->total_weight (); 405 sum += op->total_weight ();
382 } 406 }
383 407
384 carrying = weight_adjust (this, sum); 408 sum = weight_adjust (this, sum);
385}
386 409
410 if (sum != carrying)
411 {
412 carrying = sum;
413
414 if (object *pl = visible_to ())
415 if (pl != this) // player is handled lazily
416 esrv_update_item (UPD_WEIGHT, pl, this);
417 }
418}
419
387/* 420/*
388 * Used by: Crossedit: dump. Server DM commands: dumpbelow, dump. 421 * Used by: Server DM commands: dumpbelow, dump. Some error messages.
389 * Some error messages.
390 * The result of the dump is stored in the static global errmsg array.
391 */ 422 */
392char * 423char *
393dump_object (object *op) 424dump_object (object *op)
394{ 425{
395 if (!op) 426 if (!op)
… …
409get_nearest_part (object *op, const object *pl) 440get_nearest_part (object *op, const object *pl)
410{ 441{
411 object *tmp, *closest; 442 object *tmp, *closest;
412 int last_dist, i; 443 int last_dist, i;
413 444
414 if (op->more == NULL) 445 if (!op->more)
415 return op; 446 return op;
447
416 for (last_dist = distance (op, pl), closest = op, tmp = op->more; tmp != NULL; tmp = tmp->more) 448 for (last_dist = distance (op, pl), closest = op, tmp = op->more;
449 tmp;
450 tmp = tmp->more)
417 if ((i = distance (tmp, pl)) < last_dist) 451 if ((i = distance (tmp, pl)) < last_dist)
418 closest = tmp, last_dist = i; 452 closest = tmp, last_dist = i;
453
419 return closest; 454 return closest;
420} 455}
421 456
422/* 457/*
423 * Returns the object which has the count-variable equal to the argument. 458 * Returns the object which has the count-variable equal to the argument.
459 * VERRRY slow.
424 */ 460 */
425object * 461object *
426find_object (tag_t i) 462find_object (tag_t i)
427{ 463{
428 for_all_objects (op) 464 for_all_objects (op)
… …
553 } 589 }
554 590
555 op->key_values = 0; 591 op->key_values = 0;
556} 592}
557 593
558object & 594/*
559object::operator =(const object &src) 595 * copy_to first frees everything allocated by the dst object,
596 * and then copies the contents of itself into the second
597 * object, allocating what needs to be allocated. Basically, any
598 * data that is malloc'd needs to be re-malloc/copied. Otherwise,
599 * if the first object is freed, the pointers in the new object
600 * will point at garbage.
601 */
602void
603object::copy_to (object *dst)
560{ 604{
561 bool is_freed = flag [FLAG_FREED]; 605 dst->remove ();
562 bool is_removed = flag [FLAG_REMOVED];
563
564 *(object_copy *)this = src; 606 *(object_copy *)dst = *this;
565
566 flag [FLAG_FREED] = is_freed;
567 flag [FLAG_REMOVED] = is_removed; 607 dst->flag [FLAG_REMOVED] = true;
568 608
569 /* Copy over key_values, if any. */ 609 /* Copy over key_values, if any. */
570 if (src.key_values) 610 if (key_values)
571 { 611 {
572 key_value *tail = 0; 612 key_value *tail = 0;
573 key_values = 0; 613 dst->key_values = 0;
574 614
575 for (key_value *i = src.key_values; i; i = i->next) 615 for (key_value *i = key_values; i; i = i->next)
576 { 616 {
577 key_value *new_link = new key_value; 617 key_value *new_link = new key_value;
578 618
579 new_link->next = 0; 619 new_link->next = 0;
580 new_link->key = i->key; 620 new_link->key = i->key;
581 new_link->value = i->value; 621 new_link->value = i->value;
582 622
583 /* Try and be clever here, too. */ 623 /* Try and be clever here, too. */
584 if (!key_values) 624 if (!dst->key_values)
585 { 625 {
586 key_values = new_link; 626 dst->key_values = new_link;
587 tail = new_link; 627 tail = new_link;
588 } 628 }
589 else 629 else
590 { 630 {
591 tail->next = new_link; 631 tail->next = new_link;
592 tail = new_link; 632 tail = new_link;
593 } 633 }
594 } 634 }
595 } 635 }
596}
597
598/*
599 * copy_to first frees everything allocated by the dst object,
600 * and then copies the contents of itself into the second
601 * object, allocating what needs to be allocated. Basically, any
602 * data that is malloc'd needs to be re-malloc/copied. Otherwise,
603 * if the first object is freed, the pointers in the new object
604 * will point at garbage.
605 */
606void
607object::copy_to (object *dst)
608{
609 *dst = *this;
610 636
611 if (speed < 0) 637 if (speed < 0)
612 dst->speed_left -= rndm (); 638 dst->speed_left -= rndm ();
613 639
614 dst->set_speed (dst->speed); 640 dst->set_speed (dst->speed);
… …
636object * 662object *
637object::clone () 663object::clone ()
638{ 664{
639 object *neu = create (); 665 object *neu = create ();
640 copy_to (neu); 666 copy_to (neu);
667 neu->map = map; // not copied by copy_to
641 return neu; 668 return neu;
642} 669}
643 670
644/* 671/*
645 * If an object with the IS_TURNABLE() flag needs to be turned due 672 * If an object with the IS_TURNABLE() flag needs to be turned due
… …
696 * UP_OBJ_FACE: only the objects face has changed. 723 * UP_OBJ_FACE: only the objects face has changed.
697 */ 724 */
698void 725void
699update_object (object *op, int action) 726update_object (object *op, int action)
700{ 727{
701 if (op == NULL) 728 if (!op)
702 { 729 {
703 /* this should never happen */ 730 /* this should never happen */
704 LOG (llevDebug, "update_object() called for NULL object.\n"); 731 LOG (llevError | logBacktrace, "update_object() called for NULL object.\n");
705 return; 732 return;
706 } 733 }
707 734
708 if (op->env) 735 if (!op->is_on_map ())
709 { 736 {
710 /* Animation is currently handled by client, so nothing 737 /* Animation is currently handled by client, so nothing
711 * to do in this case. 738 * to do in this case.
712 */ 739 */
713 return; 740 return;
714 } 741 }
715
716 /* If the map is saving, don't do anything as everything is
717 * going to get freed anyways.
718 */
719 if (!op->map || op->map->in_memory == MAP_SAVING)
720 return;
721 742
722 /* make sure the object is within map boundaries */ 743 /* make sure the object is within map boundaries */
723 if (op->x < 0 || op->x >= op->map->width || op->y < 0 || op->y >= op->map->height) 744 if (op->x < 0 || op->x >= op->map->width || op->y < 0 || op->y >= op->map->height)
724 { 745 {
725 LOG (llevError, "update_object() called for object out of map!\n"); 746 LOG (llevError, "update_object() called for object out of map!\n");
… …
868object::destroy_inv (bool drop_to_ground) 889object::destroy_inv (bool drop_to_ground)
869{ 890{
870 // need to check first, because the checks below might segfault 891 // need to check first, because the checks below might segfault
871 // as we might be on an invalid mapspace and crossfire code 892 // as we might be on an invalid mapspace and crossfire code
872 // is too buggy to ensure that the inventory is empty. 893 // is too buggy to ensure that the inventory is empty.
873 // corollary: if you create arrows etc. with stuff in tis inventory, 894 // corollary: if you create arrows etc. with stuff in its inventory,
874 // cf will crash below with off-map x and y 895 // cf will crash below with off-map x and y
875 if (!inv) 896 if (!inv)
876 return; 897 return;
877 898
878 /* Only if the space blocks everything do we not process - 899 /* Only if the space blocks everything do we not process -
… …
885 || map->nodrop 906 || map->nodrop
886 || ms ().move_block == MOVE_ALL) 907 || ms ().move_block == MOVE_ALL)
887 { 908 {
888 while (inv) 909 while (inv)
889 { 910 {
890 inv->destroy_inv (drop_to_ground); 911 inv->destroy_inv (false);
891 inv->destroy (); 912 inv->destroy ();
892 } 913 }
893 } 914 }
894 else 915 else
895 { /* Put objects in inventory onto this space */ 916 { /* Put objects in inventory onto this space */
… …
901 || op->flag [FLAG_NO_DROP] 922 || op->flag [FLAG_NO_DROP]
902 || op->type == RUNE 923 || op->type == RUNE
903 || op->type == TRAP 924 || op->type == TRAP
904 || op->flag [FLAG_IS_A_TEMPLATE] 925 || op->flag [FLAG_IS_A_TEMPLATE]
905 || op->flag [FLAG_DESTROY_ON_DEATH]) 926 || op->flag [FLAG_DESTROY_ON_DEATH])
906 op->destroy (); 927 op->destroy (true);
907 else 928 else
908 map->insert (op, x, y); 929 map->insert (op, x, y);
909 } 930 }
910 } 931 }
911} 932}
… …
915 object *op = new object; 936 object *op = new object;
916 op->link (); 937 op->link ();
917 return op; 938 return op;
918} 939}
919 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 nodrop = 1;
950
951 alloc ();
952 in_memory = MAP_ACTIVE;
953 }
954
955 ~freed_map ()
956 {
957 destroy ();
958 }
959} freed_map; // freed objects are moved here to avoid crashes
960
920void 961void
921object::do_destroy () 962object::do_destroy ()
922{ 963{
923 attachable::do_destroy ();
924
925 if (flag [FLAG_IS_LINKED]) 964 if (flag [FLAG_IS_LINKED])
926 remove_button_link (this); 965 remove_button_link (this);
927 966
928 if (flag [FLAG_FRIENDLY]) 967 if (flag [FLAG_FRIENDLY])
929 remove_friendly_object (this); 968 remove_friendly_object (this);
930 969
931 if (!flag [FLAG_REMOVED])
932 remove (); 970 remove ();
933 971
934 destroy_inv (true); 972 attachable::do_destroy ();
935 973
936 deactivate (); 974 deactivate ();
937 unlink (); 975 unlink ();
938 976
939 flag [FLAG_FREED] = 1; 977 flag [FLAG_FREED] = 1;
940 978
941 // hack to ensure that freed objects still have a valid map 979 // hack to ensure that freed objects still have a valid map
942 {
943 static maptile *freed_map; // freed objects are moved here to avoid crashes
944
945 if (!freed_map)
946 {
947 freed_map = new maptile;
948
949 freed_map->path = "<freed objects map>";
950 freed_map->name = "/internal/freed_objects_map";
951 freed_map->width = 3;
952 freed_map->height = 3;
953 freed_map->nodrop = 1;
954
955 freed_map->alloc ();
956 freed_map->in_memory = MAP_ACTIVE;
957 }
958
959 map = freed_map; 980 map = &freed_map;
960 x = 1; 981 x = 1;
961 y = 1; 982 y = 1;
962 }
963 983
964 if (more) 984 if (more)
965 { 985 {
966 more->destroy (); 986 more->destroy ();
967 more = 0; 987 more = 0;
… …
980object::destroy (bool destroy_inventory) 1000object::destroy (bool destroy_inventory)
981{ 1001{
982 if (destroyed ()) 1002 if (destroyed ())
983 return; 1003 return;
984 1004
1005 if (!is_head () && !head->destroyed ())
1006 {
1007 LOG (llevError | logBacktrace, "tried to destroy the tail of an object");
1008 head->destroy (destroy_inventory);
1009 return;
1010 }
1011
985 if (destroy_inventory) 1012 destroy_inv (!destroy_inventory);
986 destroy_inv (false);
987 1013
988 if (is_head ()) 1014 if (is_head ())
989 if (sound_destroy) 1015 if (sound_destroy)
990 play_sound (sound_destroy); 1016 play_sound (sound_destroy);
991 else if (flag [FLAG_MONSTER]) 1017 else if (flag [FLAG_MONSTER])
… …
1005object::do_remove () 1031object::do_remove ()
1006{ 1032{
1007 object *tmp, *last = 0; 1033 object *tmp, *last = 0;
1008 object *otmp; 1034 object *otmp;
1009 1035
1010 if (QUERY_FLAG (this, FLAG_REMOVED)) 1036 if (flag [FLAG_REMOVED])
1011 return; 1037 return;
1012 1038
1013 SET_FLAG (this, FLAG_REMOVED);
1014 INVOKE_OBJECT (REMOVE, this); 1039 INVOKE_OBJECT (REMOVE, this);
1040
1041 flag [FLAG_REMOVED] = true;
1015 1042
1016 if (more) 1043 if (more)
1017 more->remove (); 1044 more->remove ();
1018 1045
1019 /* 1046 /*
1020 * In this case, the object to be removed is in someones 1047 * In this case, the object to be removed is in someones
1021 * inventory. 1048 * inventory.
1022 */ 1049 */
1023 if (env) 1050 if (env)
1024 { 1051 {
1052 flag [FLAG_REMOVED] = false; // hack around the issue of visible_to checking flag_removed
1053 if (object *pl = visible_to ())
1054 esrv_del_item (pl->contr, count);
1055 flag [FLAG_REMOVED] = true; // hack around the issue of visible_to checking flag_removed
1056
1057 adjust_weight (env, -total_weight ());
1058
1059 *(above ? &above->below : &env->inv) = below;
1060
1025 if (nrof) 1061 if (below)
1026 sub_weight (env, weight * nrof); 1062 below->above = above;
1027 else 1063
1028 sub_weight (env, weight + carrying); 1064 /* we set up values so that it could be inserted into
1065 * the map, but we don't actually do that - it is up
1066 * to the caller to decide what we want to do.
1067 */
1068 map = env->map;
1069 x = env->x;
1070 y = env->y;
1071 above = 0;
1072 below = 0;
1073 env = 0;
1029 1074
1030 /* NO_FIX_PLAYER is set when a great many changes are being 1075 /* NO_FIX_PLAYER is set when a great many changes are being
1031 * made to players inventory. If set, avoiding the call 1076 * made to players inventory. If set, avoiding the call
1032 * to save cpu time. 1077 * to save cpu time.
1033 */ 1078 */
1034 if ((otmp = in_player ()) && otmp->contr && !QUERY_FLAG (otmp, FLAG_NO_FIX_PLAYER)) 1079 if ((otmp = in_player ()) && otmp->contr && !QUERY_FLAG (otmp, FLAG_NO_FIX_PLAYER))
1035 otmp->update_stats (); 1080 otmp->update_stats ();
1036
1037 if (above)
1038 above->below = below;
1039 else
1040 env->inv = below;
1041
1042 if (below)
1043 below->above = above;
1044
1045 /* we set up values so that it could be inserted into
1046 * the map, but we don't actually do that - it is up
1047 * to the caller to decide what we want to do.
1048 */
1049 x = env->x, y = env->y;
1050 map = env->map;
1051 above = 0, below = 0;
1052 env = 0;
1053 } 1081 }
1054 else if (map) 1082 else if (map)
1055 { 1083 {
1056 if (type == PLAYER)
1057 {
1058 // leaving a spot always closes any open container on the ground
1059 if (container && !container->env)
1060 // this causes spurious floorbox updates, but it ensures
1061 // that the CLOSE event is being sent.
1062 close_container ();
1063
1064 --map->players;
1065 map->touch ();
1066 }
1067
1068 map->dirty = true; 1084 map->dirty = true;
1069 mapspace &ms = this->ms (); 1085 mapspace &ms = this->ms ();
1086
1087 if (object *pl = ms.player ())
1088 {
1089 if (type == PLAYER) // this == pl(!)
1090 {
1091 // leaving a spot always closes any open container on the ground
1092 if (container && !container->env)
1093 // this causes spurious floorbox updates, but it ensures
1094 // that the CLOSE event is being sent.
1095 close_container ();
1096
1097 --map->players;
1098 map->touch ();
1099 }
1100 else if (pl->container == this)
1101 {
1102 // removing a container should close it
1103 close_container ();
1104 }
1105
1106 esrv_del_item (pl->contr, count);
1107 }
1070 1108
1071 /* link the object above us */ 1109 /* link the object above us */
1072 if (above) 1110 if (above)
1073 above->below = below; 1111 above->below = below;
1074 else 1112 else
… …
1104 * removed (most likely destroyed), update the player view 1142 * removed (most likely destroyed), update the player view
1105 * appropriately. 1143 * appropriately.
1106 */ 1144 */
1107 pl->close_container (); 1145 pl->close_container ();
1108 1146
1147 //TODO: the floorbox prev/next might need updating
1148 //esrv_del_item (pl->contr, count);
1149 //TODO: update floorbox to preserve ordering
1150 if (pl->contr->ns)
1109 pl->contr->ns->floorbox_update (); 1151 pl->contr->ns->floorbox_update ();
1110 } 1152 }
1111 1153
1112 for (tmp = ms.bot; tmp; tmp = tmp->above) 1154 for (tmp = ms.bot; tmp; tmp = tmp->above)
1113 { 1155 {
1114 /* 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
… …
1158 if (!top) 1200 if (!top)
1159 for (top = op; top && top->above; top = top->above) 1201 for (top = op; top && top->above; top = top->above)
1160 ; 1202 ;
1161 1203
1162 for (; top; top = top->below) 1204 for (; top; top = top->below)
1163 {
1164 if (top == op)
1165 continue;
1166
1167 if (object::can_merge (op, top)) 1205 if (object::can_merge (op, top))
1168 { 1206 {
1169 top->nrof += op->nrof; 1207 top->nrof += op->nrof;
1170 1208
1171/* CLEAR_FLAG(top,FLAG_STARTEQUIP);*/ 1209 if (object *pl = top->visible_to ())
1172 op->weight = 0; /* Don't want any adjustements now */ 1210 esrv_update_item (UPD_NROF, pl, top);
1211
1212 op->weight = 0; // cancel the addition above
1213 op->carrying = 0; // must be 0 already
1214
1173 op->destroy (); 1215 op->destroy (1);
1216
1174 return top; 1217 return top;
1175 } 1218 }
1176 }
1177 1219
1178 return 0; 1220 return 0;
1179} 1221}
1180 1222
1181void 1223void
… …
1240object * 1282object *
1241insert_ob_in_map (object *op, maptile *m, object *originator, int flag) 1283insert_ob_in_map (object *op, maptile *m, object *originator, int flag)
1242{ 1284{
1243 assert (!op->flag [FLAG_FREED]); 1285 assert (!op->flag [FLAG_FREED]);
1244 1286
1245 object *top, *floor = NULL;
1246
1247 op->remove (); 1287 op->remove ();
1248 1288
1249 /* Ideally, the caller figures this out. However, it complicates a lot 1289 /* Ideally, the caller figures this out. However, it complicates a lot
1250 * of areas of callers (eg, anything that uses find_free_spot would now 1290 * of areas of callers (eg, anything that uses find_free_spot would now
1251 * need extra work 1291 * need extra work
1252 */ 1292 */
1253 if (!xy_normalise (m, op->x, op->y)) 1293 if (!xy_normalise (m, op->x, op->y))
1254 { 1294 {
1255 op->destroy (); 1295 op->destroy (1);
1256 return 0; 1296 return 0;
1257 } 1297 }
1258 1298
1259 if (object *more = op->more) 1299 if (object *more = op->more)
1260 if (!insert_ob_in_map (more, m, originator, flag)) 1300 if (!insert_ob_in_map (more, m, originator, flag))
… …
1269 */ 1309 */
1270 if (op->nrof && !(flag & INS_NO_MERGE)) 1310 if (op->nrof && !(flag & INS_NO_MERGE))
1271 for (object *tmp = ms.bot; tmp; tmp = tmp->above) 1311 for (object *tmp = ms.bot; tmp; tmp = tmp->above)
1272 if (object::can_merge (op, tmp)) 1312 if (object::can_merge (op, tmp))
1273 { 1313 {
1314 // TODO: we atcually want to update tmp, not op,
1315 // but some caller surely breaks when we return tmp
1316 // from here :/
1274 op->nrof += tmp->nrof; 1317 op->nrof += tmp->nrof;
1275 tmp->destroy (); 1318 tmp->destroy (1);
1276 } 1319 }
1277 1320
1278 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 */
1279 CLEAR_FLAG (op, FLAG_INV_LOCKED); 1322 CLEAR_FLAG (op, FLAG_INV_LOCKED);
1280 1323
… …
1300 /* since *below* originator, no need to update top */ 1343 /* since *below* originator, no need to update top */
1301 originator->below = op; 1344 originator->below = op;
1302 } 1345 }
1303 else 1346 else
1304 { 1347 {
1348 object *top, *floor = NULL;
1349
1305 top = ms.bot; 1350 top = ms.bot;
1306 1351
1307 /* If there are other objects, then */ 1352 /* If there are other objects, then */
1308 if (top) 1353 if (top)
1309 { 1354 {
… …
1408 } 1453 }
1409 1454
1410 op->map->dirty = true; 1455 op->map->dirty = true;
1411 1456
1412 if (object *pl = ms.player ()) 1457 if (object *pl = ms.player ())
1458 //TODO: the floorbox prev/next might need updating
1459 //esrv_send_item (pl, op);
1460 //TODO: update floorbox to preserve ordering
1461 if (pl->contr->ns)
1413 pl->contr->ns->floorbox_update (); 1462 pl->contr->ns->floorbox_update ();
1414 1463
1415 /* If this object glows, it may affect lighting conditions that are 1464 /* If this object glows, it may affect lighting conditions that are
1416 * visible to others on this map. But update_all_los is really 1465 * visible to others on this map. But update_all_los is really
1417 * an inefficient way to do this, as it means los for all players 1466 * an inefficient way to do this, as it means los for all players
1418 * on the map will get recalculated. The players could very well 1467 * on the map will get recalculated. The players could very well
… …
1460 * op is the object to insert it under: supplies x and the map. 1509 * op is the object to insert it under: supplies x and the map.
1461 */ 1510 */
1462void 1511void
1463replace_insert_ob_in_map (const char *arch_string, object *op) 1512replace_insert_ob_in_map (const char *arch_string, object *op)
1464{ 1513{
1465 object *tmp, *tmp1;
1466
1467 /* first search for itself and remove any old instances */ 1514 /* first search for itself and remove any old instances */
1468 1515
1469 for (tmp = op->ms ().bot; tmp; tmp = tmp->above) 1516 for (object *tmp = op->ms ().bot; tmp; tmp = tmp->above)
1470 if (!strcmp (tmp->arch->archname, arch_string)) /* same archetype */ 1517 if (!strcmp (tmp->arch->archname, arch_string)) /* same archetype */
1471 tmp->destroy (); 1518 tmp->destroy (1);
1472 1519
1473 tmp1 = arch_to_object (archetype::find (arch_string)); 1520 object *tmp = arch_to_object (archetype::find (arch_string));
1474 1521
1475 tmp1->x = op->x; 1522 tmp->x = op->x;
1476 tmp1->y = op->y; 1523 tmp->y = op->y;
1524
1477 insert_ob_in_map (tmp1, op->map, op, 0); 1525 insert_ob_in_map (tmp, op->map, op, 0);
1478} 1526}
1479 1527
1480object * 1528object *
1481object::insert_at (object *where, object *originator, int flags) 1529object::insert_at (object *where, object *originator, int flags)
1482{ 1530{
… …
1485 else 1533 else
1486 return where->map->insert (this, where->x, where->y, originator, flags); 1534 return where->map->insert (this, where->x, where->y, originator, flags);
1487} 1535}
1488 1536
1489/* 1537/*
1490 * get_split_ob(ob,nr) splits up ob into two parts. The part which
1491 * is returned contains nr objects, and the remaining parts contains
1492 * the rest (or is removed and freed if that number is 0).
1493 * On failure, NULL is returned, and the reason put into the
1494 * global static errmsg array.
1495 */
1496object *
1497get_split_ob (object *orig_ob, uint32 nr)
1498{
1499 object *newob;
1500 int is_removed = (QUERY_FLAG (orig_ob, FLAG_REMOVED) != 0);
1501
1502 if (orig_ob->nrof < nr)
1503 {
1504 sprintf (errmsg, "There are only %d %ss.", orig_ob->nrof ? orig_ob->nrof : 1, &orig_ob->name);
1505 return NULL;
1506 }
1507
1508 newob = object_create_clone (orig_ob);
1509
1510 if ((orig_ob->nrof -= nr) < 1)
1511 orig_ob->destroy (1);
1512 else if (!is_removed)
1513 {
1514 if (orig_ob->env != NULL)
1515 sub_weight (orig_ob->env, orig_ob->weight * nr);
1516 if (orig_ob->env == NULL && orig_ob->map->in_memory != MAP_ACTIVE)
1517 {
1518 strcpy (errmsg, "Tried to split object whose map is not in memory.");
1519 LOG (llevDebug, "Error, Tried to split object whose map is not in memory.\n");
1520 return NULL;
1521 }
1522 }
1523
1524 newob->nrof = nr;
1525
1526 return newob;
1527}
1528
1529/*
1530 * decrease_ob_nr(object, number) decreases a specified number from 1538 * decrease(object, number) decreases a specified number from
1531 * the amount of an object. If the amount reaches 0, the object 1539 * the amount of an object. If the amount reaches 0, the object
1532 * is subsequently removed and freed. 1540 * is subsequently removed and freed.
1533 * 1541 *
1534 * Return value: 'op' if something is left, NULL if the amount reached 0 1542 * Return value: 'op' if something is left, NULL if the amount reached 0
1535 */ 1543 */
1544bool
1545object::decrease (sint32 nr)
1546{
1547 if (!nr)
1548 return true;
1549
1550 nr = min (nr, nrof);
1551
1552 nrof -= nr;
1553
1554 if (nrof)
1555 {
1556 adjust_weight (env, -weight * nr); // carrying == 0
1557
1558 if (object *pl = visible_to ())
1559 esrv_update_item (UPD_NROF, pl, this);
1560
1561 return true;
1562 }
1563 else
1564 {
1565 destroy (1);
1566 return false;
1567 }
1568}
1569
1570/*
1571 * split(ob,nr) splits up ob into two parts. The part which
1572 * is returned contains nr objects, and the remaining parts contains
1573 * the rest (or is removed and returned if that number is 0).
1574 * On failure, NULL is returned.
1575 */
1536object * 1576object *
1537decrease_ob_nr (object *op, uint32 i) 1577object::split (sint32 nr)
1538{ 1578{
1539 object *tmp; 1579 int have = number_of ();
1540 1580
1541 if (i == 0) /* objects with op->nrof require this check */ 1581 if (have < nr)
1542 return op; 1582 return 0;
1543 1583 else if (have == nr)
1544 if (i > op->nrof)
1545 i = op->nrof;
1546
1547 if (QUERY_FLAG (op, FLAG_REMOVED))
1548 op->nrof -= i;
1549 else if (op->env)
1550 { 1584 {
1551 /* is this object in the players inventory, or sub container
1552 * therein?
1553 */
1554 tmp = op->in_player ();
1555 /* nope. Is this a container the player has opened?
1556 * If so, set tmp to that player.
1557 * IMO, searching through all the players will mostly
1558 * likely be quicker than following op->env to the map,
1559 * and then searching the map for a player.
1560 */
1561 if (!tmp)
1562 for_all_players (pl)
1563 if (pl->ob->container == op->env)
1564 {
1565 tmp = pl->ob;
1566 break;
1567 }
1568
1569 if (i < op->nrof)
1570 {
1571 sub_weight (op->env, op->weight * i);
1572 op->nrof -= i;
1573 if (tmp)
1574 esrv_send_item (tmp, op);
1575 }
1576 else
1577 {
1578 op->remove (); 1585 remove ();
1579 op->nrof = 0; 1586 return this;
1580 if (tmp)
1581 esrv_del_item (tmp->contr, op->count);
1582 }
1583 } 1587 }
1584 else 1588 else
1585 { 1589 {
1586 object *above = op->above; 1590 decrease (nr);
1587 1591
1588 if (i < op->nrof) 1592 object *op = deep_clone ();
1589 op->nrof -= i; 1593 op->nrof = nr;
1590 else
1591 {
1592 op->remove ();
1593 op->nrof = 0;
1594 }
1595
1596 /* Since we just removed op, op->above is null */
1597 for (tmp = above; tmp; tmp = tmp->above)
1598 if (tmp->type == PLAYER)
1599 {
1600 if (op->nrof)
1601 esrv_send_item (tmp, op);
1602 else
1603 esrv_del_item (tmp->contr, op->count);
1604 }
1605 }
1606
1607 if (op->nrof)
1608 return op; 1594 return op;
1609 else
1610 {
1611 op->destroy ();
1612 return 0;
1613 } 1595 }
1614} 1596}
1615 1597
1616object * 1598object *
1617insert_ob_in_ob (object *op, object *where) 1599insert_ob_in_ob (object *op, object *where)
… …
1642 * be != op, if items are merged. -Tero 1624 * be != op, if items are merged. -Tero
1643 */ 1625 */
1644object * 1626object *
1645object::insert (object *op) 1627object::insert (object *op)
1646{ 1628{
1647 if (!QUERY_FLAG (op, FLAG_REMOVED))
1648 op->remove ();
1649
1650 if (op->more) 1629 if (op->more)
1651 { 1630 {
1652 LOG (llevError, "Tried to insert multipart object %s (%d)\n", &op->name, op->count); 1631 LOG (llevError, "Tried to insert multipart object %s (%d)\n", &op->name, op->count);
1653 return op; 1632 return op;
1654 } 1633 }
1655 1634
1656 CLEAR_FLAG (op, FLAG_OBJ_ORIGINAL); 1635 op->remove ();
1657 CLEAR_FLAG (op, FLAG_REMOVED); 1636
1637 op->flag [FLAG_OBJ_ORIGINAL] = 0;
1658 1638
1659 if (op->nrof) 1639 if (op->nrof)
1660 {
1661 for (object *tmp = inv; tmp; tmp = tmp->below) 1640 for (object *tmp = inv; tmp; tmp = tmp->below)
1662 if (object::can_merge (tmp, op)) 1641 if (object::can_merge (tmp, op))
1663 { 1642 {
1664 /* return the original object and remove inserted object 1643 /* return the original object and remove inserted object
1665 (client needs the original object) */ 1644 (client needs the original object) */
1666 tmp->nrof += op->nrof; 1645 tmp->nrof += op->nrof;
1667 /* Weight handling gets pretty funky. Since we are adding to 1646
1668 * tmp->nrof, we need to increase the weight. 1647 if (object *pl = tmp->visible_to ())
1669 */ 1648 esrv_update_item (UPD_NROF, pl, tmp);
1649
1670 add_weight (this, op->weight * op->nrof); 1650 adjust_weight (this, op->total_weight ());
1671 SET_FLAG (op, FLAG_REMOVED); 1651
1672 op->destroy (); /* free the inserted object */ 1652 op->destroy (1);
1673 op = tmp; 1653 op = tmp;
1674 op->remove (); /* and fix old object's links */ 1654 goto inserted;
1675 CLEAR_FLAG (op, FLAG_REMOVED);
1676 break;
1677 } 1655 }
1678 1656
1679 /* I assume combined objects have no inventory
1680 * We add the weight - this object could have just been removed
1681 * (if it was possible to merge). calling remove_ob will subtract
1682 * the weight, so we need to add it in again, since we actually do
1683 * the linking below
1684 */
1685 add_weight (this, op->weight * op->nrof);
1686 }
1687 else
1688 add_weight (this, (op->weight + op->carrying));
1689
1690 if (object *otmp = this->in_player ())
1691 if (otmp->contr && !QUERY_FLAG (otmp, FLAG_NO_FIX_PLAYER))
1692 otmp->update_stats ();
1693
1694 op->owner = 0; // its his/hers now. period. 1657 op->owner = 0; // it's his/hers now. period.
1695 op->map = 0; 1658 op->map = 0;
1659 op->x = 0;
1660 op->y = 0;
1661
1662 op->above = 0;
1663 op->below = inv;
1696 op->env = this; 1664 op->env = this;
1697 op->above = 0;
1698 op->below = 0;
1699 op->x = op->y = 0;
1700 1665
1666 if (inv)
1667 inv->above = op;
1668
1669 inv = op;
1670
1671 op->flag [FLAG_REMOVED] = 0;
1672
1673 if (object *pl = op->visible_to ())
1674 esrv_send_item (pl, op);
1675
1676 adjust_weight (this, op->total_weight ());
1677
1678inserted:
1701 /* reset the light list and los of the players on the map */ 1679 /* reset the light list and los of the players on the map */
1702 if (op->glow_radius && map) 1680 if (op->glow_radius && map && map->darkness)
1703 {
1704#ifdef DEBUG_LIGHTS
1705 LOG (llevDebug, " insert_ob_in_ob(): got %s to insert in map/op\n", op->name);
1706#endif /* DEBUG_LIGHTS */
1707 if (map->darkness)
1708 update_all_los (map, x, y); 1681 update_all_los (map, x, y);
1709 }
1710 1682
1711 /* Client has no idea of ordering so lets not bother ordering it here. 1683 // if this is a player's inventory, update stats
1712 * It sure simplifies this function... 1684 if (type == PLAYER && !flag [FLAG_NO_FIX_PLAYER])
1713 */ 1685 update_stats ();
1714 if (!inv)
1715 inv = op;
1716 else
1717 {
1718 op->below = inv;
1719 op->below->above = op;
1720 inv = op;
1721 }
1722 1686
1723 INVOKE_OBJECT (INSERT, this); 1687 INVOKE_OBJECT (INSERT, this);
1724 1688
1725 return op; 1689 return op;
1726} 1690}
… …
1854 LOG (llevError, "Present_arch called outside map.\n"); 1818 LOG (llevError, "Present_arch called outside map.\n");
1855 return NULL; 1819 return NULL;
1856 } 1820 }
1857 1821
1858 for (object *tmp = m->at (x, y).bot; tmp; tmp = tmp->above) 1822 for (object *tmp = m->at (x, y).bot; tmp; tmp = tmp->above)
1859 if (tmp->arch == at) 1823 if (tmp->arch->archname == at->archname)
1860 return tmp; 1824 return tmp;
1861 1825
1862 return NULL; 1826 return NULL;
1863} 1827}
1864 1828
… …
1928 * The first matching object is returned, or NULL if none. 1892 * The first matching object is returned, or NULL if none.
1929 */ 1893 */
1930object * 1894object *
1931present_arch_in_ob (const archetype *at, const object *op) 1895present_arch_in_ob (const archetype *at, const object *op)
1932{ 1896{
1933 for (object *tmp = op->inv; tmp != NULL; tmp = tmp->below) 1897 for (object *tmp = op->inv; tmp; tmp = tmp->below)
1934 if (tmp->arch == at) 1898 if (tmp->arch->archname == at->archname)
1935 return tmp; 1899 return tmp;
1936 1900
1937 return NULL; 1901 return NULL;
1938} 1902}
1939 1903
… …
2348 2312
2349/* 2313/*
2350 * create clone from object to another 2314 * create clone from object to another
2351 */ 2315 */
2352object * 2316object *
2353object_create_clone (object *asrc) 2317object::deep_clone ()
2354{ 2318{
2355 object *dst = 0, *tmp, *src, *prev, *item; 2319 assert (("deep_clone called on non-head object", is_head ()));
2356 2320
2357 if (!asrc) 2321 object *dst = clone ();
2358 return 0;
2359 2322
2360 src = asrc->head_ (); 2323 object *prev = dst;
2361
2362 prev = 0;
2363 for (object *part = src; part; part = part->more) 2324 for (object *part = this->more; part; part = part->more)
2364 { 2325 {
2365 tmp = part->clone (); 2326 object *tmp = part->clone ();
2366 tmp->x -= src->x;
2367 tmp->y -= src->y;
2368
2369 if (!part->head)
2370 {
2371 dst = tmp;
2372 tmp->head = 0;
2373 }
2374 else
2375 tmp->head = dst; 2327 tmp->head = dst;
2376
2377 tmp->more = 0;
2378
2379 if (prev)
2380 prev->more = tmp; 2328 prev->more = tmp;
2381
2382 prev = tmp; 2329 prev = tmp;
2383 } 2330 }
2384 2331
2385 for (item = src->inv; item; item = item->below) 2332 for (object *item = inv; item; item = item->below)
2386 insert_ob_in_ob (object_create_clone (item), dst); 2333 insert_ob_in_ob (item->deep_clone (), dst);
2387 2334
2388 return dst; 2335 return dst;
2389} 2336}
2390 2337
2391/* This returns the first object in who's inventory that 2338/* This returns the first object in who's inventory that
… …
2400 return tmp; 2347 return tmp;
2401 2348
2402 return 0; 2349 return 0;
2403} 2350}
2404 2351
2405/* If ob has a field named key, return the link from the list, 2352const shstr &
2406 * otherwise return NULL. 2353object::kv_get (const shstr &key) const
2407 *
2408 * key must be a passed in shared string - otherwise, this won't
2409 * do the desired thing.
2410 */
2411key_value *
2412get_ob_key_link (const object *ob, const char *key)
2413{ 2354{
2414 for (key_value *link = ob->key_values; link; link = link->next) 2355 for (key_value *kv = key_values; kv; kv = kv->next)
2415 if (link->key == key) 2356 if (kv->key == key)
2416 return link;
2417
2418 return 0;
2419}
2420
2421/*
2422 * Returns the value of op has an extra_field for key, or NULL.
2423 *
2424 * The argument doesn't need to be a shared string.
2425 *
2426 * The returned string is shared.
2427 */
2428const char *
2429get_ob_key_value (const object *op, const char *const key)
2430{
2431 key_value *link;
2432 shstr_cmp canonical_key (key);
2433
2434 if (!canonical_key)
2435 {
2436 /* 1. There being a field named key on any object
2437 * implies there'd be a shared string to find.
2438 * 2. Since there isn't, no object has this field.
2439 * 3. Therefore, *this* object doesn't have this field.
2440 */
2441 return 0;
2442 }
2443
2444 /* This is copied from get_ob_key_link() above -
2445 * only 4 lines, and saves the function call overhead.
2446 */
2447 for (link = op->key_values; link; link = link->next)
2448 if (link->key == canonical_key)
2449 return link->value; 2357 return kv->value;
2450 2358
2451 return 0; 2359 return shstr_null;
2452} 2360}
2453 2361
2454/* 2362void
2455 * Updates the canonical_key in op to value. 2363object::kv_set (const shstr &key, const shstr &value)
2456 *
2457 * canonical_key is a shared string (value doesn't have to be).
2458 *
2459 * Unless add_key is TRUE, it won't add fields, only change the value of existing
2460 * keys.
2461 *
2462 * Returns TRUE on success.
2463 */
2464int
2465set_ob_key_value_s (object *op, const shstr & canonical_key, const char *value, int add_key)
2466{ 2364{
2467 key_value *field = NULL, *last = NULL; 2365 for (key_value *kv = key_values; kv; kv = kv->next)
2468 2366 if (kv->key == key)
2469 for (field = op->key_values; field != NULL; field = field->next)
2470 {
2471 if (field->key != canonical_key)
2472 { 2367 {
2473 last = field; 2368 kv->value = value;
2474 continue; 2369 return;
2475 } 2370 }
2476 2371
2477 if (value) 2372 key_value *kv = new key_value;
2478 field->value = value; 2373
2479 else 2374 kv->next = key_values;
2375 kv->key = key;
2376 kv->value = value;
2377
2378 key_values = kv;
2379}
2380
2381void
2382object::kv_del (const shstr &key)
2383{
2384 for (key_value **kvp = &key_values; *kvp; kvp = &(*kvp)->next)
2385 if ((*kvp)->key == key)
2480 { 2386 {
2481 /* Basically, if the archetype has this key set, 2387 key_value *kv = *kvp;
2482 * we need to store the null value so when we save 2388 *kvp = (*kvp)->next;
2483 * it, we save the empty value so that when we load, 2389 delete kv;
2484 * we get this value back again. 2390 return;
2485 */
2486 if (get_ob_key_link (op->arch, canonical_key))
2487 field->value = 0;
2488 else
2489 {
2490 if (last)
2491 last->next = field->next;
2492 else
2493 op->key_values = field->next;
2494
2495 delete field;
2496 }
2497 } 2391 }
2498 return TRUE;
2499 }
2500 /* IF we get here, key doesn't exist */
2501
2502 /* No field, we'll have to add it. */
2503
2504 if (!add_key)
2505 return FALSE;
2506
2507 /* There isn't any good reason to store a null
2508 * value in the key/value list. If the archetype has
2509 * this key, then we should also have it, so shouldn't
2510 * be here. If user wants to store empty strings,
2511 * should pass in ""
2512 */
2513 if (value == NULL)
2514 return TRUE;
2515
2516 field = new key_value;
2517
2518 field->key = canonical_key;
2519 field->value = value;
2520 /* Usual prepend-addition. */
2521 field->next = op->key_values;
2522 op->key_values = field;
2523
2524 return TRUE;
2525}
2526
2527/*
2528 * Updates the key in op to value.
2529 *
2530 * If add_key is FALSE, this will only update existing keys,
2531 * and not add new ones.
2532 * In general, should be little reason FALSE is ever passed in for add_key
2533 *
2534 * Returns TRUE on success.
2535 */
2536int
2537set_ob_key_value (object *op, const char *key, const char *value, int add_key)
2538{
2539 shstr key_ (key);
2540
2541 return set_ob_key_value_s (op, key_, value, add_key);
2542} 2392}
2543 2393
2544object::depth_iterator::depth_iterator (object *container) 2394object::depth_iterator::depth_iterator (object *container)
2545: iterator_base (container) 2395: iterator_base (container)
2546{ 2396{
… …
2604 &name, 2454 &name,
2605 title ? "\",title:\"" : "", 2455 title ? "\",title:\"" : "",
2606 title ? (const char *)title : "", 2456 title ? (const char *)title : "",
2607 flag_desc (flagdesc, 512), type); 2457 flag_desc (flagdesc, 512), type);
2608 2458
2609 if (!this->flag[FLAG_REMOVED] && env) 2459 if (!flag[FLAG_REMOVED] && env)
2610 p += snprintf (p, 256, "(in %s)", env->debug_desc (info2)); 2460 p += snprintf (p, 256, "(in %s)", env->debug_desc (info2));
2611 2461
2612 if (map) 2462 if (map)
2613 p += snprintf (p, 256, "(on %s@%d+%d)", &map->path, x, y); 2463 p += snprintf (p, 256, "(on %s@%d+%d)", &map->path, x, y);
2614 2464
… …
2644object::open_container (object *new_container) 2494object::open_container (object *new_container)
2645{ 2495{
2646 if (container == new_container) 2496 if (container == new_container)
2647 return; 2497 return;
2648 2498
2649 if (object *old_container = container) 2499 object *old_container = container;
2500
2501 if (old_container)
2650 { 2502 {
2651 if (INVOKE_OBJECT (CLOSE, old_container, ARG_OBJECT (this))) 2503 if (INVOKE_OBJECT (CLOSE, old_container, ARG_OBJECT (this)))
2652 return; 2504 return;
2653 2505
2654#if 0 2506#if 0
… …
2656 if (object *closer = old_container->inv) 2508 if (object *closer = old_container->inv)
2657 if (closer->type == CLOSE_CON) 2509 if (closer->type == CLOSE_CON)
2658 closer->destroy (); 2510 closer->destroy ();
2659#endif 2511#endif
2660 2512
2513 // make sure the container is available
2514 esrv_send_item (this, old_container);
2515
2661 old_container->flag [FLAG_APPLIED] = 0; 2516 old_container->flag [FLAG_APPLIED] = false;
2662 container = 0; 2517 container = 0;
2663 2518
2519 // client needs item update to make it work, client bug requires this to be separate
2664 esrv_update_item (UPD_FLAGS, this, old_container); 2520 esrv_update_item (UPD_FLAGS, this, old_container);
2521
2665 new_draw_info_format (NDI_UNIQUE, 0, this, "You close %s.", query_name (old_container)); 2522 new_draw_info_format (NDI_UNIQUE, 0, this, "You close %s.", query_name (old_container));
2666 play_sound (sound_find ("chest_close")); 2523 play_sound (sound_find ("chest_close"));
2667 } 2524 }
2668 2525
2669 if (new_container) 2526 if (new_container)
… …
2682 } 2539 }
2683#endif 2540#endif
2684 2541
2685 new_draw_info_format (NDI_UNIQUE, 0, this, "You open %s.", query_name (new_container)); 2542 new_draw_info_format (NDI_UNIQUE, 0, this, "You open %s.", query_name (new_container));
2686 2543
2544 // make sure the container is available, client bug requires this to be separate
2545 esrv_send_item (this, new_container);
2546
2687 new_container->flag [FLAG_APPLIED] = 1; 2547 new_container->flag [FLAG_APPLIED] = true;
2688 container = new_container; 2548 container = new_container;
2689 2549
2550 // client needs flag change
2690 esrv_update_item (UPD_FLAGS, this, new_container); 2551 esrv_update_item (UPD_FLAGS, this, new_container);
2691 esrv_send_inventory (this, new_container); 2552 esrv_send_inventory (this, new_container);
2692 play_sound (sound_find ("chest_open")); 2553 play_sound (sound_find ("chest_open"));
2693 } 2554 }
2555// else if (!old_container->env && contr && contr->ns)
2556// contr->ns->floorbox_reset ();
2694} 2557}
2695 2558
2696object * 2559object *
2697object::force_find (const shstr name) 2560object::force_find (const shstr name)
2698{ 2561{
… …
2724 2587
2725 insert (force); 2588 insert (force);
2726} 2589}
2727 2590
2728void 2591void
2729object::play_sound (faceidx sound) const 2592object::play_sound (faceidx sound)
2730{ 2593{
2731 if (!sound) 2594 if (!sound)
2732 return; 2595 return;
2733 2596
2734 if (flag [FLAG_REMOVED]) 2597 if (flag [FLAG_REMOVED])

Diff Legend

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