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.200 by root, Sun Jan 13 08:55:41 2008 UTC vs.
Revision 1.227 by root, Sat May 3 09:04:17 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
38int nrofallocobjects = 0; 34UUID UUID::cur;
39static UUID uuid; 35static uint64_t seq_next_save;
40const uint64 UUID_SKIP = 1<<19; 36static const uint64 UUID_GAP = 1<<19;
41 37
42objectvec objects; 38objectvec objects;
43activevec actives; 39activevec actives;
44 40
45short 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,
46 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
47}; 46};
48short 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,
49 -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
50}; 52};
51int 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,
52 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
53}; 58};
54int freedir[SIZEOFFREE] = { 59int freedir[SIZEOFFREE] = {
55 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,
56 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
57}; 64};
58 65
59static void 66static void
60write_uuid (void) 67write_uuid (uval64 skip, bool sync)
61{ 68{
62 char filename1[MAX_BUF], filename2[MAX_BUF]; 69 CALL_BEGIN (2);
63 70 CALL_ARG_SV (newSVval64 (skip));
64 sprintf (filename1, "%s/uuid", settings.localdir); 71 CALL_ARG_SV (boolSV (sync));
65 sprintf (filename2, "%s/uuid~", settings.localdir); 72 CALL_CALL ("cf::write_uuid", G_DISCARD);
66 73 CALL_END;
67 FILE *fp;
68
69 if (!(fp = fopen (filename2, "w")))
70 {
71 LOG (llevError, "ERROR: cannot open %s for writing, unable to write UUID!\n", filename2);
72 return;
73 }
74
75 fprintf (fp, "<1,%llx>\n", (unsigned long long)uuid.seq + UUID_SKIP * 2);
76 fclose (fp);
77 rename (filename2, filename1);
78} 74}
79 75
80static void 76static void
81read_uuid (void) 77read_uuid (void)
82{ 78{
83 char filename[MAX_BUF]; 79 char filename[MAX_BUF];
84 80
85 sprintf (filename, "%s/uuid", settings.localdir); 81 sprintf (filename, "%s/uuid", settings.localdir);
82
83 seq_next_save = 0;
86 84
87 FILE *fp; 85 FILE *fp;
88 86
89 if (!(fp = fopen (filename, "r"))) 87 if (!(fp = fopen (filename, "r")))
90 { 88 {
91 if (errno == ENOENT) 89 if (errno == ENOENT)
92 { 90 {
93 LOG (llevInfo, "RESET uid to 1\n"); 91 LOG (llevInfo, "RESET uid to 1\n");
94 uuid.seq = 0; 92 UUID::cur.seq = 0;
95 write_uuid (); 93 write_uuid (UUID_GAP, true);
96 return; 94 return;
97 } 95 }
98 96
99 LOG (llevError, "FATAL: cannot open %s for reading!\n", filename); 97 LOG (llevError, "FATAL: cannot open %s for reading!\n", filename);
100 _exit (1); 98 _exit (1);
101 } 99 }
102 100
103 int version; 101 UUID::BUF buf;
104 unsigned long long uid; 102 buf[0] = 0;
105 if (2 != fscanf (fp, "<%d,%llx>\n", &version, &uid) || version != 1) 103 fgets (buf, sizeof (buf), fp);
104
105 if (!UUID::cur.parse (buf))
106 { 106 {
107 LOG (llevError, "FATAL: error reading uid from %s!\n", filename); 107 LOG (llevError, "FATAL: error reading uid from %s (%s)!\n", filename, buf);
108 _exit (1); 108 _exit (1);
109 } 109 }
110 110
111 uuid.seq = uid; 111 LOG (llevDebug, "read UUID: %s\n", UUID::cur.c_str ());
112 write_uuid (); 112
113 LOG (llevDebug, "read UID: %" PRId64 "\n", uid); 113 write_uuid (UUID_GAP, true);
114 fclose (fp); 114 fclose (fp);
115} 115}
116 116
117UUID 117UUID
118gen_uuid () 118UUID::gen ()
119{ 119{
120 UUID uid; 120 UUID uid;
121 121
122 uid.seq = ++uuid.seq; 122 uid.seq = ++cur.seq;
123 123
124 if (!(uuid.seq & (UUID_SKIP - 1))) 124 if (expect_false (cur.seq >= seq_next_save))
125 write_uuid (); 125 {
126 seq_next_save = UUID::cur.seq + (UUID_GAP >> 1);
127 write_uuid (UUID_GAP, false);
128 }
129
126 130
127 return uid; 131 return uid;
128} 132}
129 133
130void 134void
131init_uuid () 135UUID::init ()
132{ 136{
133 read_uuid (); 137 read_uuid ();
134} 138}
135 139
136/* 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. */
137static int 141static bool
138compare_ob_value_lists_one (const object *wants, const object *has) 142compare_ob_value_lists_one (const object *wants, const object *has)
139{ 143{
140 key_value *wants_field; 144 key_value *wants_field;
141 145
142 /* 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
150 key_value *has_field; 154 key_value *has_field;
151 155
152 /* Look for a field in has with the same key. */ 156 /* Look for a field in has with the same key. */
153 has_field = get_ob_key_link (has, wants_field->key); 157 has_field = get_ob_key_link (has, wants_field->key);
154 158
155 if (has_field == NULL) 159 if (!has_field)
156 {
157 /* No field with that name. */ 160 return 0; /* No field with that name. */
158 return FALSE;
159 }
160 161
161 /* Found the matching field. */ 162 /* Found the matching field. */
162 if (has_field->value != wants_field->value) 163 if (has_field->value != wants_field->value)
163 {
164 /* 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. */
165 return FALSE;
166 }
167 165
168 /* 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. */
169 } 167 }
170 168
171 /* 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. */
172 return TRUE; 170 return 1;
173} 171}
174 172
175/* Returns TRUE if ob1 has the same key_values as ob2. */ 173/* Returns TRUE if ob1 has the same key_values as ob2. */
176static int 174static bool
177compare_ob_value_lists (const object *ob1, const object *ob2) 175compare_ob_value_lists (const object *ob1, const object *ob2)
178{ 176{
179 /* 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,
180 * so we need to run the comparison *twice*. :( 178 * so we need to run the comparison *twice*. :(
181 */ 179 */
202 || ob1->speed != ob2->speed 200 || ob1->speed != ob2->speed
203 || ob1->value != ob2->value 201 || ob1->value != ob2->value
204 || ob1->name != ob2->name) 202 || ob1->name != ob2->name)
205 return 0; 203 return 0;
206 204
207 //TODO: this ain't working well, use nicer and correct overflow check 205 /* Do not merge objects if nrof would overflow. First part checks
208 /* 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
209 * 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
210 * used to store nrof). 208 * nrof values.
211 */ 209 */
212 if (ob1->nrof + ob2->nrof >= 1UL << 31) 210 if (~ob1->nrof < ob2->nrof || ob1->nrof + ob2->nrof > (1UL << 31))
213 return 0; 211 return 0;
214 212
215 /* If the objects have been identified, set the BEEN_APPLIED flag. 213 /* If the objects have been identified, set the BEEN_APPLIED flag.
216 * 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
217 * 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
218 * 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
219 * flags lose any meaning. 217 * flags lose any meaning.
220 */ 218 */
221 if (QUERY_FLAG (ob1, FLAG_IDENTIFIED)) 219 if (QUERY_FLAG (ob1, FLAG_IDENTIFIED))
222 SET_FLAG (ob1, FLAG_BEEN_APPLIED); 220 SET_FLAG (ob1, FLAG_BEEN_APPLIED);
223 221
224 if (QUERY_FLAG (ob2, FLAG_IDENTIFIED)) 222 if (QUERY_FLAG (ob2, FLAG_IDENTIFIED))
225 SET_FLAG (ob2, FLAG_BEEN_APPLIED); 223 SET_FLAG (ob2, FLAG_BEEN_APPLIED);
226 224
227 if ((ob1->flag ^ ob2->flag).reset (FLAG_INV_LOCKED).reset (FLAG_CLIENT_SENT).any () 225 if (ob1->arch->name != ob2->arch->name
228 || ob1->arch != ob2->arch
229 || ob1->name != ob2->name 226 || ob1->name != ob2->name
230 || ob1->title != ob2->title 227 || ob1->title != ob2->title
231 || ob1->msg != ob2->msg 228 || ob1->msg != ob2->msg
232 || ob1->weight != ob2->weight 229 || ob1->weight != ob2->weight
233 || memcmp (&ob1->resist, &ob2->resist, sizeof (ob1->resist))
234 || memcmp (&ob1->stats , &ob2->stats , sizeof (ob1->stats) )
235 || ob1->attacktype != ob2->attacktype 230 || ob1->attacktype != ob2->attacktype
236 || ob1->magic != ob2->magic 231 || ob1->magic != ob2->magic
237 || ob1->slaying != ob2->slaying 232 || ob1->slaying != ob2->slaying
238 || ob1->skill != ob2->skill 233 || ob1->skill != ob2->skill
239 || ob1->value != ob2->value 234 || ob1->value != ob2->value
246 || ob1->move_block != ob2->move_block 241 || ob1->move_block != ob2->move_block
247 || ob1->move_allow != ob2->move_allow 242 || ob1->move_allow != ob2->move_allow
248 || ob1->move_on != ob2->move_on 243 || ob1->move_on != ob2->move_on
249 || ob1->move_off != ob2->move_off 244 || ob1->move_off != ob2->move_off
250 || ob1->move_slow != ob2->move_slow 245 || ob1->move_slow != ob2->move_slow
251 || 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)))
252 return 0; 249 return 0;
253 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
254 /* This is really a spellbook check - really, we should 258 /* This is really a spellbook check - we should in general
255 * check all objects in the inventory. 259 * not merge objects with real inventories, as splitting them
260 * is hard.
256 */ 261 */
257 if (ob1->inv || ob2->inv) 262 if (ob1->inv || ob2->inv)
258 { 263 {
259 if (!(ob1->inv && ob2->inv)) 264 if (!(ob1->inv && ob2->inv))
260 return 0; /* inventories differ in length */ 265 return 0; /* inventories differ in length */
261 266
262 if (ob1->inv->below || ob2->inv->below) 267 if (ob1->inv->below || ob2->inv->below)
263 return 0; /* more than one object in inv */ 268 return 0; /* more than one object in inv */
264 269
265 if (!object::can_merge (ob1->inv, ob2->inv)) 270 if (!object::can_merge (ob1->inv, ob2->inv))
266 return 0; /* inventory objexts differ */ 271 return 0; /* inventory objects differ */
267 272
268 /* 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
269 * if it is valid. 274 * if it is valid.
270 */ 275 */
271 } 276 }
290 if (ob1->level != ob2->level) 295 if (ob1->level != ob2->level)
291 return 0; 296 return 0;
292 break; 297 break;
293 } 298 }
294 299
295 if (ob1->key_values != NULL || ob2->key_values != NULL) 300 if (ob1->key_values || ob2->key_values)
296 { 301 {
297 /* At least one of these has key_values. */ 302 /* At least one of these has key_values. */
298 if ((ob1->key_values == NULL) != (ob2->key_values == NULL)) 303 if ((!ob1->key_values) != (!ob2->key_values))
299 /* One has fields, but the other one doesn't. */ 304 return 0; /* One has fields, but the other one doesn't. */
300 return 0; 305
301 else if (!compare_ob_value_lists (ob1, ob2)) 306 if (!compare_ob_value_lists (ob1, ob2))
302 return 0; 307 return 0;
303 } 308 }
304 309
305 if (ob1->self || ob2->self) 310 if (ob1->self || ob2->self)
306 { 311 {
312 int k1 = ob1->self ? HvTOTALKEYS (ob1->self) : 0; 317 int k1 = ob1->self ? HvTOTALKEYS (ob1->self) : 0;
313 int k2 = ob2->self ? HvTOTALKEYS (ob2->self) : 0; 318 int k2 = ob2->self ? HvTOTALKEYS (ob2->self) : 0;
314 319
315 if (k1 != k2) 320 if (k1 != k2)
316 return 0; 321 return 0;
322
317 else if (k1 == 0) 323 if (k1 == 0)
318 return 1; 324 return 1;
325
319 else if (!cfperl_can_merge (ob1, ob2)) 326 if (!cfperl_can_merge (ob1, ob2))
320 return 0; 327 return 0;
321 } 328 }
322 } 329 }
323 330
324 /* Everything passes, must be OK. */ 331 /* Everything passes, must be OK. */
325 return 1; 332 return 1;
326} 333}
327 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
328/* 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/*
329 * sum_weight() is a recursive function which calculates the weight 405 * this is a recursive function which calculates the weight
330 * 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
331 * containers are carrying, and sums it up. 407 * containers are carrying, and sums it up.
332 */ 408 */
333long 409void
334sum_weight (object *op) 410object::update_weight ()
335{ 411{
336 long sum; 412 sint32 sum = 0;
337 object *inv;
338 413
339 for (sum = 0, inv = op->inv; inv; inv = inv->below) 414 for (object *op = inv; op; op = op->below)
340 { 415 {
341 if (inv->inv) 416 if (op->inv)
342 sum_weight (inv); 417 op->update_weight ();
343 418
344 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)
345 } 425 {
346
347 if (op->type == CONTAINER && op->stats.Str)
348 sum = (sum * (100 - op->stats.Str)) / 100;
349
350 if (op->carrying != sum)
351 op->carrying = sum; 426 carrying = sum;
352 427
353 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 }
354} 432}
355 433
356/** 434/*
357 * Return the outermost environment object for a given object. 435 * Used by: Server DM commands: dumpbelow, dump. Some error messages.
358 */
359
360object *
361object_get_env_recursive (object *op)
362{
363 while (op->env != NULL)
364 op = op->env;
365 return op;
366}
367
368/*
369 * Used by: Crossedit: dump. Server DM commands: dumpbelow, dump.
370 * Some error messages.
371 * The result of the dump is stored in the static global errmsg array.
372 */ 436 */
373char * 437char *
374dump_object (object *op) 438dump_object (object *op)
375{ 439{
376 if (!op) 440 if (!op)
390get_nearest_part (object *op, const object *pl) 454get_nearest_part (object *op, const object *pl)
391{ 455{
392 object *tmp, *closest; 456 object *tmp, *closest;
393 int last_dist, i; 457 int last_dist, i;
394 458
395 if (op->more == NULL) 459 if (!op->more)
396 return op; 460 return op;
461
397 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)
398 if ((i = distance (tmp, pl)) < last_dist) 465 if ((i = distance (tmp, pl)) < last_dist)
399 closest = tmp, last_dist = i; 466 closest = tmp, last_dist = i;
467
400 return closest; 468 return closest;
401} 469}
402 470
403/* 471/*
404 * 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.
405 */ 474 */
406object * 475object *
407find_object (tag_t i) 476find_object (tag_t i)
408{ 477{
409 for_all_objects (op) 478 for_all_objects (op)
427 for_all_objects (op) 496 for_all_objects (op)
428 if (op->name == str_) 497 if (op->name == str_)
429 break; 498 break;
430 499
431 return op; 500 return op;
432}
433
434void
435free_all_object_data ()
436{
437 LOG (llevDebug, "%d allocated objects\n", nrofallocobjects);
438} 501}
439 502
440/* 503/*
441 * Sets the owner and sets the skill and exp pointers to owner's current 504 * Sets the owner and sets the skill and exp pointers to owner's current
442 * skill and experience objects. 505 * skill and experience objects.
540 } 603 }
541 604
542 op->key_values = 0; 605 op->key_values = 0;
543} 606}
544 607
545object & 608/*
546object::operator =(const object &src) 609 * copy_to first frees everything allocated by the dst object,
610 * and then copies the contents of itself into the second
611 * object, allocating what needs to be allocated. Basically, any
612 * data that is malloc'd needs to be re-malloc/copied. Otherwise,
613 * if the first object is freed, the pointers in the new object
614 * will point at garbage.
615 */
616void
617object::copy_to (object *dst)
547{ 618{
548 bool is_freed = flag [FLAG_FREED]; 619 dst->remove ();
549 bool is_removed = flag [FLAG_REMOVED];
550
551 *(object_copy *)this = src; 620 *(object_copy *)dst = *this;
552
553 flag [FLAG_FREED] = is_freed;
554 flag [FLAG_REMOVED] = is_removed; 621 dst->flag [FLAG_REMOVED] = true;
555 622
556 /* Copy over key_values, if any. */ 623 /* Copy over key_values, if any. */
557 if (src.key_values) 624 if (key_values)
558 { 625 {
559 key_value *tail = 0; 626 key_value *tail = 0;
560 key_values = 0; 627 dst->key_values = 0;
561 628
562 for (key_value *i = src.key_values; i; i = i->next) 629 for (key_value *i = key_values; i; i = i->next)
563 { 630 {
564 key_value *new_link = new key_value; 631 key_value *new_link = new key_value;
565 632
566 new_link->next = 0; 633 new_link->next = 0;
567 new_link->key = i->key; 634 new_link->key = i->key;
568 new_link->value = i->value; 635 new_link->value = i->value;
569 636
570 /* Try and be clever here, too. */ 637 /* Try and be clever here, too. */
571 if (!key_values) 638 if (!dst->key_values)
572 { 639 {
573 key_values = new_link; 640 dst->key_values = new_link;
574 tail = new_link; 641 tail = new_link;
575 } 642 }
576 else 643 else
577 { 644 {
578 tail->next = new_link; 645 tail->next = new_link;
579 tail = new_link; 646 tail = new_link;
580 } 647 }
581 } 648 }
582 } 649 }
583}
584
585/*
586 * copy_to first frees everything allocated by the dst object,
587 * and then copies the contents of itself into the second
588 * object, allocating what needs to be allocated. Basically, any
589 * data that is malloc'd needs to be re-malloc/copied. Otherwise,
590 * if the first object is freed, the pointers in the new object
591 * will point at garbage.
592 */
593void
594object::copy_to (object *dst)
595{
596 *dst = *this;
597 650
598 if (speed < 0) 651 if (speed < 0)
599 dst->speed_left -= rndm (); 652 dst->speed_left -= rndm ();
600 653
601 dst->set_speed (dst->speed); 654 dst->set_speed (dst->speed);
603 656
604void 657void
605object::instantiate () 658object::instantiate ()
606{ 659{
607 if (!uuid.seq) // HACK 660 if (!uuid.seq) // HACK
608 uuid = gen_uuid (); 661 uuid = UUID::gen ();
609 662
610 speed_left = -0.1f; 663 speed_left = -0.1f;
611 /* copy the body_info to the body_used - this is only really 664 /* copy the body_info to the body_used - this is only really
612 * need for monsters, but doesn't hurt to do it for everything. 665 * need for monsters, but doesn't hurt to do it for everything.
613 * by doing so, when a monster is created, it has good starting 666 * by doing so, when a monster is created, it has good starting
623object * 676object *
624object::clone () 677object::clone ()
625{ 678{
626 object *neu = create (); 679 object *neu = create ();
627 copy_to (neu); 680 copy_to (neu);
681 neu->map = map; // not copied by copy_to
628 return neu; 682 return neu;
629} 683}
630 684
631/* 685/*
632 * If an object with the IS_TURNABLE() flag needs to be turned due 686 * If an object with the IS_TURNABLE() flag needs to be turned due
683 * UP_OBJ_FACE: only the objects face has changed. 737 * UP_OBJ_FACE: only the objects face has changed.
684 */ 738 */
685void 739void
686update_object (object *op, int action) 740update_object (object *op, int action)
687{ 741{
688 if (op == NULL) 742 if (!op)
689 { 743 {
690 /* this should never happen */ 744 /* this should never happen */
691 LOG (llevDebug, "update_object() called for NULL object.\n"); 745 LOG (llevError | logBacktrace, "update_object() called for NULL object.\n");
692 return; 746 return;
693 } 747 }
694 748
695 if (op->env) 749 if (!op->is_on_map ())
696 { 750 {
697 /* Animation is currently handled by client, so nothing 751 /* Animation is currently handled by client, so nothing
698 * to do in this case. 752 * to do in this case.
699 */ 753 */
700 return; 754 return;
701 } 755 }
702
703 /* If the map is saving, don't do anything as everything is
704 * going to get freed anyways.
705 */
706 if (!op->map || op->map->in_memory == MAP_SAVING)
707 return;
708 756
709 /* make sure the object is within map boundaries */ 757 /* make sure the object is within map boundaries */
710 if (op->x < 0 || op->x >= op->map->width || op->y < 0 || op->y >= op->map->height) 758 if (op->x < 0 || op->x >= op->map->width || op->y < 0 || op->y >= op->map->height)
711 { 759 {
712 LOG (llevError, "update_object() called for object out of map!\n"); 760 LOG (llevError, "update_object() called for object out of map!\n");
772static int object_count; 820static int object_count;
773 821
774void object::link () 822void object::link ()
775{ 823{
776 assert (!index);//D 824 assert (!index);//D
777 uuid = gen_uuid (); 825 uuid = UUID::gen ();
778 count = ++object_count; 826 count = ++object_count;
779 827
780 refcnt_inc (); 828 refcnt_inc ();
781 objects.insert (this); 829 objects.insert (this);
782} 830}
855object::destroy_inv (bool drop_to_ground) 903object::destroy_inv (bool drop_to_ground)
856{ 904{
857 // need to check first, because the checks below might segfault 905 // need to check first, because the checks below might segfault
858 // as we might be on an invalid mapspace and crossfire code 906 // as we might be on an invalid mapspace and crossfire code
859 // is too buggy to ensure that the inventory is empty. 907 // is too buggy to ensure that the inventory is empty.
860 // corollary: if you create arrows etc. with stuff in tis inventory, 908 // corollary: if you create arrows etc. with stuff in its inventory,
861 // cf will crash below with off-map x and y 909 // cf will crash below with off-map x and y
862 if (!inv) 910 if (!inv)
863 return; 911 return;
864 912
865 /* Only if the space blocks everything do we not process - 913 /* Only if the space blocks everything do we not process -
866 * if some form of movement is allowed, let objects 914 * if some form of movement is allowed, let objects
867 * drop on that space. 915 * drop on that space.
868 */ 916 */
869 if (!drop_to_ground 917 if (!drop_to_ground
870 || !map 918 || !map
871 || map->in_memory != MAP_IN_MEMORY 919 || map->in_memory != MAP_ACTIVE
872 || map->nodrop 920 || map->nodrop
873 || ms ().move_block == MOVE_ALL) 921 || ms ().move_block == MOVE_ALL)
874 { 922 {
875 while (inv) 923 while (inv)
876 { 924 {
877 inv->destroy_inv (drop_to_ground); 925 inv->destroy_inv (false);
878 inv->destroy (); 926 inv->destroy ();
879 } 927 }
880 } 928 }
881 else 929 else
882 { /* Put objects in inventory onto this space */ 930 { /* Put objects in inventory onto this space */
888 || op->flag [FLAG_NO_DROP] 936 || op->flag [FLAG_NO_DROP]
889 || op->type == RUNE 937 || op->type == RUNE
890 || op->type == TRAP 938 || op->type == TRAP
891 || op->flag [FLAG_IS_A_TEMPLATE] 939 || op->flag [FLAG_IS_A_TEMPLATE]
892 || op->flag [FLAG_DESTROY_ON_DEATH]) 940 || op->flag [FLAG_DESTROY_ON_DEATH])
893 op->destroy (); 941 op->destroy (true);
894 else 942 else
895 map->insert (op, x, y); 943 map->insert (op, x, y);
896 } 944 }
897 } 945 }
898} 946}
902 object *op = new object; 950 object *op = new object;
903 op->link (); 951 op->link ();
904 return op; 952 return op;
905} 953}
906 954
955static struct freed_map : maptile
956{
957 freed_map ()
958 {
959 path = "<freed objects map>";
960 name = "/internal/freed_objects_map";
961 width = 3;
962 height = 3;
963 nodrop = 1;
964
965 alloc ();
966 in_memory = MAP_ACTIVE;
967 }
968} freed_map; // freed objects are moved here to avoid crashes
969
907void 970void
908object::do_destroy () 971object::do_destroy ()
909{ 972{
910 attachable::do_destroy ();
911
912 if (flag [FLAG_IS_LINKED]) 973 if (flag [FLAG_IS_LINKED])
913 remove_button_link (this); 974 remove_button_link (this);
914 975
915 if (flag [FLAG_FRIENDLY]) 976 if (flag [FLAG_FRIENDLY])
916 remove_friendly_object (this); 977 remove_friendly_object (this);
917 978
918 if (!flag [FLAG_REMOVED])
919 remove (); 979 remove ();
920 980
921 destroy_inv (true); 981 attachable::do_destroy ();
922 982
923 deactivate (); 983 deactivate ();
924 unlink (); 984 unlink ();
925 985
926 flag [FLAG_FREED] = 1; 986 flag [FLAG_FREED] = 1;
927 987
928 // hack to ensure that freed objects still have a valid map 988 // hack to ensure that freed objects still have a valid map
929 {
930 static maptile *freed_map; // freed objects are moved here to avoid crashes
931
932 if (!freed_map)
933 {
934 freed_map = new maptile;
935
936 freed_map->path = "<freed objects map>";
937 freed_map->name = "/internal/freed_objects_map";
938 freed_map->width = 3;
939 freed_map->height = 3;
940
941 freed_map->alloc ();
942 freed_map->in_memory = MAP_IN_MEMORY;
943 }
944
945 map = freed_map; 989 map = &freed_map;
946 x = 1; 990 x = 1;
947 y = 1; 991 y = 1;
948 }
949 992
950 if (more) 993 if (more)
951 { 994 {
952 more->destroy (); 995 more->destroy ();
953 more = 0; 996 more = 0;
966object::destroy (bool destroy_inventory) 1009object::destroy (bool destroy_inventory)
967{ 1010{
968 if (destroyed ()) 1011 if (destroyed ())
969 return; 1012 return;
970 1013
1014 if (!is_head () && !head->destroyed ())
1015 {
1016 LOG (llevError | logBacktrace, "tried to destroy the tail of an object");
1017 head->destroy (destroy_inventory);
1018 return;
1019 }
1020
971 if (destroy_inventory) 1021 destroy_inv (!destroy_inventory);
972 destroy_inv (false);
973 1022
974 if (is_head ()) 1023 if (is_head ())
975 if (sound_destroy) 1024 if (sound_destroy)
976 play_sound (sound_destroy); 1025 play_sound (sound_destroy);
977 else if (flag [FLAG_MONSTER]) 1026 else if (flag [FLAG_MONSTER])
978 play_sound (sound_find ("monster_destroy")); // quick hack, too lazy to create a generic mechanism 1027 play_sound (sound_find ("monster_destroy")); // quick hack, too lazy to create a generic mechanism
979 1028
980 attachable::destroy (); 1029 attachable::destroy ();
981}
982
983/*
984 * sub_weight() recursively (outwards) subtracts a number from the
985 * weight of an object (and what is carried by it's environment(s)).
986 */
987void
988sub_weight (object *op, signed long weight)
989{
990 while (op != NULL)
991 {
992 if (op->type == CONTAINER)
993 weight = (signed long) (weight * (100 - op->stats.Str) / 100);
994
995 op->carrying -= weight;
996 op = op->env;
997 }
998} 1030}
999 1031
1000/* op->remove (): 1032/* op->remove ():
1001 * This function removes the object op from the linked list of objects 1033 * This function removes the object op from the linked list of objects
1002 * which it is currently tied to. When this function is done, the 1034 * which it is currently tied to. When this function is done, the
1008object::do_remove () 1040object::do_remove ()
1009{ 1041{
1010 object *tmp, *last = 0; 1042 object *tmp, *last = 0;
1011 object *otmp; 1043 object *otmp;
1012 1044
1013 if (QUERY_FLAG (this, FLAG_REMOVED)) 1045 if (flag [FLAG_REMOVED])
1014 return; 1046 return;
1015 1047
1016 SET_FLAG (this, FLAG_REMOVED);
1017 INVOKE_OBJECT (REMOVE, this); 1048 INVOKE_OBJECT (REMOVE, this);
1049
1050 flag [FLAG_REMOVED] = true;
1018 1051
1019 if (more) 1052 if (more)
1020 more->remove (); 1053 more->remove ();
1021 1054
1022 /* 1055 /*
1023 * In this case, the object to be removed is in someones 1056 * In this case, the object to be removed is in someones
1024 * inventory. 1057 * inventory.
1025 */ 1058 */
1026 if (env) 1059 if (env)
1027 { 1060 {
1061 flag [FLAG_REMOVED] = false; // hack around the issue of visible_to checking flag_removed
1062 if (object *pl = visible_to ())
1063 esrv_del_item (pl->contr, count);
1064 flag [FLAG_REMOVED] = true; // hack around the issue of visible_to checking flag_removed
1065
1066 adjust_weight (env, -total_weight ());
1067
1068 *(above ? &above->below : &env->inv) = below;
1069
1028 if (nrof) 1070 if (below)
1029 sub_weight (env, weight * nrof); 1071 below->above = above;
1030 else 1072
1031 sub_weight (env, weight + carrying); 1073 /* we set up values so that it could be inserted into
1074 * the map, but we don't actually do that - it is up
1075 * to the caller to decide what we want to do.
1076 */
1077 map = env->map;
1078 x = env->x;
1079 y = env->y;
1080 above = 0;
1081 below = 0;
1082 env = 0;
1032 1083
1033 /* NO_FIX_PLAYER is set when a great many changes are being 1084 /* NO_FIX_PLAYER is set when a great many changes are being
1034 * made to players inventory. If set, avoiding the call 1085 * made to players inventory. If set, avoiding the call
1035 * to save cpu time. 1086 * to save cpu time.
1036 */ 1087 */
1037 if ((otmp = in_player ()) && otmp->contr && !QUERY_FLAG (otmp, FLAG_NO_FIX_PLAYER)) 1088 if ((otmp = in_player ()) && otmp->contr && !QUERY_FLAG (otmp, FLAG_NO_FIX_PLAYER))
1038 otmp->update_stats (); 1089 otmp->update_stats ();
1039
1040 if (above)
1041 above->below = below;
1042 else
1043 env->inv = below;
1044
1045 if (below)
1046 below->above = above;
1047
1048 /* we set up values so that it could be inserted into
1049 * the map, but we don't actually do that - it is up
1050 * to the caller to decide what we want to do.
1051 */
1052 x = env->x, y = env->y;
1053 map = env->map;
1054 above = 0, below = 0;
1055 env = 0;
1056 } 1090 }
1057 else if (map) 1091 else if (map)
1058 { 1092 {
1059 if (type == PLAYER)
1060 {
1061 // leaving a spot always closes any open container on the ground
1062 if (container && !container->env)
1063 // this causes spurious floorbox updates, but it ensures
1064 // that the CLOSE event is being sent.
1065 close_container ();
1066
1067 --map->players;
1068 map->touch ();
1069 }
1070
1071 map->dirty = true; 1093 map->dirty = true;
1072 mapspace &ms = this->ms (); 1094 mapspace &ms = this->ms ();
1095
1096 if (object *pl = ms.player ())
1097 {
1098 if (type == PLAYER) // this == pl(!)
1099 {
1100 // leaving a spot always closes any open container on the ground
1101 if (container && !container->env)
1102 // this causes spurious floorbox updates, but it ensures
1103 // that the CLOSE event is being sent.
1104 close_container ();
1105
1106 --map->players;
1107 map->touch ();
1108 }
1109 else if (pl->container == this)
1110 {
1111 // removing a container should close it
1112 close_container ();
1113 }
1114
1115 esrv_del_item (pl->contr, count);
1116 }
1073 1117
1074 /* link the object above us */ 1118 /* link the object above us */
1075 if (above) 1119 if (above)
1076 above->below = below; 1120 above->below = below;
1077 else 1121 else
1107 * removed (most likely destroyed), update the player view 1151 * removed (most likely destroyed), update the player view
1108 * appropriately. 1152 * appropriately.
1109 */ 1153 */
1110 pl->close_container (); 1154 pl->close_container ();
1111 1155
1156 //TODO: the floorbox prev/next might need updating
1157 //esrv_del_item (pl->contr, count);
1158 //TODO: update floorbox to preserve ordering
1159 if (pl->contr->ns)
1112 pl->contr->ns->floorbox_update (); 1160 pl->contr->ns->floorbox_update ();
1113 } 1161 }
1114 1162
1115 for (tmp = ms.bot; tmp; tmp = tmp->above) 1163 for (tmp = ms.bot; tmp; tmp = tmp->above)
1116 { 1164 {
1117 /* No point updating the players look faces if he is the object 1165 /* No point updating the players look faces if he is the object
1161 if (!top) 1209 if (!top)
1162 for (top = op; top && top->above; top = top->above) 1210 for (top = op; top && top->above; top = top->above)
1163 ; 1211 ;
1164 1212
1165 for (; top; top = top->below) 1213 for (; top; top = top->below)
1166 {
1167 if (top == op)
1168 continue;
1169
1170 if (object::can_merge (op, top)) 1214 if (object::can_merge (op, top))
1171 { 1215 {
1172 top->nrof += op->nrof; 1216 top->nrof += op->nrof;
1173 1217
1174/* CLEAR_FLAG(top,FLAG_STARTEQUIP);*/ 1218 if (object *pl = top->visible_to ())
1175 op->weight = 0; /* Don't want any adjustements now */ 1219 esrv_update_item (UPD_NROF, pl, top);
1220
1221 op->weight = 0; // cancel the addition above
1222 op->carrying = 0; // must be 0 already
1223
1176 op->destroy (); 1224 op->destroy (1);
1225
1177 return top; 1226 return top;
1178 } 1227 }
1179 }
1180 1228
1181 return 0; 1229 return 0;
1182} 1230}
1183 1231
1184void 1232void
1243object * 1291object *
1244insert_ob_in_map (object *op, maptile *m, object *originator, int flag) 1292insert_ob_in_map (object *op, maptile *m, object *originator, int flag)
1245{ 1293{
1246 assert (!op->flag [FLAG_FREED]); 1294 assert (!op->flag [FLAG_FREED]);
1247 1295
1248 object *top, *floor = NULL;
1249
1250 op->remove (); 1296 op->remove ();
1251 1297
1252 /* Ideally, the caller figures this out. However, it complicates a lot 1298 /* Ideally, the caller figures this out. However, it complicates a lot
1253 * of areas of callers (eg, anything that uses find_free_spot would now 1299 * of areas of callers (eg, anything that uses find_free_spot would now
1254 * need extra work 1300 * need extra work
1255 */ 1301 */
1256 if (!xy_normalise (m, op->x, op->y)) 1302 if (!xy_normalise (m, op->x, op->y))
1257 { 1303 {
1258 op->destroy (); 1304 op->destroy (1);
1259 return 0; 1305 return 0;
1260 } 1306 }
1261 1307
1262 if (object *more = op->more) 1308 if (object *more = op->more)
1263 if (!insert_ob_in_map (more, m, originator, flag)) 1309 if (!insert_ob_in_map (more, m, originator, flag))
1272 */ 1318 */
1273 if (op->nrof && !(flag & INS_NO_MERGE)) 1319 if (op->nrof && !(flag & INS_NO_MERGE))
1274 for (object *tmp = ms.bot; tmp; tmp = tmp->above) 1320 for (object *tmp = ms.bot; tmp; tmp = tmp->above)
1275 if (object::can_merge (op, tmp)) 1321 if (object::can_merge (op, tmp))
1276 { 1322 {
1323 // TODO: we atcually want to update tmp, not op,
1324 // but some caller surely breaks when we return tmp
1325 // from here :/
1277 op->nrof += tmp->nrof; 1326 op->nrof += tmp->nrof;
1278 tmp->destroy (); 1327 tmp->destroy (1);
1279 } 1328 }
1280 1329
1281 CLEAR_FLAG (op, FLAG_APPLIED); /* hack for fixing F_APPLIED in items of dead people */ 1330 CLEAR_FLAG (op, FLAG_APPLIED); /* hack for fixing F_APPLIED in items of dead people */
1282 CLEAR_FLAG (op, FLAG_INV_LOCKED); 1331 CLEAR_FLAG (op, FLAG_INV_LOCKED);
1283 1332
1303 /* since *below* originator, no need to update top */ 1352 /* since *below* originator, no need to update top */
1304 originator->below = op; 1353 originator->below = op;
1305 } 1354 }
1306 else 1355 else
1307 { 1356 {
1357 object *top, *floor = NULL;
1358
1308 top = ms.bot; 1359 top = ms.bot;
1309 1360
1310 /* If there are other objects, then */ 1361 /* If there are other objects, then */
1311 if (top) 1362 if (top)
1312 { 1363 {
1411 } 1462 }
1412 1463
1413 op->map->dirty = true; 1464 op->map->dirty = true;
1414 1465
1415 if (object *pl = ms.player ()) 1466 if (object *pl = ms.player ())
1467 //TODO: the floorbox prev/next might need updating
1468 //esrv_send_item (pl, op);
1469 //TODO: update floorbox to preserve ordering
1470 if (pl->contr->ns)
1416 pl->contr->ns->floorbox_update (); 1471 pl->contr->ns->floorbox_update ();
1417 1472
1418 /* If this object glows, it may affect lighting conditions that are 1473 /* If this object glows, it may affect lighting conditions that are
1419 * visible to others on this map. But update_all_los is really 1474 * visible to others on this map. But update_all_los is really
1420 * an inefficient way to do this, as it means los for all players 1475 * an inefficient way to do this, as it means los for all players
1421 * on the map will get recalculated. The players could very well 1476 * on the map will get recalculated. The players could very well
1463 * op is the object to insert it under: supplies x and the map. 1518 * op is the object to insert it under: supplies x and the map.
1464 */ 1519 */
1465void 1520void
1466replace_insert_ob_in_map (const char *arch_string, object *op) 1521replace_insert_ob_in_map (const char *arch_string, object *op)
1467{ 1522{
1468 object *tmp, *tmp1;
1469
1470 /* first search for itself and remove any old instances */ 1523 /* first search for itself and remove any old instances */
1471 1524
1472 for (tmp = op->ms ().bot; tmp; tmp = tmp->above) 1525 for (object *tmp = op->ms ().bot; tmp; tmp = tmp->above)
1473 if (!strcmp (tmp->arch->archname, arch_string)) /* same archetype */ 1526 if (!strcmp (tmp->arch->archname, arch_string)) /* same archetype */
1474 tmp->destroy (); 1527 tmp->destroy (1);
1475 1528
1476 tmp1 = arch_to_object (archetype::find (arch_string)); 1529 object *tmp = arch_to_object (archetype::find (arch_string));
1477 1530
1478 tmp1->x = op->x; 1531 tmp->x = op->x;
1479 tmp1->y = op->y; 1532 tmp->y = op->y;
1533
1480 insert_ob_in_map (tmp1, op->map, op, 0); 1534 insert_ob_in_map (tmp, op->map, op, 0);
1481} 1535}
1482 1536
1483object * 1537object *
1484object::insert_at (object *where, object *originator, int flags) 1538object::insert_at (object *where, object *originator, int flags)
1485{ 1539{
1540 if (where->env)
1541 return where->env->insert (this);
1542 else
1486 return where->map->insert (this, where->x, where->y, originator, flags); 1543 return where->map->insert (this, where->x, where->y, originator, flags);
1487} 1544}
1488 1545
1489/* 1546/*
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_IN_MEMORY)
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 1547 * decrease(object, number) decreases a specified number from
1531 * the amount of an object. If the amount reaches 0, the object 1548 * the amount of an object. If the amount reaches 0, the object
1532 * is subsequently removed and freed. 1549 * is subsequently removed and freed.
1533 * 1550 *
1534 * Return value: 'op' if something is left, NULL if the amount reached 0 1551 * Return value: 'op' if something is left, NULL if the amount reached 0
1535 */ 1552 */
1553bool
1554object::decrease (sint32 nr)
1555{
1556 if (!nr)
1557 return true;
1558
1559 nr = min (nr, nrof);
1560
1561 nrof -= nr;
1562
1563 if (nrof)
1564 {
1565 adjust_weight (env, -weight * nr); // carrying == 0
1566
1567 if (object *pl = visible_to ())
1568 esrv_update_item (UPD_NROF, pl, this);
1569
1570 return true;
1571 }
1572 else
1573 {
1574 destroy (1);
1575 return false;
1576 }
1577}
1578
1579/*
1580 * split(ob,nr) splits up ob into two parts. The part which
1581 * is returned contains nr objects, and the remaining parts contains
1582 * the rest (or is removed and returned if that number is 0).
1583 * On failure, NULL is returned.
1584 */
1536object * 1585object *
1537decrease_ob_nr (object *op, uint32 i) 1586object::split (sint32 nr)
1538{ 1587{
1539 object *tmp; 1588 int have = number_of ();
1540 1589
1541 if (i == 0) /* objects with op->nrof require this check */ 1590 if (have < nr)
1542 return op; 1591 return 0;
1543 1592 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 { 1593 {
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 (); 1594 remove ();
1579 op->nrof = 0; 1595 return this;
1580 if (tmp)
1581 esrv_del_item (tmp->contr, op->count);
1582 }
1583 } 1596 }
1584 else 1597 else
1585 { 1598 {
1586 object *above = op->above; 1599 decrease (nr);
1587 1600
1588 if (i < op->nrof) 1601 object *op = object_create_clone (this);
1589 op->nrof -= i; 1602 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; 1603 return op;
1609 else
1610 {
1611 op->destroy ();
1612 return 0;
1613 }
1614}
1615
1616/*
1617 * add_weight(object, weight) adds the specified weight to an object,
1618 * and also updates how much the environment(s) is/are carrying.
1619 */
1620void
1621add_weight (object *op, signed long weight)
1622{
1623 while (op != NULL)
1624 {
1625 if (op->type == CONTAINER)
1626 weight = (signed long) (weight * (100 - op->stats.Str) / 100);
1627
1628 op->carrying += weight;
1629 op = op->env;
1630 } 1604 }
1631} 1605}
1632 1606
1633object * 1607object *
1634insert_ob_in_ob (object *op, object *where) 1608insert_ob_in_ob (object *op, object *where)
1659 * be != op, if items are merged. -Tero 1633 * be != op, if items are merged. -Tero
1660 */ 1634 */
1661object * 1635object *
1662object::insert (object *op) 1636object::insert (object *op)
1663{ 1637{
1664 if (!QUERY_FLAG (op, FLAG_REMOVED))
1665 op->remove ();
1666
1667 if (op->more) 1638 if (op->more)
1668 { 1639 {
1669 LOG (llevError, "Tried to insert multipart object %s (%d)\n", &op->name, op->count); 1640 LOG (llevError, "Tried to insert multipart object %s (%d)\n", &op->name, op->count);
1670 return op; 1641 return op;
1671 } 1642 }
1672 1643
1673 CLEAR_FLAG (op, FLAG_OBJ_ORIGINAL); 1644 op->remove ();
1674 CLEAR_FLAG (op, FLAG_REMOVED); 1645
1646 op->flag [FLAG_OBJ_ORIGINAL] = 0;
1675 1647
1676 if (op->nrof) 1648 if (op->nrof)
1677 {
1678 for (object *tmp = inv; tmp; tmp = tmp->below) 1649 for (object *tmp = inv; tmp; tmp = tmp->below)
1679 if (object::can_merge (tmp, op)) 1650 if (object::can_merge (tmp, op))
1680 { 1651 {
1681 /* return the original object and remove inserted object 1652 /* return the original object and remove inserted object
1682 (client needs the original object) */ 1653 (client needs the original object) */
1683 tmp->nrof += op->nrof; 1654 tmp->nrof += op->nrof;
1684 /* Weight handling gets pretty funky. Since we are adding to 1655
1685 * tmp->nrof, we need to increase the weight. 1656 if (object *pl = tmp->visible_to ())
1686 */ 1657 esrv_update_item (UPD_NROF, pl, tmp);
1658
1687 add_weight (this, op->weight * op->nrof); 1659 adjust_weight (this, op->total_weight ());
1688 SET_FLAG (op, FLAG_REMOVED); 1660
1689 op->destroy (); /* free the inserted object */ 1661 op->destroy (1);
1690 op = tmp; 1662 op = tmp;
1691 op->remove (); /* and fix old object's links */ 1663 goto inserted;
1692 CLEAR_FLAG (op, FLAG_REMOVED);
1693 break;
1694 } 1664 }
1695 1665
1696 /* I assume combined objects have no inventory
1697 * We add the weight - this object could have just been removed
1698 * (if it was possible to merge). calling remove_ob will subtract
1699 * the weight, so we need to add it in again, since we actually do
1700 * the linking below
1701 */
1702 add_weight (this, op->weight * op->nrof);
1703 }
1704 else
1705 add_weight (this, (op->weight + op->carrying));
1706
1707 if (object *otmp = this->in_player ())
1708 if (otmp->contr && !QUERY_FLAG (otmp, FLAG_NO_FIX_PLAYER))
1709 otmp->update_stats ();
1710
1711 op->owner = 0; // its his/hers now. period. 1666 op->owner = 0; // it's his/hers now. period.
1712 op->map = 0; 1667 op->map = 0;
1668 op->x = 0;
1669 op->y = 0;
1670
1671 op->above = 0;
1672 op->below = inv;
1713 op->env = this; 1673 op->env = this;
1714 op->above = 0;
1715 op->below = 0;
1716 op->x = op->y = 0;
1717 1674
1675 if (inv)
1676 inv->above = op;
1677
1678 inv = op;
1679
1680 op->flag [FLAG_REMOVED] = 0;
1681
1682 if (object *pl = op->visible_to ())
1683 esrv_send_item (pl, op);
1684
1685 adjust_weight (this, op->total_weight ());
1686
1687inserted:
1718 /* reset the light list and los of the players on the map */ 1688 /* reset the light list and los of the players on the map */
1719 if (op->glow_radius && map) 1689 if (op->glow_radius && map && map->darkness)
1720 {
1721#ifdef DEBUG_LIGHTS
1722 LOG (llevDebug, " insert_ob_in_ob(): got %s to insert in map/op\n", op->name);
1723#endif /* DEBUG_LIGHTS */
1724 if (map->darkness)
1725 update_all_los (map, x, y); 1690 update_all_los (map, x, y);
1726 }
1727 1691
1728 /* Client has no idea of ordering so lets not bother ordering it here. 1692 // if this is a player's inventory, update stats
1729 * It sure simplifies this function... 1693 if (type == PLAYER && !flag [FLAG_NO_FIX_PLAYER])
1730 */ 1694 update_stats ();
1731 if (!inv)
1732 inv = op;
1733 else
1734 {
1735 op->below = inv;
1736 op->below->above = op;
1737 inv = op;
1738 }
1739 1695
1740 INVOKE_OBJECT (INSERT, this); 1696 INVOKE_OBJECT (INSERT, this);
1741 1697
1742 return op; 1698 return op;
1743} 1699}
2367 * create clone from object to another 2323 * create clone from object to another
2368 */ 2324 */
2369object * 2325object *
2370object_create_clone (object *asrc) 2326object_create_clone (object *asrc)
2371{ 2327{
2372 object *dst = 0, *tmp, *src, *prev, *item; 2328 object *dst = 0;
2373 2329
2374 if (!asrc) 2330 if (!asrc)
2375 return 0; 2331 return 0;
2376 2332
2377 src = asrc->head_ (); 2333 object *src = asrc->head_ ();
2378 2334
2379 prev = 0; 2335 object *prev = 0;
2380 for (object *part = src; part; part = part->more) 2336 for (object *part = src; part; part = part->more)
2381 { 2337 {
2382 tmp = part->clone (); 2338 object *tmp = part->clone ();
2339
2383 tmp->x -= src->x; 2340 tmp->x -= src->x;
2384 tmp->y -= src->y; 2341 tmp->y -= src->y;
2385 2342
2386 if (!part->head) 2343 if (!part->head)
2387 { 2344 {
2397 prev->more = tmp; 2354 prev->more = tmp;
2398 2355
2399 prev = tmp; 2356 prev = tmp;
2400 } 2357 }
2401 2358
2402 for (item = src->inv; item; item = item->below) 2359 for (object *item = src->inv; item; item = item->below)
2403 insert_ob_in_ob (object_create_clone (item), dst); 2360 insert_ob_in_ob (object_create_clone (item), dst);
2404 2361
2405 return dst; 2362 return dst;
2406} 2363}
2407 2364
2613{ 2570{
2614 char flagdesc[512]; 2571 char flagdesc[512];
2615 char info2[256 * 4]; 2572 char info2[256 * 4];
2616 char *p = info; 2573 char *p = info;
2617 2574
2618 p += snprintf (p, 512, "{cnt:%d,uuid:<1.%" PRIx64 ">,name:\"%s\"%s%s,flags:[%s],type:%d}", 2575 p += snprintf (p, 512, "{cnt:%d,uuid:%s,name:\"%s\"%s%s,flags:[%s],type:%d}",
2619 count, uuid.seq, 2576 count,
2577 uuid.c_str (),
2620 &name, 2578 &name,
2621 title ? "\",title:\"" : "", 2579 title ? "\",title:\"" : "",
2622 title ? (const char *)title : "", 2580 title ? (const char *)title : "",
2623 flag_desc (flagdesc, 512), type); 2581 flag_desc (flagdesc, 512), type);
2624 2582
2625 if (!this->flag[FLAG_REMOVED] && env) 2583 if (!flag[FLAG_REMOVED] && env)
2626 p += snprintf (p, 256, "(in %s)", env->debug_desc (info2)); 2584 p += snprintf (p, 256, "(in %s)", env->debug_desc (info2));
2627 2585
2628 if (map) 2586 if (map)
2629 p += snprintf (p, 256, "(on %s@%d+%d)", &map->path, x, y); 2587 p += snprintf (p, 256, "(on %s@%d+%d)", &map->path, x, y);
2630 2588
2660object::open_container (object *new_container) 2618object::open_container (object *new_container)
2661{ 2619{
2662 if (container == new_container) 2620 if (container == new_container)
2663 return; 2621 return;
2664 2622
2665 if (object *old_container = container) 2623 object *old_container = container;
2624
2625 if (old_container)
2666 { 2626 {
2667 if (INVOKE_OBJECT (CLOSE, old_container, ARG_OBJECT (this))) 2627 if (INVOKE_OBJECT (CLOSE, old_container, ARG_OBJECT (this)))
2668 return; 2628 return;
2669 2629
2670#if 0 2630#if 0
2672 if (object *closer = old_container->inv) 2632 if (object *closer = old_container->inv)
2673 if (closer->type == CLOSE_CON) 2633 if (closer->type == CLOSE_CON)
2674 closer->destroy (); 2634 closer->destroy ();
2675#endif 2635#endif
2676 2636
2637 // make sure the container is available
2638 esrv_send_item (this, old_container);
2639
2677 old_container->flag [FLAG_APPLIED] = 0; 2640 old_container->flag [FLAG_APPLIED] = false;
2678 container = 0; 2641 container = 0;
2679 2642
2643 // client needs item update to make it work, client bug requires this to be separate
2680 esrv_update_item (UPD_FLAGS, this, old_container); 2644 esrv_update_item (UPD_FLAGS, this, old_container);
2645
2681 new_draw_info_format (NDI_UNIQUE, 0, this, "You close %s.", query_name (old_container)); 2646 new_draw_info_format (NDI_UNIQUE, 0, this, "You close %s.", query_name (old_container));
2682 play_sound (sound_find ("chest_close")); 2647 play_sound (sound_find ("chest_close"));
2683 } 2648 }
2684 2649
2685 if (new_container) 2650 if (new_container)
2698 } 2663 }
2699#endif 2664#endif
2700 2665
2701 new_draw_info_format (NDI_UNIQUE, 0, this, "You open %s.", query_name (new_container)); 2666 new_draw_info_format (NDI_UNIQUE, 0, this, "You open %s.", query_name (new_container));
2702 2667
2668 // make sure the container is available, client bug requires this to be separate
2669 esrv_send_item (this, new_container);
2670
2703 new_container->flag [FLAG_APPLIED] = 1; 2671 new_container->flag [FLAG_APPLIED] = true;
2704 container = new_container; 2672 container = new_container;
2705 2673
2674 // client needs flag change
2706 esrv_update_item (UPD_FLAGS, this, new_container); 2675 esrv_update_item (UPD_FLAGS, this, new_container);
2707 esrv_send_inventory (this, new_container); 2676 esrv_send_inventory (this, new_container);
2708 play_sound (sound_find ("chest_open")); 2677 play_sound (sound_find ("chest_open"));
2709 } 2678 }
2679// else if (!old_container->env && contr && contr->ns)
2680// contr->ns->floorbox_reset ();
2710} 2681}
2711 2682
2712object * 2683object *
2713object::force_find (const shstr name) 2684object::force_find (const shstr name)
2714{ 2685{
2740 2711
2741 insert (force); 2712 insert (force);
2742} 2713}
2743 2714
2744void 2715void
2745object::play_sound (faceidx sound) const 2716object::play_sound (faceidx sound)
2746{ 2717{
2747 if (!sound) 2718 if (!sound)
2748 return; 2719 return;
2749 2720
2750 if (flag [FLAG_REMOVED]) 2721 if (flag [FLAG_REMOVED])

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines