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.202 by root, Thu Apr 10 15:35:15 2008 UTC vs.
Revision 1.223 by root, Wed Apr 30 08:29:31 2008 UTC

1/* 1/*
2 * This file is part of Deliantra, the Roguelike Realtime MMORPG. 2 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
3 * 3 *
4 * Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Deliantra team 4 * Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5 * Copyright (©) 2001,2007 Mark Wedel & Crossfire Development Team 5 * Copyright (©) 2001,2007 Mark Wedel & Crossfire Development Team
6 * Copyright (©) 1992,2007 Frank Tore Johansen 6 * Copyright (©) 1992,2007 Frank Tore Johansen
7 * 7 *
8 * Deliantra is free software: you can redistribute it and/or modify 8 * Deliantra is free software: you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by 9 * it under the terms of the GNU General Public License as published by
… …
19 * along with this program. If not, see <http://www.gnu.org/licenses/>. 19 * along with this program. If not, see <http://www.gnu.org/licenses/>.
20 * 20 *
21 * The authors can be reached via e-mail to <support@deliantra.net> 21 * The authors can be reached via e-mail to <support@deliantra.net>
22 */ 22 */
23 23
24/* Eneq(@csd.uu.se): Added weight-modifiers in environment of objects.
25 sub/add_weight will transcend the environment updating the carrying
26 variable. */
27#include <global.h> 24#include <global.h>
28#include <stdio.h> 25#include <stdio.h>
29#include <sys/types.h> 26#include <sys/types.h>
30#include <sys/uio.h> 27#include <sys/uio.h>
31#include <object.h> 28#include <object.h>
32#include <funcpoint.h>
33#include <sproto.h> 29#include <sproto.h>
34#include <loader.h> 30#include <loader.h>
35 31
36#include <bitset> 32#include <bitset>
37 33
38UUID UUID::cur; 34UUID UUID::cur;
35static uint64_t seq_next_save;
39static const uint64 UUID_SKIP = 1<<19; 36static const uint64 UUID_GAP = 1<<19;
40 37
41objectvec objects; 38objectvec objects;
42activevec actives; 39activevec actives;
43 40
44short freearr_x[SIZEOFFREE] = { 0, 0, 1, 1, 1, 0, -1, -1, -1, 0, 1, 2, 2, 2, 2, 2, 1, 0, -1, -2, -2, -2, -2, -2, -1, 41short freearr_x[SIZEOFFREE] = {
42 0,
43 0, 1, 1, 1, 0, -1, -1, -1,
44 0, 1, 2, 2, 2, 2, 2, 1, 0, -1, -2, -2, -2, -2, -2, -1,
45 0, 1, 2, 3, 3, 3, 3, 3, 3, 3, 2, 1, 0, -1, -2, -3, -3, -3, -3, -3, -3, -3, -2, -1 45 0, 1, 2, 3, 3, 3, 3, 3, 3, 3, 2, 1, 0, -1, -2, -3, -3, -3, -3, -3, -3, -3, -2, -1
46}; 46};
47short freearr_y[SIZEOFFREE] = { 0, -1, -1, 0, 1, 1, 1, 0, -1, -2, -2, -2, -1, 0, 1, 2, 2, 2, 2, 2, 1, 0, -1, -2, -2, 47short freearr_y[SIZEOFFREE] = {
48 0,
49 -1, -1, 0, 1, 1, 1, 0, -1,
50 -2, -2, -2, -1, 0, 1, 2, 2, 2, 2, 2, 1, 0, -1, -2, -2,
48 -3, -3, -3, -3, -2, -1, 0, 1, 2, 3, 3, 3, 3, 3, 3, 3, 2, 1, 0, -1, -2, -3, -3, -3 51 -3, -3, -3, -3, -2, -1, 0, 1, 2, 3, 3, 3, 3, 3, 3, 3, 2, 1, 0, -1, -2, -3, -3, -3
49}; 52};
50int maxfree[SIZEOFFREE] = { 0, 9, 10, 13, 14, 17, 18, 21, 22, 25, 26, 27, 30, 31, 32, 33, 36, 37, 39, 39, 42, 43, 44, 45, 53int maxfree[SIZEOFFREE] = {
54 0,
55 9, 10, 13, 14, 17, 18, 21, 22,
56 25, 26, 27, 30, 31, 32, 33, 36, 37, 39, 39, 42, 43, 44, 45, 48,
51 48, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49 57 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49
52}; 58};
53int freedir[SIZEOFFREE] = { 59int freedir[SIZEOFFREE] = {
54 0, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 2, 2, 3, 4, 4, 4, 5, 6, 6, 6, 7, 8, 8, 8, 60 0,
61 1, 2, 3, 4, 5, 6, 7, 8,
62 1, 2, 2, 2, 3, 4, 4, 4, 5, 6, 6, 6, 7, 8, 8, 8,
55 1, 2, 2, 2, 2, 2, 3, 4, 4, 4, 4, 4, 5, 6, 6, 6, 6, 6, 7, 8, 8, 8, 8, 8 63 1, 2, 2, 2, 2, 2, 3, 4, 4, 4, 4, 4, 5, 6, 6, 6, 6, 6, 7, 8, 8, 8, 8, 8
56}; 64};
57 65
58static void 66static void
59write_uuid (void) 67write_uuid (uval64 skip, bool sync)
60{ 68{
61 char filename1[MAX_BUF], filename2[MAX_BUF]; 69 CALL_BEGIN (2);
62 70 CALL_ARG_SV (newSVval64 (skip));
63 sprintf (filename1, "%s/uuid", settings.localdir); 71 CALL_ARG_SV (boolSV (sync));
64 sprintf (filename2, "%s/uuid~", settings.localdir); 72 CALL_CALL ("cf::write_uuid", G_DISCARD);
65 73 CALL_END;
66 FILE *fp;
67
68 if (!(fp = fopen (filename2, "w")))
69 {
70 LOG (llevError, "ERROR: cannot open %s for writing, unable to write UUID!\n", filename2);
71 return;
72 }
73
74 fprintf (fp, "<1,%llx>\n", (unsigned long long)UUID::cur.seq + UUID_SKIP * 2);
75 fclose (fp);
76 rename (filename2, filename1);
77} 74}
78 75
79static void 76static void
80read_uuid (void) 77read_uuid (void)
81{ 78{
82 char filename[MAX_BUF]; 79 char filename[MAX_BUF];
83 80
84 sprintf (filename, "%s/uuid", settings.localdir); 81 sprintf (filename, "%s/uuid", settings.localdir);
82
83 seq_next_save = 0;
85 84
86 FILE *fp; 85 FILE *fp;
87 86
88 if (!(fp = fopen (filename, "r"))) 87 if (!(fp = fopen (filename, "r")))
89 { 88 {
90 if (errno == ENOENT) 89 if (errno == ENOENT)
91 { 90 {
92 LOG (llevInfo, "RESET uid to 1\n"); 91 LOG (llevInfo, "RESET uid to 1\n");
93 UUID::cur.seq = 0; 92 UUID::cur.seq = 0;
94 write_uuid (); 93 write_uuid (UUID_GAP, true);
95 return; 94 return;
96 } 95 }
97 96
98 LOG (llevError, "FATAL: cannot open %s for reading!\n", filename); 97 LOG (llevError, "FATAL: cannot open %s for reading!\n", filename);
99 _exit (1); 98 _exit (1);
100 } 99 }
101 100
102 int version; 101 UUID::BUF buf;
103 unsigned long long uid; 102 buf[0] = 0;
104 if (2 != fscanf (fp, "<%d,%llx>\n", &version, &uid) || version != 1) 103 fgets (buf, sizeof (buf), fp);
104
105 if (!UUID::cur.parse (buf))
105 { 106 {
106 LOG (llevError, "FATAL: error reading uid from %s!\n", filename); 107 LOG (llevError, "FATAL: error reading uid from %s (%s)!\n", filename, buf);
107 _exit (1); 108 _exit (1);
108 } 109 }
109 110
110 UUID::cur.seq = uid; 111 LOG (llevDebug, "read UUID: %s\n", UUID::cur.c_str ());
111 write_uuid (); 112
112 LOG (llevDebug, "read UID: %" PRId64 "\n", uid); 113 write_uuid (UUID_GAP, true);
113 fclose (fp); 114 fclose (fp);
114} 115}
115 116
116UUID 117UUID
117UUID::gen () 118UUID::gen ()
118{ 119{
119 UUID uid; 120 UUID uid;
120 121
121 uid.seq = ++cur.seq; 122 uid.seq = ++cur.seq;
122 123
123 if (!(cur.seq & (UUID_SKIP - 1))) 124 if (expect_false (cur.seq >= seq_next_save))
124 write_uuid (); 125 {
126 seq_next_save = UUID::cur.seq + (UUID_GAP >> 1);
127 write_uuid (UUID_GAP, false);
128 }
129
125 130
126 return uid; 131 return uid;
127} 132}
128 133
129void 134void
… …
131{ 136{
132 read_uuid (); 137 read_uuid ();
133} 138}
134 139
135/* 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. */
136static int 141static bool
137compare_ob_value_lists_one (const object *wants, const object *has) 142compare_ob_value_lists_one (const object *wants, const object *has)
138{ 143{
139 key_value *wants_field; 144 key_value *wants_field;
140 145
141 /* n-squared behaviour (see get_ob_key_link()), but I'm hoping both 146 /* n-squared behaviour (see get_ob_key_link()), but I'm hoping both
… …
149 key_value *has_field; 154 key_value *has_field;
150 155
151 /* Look for a field in has with the same key. */ 156 /* Look for a field in has with the same key. */
152 has_field = get_ob_key_link (has, wants_field->key); 157 has_field = get_ob_key_link (has, wants_field->key);
153 158
154 if (has_field == NULL) 159 if (!has_field)
155 {
156 /* No field with that name. */ 160 return 0; /* No field with that name. */
157 return FALSE;
158 }
159 161
160 /* Found the matching field. */ 162 /* Found the matching field. */
161 if (has_field->value != wants_field->value) 163 if (has_field->value != wants_field->value)
162 {
163 /* Values don't match, so this half of the comparison is false. */ 164 return 0; /* Values don't match, so this half of the comparison is false. */
164 return FALSE;
165 }
166 165
167 /* If we get here, we found a match. Now for the next field in wants. */ 166 /* If we get here, we found a match. Now for the next field in wants. */
168 } 167 }
169 168
170 /* If we get here, every field in wants has a matching field in has. */ 169 /* If we get here, every field in wants has a matching field in has. */
171 return TRUE; 170 return 1;
172} 171}
173 172
174/* Returns TRUE if ob1 has the same key_values as ob2. */ 173/* Returns TRUE if ob1 has the same key_values as ob2. */
175static int 174static bool
176compare_ob_value_lists (const object *ob1, const object *ob2) 175compare_ob_value_lists (const object *ob1, const object *ob2)
177{ 176{
178 /* However, there may be fields in has which aren't partnered in wants, 177 /* However, there may be fields in has which aren't partnered in wants,
179 * so we need to run the comparison *twice*. :( 178 * so we need to run the comparison *twice*. :(
180 */ 179 */
… …
201 || ob1->speed != ob2->speed 200 || ob1->speed != ob2->speed
202 || ob1->value != ob2->value 201 || ob1->value != ob2->value
203 || ob1->name != ob2->name) 202 || ob1->name != ob2->name)
204 return 0; 203 return 0;
205 204
206 //TODO: this ain't working well, use nicer and correct overflow check 205 /* Do not merge objects if nrof would overflow. First part checks
207 /* Do not merge objects if nrof would overflow. We use 1UL<<31 since that 206 * for unsigned overflow (2c), second part checks whether the result
208 * value could not be stored in a sint32 (which unfortunately sometimes is 207 * would fit into a 32 bit signed int, which is often used to hold
209 * used to store nrof). 208 * nrof values.
210 */ 209 */
211 if (ob1->nrof + ob2->nrof >= 1UL << 31) 210 if (~ob1->nrof < ob2->nrof || ob1->nrof + ob2->nrof > (1UL << 31))
212 return 0; 211 return 0;
213 212
214 /* If the objects have been identified, set the BEEN_APPLIED flag. 213 /* If the objects have been identified, set the BEEN_APPLIED flag.
215 * This is to the comparison of the flags below will be OK. We 214 * This is to the comparison of the flags below will be OK. We
216 * just can't ignore the been applied or identified flags, as they 215 * just can't ignore the been applied or identified flags, as they
217 * are not equal - just if it has been identified, the been_applied 216 * are not equal - just if it has been identified, the been_applied
218 * flags lose any meaning. 217 * flags lose any meaning.
219 */ 218 */
220 if (QUERY_FLAG (ob1, FLAG_IDENTIFIED)) 219 if (QUERY_FLAG (ob1, FLAG_IDENTIFIED))
221 SET_FLAG (ob1, FLAG_BEEN_APPLIED); 220 SET_FLAG (ob1, FLAG_BEEN_APPLIED);
222 221
223 if (QUERY_FLAG (ob2, FLAG_IDENTIFIED)) 222 if (QUERY_FLAG (ob2, FLAG_IDENTIFIED))
224 SET_FLAG (ob2, FLAG_BEEN_APPLIED); 223 SET_FLAG (ob2, FLAG_BEEN_APPLIED);
225 224
226 if ((ob1->flag ^ ob2->flag).reset (FLAG_INV_LOCKED).reset (FLAG_CLIENT_SENT).any () 225 if (ob1->arch->name != ob2->arch->name
227 || ob1->arch != ob2->arch
228 || ob1->name != ob2->name 226 || ob1->name != ob2->name
229 || ob1->title != ob2->title 227 || ob1->title != ob2->title
230 || ob1->msg != ob2->msg 228 || ob1->msg != ob2->msg
231 || ob1->weight != ob2->weight 229 || ob1->weight != ob2->weight
232 || memcmp (&ob1->resist, &ob2->resist, sizeof (ob1->resist))
233 || memcmp (&ob1->stats , &ob2->stats , sizeof (ob1->stats) )
234 || ob1->attacktype != ob2->attacktype 230 || ob1->attacktype != ob2->attacktype
235 || ob1->magic != ob2->magic 231 || ob1->magic != ob2->magic
236 || ob1->slaying != ob2->slaying 232 || ob1->slaying != ob2->slaying
237 || ob1->skill != ob2->skill 233 || ob1->skill != ob2->skill
238 || ob1->value != ob2->value 234 || ob1->value != ob2->value
… …
245 || ob1->move_block != ob2->move_block 241 || ob1->move_block != ob2->move_block
246 || ob1->move_allow != ob2->move_allow 242 || ob1->move_allow != ob2->move_allow
247 || ob1->move_on != ob2->move_on 243 || ob1->move_on != ob2->move_on
248 || ob1->move_off != ob2->move_off 244 || ob1->move_off != ob2->move_off
249 || ob1->move_slow != ob2->move_slow 245 || ob1->move_slow != ob2->move_slow
250 || ob1->move_slow_penalty != ob2->move_slow_penalty) 246 || ob1->move_slow_penalty != ob2->move_slow_penalty
247 || memcmp (&ob1->resist, &ob2->resist, sizeof (ob1->resist))
248 || memcmp (&ob1->stats , &ob2->stats , sizeof (ob1->stats)))
251 return 0; 249 return 0;
252 250
251 if ((ob1->flag ^ ob2->flag)
252 .reset (FLAG_INV_LOCKED)
253 .reset (FLAG_CLIENT_SENT)
254 .reset (FLAG_REMOVED)
255 .any ())
256 return 0;
257
253 /* This is really a spellbook check - really, we should 258 /* This is really a spellbook check - we should in general
254 * check all objects in the inventory. 259 * not merge objects with real inventories, as splitting them
260 * is hard.
255 */ 261 */
256 if (ob1->inv || ob2->inv) 262 if (ob1->inv || ob2->inv)
257 { 263 {
258 if (!(ob1->inv && ob2->inv)) 264 if (!(ob1->inv && ob2->inv))
259 return 0; /* inventories differ in length */ 265 return 0; /* inventories differ in length */
260 266
261 if (ob1->inv->below || ob2->inv->below) 267 if (ob1->inv->below || ob2->inv->below)
262 return 0; /* more than one object in inv */ 268 return 0; /* more than one object in inv */
263 269
264 if (!object::can_merge (ob1->inv, ob2->inv)) 270 if (!object::can_merge (ob1->inv, ob2->inv))
265 return 0; /* inventory objexts differ */ 271 return 0; /* inventory objects differ */
266 272
267 /* inventory ok - still need to check rest of this object to see 273 /* inventory ok - still need to check rest of this object to see
268 * if it is valid. 274 * if it is valid.
269 */ 275 */
270 } 276 }
… …
289 if (ob1->level != ob2->level) 295 if (ob1->level != ob2->level)
290 return 0; 296 return 0;
291 break; 297 break;
292 } 298 }
293 299
294 if (ob1->key_values != NULL || ob2->key_values != NULL) 300 if (ob1->key_values || ob2->key_values)
295 { 301 {
296 /* At least one of these has key_values. */ 302 /* At least one of these has key_values. */
297 if ((ob1->key_values == NULL) != (ob2->key_values == NULL)) 303 if ((!ob1->key_values) != (!ob2->key_values))
298 /* One has fields, but the other one doesn't. */ 304 return 0; /* One has fields, but the other one doesn't. */
299 return 0; 305
300 else if (!compare_ob_value_lists (ob1, ob2)) 306 if (!compare_ob_value_lists (ob1, ob2))
301 return 0; 307 return 0;
302 } 308 }
303 309
304 if (ob1->self || ob2->self) 310 if (ob1->self || ob2->self)
305 { 311 {
… …
311 int k1 = ob1->self ? HvTOTALKEYS (ob1->self) : 0; 317 int k1 = ob1->self ? HvTOTALKEYS (ob1->self) : 0;
312 int k2 = ob2->self ? HvTOTALKEYS (ob2->self) : 0; 318 int k2 = ob2->self ? HvTOTALKEYS (ob2->self) : 0;
313 319
314 if (k1 != k2) 320 if (k1 != k2)
315 return 0; 321 return 0;
322
316 else if (k1 == 0) 323 if (k1 == 0)
317 return 1; 324 return 1;
325
318 else if (!cfperl_can_merge (ob1, ob2)) 326 if (!cfperl_can_merge (ob1, ob2))
319 return 0; 327 return 0;
320 } 328 }
321 } 329 }
322 330
323 /* Everything passes, must be OK. */ 331 /* Everything passes, must be OK. */
324 return 1; 332 return 1;
325} 333}
326 334
335// find player who can see this object
336object *
337object::visible_to () const
338{
339 if (client_visible () && !flag [FLAG_REMOVED])
340 {
341 // see if we are in a container of sorts
342 if (env)
343 {
344 // the player inventory itself is always visible
345 if (env->type == PLAYER)
346 return env;
347
348 // else a player could have our env open
349 object *envest = env->outer_env ();
350
351 // the player itself is always on a map, so we will find him here
352 // even if our inv is in a player.
353 if (envest->is_on_map ())
354 if (object *pl = envest->ms ().player ())
355 if (pl->container == env)
356 return pl;
357 }
358 else
359 {
360 // maybe there is a player standing on the same mapspace
361 // this will catch the case where "this" is a player
362 if (object *pl = ms ().player ())
363 if (!pl->container || this == pl->container)
364 return pl;
365 }
366 }
367
368 return 0;
369}
370
371// adjust weight per container type ("of holding")
372static sint32
373weight_adjust (object *op, sint32 weight)
374{
375 return op->type == CONTAINER
376 ? lerp (weight, 0, 100, 0, 100 - op->stats.Str)
377 : weight;
378}
379
327/* 380/*
381 * adjust_weight(object, weight) adds the specified weight to an object,
382 * and also updates how much the environment(s) is/are carrying.
383 */
384static void
385adjust_weight (object *op, sint32 weight)
386{
387 while (op)
388 {
389 weight = weight_adjust (op, weight);
390
391 if (!weight)
392 return;
393
394 op->carrying += weight;
395
396 if (object *pl = op->visible_to ())
397 if (pl != op) // player is handled lazily
398 esrv_update_item (UPD_WEIGHT, pl, op);
399
400 op = op->env;
401 }
402}
403
404/*
328 * sum_weight() is a recursive function which calculates the weight 405 * this is a recursive function which calculates the weight
329 * an object is carrying. It goes through in figures out how much 406 * an object is carrying. It goes through op and figures out how much
330 * containers are carrying, and sums it up. 407 * containers are carrying, and sums it up.
331 */ 408 */
332long 409void
333sum_weight (object *op) 410object::update_weight ()
334{ 411{
335 long sum; 412 sint32 sum = 0;
336 object *inv;
337 413
338 for (sum = 0, inv = op->inv; inv; inv = inv->below) 414 for (object *op = inv; op; op = op->below)
339 { 415 {
340 if (inv->inv) 416 if (op->inv)
341 sum_weight (inv); 417 op->update_weight ();
342 418
343 sum += inv->carrying + inv->weight * (inv->nrof ? inv->nrof : 1); 419 sum += op->total_weight ();
420 }
421
422 sum = weight_adjust (this, sum);
423
424 if (sum != carrying)
344 } 425 {
345
346 if (op->type == CONTAINER && op->stats.Str)
347 sum = (sum * (100 - op->stats.Str)) / 100;
348
349 if (op->carrying != sum)
350 op->carrying = sum; 426 carrying = sum;
351 427
352 return sum; 428 if (object *pl = visible_to ())
429 if (pl != this) // player is handled lazily
430 esrv_update_item (UPD_WEIGHT, pl, this);
431 }
353} 432}
354 433
355/** 434/*
356 * Return the outermost environment object for a given object. 435 * Used by: Server DM commands: dumpbelow, dump. Some error messages.
357 */
358
359object *
360object_get_env_recursive (object *op)
361{
362 while (op->env != NULL)
363 op = op->env;
364 return op;
365}
366
367/*
368 * Used by: Crossedit: dump. Server DM commands: dumpbelow, dump.
369 * Some error messages.
370 * The result of the dump is stored in the static global errmsg array.
371 */ 436 */
372char * 437char *
373dump_object (object *op) 438dump_object (object *op)
374{ 439{
375 if (!op) 440 if (!op)
… …
389get_nearest_part (object *op, const object *pl) 454get_nearest_part (object *op, const object *pl)
390{ 455{
391 object *tmp, *closest; 456 object *tmp, *closest;
392 int last_dist, i; 457 int last_dist, i;
393 458
394 if (op->more == NULL) 459 if (!op->more)
395 return op; 460 return op;
461
396 for (last_dist = distance (op, pl), closest = op, tmp = op->more; tmp != NULL; tmp = tmp->more) 462 for (last_dist = distance (op, pl), closest = op, tmp = op->more;
463 tmp;
464 tmp = tmp->more)
397 if ((i = distance (tmp, pl)) < last_dist) 465 if ((i = distance (tmp, pl)) < last_dist)
398 closest = tmp, last_dist = i; 466 closest = tmp, last_dist = i;
467
399 return closest; 468 return closest;
400} 469}
401 470
402/* 471/*
403 * Returns the object which has the count-variable equal to the argument. 472 * Returns the object which has the count-variable equal to the argument.
473 * VERRRY slow.
404 */ 474 */
405object * 475object *
406find_object (tag_t i) 476find_object (tag_t i)
407{ 477{
408 for_all_objects (op) 478 for_all_objects (op)
… …
676 * UP_OBJ_FACE: only the objects face has changed. 746 * UP_OBJ_FACE: only the objects face has changed.
677 */ 747 */
678void 748void
679update_object (object *op, int action) 749update_object (object *op, int action)
680{ 750{
681 if (op == NULL) 751 if (!op)
682 { 752 {
683 /* this should never happen */ 753 /* this should never happen */
684 LOG (llevDebug, "update_object() called for NULL object.\n"); 754 LOG (llevError | logBacktrace, "update_object() called for NULL object.\n");
685 return; 755 return;
686 } 756 }
687 757
688 if (op->env) 758 if (!op->is_on_map ())
689 { 759 {
690 /* Animation is currently handled by client, so nothing 760 /* Animation is currently handled by client, so nothing
691 * to do in this case. 761 * to do in this case.
692 */ 762 */
693 return; 763 return;
694 } 764 }
695
696 /* If the map is saving, don't do anything as everything is
697 * going to get freed anyways.
698 */
699 if (!op->map || op->map->in_memory == MAP_SAVING)
700 return;
701 765
702 /* make sure the object is within map boundaries */ 766 /* make sure the object is within map boundaries */
703 if (op->x < 0 || op->x >= op->map->width || op->y < 0 || op->y >= op->map->height) 767 if (op->x < 0 || op->x >= op->map->width || op->y < 0 || op->y >= op->map->height)
704 { 768 {
705 LOG (llevError, "update_object() called for object out of map!\n"); 769 LOG (llevError, "update_object() called for object out of map!\n");
… …
848object::destroy_inv (bool drop_to_ground) 912object::destroy_inv (bool drop_to_ground)
849{ 913{
850 // need to check first, because the checks below might segfault 914 // need to check first, because the checks below might segfault
851 // as we might be on an invalid mapspace and crossfire code 915 // as we might be on an invalid mapspace and crossfire code
852 // is too buggy to ensure that the inventory is empty. 916 // is too buggy to ensure that the inventory is empty.
853 // corollary: if you create arrows etc. with stuff in tis inventory, 917 // corollary: if you create arrows etc. with stuff in its inventory,
854 // cf will crash below with off-map x and y 918 // cf will crash below with off-map x and y
855 if (!inv) 919 if (!inv)
856 return; 920 return;
857 921
858 /* Only if the space blocks everything do we not process - 922 /* Only if the space blocks everything do we not process -
859 * if some form of movement is allowed, let objects 923 * if some form of movement is allowed, let objects
860 * drop on that space. 924 * drop on that space.
861 */ 925 */
862 if (!drop_to_ground 926 if (!drop_to_ground
863 || !map 927 || !map
864 || map->in_memory != MAP_IN_MEMORY 928 || map->in_memory != MAP_ACTIVE
865 || map->nodrop 929 || map->nodrop
866 || ms ().move_block == MOVE_ALL) 930 || ms ().move_block == MOVE_ALL)
867 { 931 {
868 while (inv) 932 while (inv)
869 { 933 {
870 inv->destroy_inv (drop_to_ground); 934 inv->destroy_inv (false);
871 inv->destroy (); 935 inv->destroy ();
872 } 936 }
873 } 937 }
874 else 938 else
875 { /* Put objects in inventory onto this space */ 939 { /* Put objects in inventory onto this space */
… …
881 || op->flag [FLAG_NO_DROP] 945 || op->flag [FLAG_NO_DROP]
882 || op->type == RUNE 946 || op->type == RUNE
883 || op->type == TRAP 947 || op->type == TRAP
884 || op->flag [FLAG_IS_A_TEMPLATE] 948 || op->flag [FLAG_IS_A_TEMPLATE]
885 || op->flag [FLAG_DESTROY_ON_DEATH]) 949 || op->flag [FLAG_DESTROY_ON_DEATH])
886 op->destroy (); 950 op->destroy (true);
887 else 951 else
888 map->insert (op, x, y); 952 map->insert (op, x, y);
889 } 953 }
890 } 954 }
891} 955}
… …
895 object *op = new object; 959 object *op = new object;
896 op->link (); 960 op->link ();
897 return op; 961 return op;
898} 962}
899 963
964static struct freed_map : maptile
965{
966 freed_map ()
967 {
968 path = "<freed objects map>";
969 name = "/internal/freed_objects_map";
970 width = 3;
971 height = 3;
972 nodrop = 1;
973
974 alloc ();
975 in_memory = MAP_ACTIVE;
976 }
977} freed_map; // freed objects are moved here to avoid crashes
978
900void 979void
901object::do_destroy () 980object::do_destroy ()
902{ 981{
903 attachable::do_destroy ();
904
905 if (flag [FLAG_IS_LINKED]) 982 if (flag [FLAG_IS_LINKED])
906 remove_button_link (this); 983 remove_button_link (this);
907 984
908 if (flag [FLAG_FRIENDLY]) 985 if (flag [FLAG_FRIENDLY])
909 remove_friendly_object (this); 986 remove_friendly_object (this);
910 987
911 if (!flag [FLAG_REMOVED])
912 remove (); 988 remove ();
913 989
914 destroy_inv (true); 990 attachable::do_destroy ();
915 991
916 deactivate (); 992 deactivate ();
917 unlink (); 993 unlink ();
918 994
919 flag [FLAG_FREED] = 1; 995 flag [FLAG_FREED] = 1;
920 996
921 // hack to ensure that freed objects still have a valid map 997 // hack to ensure that freed objects still have a valid map
922 {
923 static maptile *freed_map; // freed objects are moved here to avoid crashes
924
925 if (!freed_map)
926 {
927 freed_map = new maptile;
928
929 freed_map->path = "<freed objects map>";
930 freed_map->name = "/internal/freed_objects_map";
931 freed_map->width = 3;
932 freed_map->height = 3;
933 freed_map->nodrop = 1;
934
935 freed_map->alloc ();
936 freed_map->in_memory = MAP_IN_MEMORY;
937 }
938
939 map = freed_map; 998 map = &freed_map;
940 x = 1; 999 x = 1;
941 y = 1; 1000 y = 1;
942 }
943 1001
944 if (more) 1002 if (more)
945 { 1003 {
946 more->destroy (); 1004 more->destroy ();
947 more = 0; 1005 more = 0;
… …
960object::destroy (bool destroy_inventory) 1018object::destroy (bool destroy_inventory)
961{ 1019{
962 if (destroyed ()) 1020 if (destroyed ())
963 return; 1021 return;
964 1022
1023 if (!is_head () && !head->destroyed ())
1024 {
1025 LOG (llevError | logBacktrace, "tried to destroy the tail of an object");
1026 head->destroy (destroy_inventory);
1027 return;
1028 }
1029
965 if (destroy_inventory) 1030 destroy_inv (!destroy_inventory);
966 destroy_inv (false);
967 1031
968 if (is_head ()) 1032 if (is_head ())
969 if (sound_destroy) 1033 if (sound_destroy)
970 play_sound (sound_destroy); 1034 play_sound (sound_destroy);
971 else if (flag [FLAG_MONSTER]) 1035 else if (flag [FLAG_MONSTER])
972 play_sound (sound_find ("monster_destroy")); // quick hack, too lazy to create a generic mechanism 1036 play_sound (sound_find ("monster_destroy")); // quick hack, too lazy to create a generic mechanism
973 1037
974 attachable::destroy (); 1038 attachable::destroy ();
975}
976
977/*
978 * sub_weight() recursively (outwards) subtracts a number from the
979 * weight of an object (and what is carried by it's environment(s)).
980 */
981void
982sub_weight (object *op, signed long weight)
983{
984 while (op != NULL)
985 {
986 if (op->type == CONTAINER)
987 weight = (signed long) (weight * (100 - op->stats.Str) / 100);
988
989 op->carrying -= weight;
990 op = op->env;
991 }
992} 1039}
993 1040
994/* op->remove (): 1041/* op->remove ():
995 * This function removes the object op from the linked list of objects 1042 * This function removes the object op from the linked list of objects
996 * which it is currently tied to. When this function is done, the 1043 * which it is currently tied to. When this function is done, the
… …
1002object::do_remove () 1049object::do_remove ()
1003{ 1050{
1004 object *tmp, *last = 0; 1051 object *tmp, *last = 0;
1005 object *otmp; 1052 object *otmp;
1006 1053
1007 if (QUERY_FLAG (this, FLAG_REMOVED)) 1054 if (flag [FLAG_REMOVED])
1008 return; 1055 return;
1009 1056
1010 SET_FLAG (this, FLAG_REMOVED);
1011 INVOKE_OBJECT (REMOVE, this); 1057 INVOKE_OBJECT (REMOVE, this);
1058
1059 flag [FLAG_REMOVED] = true;
1012 1060
1013 if (more) 1061 if (more)
1014 more->remove (); 1062 more->remove ();
1015 1063
1016 /* 1064 /*
1017 * In this case, the object to be removed is in someones 1065 * In this case, the object to be removed is in someones
1018 * inventory. 1066 * inventory.
1019 */ 1067 */
1020 if (env) 1068 if (env)
1021 { 1069 {
1070 flag [FLAG_REMOVED] = false; // hack around the issue of visible_to checking flag_removed
1071 if (object *pl = visible_to ())
1072 esrv_del_item (pl->contr, count);
1073 flag [FLAG_REMOVED] = true; // hack around the issue of visible_to checking flag_removed
1074
1075 adjust_weight (env, -total_weight ());
1076
1077 *(above ? &above->below : &env->inv) = below;
1078
1022 if (nrof) 1079 if (below)
1023 sub_weight (env, weight * nrof); 1080 below->above = above;
1024 else 1081
1025 sub_weight (env, weight + carrying); 1082 /* we set up values so that it could be inserted into
1083 * the map, but we don't actually do that - it is up
1084 * to the caller to decide what we want to do.
1085 */
1086 map = env->map;
1087 x = env->x;
1088 y = env->y;
1089 above = 0;
1090 below = 0;
1091 env = 0;
1026 1092
1027 /* NO_FIX_PLAYER is set when a great many changes are being 1093 /* NO_FIX_PLAYER is set when a great many changes are being
1028 * made to players inventory. If set, avoiding the call 1094 * made to players inventory. If set, avoiding the call
1029 * to save cpu time. 1095 * to save cpu time.
1030 */ 1096 */
1031 if ((otmp = in_player ()) && otmp->contr && !QUERY_FLAG (otmp, FLAG_NO_FIX_PLAYER)) 1097 if ((otmp = in_player ()) && otmp->contr && !QUERY_FLAG (otmp, FLAG_NO_FIX_PLAYER))
1032 otmp->update_stats (); 1098 otmp->update_stats ();
1033
1034 if (above)
1035 above->below = below;
1036 else
1037 env->inv = below;
1038
1039 if (below)
1040 below->above = above;
1041
1042 /* we set up values so that it could be inserted into
1043 * the map, but we don't actually do that - it is up
1044 * to the caller to decide what we want to do.
1045 */
1046 x = env->x, y = env->y;
1047 map = env->map;
1048 above = 0, below = 0;
1049 env = 0;
1050 } 1099 }
1051 else if (map) 1100 else if (map)
1052 { 1101 {
1053 if (type == PLAYER)
1054 {
1055 // leaving a spot always closes any open container on the ground
1056 if (container && !container->env)
1057 // this causes spurious floorbox updates, but it ensures
1058 // that the CLOSE event is being sent.
1059 close_container ();
1060
1061 --map->players;
1062 map->touch ();
1063 }
1064
1065 map->dirty = true; 1102 map->dirty = true;
1066 mapspace &ms = this->ms (); 1103 mapspace &ms = this->ms ();
1104
1105 if (object *pl = ms.player ())
1106 {
1107 if (type == PLAYER) // this == pl(!)
1108 {
1109 // leaving a spot always closes any open container on the ground
1110 if (container && !container->env)
1111 // this causes spurious floorbox updates, but it ensures
1112 // that the CLOSE event is being sent.
1113 close_container ();
1114
1115 --map->players;
1116 map->touch ();
1117 }
1118 else if (pl->container == this)
1119 {
1120 // removing a container should close it
1121 close_container ();
1122 }
1123
1124 esrv_del_item (pl->contr, count);
1125 }
1067 1126
1068 /* link the object above us */ 1127 /* link the object above us */
1069 if (above) 1128 if (above)
1070 above->below = below; 1129 above->below = below;
1071 else 1130 else
… …
1101 * removed (most likely destroyed), update the player view 1160 * removed (most likely destroyed), update the player view
1102 * appropriately. 1161 * appropriately.
1103 */ 1162 */
1104 pl->close_container (); 1163 pl->close_container ();
1105 1164
1106 pl->contr->ns->floorbox_update (); 1165 //TODO: the floorbox prev/next might need updating
1166 esrv_del_item (pl->contr, count);
1107 } 1167 }
1108 1168
1109 for (tmp = ms.bot; tmp; tmp = tmp->above) 1169 for (tmp = ms.bot; tmp; tmp = tmp->above)
1110 { 1170 {
1111 /* No point updating the players look faces if he is the object 1171 /* No point updating the players look faces if he is the object
… …
1155 if (!top) 1215 if (!top)
1156 for (top = op; top && top->above; top = top->above) 1216 for (top = op; top && top->above; top = top->above)
1157 ; 1217 ;
1158 1218
1159 for (; top; top = top->below) 1219 for (; top; top = top->below)
1160 {
1161 if (top == op)
1162 continue;
1163
1164 if (object::can_merge (op, top)) 1220 if (object::can_merge (op, top))
1165 { 1221 {
1166 top->nrof += op->nrof; 1222 top->nrof += op->nrof;
1167 1223
1168/* CLEAR_FLAG(top,FLAG_STARTEQUIP);*/ 1224 if (object *pl = top->visible_to ())
1169 op->weight = 0; /* Don't want any adjustements now */ 1225 esrv_update_item (UPD_NROF, pl, top);
1226
1227 op->weight = 0; // cancel the addition above
1228 op->carrying = 0; // must be 0 already
1229
1170 op->destroy (); 1230 op->destroy (1);
1231
1171 return top; 1232 return top;
1172 } 1233 }
1173 }
1174 1234
1175 return 0; 1235 return 0;
1176} 1236}
1177 1237
1178void 1238void
… …
1237object * 1297object *
1238insert_ob_in_map (object *op, maptile *m, object *originator, int flag) 1298insert_ob_in_map (object *op, maptile *m, object *originator, int flag)
1239{ 1299{
1240 assert (!op->flag [FLAG_FREED]); 1300 assert (!op->flag [FLAG_FREED]);
1241 1301
1242 object *top, *floor = NULL;
1243
1244 op->remove (); 1302 op->remove ();
1245 1303
1246 /* Ideally, the caller figures this out. However, it complicates a lot 1304 /* Ideally, the caller figures this out. However, it complicates a lot
1247 * of areas of callers (eg, anything that uses find_free_spot would now 1305 * of areas of callers (eg, anything that uses find_free_spot would now
1248 * need extra work 1306 * need extra work
1249 */ 1307 */
1250 if (!xy_normalise (m, op->x, op->y)) 1308 if (!xy_normalise (m, op->x, op->y))
1251 { 1309 {
1252 op->destroy (); 1310 op->destroy (1);
1253 return 0; 1311 return 0;
1254 } 1312 }
1255 1313
1256 if (object *more = op->more) 1314 if (object *more = op->more)
1257 if (!insert_ob_in_map (more, m, originator, flag)) 1315 if (!insert_ob_in_map (more, m, originator, flag))
… …
1266 */ 1324 */
1267 if (op->nrof && !(flag & INS_NO_MERGE)) 1325 if (op->nrof && !(flag & INS_NO_MERGE))
1268 for (object *tmp = ms.bot; tmp; tmp = tmp->above) 1326 for (object *tmp = ms.bot; tmp; tmp = tmp->above)
1269 if (object::can_merge (op, tmp)) 1327 if (object::can_merge (op, tmp))
1270 { 1328 {
1329 // TODO: we atcually want to update tmp, not op,
1330 // but some caller surely breaks when we return tmp
1331 // from here :/
1271 op->nrof += tmp->nrof; 1332 op->nrof += tmp->nrof;
1272 tmp->destroy (); 1333 tmp->destroy (1);
1273 } 1334 }
1274 1335
1275 CLEAR_FLAG (op, FLAG_APPLIED); /* hack for fixing F_APPLIED in items of dead people */ 1336 CLEAR_FLAG (op, FLAG_APPLIED); /* hack for fixing F_APPLIED in items of dead people */
1276 CLEAR_FLAG (op, FLAG_INV_LOCKED); 1337 CLEAR_FLAG (op, FLAG_INV_LOCKED);
1277 1338
… …
1297 /* since *below* originator, no need to update top */ 1358 /* since *below* originator, no need to update top */
1298 originator->below = op; 1359 originator->below = op;
1299 } 1360 }
1300 else 1361 else
1301 { 1362 {
1363 object *top, *floor = NULL;
1364
1302 top = ms.bot; 1365 top = ms.bot;
1303 1366
1304 /* If there are other objects, then */ 1367 /* If there are other objects, then */
1305 if (top) 1368 if (top)
1306 { 1369 {
… …
1405 } 1468 }
1406 1469
1407 op->map->dirty = true; 1470 op->map->dirty = true;
1408 1471
1409 if (object *pl = ms.player ()) 1472 if (object *pl = ms.player ())
1410 pl->contr->ns->floorbox_update (); 1473 //TODO: the floorbox prev/next might need updating
1474 esrv_send_item (pl, op);
1411 1475
1412 /* If this object glows, it may affect lighting conditions that are 1476 /* If this object glows, it may affect lighting conditions that are
1413 * visible to others on this map. But update_all_los is really 1477 * visible to others on this map. But update_all_los is really
1414 * an inefficient way to do this, as it means los for all players 1478 * an inefficient way to do this, as it means los for all players
1415 * on the map will get recalculated. The players could very well 1479 * on the map will get recalculated. The players could very well
… …
1457 * op is the object to insert it under: supplies x and the map. 1521 * op is the object to insert it under: supplies x and the map.
1458 */ 1522 */
1459void 1523void
1460replace_insert_ob_in_map (const char *arch_string, object *op) 1524replace_insert_ob_in_map (const char *arch_string, object *op)
1461{ 1525{
1462 object *tmp, *tmp1;
1463
1464 /* first search for itself and remove any old instances */ 1526 /* first search for itself and remove any old instances */
1465 1527
1466 for (tmp = op->ms ().bot; tmp; tmp = tmp->above) 1528 for (object *tmp = op->ms ().bot; tmp; tmp = tmp->above)
1467 if (!strcmp (tmp->arch->archname, arch_string)) /* same archetype */ 1529 if (!strcmp (tmp->arch->archname, arch_string)) /* same archetype */
1468 tmp->destroy (); 1530 tmp->destroy (1);
1469 1531
1470 tmp1 = arch_to_object (archetype::find (arch_string)); 1532 object *tmp = arch_to_object (archetype::find (arch_string));
1471 1533
1472 tmp1->x = op->x; 1534 tmp->x = op->x;
1473 tmp1->y = op->y; 1535 tmp->y = op->y;
1536
1474 insert_ob_in_map (tmp1, op->map, op, 0); 1537 insert_ob_in_map (tmp, op->map, op, 0);
1475} 1538}
1476 1539
1477object * 1540object *
1478object::insert_at (object *where, object *originator, int flags) 1541object::insert_at (object *where, object *originator, int flags)
1479{ 1542{
1543 if (where->env)
1544 return where->env->insert (this);
1545 else
1480 return where->map->insert (this, where->x, where->y, originator, flags); 1546 return where->map->insert (this, where->x, where->y, originator, flags);
1481} 1547}
1482 1548
1483/* 1549/*
1484 * get_split_ob(ob,nr) splits up ob into two parts. The part which
1485 * is returned contains nr objects, and the remaining parts contains
1486 * the rest (or is removed and freed if that number is 0).
1487 * On failure, NULL is returned, and the reason put into the
1488 * global static errmsg array.
1489 */
1490object *
1491get_split_ob (object *orig_ob, uint32 nr)
1492{
1493 object *newob;
1494 int is_removed = (QUERY_FLAG (orig_ob, FLAG_REMOVED) != 0);
1495
1496 if (orig_ob->nrof < nr)
1497 {
1498 sprintf (errmsg, "There are only %d %ss.", orig_ob->nrof ? orig_ob->nrof : 1, &orig_ob->name);
1499 return NULL;
1500 }
1501
1502 newob = object_create_clone (orig_ob);
1503
1504 if ((orig_ob->nrof -= nr) < 1)
1505 orig_ob->destroy (1);
1506 else if (!is_removed)
1507 {
1508 if (orig_ob->env != NULL)
1509 sub_weight (orig_ob->env, orig_ob->weight * nr);
1510 if (orig_ob->env == NULL && orig_ob->map->in_memory != MAP_IN_MEMORY)
1511 {
1512 strcpy (errmsg, "Tried to split object whose map is not in memory.");
1513 LOG (llevDebug, "Error, Tried to split object whose map is not in memory.\n");
1514 return NULL;
1515 }
1516 }
1517
1518 newob->nrof = nr;
1519
1520 return newob;
1521}
1522
1523/*
1524 * decrease_ob_nr(object, number) decreases a specified number from 1550 * decrease(object, number) decreases a specified number from
1525 * the amount of an object. If the amount reaches 0, the object 1551 * the amount of an object. If the amount reaches 0, the object
1526 * is subsequently removed and freed. 1552 * is subsequently removed and freed.
1527 * 1553 *
1528 * Return value: 'op' if something is left, NULL if the amount reached 0 1554 * Return value: 'op' if something is left, NULL if the amount reached 0
1529 */ 1555 */
1556bool
1557object::decrease (sint32 nr)
1558{
1559 if (!nr)
1560 return true;
1561
1562 nr = min (nr, nrof);
1563
1564 nrof -= nr;
1565
1566 if (nrof)
1567 {
1568 adjust_weight (env, -weight * nr); // carrying == 0
1569
1570 if (object *pl = visible_to ())
1571 esrv_update_item (UPD_NROF, pl, this);
1572
1573 return true;
1574 }
1575 else
1576 {
1577 destroy (1);
1578 return false;
1579 }
1580}
1581
1582/*
1583 * split(ob,nr) splits up ob into two parts. The part which
1584 * is returned contains nr objects, and the remaining parts contains
1585 * the rest (or is removed and returned if that number is 0).
1586 * On failure, NULL is returned.
1587 */
1530object * 1588object *
1531decrease_ob_nr (object *op, uint32 i) 1589object::split (sint32 nr)
1532{ 1590{
1533 object *tmp; 1591 int have = number_of ();
1534 1592
1535 if (i == 0) /* objects with op->nrof require this check */ 1593 if (have < nr)
1536 return op; 1594 return 0;
1537 1595 else if (have == nr)
1538 if (i > op->nrof)
1539 i = op->nrof;
1540
1541 if (QUERY_FLAG (op, FLAG_REMOVED))
1542 op->nrof -= i;
1543 else if (op->env)
1544 { 1596 {
1545 /* is this object in the players inventory, or sub container
1546 * therein?
1547 */
1548 tmp = op->in_player ();
1549 /* nope. Is this a container the player has opened?
1550 * If so, set tmp to that player.
1551 * IMO, searching through all the players will mostly
1552 * likely be quicker than following op->env to the map,
1553 * and then searching the map for a player.
1554 */
1555 if (!tmp)
1556 for_all_players (pl)
1557 if (pl->ob->container == op->env)
1558 {
1559 tmp = pl->ob;
1560 break;
1561 }
1562
1563 if (i < op->nrof)
1564 {
1565 sub_weight (op->env, op->weight * i);
1566 op->nrof -= i;
1567 if (tmp)
1568 esrv_send_item (tmp, op);
1569 }
1570 else
1571 {
1572 op->remove (); 1597 remove ();
1573 op->nrof = 0; 1598 return this;
1574 if (tmp)
1575 esrv_del_item (tmp->contr, op->count);
1576 }
1577 } 1599 }
1578 else 1600 else
1579 { 1601 {
1580 object *above = op->above; 1602 decrease (nr);
1581 1603
1582 if (i < op->nrof) 1604 object *op = object_create_clone (this);
1583 op->nrof -= i; 1605 op->nrof = nr;
1584 else
1585 {
1586 op->remove ();
1587 op->nrof = 0;
1588 }
1589
1590 /* Since we just removed op, op->above is null */
1591 for (tmp = above; tmp; tmp = tmp->above)
1592 if (tmp->type == PLAYER)
1593 {
1594 if (op->nrof)
1595 esrv_send_item (tmp, op);
1596 else
1597 esrv_del_item (tmp->contr, op->count);
1598 }
1599 }
1600
1601 if (op->nrof)
1602 return op; 1606 return op;
1603 else
1604 {
1605 op->destroy ();
1606 return 0;
1607 }
1608}
1609
1610/*
1611 * add_weight(object, weight) adds the specified weight to an object,
1612 * and also updates how much the environment(s) is/are carrying.
1613 */
1614void
1615add_weight (object *op, signed long weight)
1616{
1617 while (op != NULL)
1618 {
1619 if (op->type == CONTAINER)
1620 weight = (signed long) (weight * (100 - op->stats.Str) / 100);
1621
1622 op->carrying += weight;
1623 op = op->env;
1624 } 1607 }
1625} 1608}
1626 1609
1627object * 1610object *
1628insert_ob_in_ob (object *op, object *where) 1611insert_ob_in_ob (object *op, object *where)
… …
1653 * be != op, if items are merged. -Tero 1636 * be != op, if items are merged. -Tero
1654 */ 1637 */
1655object * 1638object *
1656object::insert (object *op) 1639object::insert (object *op)
1657{ 1640{
1658 if (!QUERY_FLAG (op, FLAG_REMOVED))
1659 op->remove ();
1660
1661 if (op->more) 1641 if (op->more)
1662 { 1642 {
1663 LOG (llevError, "Tried to insert multipart object %s (%d)\n", &op->name, op->count); 1643 LOG (llevError, "Tried to insert multipart object %s (%d)\n", &op->name, op->count);
1664 return op; 1644 return op;
1665 } 1645 }
1666 1646
1667 CLEAR_FLAG (op, FLAG_OBJ_ORIGINAL); 1647 op->remove ();
1668 CLEAR_FLAG (op, FLAG_REMOVED); 1648
1649 op->flag [FLAG_OBJ_ORIGINAL] = 0;
1669 1650
1670 if (op->nrof) 1651 if (op->nrof)
1671 {
1672 for (object *tmp = inv; tmp; tmp = tmp->below) 1652 for (object *tmp = inv; tmp; tmp = tmp->below)
1673 if (object::can_merge (tmp, op)) 1653 if (object::can_merge (tmp, op))
1674 { 1654 {
1675 /* return the original object and remove inserted object 1655 /* return the original object and remove inserted object
1676 (client needs the original object) */ 1656 (client needs the original object) */
1677 tmp->nrof += op->nrof; 1657 tmp->nrof += op->nrof;
1678 /* Weight handling gets pretty funky. Since we are adding to 1658
1679 * tmp->nrof, we need to increase the weight. 1659 if (object *pl = tmp->visible_to ())
1680 */ 1660 esrv_update_item (UPD_NROF, pl, tmp);
1661
1681 add_weight (this, op->weight * op->nrof); 1662 adjust_weight (this, op->total_weight ());
1682 SET_FLAG (op, FLAG_REMOVED); 1663
1683 op->destroy (); /* free the inserted object */ 1664 op->destroy (1);
1684 op = tmp; 1665 op = tmp;
1685 op->remove (); /* and fix old object's links */ 1666 goto inserted;
1686 CLEAR_FLAG (op, FLAG_REMOVED);
1687 break;
1688 } 1667 }
1689 1668
1690 /* I assume combined objects have no inventory
1691 * We add the weight - this object could have just been removed
1692 * (if it was possible to merge). calling remove_ob will subtract
1693 * the weight, so we need to add it in again, since we actually do
1694 * the linking below
1695 */
1696 add_weight (this, op->weight * op->nrof);
1697 }
1698 else
1699 add_weight (this, (op->weight + op->carrying));
1700
1701 if (object *otmp = this->in_player ())
1702 if (otmp->contr && !QUERY_FLAG (otmp, FLAG_NO_FIX_PLAYER))
1703 otmp->update_stats ();
1704
1705 op->owner = 0; // its his/hers now. period. 1669 op->owner = 0; // it's his/hers now. period.
1706 op->map = 0; 1670 op->map = 0;
1671 op->x = 0;
1672 op->y = 0;
1673
1674 op->above = 0;
1675 op->below = inv;
1707 op->env = this; 1676 op->env = this;
1708 op->above = 0;
1709 op->below = 0;
1710 op->x = op->y = 0;
1711 1677
1678 if (inv)
1679 inv->above = op;
1680
1681 inv = op;
1682
1683 op->flag [FLAG_REMOVED] = 0;
1684
1685 if (object *pl = op->visible_to ())
1686 esrv_send_item (pl, op);
1687
1688 adjust_weight (this, op->total_weight ());
1689
1690inserted:
1712 /* reset the light list and los of the players on the map */ 1691 /* reset the light list and los of the players on the map */
1713 if (op->glow_radius && map) 1692 if (op->glow_radius && map && map->darkness)
1714 {
1715#ifdef DEBUG_LIGHTS
1716 LOG (llevDebug, " insert_ob_in_ob(): got %s to insert in map/op\n", op->name);
1717#endif /* DEBUG_LIGHTS */
1718 if (map->darkness)
1719 update_all_los (map, x, y); 1693 update_all_los (map, x, y);
1720 }
1721 1694
1722 /* Client has no idea of ordering so lets not bother ordering it here. 1695 // if this is a player's inventory, update stats
1723 * It sure simplifies this function... 1696 if (type == PLAYER && !flag [FLAG_NO_FIX_PLAYER])
1724 */ 1697 update_stats ();
1725 if (!inv)
1726 inv = op;
1727 else
1728 {
1729 op->below = inv;
1730 op->below->above = op;
1731 inv = op;
1732 }
1733 1698
1734 INVOKE_OBJECT (INSERT, this); 1699 INVOKE_OBJECT (INSERT, this);
1735 1700
1736 return op; 1701 return op;
1737} 1702}
… …
2607{ 2572{
2608 char flagdesc[512]; 2573 char flagdesc[512];
2609 char info2[256 * 4]; 2574 char info2[256 * 4];
2610 char *p = info; 2575 char *p = info;
2611 2576
2612 p += snprintf (p, 512, "{cnt:%d,uuid:<1.%" PRIx64 ">,name:\"%s\"%s%s,flags:[%s],type:%d}", 2577 p += snprintf (p, 512, "{cnt:%d,uuid:%s,name:\"%s\"%s%s,flags:[%s],type:%d}",
2613 count, uuid.seq, 2578 count,
2579 uuid.c_str (),
2614 &name, 2580 &name,
2615 title ? "\",title:\"" : "", 2581 title ? "\",title:\"" : "",
2616 title ? (const char *)title : "", 2582 title ? (const char *)title : "",
2617 flag_desc (flagdesc, 512), type); 2583 flag_desc (flagdesc, 512), type);
2618 2584
2619 if (!this->flag[FLAG_REMOVED] && env) 2585 if (!flag[FLAG_REMOVED] && env)
2620 p += snprintf (p, 256, "(in %s)", env->debug_desc (info2)); 2586 p += snprintf (p, 256, "(in %s)", env->debug_desc (info2));
2621 2587
2622 if (map) 2588 if (map)
2623 p += snprintf (p, 256, "(on %s@%d+%d)", &map->path, x, y); 2589 p += snprintf (p, 256, "(on %s@%d+%d)", &map->path, x, y);
2624 2590
… …
2654object::open_container (object *new_container) 2620object::open_container (object *new_container)
2655{ 2621{
2656 if (container == new_container) 2622 if (container == new_container)
2657 return; 2623 return;
2658 2624
2659 if (object *old_container = container) 2625 object *old_container = container;
2626
2627 if (old_container)
2660 { 2628 {
2661 if (INVOKE_OBJECT (CLOSE, old_container, ARG_OBJECT (this))) 2629 if (INVOKE_OBJECT (CLOSE, old_container, ARG_OBJECT (this)))
2662 return; 2630 return;
2663 2631
2664#if 0 2632#if 0
… …
2666 if (object *closer = old_container->inv) 2634 if (object *closer = old_container->inv)
2667 if (closer->type == CLOSE_CON) 2635 if (closer->type == CLOSE_CON)
2668 closer->destroy (); 2636 closer->destroy ();
2669#endif 2637#endif
2670 2638
2639 // make sure the container is available
2640 esrv_send_item (this, old_container);
2641
2671 old_container->flag [FLAG_APPLIED] = 0; 2642 old_container->flag [FLAG_APPLIED] = false;
2672 container = 0; 2643 container = 0;
2673 2644
2645 // client needs item update to make it work, client bug requires this to be separate
2674 esrv_update_item (UPD_FLAGS, this, old_container); 2646 esrv_update_item (UPD_FLAGS, this, old_container);
2647
2675 new_draw_info_format (NDI_UNIQUE, 0, this, "You close %s.", query_name (old_container)); 2648 new_draw_info_format (NDI_UNIQUE, 0, this, "You close %s.", query_name (old_container));
2676 play_sound (sound_find ("chest_close")); 2649 play_sound (sound_find ("chest_close"));
2677 } 2650 }
2678 2651
2679 if (new_container) 2652 if (new_container)
… …
2692 } 2665 }
2693#endif 2666#endif
2694 2667
2695 new_draw_info_format (NDI_UNIQUE, 0, this, "You open %s.", query_name (new_container)); 2668 new_draw_info_format (NDI_UNIQUE, 0, this, "You open %s.", query_name (new_container));
2696 2669
2670 // make sure the container is available, client bug requires this to be separate
2671 esrv_send_item (this, new_container);
2672
2697 new_container->flag [FLAG_APPLIED] = 1; 2673 new_container->flag [FLAG_APPLIED] = true;
2698 container = new_container; 2674 container = new_container;
2699 2675
2676 // client needs flag change
2700 esrv_update_item (UPD_FLAGS, this, new_container); 2677 esrv_update_item (UPD_FLAGS, this, new_container);
2701 esrv_send_inventory (this, new_container); 2678 esrv_send_inventory (this, new_container);
2702 play_sound (sound_find ("chest_open")); 2679 play_sound (sound_find ("chest_open"));
2703 } 2680 }
2681// else if (!old_container->env && contr && contr->ns)
2682// contr->ns->floorbox_reset ();
2704} 2683}
2705 2684
2706object * 2685object *
2707object::force_find (const shstr name) 2686object::force_find (const shstr name)
2708{ 2687{
… …
2734 2713
2735 insert (force); 2714 insert (force);
2736} 2715}
2737 2716
2738void 2717void
2739object::play_sound (faceidx sound) const 2718object::play_sound (faceidx sound)
2740{ 2719{
2741 if (!sound) 2720 if (!sound)
2742 return; 2721 return;
2743 2722
2744 if (flag [FLAG_REMOVED]) 2723 if (flag [FLAG_REMOVED])

Diff Legend

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