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.233 by root, Tue May 6 18:47:32 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_for (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 {
375 // adjust by actual difference to account for rounding errors
376 // i.e. (w2 - w1) / f != w2 / f - w1 / f and the latter is correct
349 weight = weight_adjust (op, weight); 377 weight = weight_adjust_for (op, op->carrying)
378 - weight_adjust_for (op, op->carrying - weight);
379
380 if (!weight)
381 return;
350 382
351 op->carrying += weight; 383 op->carrying += weight;
384
385 if (object *pl = op->visible_to ())
386 if (pl != op) // player is handled lazily
387 esrv_update_item (UPD_WEIGHT, pl, op);
388
352 op = op->env; 389 op = op->env;
353 } 390 }
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} 391}
365 392
366/* 393/*
367 * this is a recursive function which calculates the weight 394 * this is a recursive function which calculates the weight
368 * an object is carrying. It goes through op and figures out how much 395 * an object is carrying. It goes through op and figures out how much
… …
379 op->update_weight (); 406 op->update_weight ();
380 407
381 sum += op->total_weight (); 408 sum += op->total_weight ();
382 } 409 }
383 410
384 carrying = weight_adjust (this, sum); 411 sum = weight_adjust (this, sum);
385}
386 412
413 if (sum != carrying)
414 {
415 carrying = sum;
416
417 if (object *pl = visible_to ())
418 if (pl != this) // player is handled lazily
419 esrv_update_item (UPD_WEIGHT, pl, this);
420 }
421}
422
387/* 423/*
388 * Used by: Crossedit: dump. Server DM commands: dumpbelow, dump. 424 * 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 */ 425 */
392char * 426char *
393dump_object (object *op) 427dump_object (object *op)
394{ 428{
395 if (!op) 429 if (!op)
… …
409get_nearest_part (object *op, const object *pl) 443get_nearest_part (object *op, const object *pl)
410{ 444{
411 object *tmp, *closest; 445 object *tmp, *closest;
412 int last_dist, i; 446 int last_dist, i;
413 447
414 if (op->more == NULL) 448 if (!op->more)
415 return op; 449 return op;
450
416 for (last_dist = distance (op, pl), closest = op, tmp = op->more; tmp != NULL; tmp = tmp->more) 451 for (last_dist = distance (op, pl), closest = op, tmp = op->more;
452 tmp;
453 tmp = tmp->more)
417 if ((i = distance (tmp, pl)) < last_dist) 454 if ((i = distance (tmp, pl)) < last_dist)
418 closest = tmp, last_dist = i; 455 closest = tmp, last_dist = i;
456
419 return closest; 457 return closest;
420} 458}
421 459
422/* 460/*
423 * Returns the object which has the count-variable equal to the argument. 461 * Returns the object which has the count-variable equal to the argument.
462 * VERRRY slow.
424 */ 463 */
425object * 464object *
426find_object (tag_t i) 465find_object (tag_t i)
427{ 466{
428 for_all_objects (op) 467 for_all_objects (op)
… …
553 } 592 }
554 593
555 op->key_values = 0; 594 op->key_values = 0;
556} 595}
557 596
558object & 597/*
559object::operator =(const object &src) 598 * copy_to first frees everything allocated by the dst object,
599 * and then copies the contents of itself into the second
600 * object, allocating what needs to be allocated. Basically, any
601 * data that is malloc'd needs to be re-malloc/copied. Otherwise,
602 * if the first object is freed, the pointers in the new object
603 * will point at garbage.
604 */
605void
606object::copy_to (object *dst)
560{ 607{
561 bool is_freed = flag [FLAG_FREED]; 608 dst->remove ();
562 bool is_removed = flag [FLAG_REMOVED];
563
564 *(object_copy *)this = src; 609 *(object_copy *)dst = *this;
565
566 flag [FLAG_FREED] = is_freed;
567 flag [FLAG_REMOVED] = is_removed; 610 dst->flag [FLAG_REMOVED] = true;
568 611
569 /* Copy over key_values, if any. */ 612 /* Copy over key_values, if any. */
570 if (src.key_values) 613 if (key_values)
571 { 614 {
572 key_value *tail = 0; 615 key_value *tail = 0;
573 key_values = 0; 616 dst->key_values = 0;
574 617
575 for (key_value *i = src.key_values; i; i = i->next) 618 for (key_value *i = key_values; i; i = i->next)
576 { 619 {
577 key_value *new_link = new key_value; 620 key_value *new_link = new key_value;
578 621
579 new_link->next = 0; 622 new_link->next = 0;
580 new_link->key = i->key; 623 new_link->key = i->key;
581 new_link->value = i->value; 624 new_link->value = i->value;
582 625
583 /* Try and be clever here, too. */ 626 /* Try and be clever here, too. */
584 if (!key_values) 627 if (!dst->key_values)
585 { 628 {
586 key_values = new_link; 629 dst->key_values = new_link;
587 tail = new_link; 630 tail = new_link;
588 } 631 }
589 else 632 else
590 { 633 {
591 tail->next = new_link; 634 tail->next = new_link;
592 tail = new_link; 635 tail = new_link;
593 } 636 }
594 } 637 }
595 } 638 }
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 639
611 if (speed < 0) 640 if (speed < 0)
612 dst->speed_left -= rndm (); 641 dst->speed_left -= rndm ();
613 642
614 dst->set_speed (dst->speed); 643 dst->set_speed (dst->speed);
… …
636object * 665object *
637object::clone () 666object::clone ()
638{ 667{
639 object *neu = create (); 668 object *neu = create ();
640 copy_to (neu); 669 copy_to (neu);
670 neu->map = map; // not copied by copy_to
641 return neu; 671 return neu;
642} 672}
643 673
644/* 674/*
645 * If an object with the IS_TURNABLE() flag needs to be turned due 675 * If an object with the IS_TURNABLE() flag needs to be turned due
… …
696 * UP_OBJ_FACE: only the objects face has changed. 726 * UP_OBJ_FACE: only the objects face has changed.
697 */ 727 */
698void 728void
699update_object (object *op, int action) 729update_object (object *op, int action)
700{ 730{
701 if (op == NULL) 731 if (!op)
702 { 732 {
703 /* this should never happen */ 733 /* this should never happen */
704 LOG (llevDebug, "update_object() called for NULL object.\n"); 734 LOG (llevError | logBacktrace, "update_object() called for NULL object.\n");
705 return; 735 return;
706 } 736 }
707 737
708 if (op->env) 738 if (!op->is_on_map ())
709 { 739 {
710 /* Animation is currently handled by client, so nothing 740 /* Animation is currently handled by client, so nothing
711 * to do in this case. 741 * to do in this case.
712 */ 742 */
713 return; 743 return;
714 } 744 }
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 745
722 /* make sure the object is within map boundaries */ 746 /* 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) 747 if (op->x < 0 || op->x >= op->map->width || op->y < 0 || op->y >= op->map->height)
724 { 748 {
725 LOG (llevError, "update_object() called for object out of map!\n"); 749 LOG (llevError, "update_object() called for object out of map!\n");
… …
868object::destroy_inv (bool drop_to_ground) 892object::destroy_inv (bool drop_to_ground)
869{ 893{
870 // need to check first, because the checks below might segfault 894 // need to check first, because the checks below might segfault
871 // as we might be on an invalid mapspace and crossfire code 895 // as we might be on an invalid mapspace and crossfire code
872 // is too buggy to ensure that the inventory is empty. 896 // is too buggy to ensure that the inventory is empty.
873 // corollary: if you create arrows etc. with stuff in tis inventory, 897 // corollary: if you create arrows etc. with stuff in its inventory,
874 // cf will crash below with off-map x and y 898 // cf will crash below with off-map x and y
875 if (!inv) 899 if (!inv)
876 return; 900 return;
877 901
878 /* Only if the space blocks everything do we not process - 902 /* Only if the space blocks everything do we not process -
… …
885 || map->nodrop 909 || map->nodrop
886 || ms ().move_block == MOVE_ALL) 910 || ms ().move_block == MOVE_ALL)
887 { 911 {
888 while (inv) 912 while (inv)
889 { 913 {
890 inv->destroy_inv (drop_to_ground); 914 inv->destroy_inv (false);
891 inv->destroy (); 915 inv->destroy ();
892 } 916 }
893 } 917 }
894 else 918 else
895 { /* Put objects in inventory onto this space */ 919 { /* Put objects in inventory onto this space */
… …
901 || op->flag [FLAG_NO_DROP] 925 || op->flag [FLAG_NO_DROP]
902 || op->type == RUNE 926 || op->type == RUNE
903 || op->type == TRAP 927 || op->type == TRAP
904 || op->flag [FLAG_IS_A_TEMPLATE] 928 || op->flag [FLAG_IS_A_TEMPLATE]
905 || op->flag [FLAG_DESTROY_ON_DEATH]) 929 || op->flag [FLAG_DESTROY_ON_DEATH])
906 op->destroy (); 930 op->destroy (true);
907 else 931 else
908 map->insert (op, x, y); 932 map->insert (op, x, y);
909 } 933 }
910 } 934 }
911} 935}
… …
915 object *op = new object; 939 object *op = new object;
916 op->link (); 940 op->link ();
917 return op; 941 return op;
918} 942}
919 943
944static struct freed_map : maptile
945{
946 freed_map ()
947 {
948 path = "<freed objects map>";
949 name = "/internal/freed_objects_map";
950 width = 3;
951 height = 3;
952 nodrop = 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
920void 964void
921object::do_destroy () 965object::do_destroy ()
922{ 966{
923 attachable::do_destroy ();
924
925 if (flag [FLAG_IS_LINKED]) 967 if (flag [FLAG_IS_LINKED])
926 remove_button_link (this); 968 remove_button_link (this);
927 969
928 if (flag [FLAG_FRIENDLY]) 970 if (flag [FLAG_FRIENDLY])
929 remove_friendly_object (this); 971 remove_friendly_object (this);
930 972
931 if (!flag [FLAG_REMOVED])
932 remove (); 973 remove ();
933 974
934 destroy_inv (true); 975 attachable::do_destroy ();
935 976
936 deactivate (); 977 deactivate ();
937 unlink (); 978 unlink ();
938 979
939 flag [FLAG_FREED] = 1; 980 flag [FLAG_FREED] = 1;
940 981
941 // hack to ensure that freed objects still have a valid map 982 // 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; 983 map = &freed_map;
960 x = 1; 984 x = 1;
961 y = 1; 985 y = 1;
962 }
963 986
964 if (more) 987 if (more)
965 { 988 {
966 more->destroy (); 989 more->destroy ();
967 more = 0; 990 more = 0;
… …
980object::destroy (bool destroy_inventory) 1003object::destroy (bool destroy_inventory)
981{ 1004{
982 if (destroyed ()) 1005 if (destroyed ())
983 return; 1006 return;
984 1007
1008 if (!is_head () && !head->destroyed ())
1009 {
1010 LOG (llevError | logBacktrace, "tried to destroy the tail of an object");
1011 head->destroy (destroy_inventory);
1012 return;
1013 }
1014
985 if (destroy_inventory) 1015 destroy_inv (!destroy_inventory);
986 destroy_inv (false);
987 1016
988 if (is_head ()) 1017 if (is_head ())
989 if (sound_destroy) 1018 if (sound_destroy)
990 play_sound (sound_destroy); 1019 play_sound (sound_destroy);
991 else if (flag [FLAG_MONSTER]) 1020 else if (flag [FLAG_MONSTER])
… …
1005object::do_remove () 1034object::do_remove ()
1006{ 1035{
1007 object *tmp, *last = 0; 1036 object *tmp, *last = 0;
1008 object *otmp; 1037 object *otmp;
1009 1038
1010 if (QUERY_FLAG (this, FLAG_REMOVED)) 1039 if (flag [FLAG_REMOVED])
1011 return; 1040 return;
1012 1041
1013 SET_FLAG (this, FLAG_REMOVED);
1014 INVOKE_OBJECT (REMOVE, this); 1042 INVOKE_OBJECT (REMOVE, this);
1043
1044 flag [FLAG_REMOVED] = true;
1015 1045
1016 if (more) 1046 if (more)
1017 more->remove (); 1047 more->remove ();
1018 1048
1019 /* 1049 /*
1020 * In this case, the object to be removed is in someones 1050 * In this case, the object to be removed is in someones
1021 * inventory. 1051 * inventory.
1022 */ 1052 */
1023 if (env) 1053 if (env)
1024 { 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
1060 adjust_weight (env, -total_weight ());
1061
1062 *(above ? &above->below : &env->inv) = below;
1063
1025 if (nrof) 1064 if (below)
1026 sub_weight (env, weight * nrof); 1065 below->above = above;
1027 else 1066
1028 sub_weight (env, weight + carrying); 1067 /* we set up values so that it could be inserted into
1068 * the map, but we don't actually do that - it is up
1069 * to the caller to decide what we want to do.
1070 */
1071 map = env->map;
1072 x = env->x;
1073 y = env->y;
1074 above = 0;
1075 below = 0;
1076 env = 0;
1029 1077
1030 /* NO_FIX_PLAYER is set when a great many changes are being 1078 /* NO_FIX_PLAYER is set when a great many changes are being
1031 * made to players inventory. If set, avoiding the call 1079 * made to players inventory. If set, avoiding the call
1032 * to save cpu time. 1080 * to save cpu time.
1033 */ 1081 */
1034 if ((otmp = in_player ()) && otmp->contr && !QUERY_FLAG (otmp, FLAG_NO_FIX_PLAYER)) 1082 if ((otmp = in_player ()) && otmp->contr && !QUERY_FLAG (otmp, FLAG_NO_FIX_PLAYER))
1035 otmp->update_stats (); 1083 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 } 1084 }
1054 else if (map) 1085 else if (map)
1055 { 1086 {
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; 1087 map->dirty = true;
1069 mapspace &ms = this->ms (); 1088 mapspace &ms = this->ms ();
1089
1090 if (object *pl = ms.player ())
1091 {
1092 if (type == PLAYER) // this == pl(!)
1093 {
1094 // leaving a spot always closes any open container on the ground
1095 if (container && !container->env)
1096 // this causes spurious floorbox updates, but it ensures
1097 // that the CLOSE event is being sent.
1098 close_container ();
1099
1100 --map->players;
1101 map->touch ();
1102 }
1103 else if (pl->container == this)
1104 {
1105 // removing a container should close it
1106 close_container ();
1107 }
1108
1109 esrv_del_item (pl->contr, count);
1110 }
1070 1111
1071 /* link the object above us */ 1112 /* link the object above us */
1072 if (above) 1113 if (above)
1073 above->below = below; 1114 above->below = below;
1074 else 1115 else
… …
1104 * removed (most likely destroyed), update the player view 1145 * removed (most likely destroyed), update the player view
1105 * appropriately. 1146 * appropriately.
1106 */ 1147 */
1107 pl->close_container (); 1148 pl->close_container ();
1108 1149
1150 //TODO: the floorbox prev/next might need updating
1151 //esrv_del_item (pl->contr, count);
1152 //TODO: update floorbox to preserve ordering
1153 if (pl->contr->ns)
1109 pl->contr->ns->floorbox_update (); 1154 pl->contr->ns->floorbox_update ();
1110 } 1155 }
1111 1156
1112 for (tmp = ms.bot; tmp; tmp = tmp->above) 1157 for (tmp = ms.bot; tmp; tmp = tmp->above)
1113 { 1158 {
1114 /* No point updating the players look faces if he is the object 1159 /* No point updating the players look faces if he is the object
… …
1158 if (!top) 1203 if (!top)
1159 for (top = op; top && top->above; top = top->above) 1204 for (top = op; top && top->above; top = top->above)
1160 ; 1205 ;
1161 1206
1162 for (; top; top = top->below) 1207 for (; top; top = top->below)
1163 {
1164 if (top == op)
1165 continue;
1166
1167 if (object::can_merge (op, top)) 1208 if (object::can_merge (op, top))
1168 { 1209 {
1169 top->nrof += op->nrof; 1210 top->nrof += op->nrof;
1170 1211
1171/* CLEAR_FLAG(top,FLAG_STARTEQUIP);*/ 1212 if (object *pl = top->visible_to ())
1172 op->weight = 0; /* Don't want any adjustements now */ 1213 esrv_update_item (UPD_NROF, pl, top);
1214
1215 op->weight = 0; // cancel the addition above
1216 op->carrying = 0; // must be 0 already
1217
1173 op->destroy (); 1218 op->destroy (1);
1219
1174 return top; 1220 return top;
1175 } 1221 }
1176 }
1177 1222
1178 return 0; 1223 return 0;
1179} 1224}
1180 1225
1181void 1226void
… …
1240object * 1285object *
1241insert_ob_in_map (object *op, maptile *m, object *originator, int flag) 1286insert_ob_in_map (object *op, maptile *m, object *originator, int flag)
1242{ 1287{
1243 assert (!op->flag [FLAG_FREED]); 1288 assert (!op->flag [FLAG_FREED]);
1244 1289
1245 object *top, *floor = NULL;
1246
1247 op->remove (); 1290 op->remove ();
1248 1291
1249 /* Ideally, the caller figures this out. However, it complicates a lot 1292 /* 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 1293 * of areas of callers (eg, anything that uses find_free_spot would now
1251 * need extra work 1294 * need extra work
1252 */ 1295 */
1253 if (!xy_normalise (m, op->x, op->y)) 1296 if (!xy_normalise (m, op->x, op->y))
1254 { 1297 {
1255 op->destroy (); 1298 op->head_ ()->destroy (1);// remove head_ once all tail object destroyers found
1256 return 0; 1299 return 0;
1257 } 1300 }
1258 1301
1259 if (object *more = op->more) 1302 if (object *more = op->more)
1260 if (!insert_ob_in_map (more, m, originator, flag)) 1303 if (!insert_ob_in_map (more, m, originator, flag))
… …
1269 */ 1312 */
1270 if (op->nrof && !(flag & INS_NO_MERGE)) 1313 if (op->nrof && !(flag & INS_NO_MERGE))
1271 for (object *tmp = ms.bot; tmp; tmp = tmp->above) 1314 for (object *tmp = ms.bot; tmp; tmp = tmp->above)
1272 if (object::can_merge (op, tmp)) 1315 if (object::can_merge (op, tmp))
1273 { 1316 {
1317 // TODO: we atcually want to update tmp, not op,
1318 // but some caller surely breaks when we return tmp
1319 // from here :/
1274 op->nrof += tmp->nrof; 1320 op->nrof += tmp->nrof;
1275 tmp->destroy (); 1321 tmp->destroy (1);
1276 } 1322 }
1277 1323
1278 CLEAR_FLAG (op, FLAG_APPLIED); /* hack for fixing F_APPLIED in items of dead people */ 1324 CLEAR_FLAG (op, FLAG_APPLIED); /* hack for fixing F_APPLIED in items of dead people */
1279 CLEAR_FLAG (op, FLAG_INV_LOCKED); 1325 CLEAR_FLAG (op, FLAG_INV_LOCKED);
1280 1326
… …
1300 /* since *below* originator, no need to update top */ 1346 /* since *below* originator, no need to update top */
1301 originator->below = op; 1347 originator->below = op;
1302 } 1348 }
1303 else 1349 else
1304 { 1350 {
1351 object *top, *floor = NULL;
1352
1305 top = ms.bot; 1353 top = ms.bot;
1306 1354
1307 /* If there are other objects, then */ 1355 /* If there are other objects, then */
1308 if (top) 1356 if (top)
1309 { 1357 {
… …
1408 } 1456 }
1409 1457
1410 op->map->dirty = true; 1458 op->map->dirty = true;
1411 1459
1412 if (object *pl = ms.player ()) 1460 if (object *pl = ms.player ())
1461 //TODO: the floorbox prev/next might need updating
1462 //esrv_send_item (pl, op);
1463 //TODO: update floorbox to preserve ordering
1464 if (pl->contr->ns)
1413 pl->contr->ns->floorbox_update (); 1465 pl->contr->ns->floorbox_update ();
1414 1466
1415 /* If this object glows, it may affect lighting conditions that are 1467 /* If this object glows, it may affect lighting conditions that are
1416 * visible to others on this map. But update_all_los is really 1468 * 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 1469 * 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 1470 * 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. 1512 * op is the object to insert it under: supplies x and the map.
1461 */ 1513 */
1462void 1514void
1463replace_insert_ob_in_map (const char *arch_string, object *op) 1515replace_insert_ob_in_map (const char *arch_string, object *op)
1464{ 1516{
1465 object *tmp, *tmp1;
1466
1467 /* first search for itself and remove any old instances */ 1517 /* first search for itself and remove any old instances */
1468 1518
1469 for (tmp = op->ms ().bot; tmp; tmp = tmp->above) 1519 for (object *tmp = op->ms ().bot; tmp; tmp = tmp->above)
1470 if (!strcmp (tmp->arch->archname, arch_string)) /* same archetype */ 1520 if (!strcmp (tmp->arch->archname, arch_string)) /* same archetype */
1471 tmp->destroy (); 1521 tmp->destroy (1);
1472 1522
1473 tmp1 = arch_to_object (archetype::find (arch_string)); 1523 object *tmp = arch_to_object (archetype::find (arch_string));
1474 1524
1475 tmp1->x = op->x; 1525 tmp->x = op->x;
1476 tmp1->y = op->y; 1526 tmp->y = op->y;
1527
1477 insert_ob_in_map (tmp1, op->map, op, 0); 1528 insert_ob_in_map (tmp, op->map, op, 0);
1478} 1529}
1479 1530
1480object * 1531object *
1481object::insert_at (object *where, object *originator, int flags) 1532object::insert_at (object *where, object *originator, int flags)
1482{ 1533{
… …
1485 else 1536 else
1486 return where->map->insert (this, where->x, where->y, originator, flags); 1537 return where->map->insert (this, where->x, where->y, originator, flags);
1487} 1538}
1488 1539
1489/* 1540/*
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 1541 * decrease(object, number) decreases a specified number from
1531 * the amount of an object. If the amount reaches 0, the object 1542 * the amount of an object. If the amount reaches 0, the object
1532 * is subsequently removed and freed. 1543 * is subsequently removed and freed.
1533 * 1544 *
1534 * Return value: 'op' if something is left, NULL if the amount reached 0 1545 * Return value: 'op' if something is left, NULL if the amount reached 0
1535 */ 1546 */
1547bool
1548object::decrease (sint32 nr)
1549{
1550 if (!nr)
1551 return true;
1552
1553 nr = min (nr, nrof);
1554
1555 nrof -= nr;
1556
1557 if (nrof)
1558 {
1559 adjust_weight (env, -weight * nr); // carrying == 0
1560
1561 if (object *pl = visible_to ())
1562 esrv_update_item (UPD_NROF, pl, this);
1563
1564 return true;
1565 }
1566 else
1567 {
1568 destroy (1);
1569 return false;
1570 }
1571}
1572
1573/*
1574 * split(ob,nr) splits up ob into two parts. The part which
1575 * is returned contains nr objects, and the remaining parts contains
1576 * the rest (or is removed and returned if that number is 0).
1577 * On failure, NULL is returned.
1578 */
1536object * 1579object *
1537decrease_ob_nr (object *op, uint32 i) 1580object::split (sint32 nr)
1538{ 1581{
1539 object *tmp; 1582 int have = number_of ();
1540 1583
1541 if (i == 0) /* objects with op->nrof require this check */ 1584 if (have < nr)
1542 return op; 1585 return 0;
1543 1586 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 { 1587 {
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 (); 1588 remove ();
1579 op->nrof = 0; 1589 return this;
1580 if (tmp)
1581 esrv_del_item (tmp->contr, op->count);
1582 }
1583 } 1590 }
1584 else 1591 else
1585 { 1592 {
1586 object *above = op->above; 1593 decrease (nr);
1587 1594
1588 if (i < op->nrof) 1595 object *op = deep_clone ();
1589 op->nrof -= i; 1596 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; 1597 return op;
1609 else
1610 {
1611 op->destroy ();
1612 return 0;
1613 } 1598 }
1614} 1599}
1615 1600
1616object * 1601object *
1617insert_ob_in_ob (object *op, object *where) 1602insert_ob_in_ob (object *op, object *where)
… …
1642 * be != op, if items are merged. -Tero 1627 * be != op, if items are merged. -Tero
1643 */ 1628 */
1644object * 1629object *
1645object::insert (object *op) 1630object::insert (object *op)
1646{ 1631{
1647 if (!QUERY_FLAG (op, FLAG_REMOVED))
1648 op->remove ();
1649
1650 if (op->more) 1632 if (op->more)
1651 { 1633 {
1652 LOG (llevError, "Tried to insert multipart object %s (%d)\n", &op->name, op->count); 1634 LOG (llevError, "Tried to insert multipart object %s (%d)\n", &op->name, op->count);
1653 return op; 1635 return op;
1654 } 1636 }
1655 1637
1656 CLEAR_FLAG (op, FLAG_OBJ_ORIGINAL); 1638 op->remove ();
1657 CLEAR_FLAG (op, FLAG_REMOVED); 1639
1640 op->flag [FLAG_OBJ_ORIGINAL] = 0;
1658 1641
1659 if (op->nrof) 1642 if (op->nrof)
1660 {
1661 for (object *tmp = inv; tmp; tmp = tmp->below) 1643 for (object *tmp = inv; tmp; tmp = tmp->below)
1662 if (object::can_merge (tmp, op)) 1644 if (object::can_merge (tmp, op))
1663 { 1645 {
1664 /* return the original object and remove inserted object 1646 /* return the original object and remove inserted object
1665 (client needs the original object) */ 1647 (client needs the original object) */
1666 tmp->nrof += op->nrof; 1648 tmp->nrof += op->nrof;
1667 /* Weight handling gets pretty funky. Since we are adding to 1649
1668 * tmp->nrof, we need to increase the weight. 1650 if (object *pl = tmp->visible_to ())
1669 */ 1651 esrv_update_item (UPD_NROF, pl, tmp);
1652
1670 add_weight (this, op->weight * op->nrof); 1653 adjust_weight (this, op->total_weight ());
1671 SET_FLAG (op, FLAG_REMOVED); 1654
1672 op->destroy (); /* free the inserted object */ 1655 op->destroy (1);
1673 op = tmp; 1656 op = tmp;
1674 op->remove (); /* and fix old object's links */ 1657 goto inserted;
1675 CLEAR_FLAG (op, FLAG_REMOVED);
1676 break;
1677 } 1658 }
1678 1659
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. 1660 op->owner = 0; // it's his/hers now. period.
1695 op->map = 0; 1661 op->map = 0;
1662 op->x = 0;
1663 op->y = 0;
1664
1665 op->above = 0;
1666 op->below = inv;
1696 op->env = this; 1667 op->env = this;
1697 op->above = 0;
1698 op->below = 0;
1699 op->x = op->y = 0;
1700 1668
1669 if (inv)
1670 inv->above = op;
1671
1672 inv = op;
1673
1674 op->flag [FLAG_REMOVED] = 0;
1675
1676 if (object *pl = op->visible_to ())
1677 esrv_send_item (pl, op);
1678
1679 adjust_weight (this, op->total_weight ());
1680
1681inserted:
1701 /* reset the light list and los of the players on the map */ 1682 /* reset the light list and los of the players on the map */
1702 if (op->glow_radius && map) 1683 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); 1684 update_all_los (map, x, y);
1709 }
1710 1685
1711 /* Client has no idea of ordering so lets not bother ordering it here. 1686 // if this is a player's inventory, update stats
1712 * It sure simplifies this function... 1687 if (type == PLAYER && !flag [FLAG_NO_FIX_PLAYER])
1713 */ 1688 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 1689
1723 INVOKE_OBJECT (INSERT, this); 1690 INVOKE_OBJECT (INSERT, this);
1724 1691
1725 return op; 1692 return op;
1726} 1693}
… …
1854 LOG (llevError, "Present_arch called outside map.\n"); 1821 LOG (llevError, "Present_arch called outside map.\n");
1855 return NULL; 1822 return NULL;
1856 } 1823 }
1857 1824
1858 for (object *tmp = m->at (x, y).bot; tmp; tmp = tmp->above) 1825 for (object *tmp = m->at (x, y).bot; tmp; tmp = tmp->above)
1859 if (tmp->arch == at) 1826 if (tmp->arch->archname == at->archname)
1860 return tmp; 1827 return tmp;
1861 1828
1862 return NULL; 1829 return NULL;
1863} 1830}
1864 1831
… …
1928 * The first matching object is returned, or NULL if none. 1895 * The first matching object is returned, or NULL if none.
1929 */ 1896 */
1930object * 1897object *
1931present_arch_in_ob (const archetype *at, const object *op) 1898present_arch_in_ob (const archetype *at, const object *op)
1932{ 1899{
1933 for (object *tmp = op->inv; tmp != NULL; tmp = tmp->below) 1900 for (object *tmp = op->inv; tmp; tmp = tmp->below)
1934 if (tmp->arch == at) 1901 if (tmp->arch->archname == at->archname)
1935 return tmp; 1902 return tmp;
1936 1903
1937 return NULL; 1904 return NULL;
1938} 1905}
1939 1906
… …
2348 2315
2349/* 2316/*
2350 * create clone from object to another 2317 * create clone from object to another
2351 */ 2318 */
2352object * 2319object *
2353object_create_clone (object *asrc) 2320object::deep_clone ()
2354{ 2321{
2355 object *dst = 0, *tmp, *src, *prev, *item; 2322 assert (("deep_clone called on non-head object", is_head ()));
2356 2323
2357 if (!asrc) 2324 object *dst = clone ();
2358 return 0;
2359 2325
2360 src = asrc->head_ (); 2326 object *prev = dst;
2361
2362 prev = 0;
2363 for (object *part = src; part; part = part->more) 2327 for (object *part = this->more; part; part = part->more)
2364 { 2328 {
2365 tmp = part->clone (); 2329 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; 2330 tmp->head = dst;
2376
2377 tmp->more = 0;
2378
2379 if (prev)
2380 prev->more = tmp; 2331 prev->more = tmp;
2381
2382 prev = tmp; 2332 prev = tmp;
2383 } 2333 }
2384 2334
2385 for (item = src->inv; item; item = item->below) 2335 for (object *item = inv; item; item = item->below)
2386 insert_ob_in_ob (object_create_clone (item), dst); 2336 insert_ob_in_ob (item->deep_clone (), dst);
2387 2337
2388 return dst; 2338 return dst;
2389} 2339}
2390 2340
2391/* This returns the first object in who's inventory that 2341/* This returns the first object in who's inventory that
… …
2400 return tmp; 2350 return tmp;
2401 2351
2402 return 0; 2352 return 0;
2403} 2353}
2404 2354
2405/* If ob has a field named key, return the link from the list, 2355const shstr &
2406 * otherwise return NULL. 2356object::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{ 2357{
2414 for (key_value *link = ob->key_values; link; link = link->next) 2358 for (key_value *kv = key_values; kv; kv = kv->next)
2415 if (link->key == key) 2359 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; 2360 return kv->value;
2450 2361
2451 return 0; 2362 return shstr_null;
2452} 2363}
2453 2364
2454/* 2365void
2455 * Updates the canonical_key in op to value. 2366object::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{ 2367{
2467 key_value *field = NULL, *last = NULL; 2368 for (key_value *kv = key_values; kv; kv = kv->next)
2468 2369 if (kv->key == key)
2469 for (field = op->key_values; field != NULL; field = field->next)
2470 {
2471 if (field->key != canonical_key)
2472 { 2370 {
2473 last = field; 2371 kv->value = value;
2474 continue; 2372 return;
2475 } 2373 }
2476 2374
2477 if (value) 2375 key_value *kv = new key_value;
2478 field->value = value; 2376
2479 else 2377 kv->next = key_values;
2378 kv->key = key;
2379 kv->value = value;
2380
2381 key_values = kv;
2382}
2383
2384void
2385object::kv_del (const shstr &key)
2386{
2387 for (key_value **kvp = &key_values; *kvp; kvp = &(*kvp)->next)
2388 if ((*kvp)->key == key)
2480 { 2389 {
2481 /* Basically, if the archetype has this key set, 2390 key_value *kv = *kvp;
2482 * we need to store the null value so when we save 2391 *kvp = (*kvp)->next;
2483 * it, we save the empty value so that when we load, 2392 delete kv;
2484 * we get this value back again. 2393 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 } 2394 }
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} 2395}
2543 2396
2544object::depth_iterator::depth_iterator (object *container) 2397object::depth_iterator::depth_iterator (object *container)
2545: iterator_base (container) 2398: iterator_base (container)
2546{ 2399{
… …
2604 &name, 2457 &name,
2605 title ? "\",title:\"" : "", 2458 title ? "\",title:\"" : "",
2606 title ? (const char *)title : "", 2459 title ? (const char *)title : "",
2607 flag_desc (flagdesc, 512), type); 2460 flag_desc (flagdesc, 512), type);
2608 2461
2609 if (!this->flag[FLAG_REMOVED] && env) 2462 if (!flag[FLAG_REMOVED] && env)
2610 p += snprintf (p, 256, "(in %s)", env->debug_desc (info2)); 2463 p += snprintf (p, 256, "(in %s)", env->debug_desc (info2));
2611 2464
2612 if (map) 2465 if (map)
2613 p += snprintf (p, 256, "(on %s@%d+%d)", &map->path, x, y); 2466 p += snprintf (p, 256, "(on %s@%d+%d)", &map->path, x, y);
2614 2467
… …
2644object::open_container (object *new_container) 2497object::open_container (object *new_container)
2645{ 2498{
2646 if (container == new_container) 2499 if (container == new_container)
2647 return; 2500 return;
2648 2501
2649 if (object *old_container = container) 2502 object *old_container = container;
2503
2504 if (old_container)
2650 { 2505 {
2651 if (INVOKE_OBJECT (CLOSE, old_container, ARG_OBJECT (this))) 2506 if (INVOKE_OBJECT (CLOSE, old_container, ARG_OBJECT (this)))
2652 return; 2507 return;
2653 2508
2654#if 0 2509#if 0
… …
2656 if (object *closer = old_container->inv) 2511 if (object *closer = old_container->inv)
2657 if (closer->type == CLOSE_CON) 2512 if (closer->type == CLOSE_CON)
2658 closer->destroy (); 2513 closer->destroy ();
2659#endif 2514#endif
2660 2515
2516 // make sure the container is available
2517 esrv_send_item (this, old_container);
2518
2661 old_container->flag [FLAG_APPLIED] = 0; 2519 old_container->flag [FLAG_APPLIED] = false;
2662 container = 0; 2520 container = 0;
2663 2521
2522 // client needs item update to make it work, client bug requires this to be separate
2664 esrv_update_item (UPD_FLAGS, this, old_container); 2523 esrv_update_item (UPD_FLAGS, this, old_container);
2524
2665 new_draw_info_format (NDI_UNIQUE, 0, this, "You close %s.", query_name (old_container)); 2525 new_draw_info_format (NDI_UNIQUE, 0, this, "You close %s.", query_name (old_container));
2666 play_sound (sound_find ("chest_close")); 2526 play_sound (sound_find ("chest_close"));
2667 } 2527 }
2668 2528
2669 if (new_container) 2529 if (new_container)
… …
2682 } 2542 }
2683#endif 2543#endif
2684 2544
2685 new_draw_info_format (NDI_UNIQUE, 0, this, "You open %s.", query_name (new_container)); 2545 new_draw_info_format (NDI_UNIQUE, 0, this, "You open %s.", query_name (new_container));
2686 2546
2547 // make sure the container is available, client bug requires this to be separate
2548 esrv_send_item (this, new_container);
2549
2687 new_container->flag [FLAG_APPLIED] = 1; 2550 new_container->flag [FLAG_APPLIED] = true;
2688 container = new_container; 2551 container = new_container;
2689 2552
2553 // client needs flag change
2690 esrv_update_item (UPD_FLAGS, this, new_container); 2554 esrv_update_item (UPD_FLAGS, this, new_container);
2691 esrv_send_inventory (this, new_container); 2555 esrv_send_inventory (this, new_container);
2692 play_sound (sound_find ("chest_open")); 2556 play_sound (sound_find ("chest_open"));
2693 } 2557 }
2558// else if (!old_container->env && contr && contr->ns)
2559// contr->ns->floorbox_reset ();
2694} 2560}
2695 2561
2696object * 2562object *
2697object::force_find (const shstr name) 2563object::force_find (const shstr name)
2698{ 2564{
… …
2724 2590
2725 insert (force); 2591 insert (force);
2726} 2592}
2727 2593
2728void 2594void
2729object::play_sound (faceidx sound) const 2595object::play_sound (faceidx sound)
2730{ 2596{
2731 if (!sound) 2597 if (!sound)
2732 return; 2598 return;
2733 2599
2734 if (flag [FLAG_REMOVED]) 2600 if (flag [FLAG_REMOVED])

Diff Legend

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