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.139 by root, Sat Apr 21 17:34:22 2007 UTC vs.
Revision 1.215 by root, Tue Apr 22 07:28:05 2008 UTC

1/* 1/*
2 * CrossFire, A Multiplayer game for X-windows 2 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
3 * 3 *
4 * Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team 4 * Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5 * Copyright (C) 2001 Mark Wedel & Crossfire Development Team 5 * Copyright (©) 2001,2007 Mark Wedel & Crossfire Development Team
6 * Copyright (C) 1992 Frank Tore Johansen 6 * Copyright (©) 1992,2007 Frank Tore Johansen
7 * 7 *
8 * This program 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
10 * the Free Software Foundation; either version 2 of the License, or 10 * the Free Software Foundation, either version 3 of the License, or
11 * (at your option) any later version. 11 * (at your option) any later version.
12 * 12 *
13 * This program is distributed in the hope that it will be useful, 13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details. 16 * GNU General Public License for more details.
17 * 17 *
18 * You should have received a copy of the GNU General Public License 18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software 19 * along with this program. If not, see <http://www.gnu.org/licenses/>.
20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 * 20 *
22 * The authors can be reached via e-mail at <crossfire@schmorp.de> 21 * The authors can be reached via e-mail to <support@deliantra.net>
23 */ 22 */
24 23
25/* Eneq(@csd.uu.se): Added weight-modifiers in environment of objects.
26 sub/add_weight will transcend the environment updating the carrying
27 variable. */
28#include <global.h> 24#include <global.h>
29#include <stdio.h> 25#include <stdio.h>
30#include <sys/types.h> 26#include <sys/types.h>
31#include <sys/uio.h> 27#include <sys/uio.h>
32#include <object.h> 28#include <object.h>
33#include <funcpoint.h> 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 one object has inventory but the other doesn't, not equiv */ 264 if (!(ob1->inv && ob2->inv))
260 if ((ob1->inv && !ob2->inv) || (ob2->inv && !ob1->inv)) 265 return 0; /* inventories differ in length */
261 return 0;
262 266
263 /* Now check to see if the two inventory objects could merge */ 267 if (ob1->inv->below || ob2->inv->below)
268 return 0; /* more than one object in inv */
269
264 if (!object::can_merge (ob1->inv, ob2->inv)) 270 if (!object::can_merge (ob1->inv, ob2->inv))
265 return 0; 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. */
305
306 if (!compare_ob_value_lists (ob1, ob2))
299 return 0; 307 return 0;
300 else if (!compare_ob_value_lists (ob1, ob2))
301 return 0;
302 } 308 }
303 309
304 //TODO: generate an event or call into perl for additional checks
305 if (ob1->self || ob2->self) 310 if (ob1->self || ob2->self)
306 { 311 {
307 ob1->optimise (); 312 ob1->optimise ();
308 ob2->optimise (); 313 ob2->optimise ();
309 314
310 if (ob1->self || ob2->self) 315 if (ob1->self || ob2->self)
316 {
317 int k1 = ob1->self ? HvTOTALKEYS (ob1->self) : 0;
318 int k2 = ob2->self ? HvTOTALKEYS (ob2->self) : 0;
319
320 if (k1 != k2)
311 return 0; 321 return 0;
322
323 if (k1 == 0)
324 return 1;
325
326 if (!cfperl_can_merge (ob1, ob2))
327 return 0;
328 }
312 } 329 }
313 330
314 /* Everything passes, must be OK. */ 331 /* Everything passes, must be OK. */
315 return 1; 332 return 1;
316} 333}
317 334
335// find player who can see this object
336object *
337object::visible_to () const
338{
339 if (!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 return pl;
364 }
365 }
366
367 return 0;
368}
369
370// adjust weight per container type ("of holding")
371static sint32
372weight_adjust (object *op, sint32 weight)
373{
374 return op->type == CONTAINER
375 ? lerp (weight, 0, 100, 0, 100 - op->stats.Str)
376 : weight;
377}
378
318/* 379/*
380 * adjust_weight(object, weight) adds the specified weight to an object,
381 * and also updates how much the environment(s) is/are carrying.
382 */
383static void
384adjust_weight (object *op, sint32 weight)
385{
386 while (op)
387 {
388 weight = weight_adjust (op, weight);
389
390 if (!weight)
391 return;
392
393 op->carrying += weight;
394
395 if (object *pl = op->visible_to ())
396 if (pl != op) // player is handled lazily
397 esrv_update_item (UPD_WEIGHT, pl, op);
398
399 op = op->env;
400 }
401}
402
403/*
319 * sum_weight() is a recursive function which calculates the weight 404 * this is a recursive function which calculates the weight
320 * an object is carrying. It goes through in figures out how much 405 * an object is carrying. It goes through op and figures out how much
321 * containers are carrying, and sums it up. 406 * containers are carrying, and sums it up.
322 */ 407 */
323long 408void
324sum_weight (object *op) 409object::update_weight ()
325{ 410{
326 long sum; 411 sint32 sum = 0;
327 object *inv;
328 412
329 for (sum = 0, inv = op->inv; inv != NULL; inv = inv->below) 413 for (object *op = inv; op; op = op->below)
330 { 414 {
331 if (inv->inv) 415 if (op->inv)
332 sum_weight (inv); 416 op->update_weight ();
333 sum += inv->carrying + inv->weight * (inv->nrof ? inv->nrof : 1); 417
418 sum += op->total_weight ();
419 }
420
421 sum = weight_adjust (this, sum);
422
423 if (sum != carrying)
334 } 424 {
335
336 if (op->type == CONTAINER && op->stats.Str)
337 sum = (sum * (100 - op->stats.Str)) / 100;
338
339 if (op->carrying != sum)
340 op->carrying = sum; 425 carrying = sum;
341 426
342 return sum; 427 if (object *pl = visible_to ())
428 if (pl != this) // player is handled lazily
429 esrv_update_item (UPD_WEIGHT, pl, this);
430 }
343} 431}
344 432
345/** 433/*
346 * Return the outermost environment object for a given object. 434 * Used by: Server DM commands: dumpbelow, dump. Some error messages.
347 */
348
349object *
350object_get_env_recursive (object *op)
351{
352 while (op->env != NULL)
353 op = op->env;
354 return op;
355}
356
357/*
358 * Used by: Crossedit: dump. Server DM commands: dumpbelow, dump.
359 * Some error messages.
360 * The result of the dump is stored in the static global errmsg array.
361 */ 435 */
362char * 436char *
363dump_object (object *op) 437dump_object (object *op)
364{ 438{
365 if (!op) 439 if (!op)
373/* 447/*
374 * get_nearest_part(multi-object, object 2) returns the part of the 448 * get_nearest_part(multi-object, object 2) returns the part of the
375 * multi-object 1 which is closest to the second object. 449 * multi-object 1 which is closest to the second object.
376 * If it's not a multi-object, it is returned. 450 * If it's not a multi-object, it is returned.
377 */ 451 */
378
379object * 452object *
380get_nearest_part (object *op, const object *pl) 453get_nearest_part (object *op, const object *pl)
381{ 454{
382 object *tmp, *closest; 455 object *tmp, *closest;
383 int last_dist, i; 456 int last_dist, i;
384 457
385 if (op->more == NULL) 458 if (!op->more)
386 return op; 459 return op;
460
387 for (last_dist = distance (op, pl), closest = op, tmp = op->more; tmp != NULL; tmp = tmp->more) 461 for (last_dist = distance (op, pl), closest = op, tmp = op->more;
462 tmp;
463 tmp = tmp->more)
388 if ((i = distance (tmp, pl)) < last_dist) 464 if ((i = distance (tmp, pl)) < last_dist)
389 closest = tmp, last_dist = i; 465 closest = tmp, last_dist = i;
466
390 return closest; 467 return closest;
391} 468}
392 469
393/* 470/*
394 * Returns the object which has the count-variable equal to the argument. 471 * Returns the object which has the count-variable equal to the argument.
472 * VERRRY slow.
395 */ 473 */
396object * 474object *
397find_object (tag_t i) 475find_object (tag_t i)
398{ 476{
399 for_all_objects (op) 477 for_all_objects (op)
419 break; 497 break;
420 498
421 return op; 499 return op;
422} 500}
423 501
424void
425free_all_object_data ()
426{
427 LOG (llevDebug, "%d allocated objects\n", nrofallocobjects);
428}
429
430/* 502/*
431 * Sets the owner and sets the skill and exp pointers to owner's current 503 * Sets the owner and sets the skill and exp pointers to owner's current
432 * skill and experience objects. 504 * skill and experience objects.
505 * ACTUALLY NO! investigate! TODO
433 */ 506 */
434void 507void
435object::set_owner (object *owner) 508object::set_owner (object *owner)
436{ 509{
510 // allow objects which own objects
437 if (!owner) 511 if (owner)
438 return;
439
440 /* next line added to allow objects which own objects */
441 /* Add a check for ownercounts in here, as I got into an endless loop
442 * with the fireball owning a poison cloud which then owned the
443 * fireball. I believe that was caused by one of the objects getting
444 * freed and then another object replacing it. Since the ownercounts
445 * didn't match, this check is valid and I believe that cause is valid.
446 */
447 while (owner->owner) 512 while (owner->owner)
448 owner = owner->owner; 513 owner = owner->owner;
514
515 if (flag [FLAG_FREED])
516 {
517 LOG (llevError | logBacktrace, "tried to set owner of %s to %s\n", debug_desc (), owner->debug_desc ());
518 return;
519 }
449 520
450 this->owner = owner; 521 this->owner = owner;
522}
523
524int
525object::slottype () const
526{
527 if (type == SKILL)
528 {
529 if (IS_COMBAT_SKILL (subtype)) return slot_combat;
530 if (IS_RANGED_SKILL (subtype)) return slot_ranged;
531 }
532 else
533 {
534 if (slot [body_combat].info) return slot_combat;
535 if (slot [body_range ].info) return slot_ranged;
536 }
537
538 return slot_none;
539}
540
541bool
542object::change_weapon (object *ob)
543{
544 if (current_weapon == ob)
545 return true;
546
547 if (chosen_skill)
548 chosen_skill->flag [FLAG_APPLIED] = false;
549
550 current_weapon = ob;
551 chosen_skill = !ob || ob->type == SKILL ? ob : find_skill_by_name (this, ob->skill);
552
553 if (chosen_skill)
554 chosen_skill->flag [FLAG_APPLIED] = true;
555
556 update_stats ();
557
558 if (ob)
559 {
560 // now check wether any body locations became invalid, in which case
561 // we cannot apply the weapon at the moment.
562 for (int i = 0; i < NUM_BODY_LOCATIONS; ++i)
563 if (slot[i].used < 0)
564 {
565 current_weapon = chosen_skill = 0;
566 update_stats ();
567
568 new_draw_info_format (NDI_UNIQUE, 0, this,
569 "You try to balance all your items at once, "
570 "but the %s is just too much for your body. "
571 "[You need to unapply some items first.]", &ob->name);
572 return false;
573 }
574
575 //new_draw_info_format (NDI_UNIQUE, 0, this, "You switch to your %s.", &ob->name);
576 }
577 else
578 ;//new_draw_info_format (NDI_UNIQUE, 0, this, "You unwield your weapons.");
579
580 if (ob && !ob->flag [FLAG_APPLIED] && ob->type != SPELL)
581 {
582 LOG (llevError | logBacktrace, "%s changed to unapplied weapon %s",
583 &name, ob->debug_desc ());
584 return false;
585 }
586
587 return true;
451} 588}
452 589
453/* Zero the key_values on op, decrementing the shared-string 590/* Zero the key_values on op, decrementing the shared-string
454 * refcounts and freeing the links. 591 * refcounts and freeing the links.
455 */ 592 */
519object::copy_to (object *dst) 656object::copy_to (object *dst)
520{ 657{
521 *dst = *this; 658 *dst = *this;
522 659
523 if (speed < 0) 660 if (speed < 0)
524 dst->speed_left = speed_left - rndm (); 661 dst->speed_left -= rndm ();
525 662
526 dst->set_speed (dst->speed); 663 dst->set_speed (dst->speed);
527} 664}
528 665
529void 666void
530object::instantiate () 667object::instantiate ()
531{ 668{
532 if (!uuid.seq) // HACK 669 if (!uuid.seq) // HACK
533 uuid = gen_uuid (); 670 uuid = UUID::gen ();
534 671
535 speed_left = -0.1f; 672 speed_left = -0.1f;
536 /* copy the body_info to the body_used - this is only really 673 /* copy the body_info to the body_used - this is only really
537 * need for monsters, but doesn't hurt to do it for everything. 674 * need for monsters, but doesn't hurt to do it for everything.
538 * by doing so, when a monster is created, it has good starting 675 * by doing so, when a monster is created, it has good starting
539 * values for the body_used info, so when items are created 676 * values for the body_used info, so when items are created
540 * for it, they can be properly equipped. 677 * for it, they can be properly equipped.
541 */ 678 */
542 memcpy (body_used, body_info, sizeof (body_used)); 679 for (int i = NUM_BODY_LOCATIONS; i--; )
680 slot[i].used = slot[i].info;
543 681
544 attachable::instantiate (); 682 attachable::instantiate ();
545} 683}
546 684
547object * 685object *
696static int object_count; 834static int object_count;
697 835
698void object::link () 836void object::link ()
699{ 837{
700 assert (!index);//D 838 assert (!index);//D
701 uuid = gen_uuid (); 839 uuid = UUID::gen ();
702 count = ++object_count; 840 count = ++object_count;
703 841
704 refcnt_inc (); 842 refcnt_inc ();
705 objects.insert (this); 843 objects.insert (this);
706} 844}
790 * if some form of movement is allowed, let objects 928 * if some form of movement is allowed, let objects
791 * drop on that space. 929 * drop on that space.
792 */ 930 */
793 if (!drop_to_ground 931 if (!drop_to_ground
794 || !map 932 || !map
795 || map->in_memory != MAP_IN_MEMORY 933 || map->in_memory != MAP_ACTIVE
796 || map->nodrop 934 || map->nodrop
797 || ms ().move_block == MOVE_ALL) 935 || ms ().move_block == MOVE_ALL)
798 { 936 {
799 while (inv) 937 while (inv)
800 { 938 {
829} 967}
830 968
831void 969void
832object::do_destroy () 970object::do_destroy ()
833{ 971{
834 attachable::do_destroy ();
835
836 if (flag [FLAG_IS_LINKED]) 972 if (flag [FLAG_IS_LINKED])
837 remove_button_link (this); 973 remove_button_link (this);
838 974
839 if (flag [FLAG_FRIENDLY]) 975 if (flag [FLAG_FRIENDLY])
840 {
841 remove_friendly_object (this); 976 remove_friendly_object (this);
842 977
843 if (type == GOLEM
844 && owner
845 && owner->type == PLAYER
846 && owner->contr->ranges[range_golem] == this)
847 owner->contr->ranges[range_golem] = 0;
848 }
849
850 if (!flag [FLAG_REMOVED])
851 remove (); 978 remove ();
979
980 attachable::do_destroy ();
852 981
853 destroy_inv (true); 982 destroy_inv (true);
854 983
855 deactivate (); 984 deactivate ();
856 unlink (); 985 unlink ();
863 992
864 if (!freed_map) 993 if (!freed_map)
865 { 994 {
866 freed_map = new maptile; 995 freed_map = new maptile;
867 996
997 freed_map->path = "<freed objects map>";
868 freed_map->name = "/internal/freed_objects_map"; 998 freed_map->name = "/internal/freed_objects_map";
869 freed_map->width = 3; 999 freed_map->width = 3;
870 freed_map->height = 3; 1000 freed_map->height = 3;
1001 freed_map->nodrop = 1;
871 1002
872 freed_map->alloc (); 1003 freed_map->alloc ();
873 freed_map->in_memory = MAP_IN_MEMORY; 1004 freed_map->in_memory = MAP_ACTIVE;
874 } 1005 }
875 1006
876 map = freed_map; 1007 map = freed_map;
877 x = 1; 1008 x = 1;
878 y = 1; 1009 y = 1;
879 } 1010 }
880 1011
881 head = 0;
882
883 if (more) 1012 if (more)
884 { 1013 {
885 more->destroy (); 1014 more->destroy ();
886 more = 0; 1015 more = 0;
887 } 1016 }
888 1017
1018 head = 0;
1019
889 // clear those pointers that likely might have circular references to us 1020 // clear those pointers that likely might cause circular references
890 owner = 0; 1021 owner = 0;
891 enemy = 0; 1022 enemy = 0;
892 attacked_by = 0; 1023 attacked_by = 0;
1024 current_weapon = 0;
893} 1025}
894 1026
895void 1027void
896object::destroy (bool destroy_inventory) 1028object::destroy (bool destroy_inventory)
897{ 1029{
899 return; 1031 return;
900 1032
901 if (destroy_inventory) 1033 if (destroy_inventory)
902 destroy_inv (false); 1034 destroy_inv (false);
903 1035
1036 if (is_head ())
1037 if (sound_destroy)
1038 play_sound (sound_destroy);
1039 else if (flag [FLAG_MONSTER])
1040 play_sound (sound_find ("monster_destroy")); // quick hack, too lazy to create a generic mechanism
1041
904 attachable::destroy (); 1042 attachable::destroy ();
905}
906
907/*
908 * sub_weight() recursively (outwards) subtracts a number from the
909 * weight of an object (and what is carried by it's environment(s)).
910 */
911void
912sub_weight (object *op, signed long weight)
913{
914 while (op != NULL)
915 {
916 if (op->type == CONTAINER)
917 weight = (signed long) (weight * (100 - op->stats.Str) / 100);
918
919 op->carrying -= weight;
920 op = op->env;
921 }
922} 1043}
923 1044
924/* op->remove (): 1045/* op->remove ():
925 * This function removes the object op from the linked list of objects 1046 * This function removes the object op from the linked list of objects
926 * which it is currently tied to. When this function is done, the 1047 * which it is currently tied to. When this function is done, the
932object::do_remove () 1053object::do_remove ()
933{ 1054{
934 object *tmp, *last = 0; 1055 object *tmp, *last = 0;
935 object *otmp; 1056 object *otmp;
936 1057
937 if (QUERY_FLAG (this, FLAG_REMOVED)) 1058 if (flag [FLAG_REMOVED])
938 return; 1059 return;
939 1060
940 SET_FLAG (this, FLAG_REMOVED);
941 INVOKE_OBJECT (REMOVE, this); 1061 INVOKE_OBJECT (REMOVE, this);
1062
1063 if (object *pl = visible_to ())
1064 esrv_del_item (pl->contr, count);
1065
1066 flag [FLAG_REMOVED] = true;
942 1067
943 if (more) 1068 if (more)
944 more->remove (); 1069 more->remove ();
945 1070
946 /* 1071 /*
947 * In this case, the object to be removed is in someones 1072 * In this case, the object to be removed is in someones
948 * inventory. 1073 * inventory.
949 */ 1074 */
950 if (env) 1075 if (env)
951 { 1076 {
1077 adjust_weight (env, -total_weight ());
1078
1079 *(above ? &above->below : &env->inv) = below;
1080
952 if (nrof) 1081 if (below)
953 sub_weight (env, weight * nrof); 1082 below->above = above;
954 else 1083
955 sub_weight (env, weight + carrying); 1084 /* we set up values so that it could be inserted into
1085 * the map, but we don't actually do that - it is up
1086 * to the caller to decide what we want to do.
1087 */
1088 map = env->map;
1089 x = env->x;
1090 y = env->y;
1091 above = 0;
1092 below = 0;
1093 env = 0;
956 1094
957 /* NO_FIX_PLAYER is set when a great many changes are being 1095 /* NO_FIX_PLAYER is set when a great many changes are being
958 * made to players inventory. If set, avoiding the call 1096 * made to players inventory. If set, avoiding the call
959 * to save cpu time. 1097 * to save cpu time.
960 */ 1098 */
961 if ((otmp = in_player ()) && otmp->contr && !QUERY_FLAG (otmp, FLAG_NO_FIX_PLAYER)) 1099 if ((otmp = in_player ()) && otmp->contr && !QUERY_FLAG (otmp, FLAG_NO_FIX_PLAYER))
962 otmp->update_stats (); 1100 otmp->update_stats ();
963
964 if (above)
965 above->below = below;
966 else
967 env->inv = below;
968
969 if (below)
970 below->above = above;
971
972 /* we set up values so that it could be inserted into
973 * the map, but we don't actually do that - it is up
974 * to the caller to decide what we want to do.
975 */
976 x = env->x, y = env->y;
977 map = env->map;
978 above = 0, below = 0;
979 env = 0;
980 } 1101 }
981 else if (map) 1102 else if (map)
982 { 1103 {
983 if (type == PLAYER) 1104 if (type == PLAYER)
984 { 1105 {
1022 if (map->in_memory == MAP_SAVING) 1143 if (map->in_memory == MAP_SAVING)
1023 return; 1144 return;
1024 1145
1025 int check_walk_off = !flag [FLAG_NO_APPLY]; 1146 int check_walk_off = !flag [FLAG_NO_APPLY];
1026 1147
1148 if (object *pl = ms.player ())
1149 {
1150 if (pl->container == this)
1151 /* If a container that the player is currently using somehow gets
1152 * removed (most likely destroyed), update the player view
1153 * appropriately.
1154 */
1155 pl->close_container ();
1156
1157 pl->contr->ns->floorbox_update ();
1158 }
1159
1027 for (tmp = ms.bot; tmp; tmp = tmp->above) 1160 for (tmp = ms.bot; tmp; tmp = tmp->above)
1028 { 1161 {
1029 /* No point updating the players look faces if he is the object 1162 /* No point updating the players look faces if he is the object
1030 * being removed. 1163 * being removed.
1031 */ 1164 */
1032
1033 if (tmp->type == PLAYER && tmp != this)
1034 {
1035 /* If a container that the player is currently using somehow gets
1036 * removed (most likely destroyed), update the player view
1037 * appropriately.
1038 */
1039 if (tmp->container == this)
1040 {
1041 flag [FLAG_APPLIED] = 0;
1042 tmp->container = 0;
1043 }
1044
1045 if (tmp->contr->ns)
1046 tmp->contr->ns->floorbox_update ();
1047 }
1048 1165
1049 /* See if object moving off should effect something */ 1166 /* See if object moving off should effect something */
1050 if (check_walk_off 1167 if (check_walk_off
1051 && ((move_type & tmp->move_off) 1168 && ((move_type & tmp->move_off)
1052 && (move_type & ~tmp->move_off & ~tmp->move_block) == 0)) 1169 && (move_type & ~tmp->move_off & ~tmp->move_block) == 0))
1055 1172
1056 if (destroyed ()) 1173 if (destroyed ())
1057 LOG (llevError, "BUG: remove_ob(): name %s, destroyed leaving object\n", tmp->debug_desc ()); 1174 LOG (llevError, "BUG: remove_ob(): name %s, destroyed leaving object\n", tmp->debug_desc ());
1058 } 1175 }
1059 1176
1060 /* Eneq(@csd.uu.se): Fixed this to skip tmp->above=tmp */
1061 //TODO: why is this horrible hacka fix? get rid of this code=bug! (schmorp)
1062 if (tmp->above == tmp)
1063 tmp->above = 0;
1064
1065 last = tmp; 1177 last = tmp;
1066 } 1178 }
1067 1179
1068 /* last == NULL if there are no objects on this space */ 1180 /* last == NULL if there are no objects on this space */
1069 //TODO: this makes little sense, why only update the topmost object? 1181 //TODO: this makes little sense, why only update the topmost object?
1089merge_ob (object *op, object *top) 1201merge_ob (object *op, object *top)
1090{ 1202{
1091 if (!op->nrof) 1203 if (!op->nrof)
1092 return 0; 1204 return 0;
1093 1205
1094 if (top) 1206 if (!top)
1095 for (top = op; top && top->above; top = top->above) 1207 for (top = op; top && top->above; top = top->above)
1096 ; 1208 ;
1097 1209
1098 for (; top; top = top->below) 1210 for (; top; top = top->below)
1099 {
1100 if (top == op)
1101 continue;
1102
1103 if (object::can_merge (op, top)) 1211 if (object::can_merge (op, top))
1104 { 1212 {
1105 top->nrof += op->nrof; 1213 top->nrof += op->nrof;
1106 1214
1107/* CLEAR_FLAG(top,FLAG_STARTEQUIP);*/ 1215 if (object *pl = top->visible_to ())
1108 op->weight = 0; /* Don't want any adjustements now */ 1216 esrv_update_item (UPD_NROF, pl, top);
1217
1218 op->weight = 0; // cancel the addition above
1219 op->carrying = 0; // must be 0 already
1220
1109 op->destroy (); 1221 op->destroy (1);
1222
1110 return top; 1223 return top;
1111 } 1224 }
1112 }
1113 1225
1114 return 0; 1226 return 0;
1115} 1227}
1116 1228
1117void 1229void
1120 if (more) 1232 if (more)
1121 return; 1233 return;
1122 1234
1123 object *prev = this; 1235 object *prev = this;
1124 1236
1125 for (archetype *at = arch->more; at; at = at->more) 1237 for (archetype *at = (archetype *)arch->more; at; at = (archetype *)at->more)
1126 { 1238 {
1127 object *op = arch_to_object (at); 1239 object *op = arch_to_object (at);
1128 1240
1129 op->name = name; 1241 op->name = name;
1130 op->name_pl = name_pl; 1242 op->name_pl = name_pl;
1144object * 1256object *
1145insert_ob_in_map_at (object *op, maptile *m, object *originator, int flag, int x, int y) 1257insert_ob_in_map_at (object *op, maptile *m, object *originator, int flag, int x, int y)
1146{ 1258{
1147 for (object *tmp = op->head_ (); tmp; tmp = tmp->more) 1259 for (object *tmp = op->head_ (); tmp; tmp = tmp->more)
1148 { 1260 {
1149 tmp->x = x + tmp->arch->clone.x; 1261 tmp->x = x + tmp->arch->x;
1150 tmp->y = y + tmp->arch->clone.y; 1262 tmp->y = y + tmp->arch->y;
1151 } 1263 }
1152 1264
1153 return insert_ob_in_map (op, m, originator, flag); 1265 return insert_ob_in_map (op, m, originator, flag);
1154} 1266}
1155 1267
1176object * 1288object *
1177insert_ob_in_map (object *op, maptile *m, object *originator, int flag) 1289insert_ob_in_map (object *op, maptile *m, object *originator, int flag)
1178{ 1290{
1179 assert (!op->flag [FLAG_FREED]); 1291 assert (!op->flag [FLAG_FREED]);
1180 1292
1181 object *tmp, *top, *floor = NULL; 1293 object *top, *floor = NULL;
1182 1294
1183 op->remove (); 1295 op->remove ();
1184
1185#if 0
1186 if (!m->active != !op->active)
1187 if (m->active)
1188 op->activate_recursive ();
1189 else
1190 op->deactivate_recursive ();
1191#endif
1192
1193 if (out_of_map (m, op->x, op->y))
1194 {
1195 LOG (llevError, "Trying to insert object outside the map.\n%s\n", op->debug_desc ());
1196#ifdef MANY_CORES
1197 /* Better to catch this here, as otherwise the next use of this object
1198 * is likely to cause a crash. Better to find out where it is getting
1199 * improperly inserted.
1200 */
1201 abort ();
1202#endif
1203 return op;
1204 }
1205
1206 if (object *more = op->more)
1207 {
1208 if (!insert_ob_in_map (more, m, originator, flag))
1209 {
1210 if (!op->head)
1211 LOG (llevError, "BUG: insert_ob_in_map(): inserting op->more killed op\n");
1212
1213 return 0;
1214 }
1215 }
1216
1217 CLEAR_FLAG (op, FLAG_REMOVED);
1218 1296
1219 /* Ideally, the caller figures this out. However, it complicates a lot 1297 /* Ideally, the caller figures this out. However, it complicates a lot
1220 * of areas of callers (eg, anything that uses find_free_spot would now 1298 * of areas of callers (eg, anything that uses find_free_spot would now
1221 * need extra work 1299 * need extra work
1222 */ 1300 */
1223 if (!xy_normalise (m, op->x, op->y)) 1301 if (!xy_normalise (m, op->x, op->y))
1302 {
1303 op->destroy ();
1224 return 0; 1304 return 0;
1305 }
1306
1307 if (object *more = op->more)
1308 if (!insert_ob_in_map (more, m, originator, flag))
1309 return 0;
1310
1311 CLEAR_FLAG (op, FLAG_REMOVED);
1225 1312
1226 op->map = m; 1313 op->map = m;
1227 mapspace &ms = op->ms (); 1314 mapspace &ms = op->ms ();
1228 1315
1229 /* this has to be done after we translate the coordinates. 1316 /* this has to be done after we translate the coordinates.
1230 */ 1317 */
1231 if (op->nrof && !(flag & INS_NO_MERGE)) 1318 if (op->nrof && !(flag & INS_NO_MERGE))
1232 for (tmp = ms.bot; tmp; tmp = tmp->above) 1319 for (object *tmp = ms.bot; tmp; tmp = tmp->above)
1233 if (object::can_merge (op, tmp)) 1320 if (object::can_merge (op, tmp))
1234 { 1321 {
1235 op->nrof += tmp->nrof; 1322 op->nrof += tmp->nrof;
1236 tmp->destroy (); 1323 tmp->destroy (1);
1237 } 1324 }
1238 1325
1239 CLEAR_FLAG (op, FLAG_APPLIED); /* hack for fixing F_APPLIED in items of dead people */ 1326 CLEAR_FLAG (op, FLAG_APPLIED); /* hack for fixing F_APPLIED in items of dead people */
1240 CLEAR_FLAG (op, FLAG_INV_LOCKED); 1327 CLEAR_FLAG (op, FLAG_INV_LOCKED);
1241 1328
1264 else 1351 else
1265 { 1352 {
1266 top = ms.bot; 1353 top = ms.bot;
1267 1354
1268 /* If there are other objects, then */ 1355 /* If there are other objects, then */
1269 if ((!(flag & INS_MAP_LOAD)) && top) 1356 if (top)
1270 { 1357 {
1271 object *last = 0; 1358 object *last = 0;
1272 1359
1273 /* 1360 /*
1274 * If there are multiple objects on this space, we do some trickier handling. 1361 * If there are multiple objects on this space, we do some trickier handling.
1327 if (last && last->below && last != floor) 1414 if (last && last->below && last != floor)
1328 top = last->below; 1415 top = last->below;
1329 } 1416 }
1330 } /* If objects on this space */ 1417 } /* If objects on this space */
1331 1418
1332 if (flag & INS_MAP_LOAD)
1333 top = ms.top;
1334
1335 if (flag & INS_ABOVE_FLOOR_ONLY) 1419 if (flag & INS_ABOVE_FLOOR_ONLY)
1336 top = floor; 1420 top = floor;
1337 1421
1338 /* Top is the object that our object (op) is going to get inserted above. 1422 /* Top is the object that our object (op) is going to get inserted above.
1339 */ 1423 */
1371 op->map->touch (); 1455 op->map->touch ();
1372 } 1456 }
1373 1457
1374 op->map->dirty = true; 1458 op->map->dirty = true;
1375 1459
1376 /* If we have a floor, we know the player, if any, will be above
1377 * it, so save a few ticks and start from there.
1378 */
1379 if (!(flag & INS_MAP_LOAD))
1380 if (object *pl = ms.player ()) 1460 if (object *pl = ms.player ())
1381 if (pl->contr->ns)
1382 pl->contr->ns->floorbox_update (); 1461 pl->contr->ns->floorbox_update ();
1383 1462
1384 /* If this object glows, it may affect lighting conditions that are 1463 /* If this object glows, it may affect lighting conditions that are
1385 * visible to others on this map. But update_all_los is really 1464 * visible to others on this map. But update_all_los is really
1386 * an inefficient way to do this, as it means los for all players 1465 * an inefficient way to do this, as it means los for all players
1387 * on the map will get recalculated. The players could very well 1466 * on the map will get recalculated. The players could very well
1406 * blocked() and wall() work properly), and these flags are updated by 1485 * blocked() and wall() work properly), and these flags are updated by
1407 * update_object(). 1486 * update_object().
1408 */ 1487 */
1409 1488
1410 /* if this is not the head or flag has been passed, don't check walk on status */ 1489 /* if this is not the head or flag has been passed, don't check walk on status */
1411 if (!(flag & INS_NO_WALK_ON) && !op->head) 1490 if (!(flag & INS_NO_WALK_ON) && op->head_ () == op)
1412 { 1491 {
1413 if (check_move_on (op, originator)) 1492 if (check_move_on (op, originator))
1414 return 0; 1493 return 0;
1415 1494
1416 /* If we are a multi part object, lets work our way through the check 1495 /* If we are a multi part object, lets work our way through the check
1417 * walk on's. 1496 * walk on's.
1418 */ 1497 */
1419 for (tmp = op->more; tmp != NULL; tmp = tmp->more) 1498 for (object *tmp = op->more; tmp; tmp = tmp->more)
1420 if (check_move_on (tmp, originator)) 1499 if (check_move_on (tmp, originator))
1421 return 0; 1500 return 0;
1422 } 1501 }
1423 1502
1424 return op; 1503 return op;
1429 * op is the object to insert it under: supplies x and the map. 1508 * op is the object to insert it under: supplies x and the map.
1430 */ 1509 */
1431void 1510void
1432replace_insert_ob_in_map (const char *arch_string, object *op) 1511replace_insert_ob_in_map (const char *arch_string, object *op)
1433{ 1512{
1434 object *tmp, *tmp1;
1435
1436 /* first search for itself and remove any old instances */ 1513 /* first search for itself and remove any old instances */
1437 1514
1438 for (tmp = op->ms ().bot; tmp; tmp = tmp->above) 1515 for (object *tmp = op->ms ().bot; tmp; tmp = tmp->above)
1439 if (!strcmp (tmp->arch->name, arch_string)) /* same archetype */ 1516 if (!strcmp (tmp->arch->archname, arch_string)) /* same archetype */
1440 tmp->destroy (); 1517 tmp->destroy (1);
1441 1518
1442 tmp1 = arch_to_object (archetype::find (arch_string)); 1519 object *tmp = arch_to_object (archetype::find (arch_string));
1443 1520
1444 tmp1->x = op->x; 1521 tmp->x = op->x;
1445 tmp1->y = op->y; 1522 tmp->y = op->y;
1523
1446 insert_ob_in_map (tmp1, op->map, op, 0); 1524 insert_ob_in_map (tmp, op->map, op, 0);
1447} 1525}
1448 1526
1449object * 1527object *
1450object::insert_at (object *where, object *originator, int flags) 1528object::insert_at (object *where, object *originator, int flags)
1451{ 1529{
1530 if (where->env)
1531 return where->env->insert (this);
1532 else
1452 return where->map->insert (this, where->x, where->y, originator, flags); 1533 return where->map->insert (this, where->x, where->y, originator, flags);
1453} 1534}
1454 1535
1455/* 1536/*
1456 * get_split_ob(ob,nr) splits up ob into two parts. The part which
1457 * is returned contains nr objects, and the remaining parts contains
1458 * the rest (or is removed and freed if that number is 0).
1459 * On failure, NULL is returned, and the reason put into the
1460 * global static errmsg array.
1461 */
1462object *
1463get_split_ob (object *orig_ob, uint32 nr)
1464{
1465 object *newob;
1466 int is_removed = (QUERY_FLAG (orig_ob, FLAG_REMOVED) != 0);
1467
1468 if (orig_ob->nrof < nr)
1469 {
1470 sprintf (errmsg, "There are only %d %ss.", orig_ob->nrof ? orig_ob->nrof : 1, &orig_ob->name);
1471 return NULL;
1472 }
1473
1474 newob = object_create_clone (orig_ob);
1475
1476 if ((orig_ob->nrof -= nr) < 1)
1477 orig_ob->destroy (1);
1478 else if (!is_removed)
1479 {
1480 if (orig_ob->env != NULL)
1481 sub_weight (orig_ob->env, orig_ob->weight * nr);
1482 if (orig_ob->env == NULL && orig_ob->map->in_memory != MAP_IN_MEMORY)
1483 {
1484 strcpy (errmsg, "Tried to split object whose map is not in memory.");
1485 LOG (llevDebug, "Error, Tried to split object whose map is not in memory.\n");
1486 return NULL;
1487 }
1488 }
1489
1490 newob->nrof = nr;
1491
1492 return newob;
1493}
1494
1495/*
1496 * decrease_ob_nr(object, number) decreases a specified number from 1537 * decrease(object, number) decreases a specified number from
1497 * the amount of an object. If the amount reaches 0, the object 1538 * the amount of an object. If the amount reaches 0, the object
1498 * is subsequently removed and freed. 1539 * is subsequently removed and freed.
1499 * 1540 *
1500 * Return value: 'op' if something is left, NULL if the amount reached 0 1541 * Return value: 'op' if something is left, NULL if the amount reached 0
1501 */ 1542 */
1543bool
1544object::decrease (sint32 nr)
1545{
1546 if (!nr)
1547 return true;
1548
1549 nr = min (nr, nrof);
1550
1551 nrof -= nr;
1552
1553 if (nrof)
1554 {
1555 adjust_weight (env, -weight * nr); // carrying == 0
1556
1557 if (object *pl = visible_to ())
1558 esrv_update_item (UPD_NROF, pl, this);
1559
1560 return true;
1561 }
1562 else
1563 {
1564 destroy (1);
1565 return false;
1566 }
1567}
1568
1569/*
1570 * split(ob,nr) splits up ob into two parts. The part which
1571 * is returned contains nr objects, and the remaining parts contains
1572 * the rest (or is removed and returned if that number is 0).
1573 * On failure, NULL is returned.
1574 */
1502object * 1575object *
1503decrease_ob_nr (object *op, uint32 i) 1576object::split (sint32 nr)
1504{ 1577{
1505 object *tmp; 1578 int have = number_of ();
1506 1579
1507 if (i == 0) /* objects with op->nrof require this check */ 1580 if (have < nr)
1508 return op; 1581 return 0;
1509 1582 else if (have == nr)
1510 if (i > op->nrof)
1511 i = op->nrof;
1512
1513 if (QUERY_FLAG (op, FLAG_REMOVED))
1514 op->nrof -= i;
1515 else if (op->env)
1516 { 1583 {
1517 /* is this object in the players inventory, or sub container
1518 * therein?
1519 */
1520 tmp = op->in_player ();
1521 /* nope. Is this a container the player has opened?
1522 * If so, set tmp to that player.
1523 * IMO, searching through all the players will mostly
1524 * likely be quicker than following op->env to the map,
1525 * and then searching the map for a player.
1526 */
1527 if (!tmp)
1528 for_all_players (pl)
1529 if (pl->ob->container == op->env)
1530 {
1531 tmp = pl->ob;
1532 break;
1533 }
1534
1535 if (i < op->nrof)
1536 {
1537 sub_weight (op->env, op->weight * i);
1538 op->nrof -= i;
1539 if (tmp)
1540 esrv_send_item (tmp, op);
1541 }
1542 else
1543 {
1544 op->remove (); 1584 remove ();
1545 op->nrof = 0; 1585 return this;
1546 if (tmp)
1547 esrv_del_item (tmp->contr, op->count);
1548 }
1549 } 1586 }
1550 else 1587 else
1551 { 1588 {
1552 object *above = op->above; 1589 decrease (nr);
1553 1590
1554 if (i < op->nrof) 1591 object *op = object_create_clone (this);
1555 op->nrof -= i; 1592 op->nrof = nr;
1556 else
1557 {
1558 op->remove ();
1559 op->nrof = 0;
1560 }
1561
1562 /* Since we just removed op, op->above is null */
1563 for (tmp = above; tmp; tmp = tmp->above)
1564 if (tmp->type == PLAYER)
1565 {
1566 if (op->nrof)
1567 esrv_send_item (tmp, op);
1568 else
1569 esrv_del_item (tmp->contr, op->count);
1570 }
1571 }
1572
1573 if (op->nrof)
1574 return op; 1593 return op;
1575 else
1576 {
1577 op->destroy ();
1578 return 0;
1579 }
1580}
1581
1582/*
1583 * add_weight(object, weight) adds the specified weight to an object,
1584 * and also updates how much the environment(s) is/are carrying.
1585 */
1586void
1587add_weight (object *op, signed long weight)
1588{
1589 while (op != NULL)
1590 {
1591 if (op->type == CONTAINER)
1592 weight = (signed long) (weight * (100 - op->stats.Str) / 100);
1593
1594 op->carrying += weight;
1595 op = op->env;
1596 } 1594 }
1597} 1595}
1598 1596
1599object * 1597object *
1600insert_ob_in_ob (object *op, object *where) 1598insert_ob_in_ob (object *op, object *where)
1605 LOG (llevError, "Trying to put object in NULL.\n%s\n", dump); 1603 LOG (llevError, "Trying to put object in NULL.\n%s\n", dump);
1606 free (dump); 1604 free (dump);
1607 return op; 1605 return op;
1608 } 1606 }
1609 1607
1610 if (where->head) 1608 if (where->head_ () != where)
1611 { 1609 {
1612 LOG (llevDebug, "Warning: Tried to insert object into wrong part of multipart object.\n"); 1610 LOG (llevError | logBacktrace, "Warning: Tried to insert object into wrong part of multipart object.\n");
1613 where = where->head; 1611 where = where->head;
1614 } 1612 }
1615 1613
1616 return where->insert (op); 1614 return where->insert (op);
1617} 1615}
1625 * be != op, if items are merged. -Tero 1623 * be != op, if items are merged. -Tero
1626 */ 1624 */
1627object * 1625object *
1628object::insert (object *op) 1626object::insert (object *op)
1629{ 1627{
1630 object *tmp, *otmp;
1631
1632 if (!QUERY_FLAG (op, FLAG_REMOVED))
1633 op->remove ();
1634
1635 if (op->more) 1628 if (op->more)
1636 { 1629 {
1637 LOG (llevError, "Tried to insert multipart object %s (%d)\n", &op->name, op->count); 1630 LOG (llevError, "Tried to insert multipart object %s (%d)\n", &op->name, op->count);
1638 return op; 1631 return op;
1639 } 1632 }
1640 1633
1641 CLEAR_FLAG (op, FLAG_OBJ_ORIGINAL); 1634 op->remove ();
1642 CLEAR_FLAG (op, FLAG_REMOVED); 1635
1636 op->flag [FLAG_OBJ_ORIGINAL] = 0;
1637
1643 if (op->nrof) 1638 if (op->nrof)
1644 {
1645 for (tmp = inv; tmp != NULL; tmp = tmp->below) 1639 for (object *tmp = inv; tmp; tmp = tmp->below)
1646 if (object::can_merge (tmp, op)) 1640 if (object::can_merge (tmp, op))
1647 { 1641 {
1648 /* return the original object and remove inserted object 1642 /* return the original object and remove inserted object
1649 (client needs the original object) */ 1643 (client needs the original object) */
1650 tmp->nrof += op->nrof; 1644 tmp->nrof += op->nrof;
1651 /* Weight handling gets pretty funky. Since we are adding to 1645
1652 * tmp->nrof, we need to increase the weight. 1646 if (object *pl = tmp->visible_to ())
1653 */ 1647 esrv_update_item (UPD_NROF, pl, tmp);
1648
1654 add_weight (this, op->weight * op->nrof); 1649 adjust_weight (this, op->total_weight ());
1655 SET_FLAG (op, FLAG_REMOVED); 1650
1656 op->destroy (); /* free the inserted object */ 1651 op->destroy (1);
1657 op = tmp; 1652 op = tmp;
1658 op->remove (); /* and fix old object's links */ 1653 goto inserted;
1659 CLEAR_FLAG (op, FLAG_REMOVED);
1660 break;
1661 } 1654 }
1662 1655
1663 /* I assume combined objects have no inventory 1656 op->owner = 0; // it's his/hers now. period.
1664 * We add the weight - this object could have just been removed
1665 * (if it was possible to merge). calling remove_ob will subtract
1666 * the weight, so we need to add it in again, since we actually do
1667 * the linking below
1668 */
1669 add_weight (this, op->weight * op->nrof);
1670 }
1671 else
1672 add_weight (this, (op->weight + op->carrying));
1673
1674 otmp = this->in_player ();
1675 if (otmp && otmp->contr)
1676 if (!QUERY_FLAG (otmp, FLAG_NO_FIX_PLAYER))
1677 otmp->update_stats ();
1678
1679 op->map = 0; 1657 op->map = 0;
1680 op->env = this; 1658 op->x = 0;
1659 op->y = 0;
1660
1681 op->above = 0; 1661 op->above = 0;
1682 op->below = 0; 1662 op->below = inv;
1683 op->x = 0, op->y = 0; 1663 op->env = this;
1684 1664
1665 if (inv)
1666 inv->above = op;
1667
1668 inv = op;
1669
1670 op->flag [FLAG_REMOVED] = 0;
1671
1672 if (object *pl = op->visible_to ())
1673 esrv_send_item (pl, op);
1674
1675 adjust_weight (this, op->total_weight ());
1676
1677inserted:
1685 /* reset the light list and los of the players on the map */ 1678 /* reset the light list and los of the players on the map */
1686 if ((op->glow_radius != 0) && map) 1679 if (op->glow_radius && map && map->darkness)
1687 {
1688#ifdef DEBUG_LIGHTS
1689 LOG (llevDebug, " insert_ob_in_ob(): got %s to insert in map/op\n", op->name);
1690#endif /* DEBUG_LIGHTS */
1691 if (map->darkness)
1692 update_all_los (map, x, y); 1680 update_all_los (map, x, y);
1693 }
1694 1681
1695 /* Client has no idea of ordering so lets not bother ordering it here. 1682 // if this is a player's inventory, update stats
1696 * It sure simplifies this function... 1683 if (type == PLAYER && !flag [FLAG_NO_FIX_PLAYER])
1697 */ 1684 update_stats ();
1698 if (!inv)
1699 inv = op;
1700 else
1701 {
1702 op->below = inv;
1703 op->below->above = op;
1704 inv = op;
1705 }
1706 1685
1707 INVOKE_OBJECT (INSERT, this); 1686 INVOKE_OBJECT (INSERT, this);
1708 1687
1709 return op; 1688 return op;
1710} 1689}
1925 * activate recursively a flag on an object inventory 1904 * activate recursively a flag on an object inventory
1926 */ 1905 */
1927void 1906void
1928flag_inv (object *op, int flag) 1907flag_inv (object *op, int flag)
1929{ 1908{
1930 if (op->inv)
1931 for (object *tmp = op->inv; tmp != NULL; tmp = tmp->below) 1909 for (object *tmp = op->inv; tmp; tmp = tmp->below)
1932 { 1910 {
1933 SET_FLAG (tmp, flag); 1911 SET_FLAG (tmp, flag);
1934 flag_inv (tmp, flag); 1912 flag_inv (tmp, flag);
1935 } 1913 }
1936} 1914}
1937 1915
1938/* 1916/*
1939 * deactivate recursively a flag on an object inventory 1917 * deactivate recursively a flag on an object inventory
1940 */ 1918 */
1941void 1919void
1942unflag_inv (object *op, int flag) 1920unflag_inv (object *op, int flag)
1943{ 1921{
1944 if (op->inv)
1945 for (object *tmp = op->inv; tmp != NULL; tmp = tmp->below) 1922 for (object *tmp = op->inv; tmp; tmp = tmp->below)
1946 { 1923 {
1947 CLEAR_FLAG (tmp, flag); 1924 CLEAR_FLAG (tmp, flag);
1948 unflag_inv (tmp, flag); 1925 unflag_inv (tmp, flag);
1949 } 1926 }
1950}
1951
1952/*
1953 * set_cheat(object) sets the cheat flag (WAS_WIZ) in the object and in
1954 * all it's inventory (recursively).
1955 * If checksums are used, a player will get set_cheat called for
1956 * him/her-self and all object carried by a call to this function.
1957 */
1958void
1959set_cheat (object *op)
1960{
1961 SET_FLAG (op, FLAG_WAS_WIZ);
1962 flag_inv (op, FLAG_WAS_WIZ);
1963} 1927}
1964 1928
1965/* 1929/*
1966 * find_free_spot(object, map, x, y, start, stop) will search for 1930 * find_free_spot(object, map, x, y, start, stop) will search for
1967 * a spot at the given map and coordinates which will be able to contain 1931 * a spot at the given map and coordinates which will be able to contain
1969 * to search (see the freearr_x/y[] definition). 1933 * to search (see the freearr_x/y[] definition).
1970 * It returns a random choice among the alternatives found. 1934 * It returns a random choice among the alternatives found.
1971 * start and stop are where to start relative to the free_arr array (1,9 1935 * start and stop are where to start relative to the free_arr array (1,9
1972 * does all 4 immediate directions). This returns the index into the 1936 * does all 4 immediate directions). This returns the index into the
1973 * array of the free spot, -1 if no spot available (dir 0 = x,y) 1937 * array of the free spot, -1 if no spot available (dir 0 = x,y)
1974 * Note - this only checks to see if there is space for the head of the
1975 * object - if it is a multispace object, this should be called for all
1976 * pieces.
1977 * Note2: This function does correctly handle tiled maps, but does not 1938 * Note: This function does correctly handle tiled maps, but does not
1978 * inform the caller. However, insert_ob_in_map will update as 1939 * inform the caller. However, insert_ob_in_map will update as
1979 * necessary, so the caller shouldn't need to do any special work. 1940 * necessary, so the caller shouldn't need to do any special work.
1980 * Note - updated to take an object instead of archetype - this is necessary 1941 * Note - updated to take an object instead of archetype - this is necessary
1981 * because arch_blocked (now ob_blocked) needs to know the movement type 1942 * because arch_blocked (now ob_blocked) needs to know the movement type
1982 * to know if the space in question will block the object. We can't use 1943 * to know if the space in question will block the object. We can't use
1984 * customized, changed states, etc. 1945 * customized, changed states, etc.
1985 */ 1946 */
1986int 1947int
1987find_free_spot (const object *ob, maptile *m, int x, int y, int start, int stop) 1948find_free_spot (const object *ob, maptile *m, int x, int y, int start, int stop)
1988{ 1949{
1950 int altern[SIZEOFFREE];
1989 int index = 0, flag; 1951 int index = 0, flag;
1990 int altern[SIZEOFFREE];
1991 1952
1992 for (int i = start; i < stop; i++) 1953 for (int i = start; i < stop; i++)
1993 { 1954 {
1994 flag = ob_blocked (ob, m, x + freearr_x[i], y + freearr_y[i]); 1955 mapxy pos (m, x, y); pos.move (i);
1995 if (!flag) 1956
1957 if (!pos.normalise ())
1958 continue;
1959
1960 mapspace &ms = *pos;
1961
1962 if (ms.flags () & P_IS_ALIVE)
1963 continue;
1964
1965 /* However, often
1966 * ob doesn't have any move type (when used to place exits)
1967 * so the AND operation in OB_TYPE_MOVE_BLOCK doesn't work.
1968 */
1969 if (ob && ob->move_type == 0 && ms.move_block != MOVE_ALL)
1970 {
1996 altern [index++] = i; 1971 altern [index++] = i;
1972 continue;
1973 }
1997 1974
1998 /* Basically, if we find a wall on a space, we cut down the search size. 1975 /* Basically, if we find a wall on a space, we cut down the search size.
1999 * In this way, we won't return spaces that are on another side of a wall. 1976 * In this way, we won't return spaces that are on another side of a wall.
2000 * This mostly work, but it cuts down the search size in all directions - 1977 * This mostly work, but it cuts down the search size in all directions -
2001 * if the space being examined only has a wall to the north and empty 1978 * if the space being examined only has a wall to the north and empty
2002 * spaces in all the other directions, this will reduce the search space 1979 * spaces in all the other directions, this will reduce the search space
2003 * to only the spaces immediately surrounding the target area, and 1980 * to only the spaces immediately surrounding the target area, and
2004 * won't look 2 spaces south of the target space. 1981 * won't look 2 spaces south of the target space.
2005 */ 1982 */
2006 else if ((flag & P_NO_PASS) && maxfree[i] < stop) 1983 if (ms.move_block == MOVE_ALL && maxfree[i] < stop)
1984 {
2007 stop = maxfree[i]; 1985 stop = maxfree[i];
1986 continue;
1987 }
1988
1989 /* Note it is intentional that we check ob - the movement type of the
1990 * head of the object should correspond for the entire object.
1991 */
1992 if (OB_TYPE_MOVE_BLOCK (ob, ms.move_block))
1993 continue;
1994
1995 if (ob->blocked (m, pos.x, pos.y))
1996 continue;
1997
1998 altern [index++] = i;
2008 } 1999 }
2009 2000
2010 if (!index) 2001 if (!index)
2011 return -1; 2002 return -1;
2012 2003
2021 */ 2012 */
2022int 2013int
2023find_first_free_spot (const object *ob, maptile *m, int x, int y) 2014find_first_free_spot (const object *ob, maptile *m, int x, int y)
2024{ 2015{
2025 for (int i = 0; i < SIZEOFFREE; i++) 2016 for (int i = 0; i < SIZEOFFREE; i++)
2026 if (!ob_blocked (ob, m, x + freearr_x[i], y + freearr_y[i])) 2017 if (!ob->blocked (m, x + freearr_x[i], y + freearr_y[i]))
2027 return i; 2018 return i;
2028 2019
2029 return -1; 2020 return -1;
2030} 2021}
2031 2022
2085 object *tmp; 2076 object *tmp;
2086 maptile *mp; 2077 maptile *mp;
2087 2078
2088 MoveType blocked, move_type; 2079 MoveType blocked, move_type;
2089 2080
2090 if (exclude && exclude->head) 2081 if (exclude && exclude->head_ () != exclude)
2091 { 2082 {
2092 exclude = exclude->head; 2083 exclude = exclude->head;
2093 move_type = exclude->move_type; 2084 move_type = exclude->move_type;
2094 } 2085 }
2095 else 2086 else
2118 max = maxfree[i]; 2109 max = maxfree[i];
2119 else if (mflags & P_IS_ALIVE) 2110 else if (mflags & P_IS_ALIVE)
2120 { 2111 {
2121 for (tmp = ms.bot; tmp; tmp = tmp->above) 2112 for (tmp = ms.bot; tmp; tmp = tmp->above)
2122 if ((tmp->flag [FLAG_MONSTER] || tmp->type == PLAYER) 2113 if ((tmp->flag [FLAG_MONSTER] || tmp->type == PLAYER)
2123 && (tmp != exclude || (tmp->head && tmp->head != exclude))) 2114 && (tmp != exclude || (tmp->head_ () != tmp && tmp->head_ () != exclude)))
2124 break; 2115 break;
2125 2116
2126 if (tmp) 2117 if (tmp)
2127 return freedir[i]; 2118 return freedir[i];
2128 } 2119 }
2308 * Cf 0.91.3 - don't let WIZ's pick up anything - will likely cause 2299 * Cf 0.91.3 - don't let WIZ's pick up anything - will likely cause
2309 * core dumps if they do. 2300 * core dumps if they do.
2310 * 2301 *
2311 * Add a check so we can't pick up invisible objects (0.93.8) 2302 * Add a check so we can't pick up invisible objects (0.93.8)
2312 */ 2303 */
2313
2314int 2304int
2315can_pick (const object *who, const object *item) 2305can_pick (const object *who, const object *item)
2316{ 2306{
2317 return /*QUERY_FLAG(who,FLAG_WIZ)|| */ 2307 return /*QUERY_FLAG(who,FLAG_WIZ)|| */
2318 (item->weight > 0 && !QUERY_FLAG (item, FLAG_NO_PICK) && 2308 (item->weight > 0 && !QUERY_FLAG (item, FLAG_NO_PICK) &&
2323 * create clone from object to another 2313 * create clone from object to another
2324 */ 2314 */
2325object * 2315object *
2326object_create_clone (object *asrc) 2316object_create_clone (object *asrc)
2327{ 2317{
2328 object *dst = 0, *tmp, *src, *part, *prev, *item; 2318 object *dst = 0, *tmp, *src, *prev, *item;
2329 2319
2330 if (!asrc) 2320 if (!asrc)
2331 return 0; 2321 return 0;
2332 2322
2333 src = asrc;
2334 if (src->head)
2335 src = src->head; 2323 src = asrc->head_ ();
2336 2324
2337 prev = 0; 2325 prev = 0;
2338 for (part = src; part; part = part->more) 2326 for (object *part = src; part; part = part->more)
2339 { 2327 {
2340 tmp = part->clone (); 2328 tmp = part->clone ();
2341 tmp->x -= src->x; 2329 tmp->x -= src->x;
2342 tmp->y -= src->y; 2330 tmp->y -= src->y;
2343 2331
2456 /* Basically, if the archetype has this key set, 2444 /* Basically, if the archetype has this key set,
2457 * we need to store the null value so when we save 2445 * we need to store the null value so when we save
2458 * it, we save the empty value so that when we load, 2446 * it, we save the empty value so that when we load,
2459 * we get this value back again. 2447 * we get this value back again.
2460 */ 2448 */
2461 if (get_ob_key_link (&op->arch->clone, canonical_key)) 2449 if (get_ob_key_link (op->arch, canonical_key))
2462 field->value = 0; 2450 field->value = 0;
2463 else 2451 else
2464 { 2452 {
2465 if (last) 2453 if (last)
2466 last->next = field->next; 2454 last->next = field->next;
2535 } 2523 }
2536 else 2524 else
2537 item = item->env; 2525 item = item->env;
2538} 2526}
2539 2527
2540
2541const char * 2528const char *
2542object::flag_desc (char *desc, int len) const 2529object::flag_desc (char *desc, int len) const
2543{ 2530{
2544 char *p = desc; 2531 char *p = desc;
2545 bool first = true; 2532 bool first = true;
2572{ 2559{
2573 char flagdesc[512]; 2560 char flagdesc[512];
2574 char info2[256 * 4]; 2561 char info2[256 * 4];
2575 char *p = info; 2562 char *p = info;
2576 2563
2577 p += snprintf (p, 512, "{cnt:%d,uuid:<1.%" PRIx64 ">,name:\"%s\"%s%s,flags:[%s],type:%d}", 2564 p += snprintf (p, 512, "{cnt:%d,uuid:%s,name:\"%s\"%s%s,flags:[%s],type:%d}",
2578 count, uuid.seq, 2565 count,
2566 uuid.c_str (),
2579 &name, 2567 &name,
2580 title ? "\",title:\"" : "", 2568 title ? "\",title:\"" : "",
2581 title ? (const char *)title : "", 2569 title ? (const char *)title : "",
2582 flag_desc (flagdesc, 512), type); 2570 flag_desc (flagdesc, 512), type);
2583 2571
2584 if (env) 2572 if (!this->flag[FLAG_REMOVED] && env)
2585 p += snprintf (p, 256, "(in %s)", env->debug_desc (info2)); 2573 p += snprintf (p, 256, "(in %s)", env->debug_desc (info2));
2586 2574
2587 if (map) 2575 if (map)
2588 p += snprintf (p, 256, "(on %s@%d+%d)", &map->path, x, y); 2576 p += snprintf (p, 256, "(on %s@%d+%d)", &map->path, x, y);
2589 2577
2591} 2579}
2592 2580
2593const char * 2581const char *
2594object::debug_desc () const 2582object::debug_desc () const
2595{ 2583{
2596 static char info[256 * 4]; 2584 static char info[3][256 * 4];
2585 static int info_idx;
2586
2597 return debug_desc (info); 2587 return debug_desc (info [++info_idx % 3]);
2598}
2599
2600const char *
2601object::debug_desc2 () const
2602{
2603 static char info[256 * 4];
2604 return debug_desc (info);
2605} 2588}
2606 2589
2607struct region * 2590struct region *
2608object::region () const 2591object::region () const
2609{ 2592{
2612} 2595}
2613 2596
2614const materialtype_t * 2597const materialtype_t *
2615object::dominant_material () const 2598object::dominant_material () const
2616{ 2599{
2617 if (materialtype_t *mat = name_to_material (materialname)) 2600 if (materialtype_t *mt = name_to_material (materialname))
2618 return mat; 2601 return mt;
2619 2602
2620 // omfg this is slow, this has to be temporary :)
2621 shstr unknown ("unknown");
2622
2623 return name_to_material (unknown); 2603 return name_to_material (shstr_unknown);
2624} 2604}
2625 2605
2626void 2606void
2627object::open_container (object *new_container) 2607object::open_container (object *new_container)
2628{ 2608{
2644 old_container->flag [FLAG_APPLIED] = 0; 2624 old_container->flag [FLAG_APPLIED] = 0;
2645 container = 0; 2625 container = 0;
2646 2626
2647 esrv_update_item (UPD_FLAGS, this, old_container); 2627 esrv_update_item (UPD_FLAGS, this, old_container);
2648 new_draw_info_format (NDI_UNIQUE, 0, this, "You close %s.", query_name (old_container)); 2628 new_draw_info_format (NDI_UNIQUE, 0, this, "You close %s.", query_name (old_container));
2629 play_sound (sound_find ("chest_close"));
2649 } 2630 }
2650 2631
2651 if (new_container) 2632 if (new_container)
2652 { 2633 {
2653 if (INVOKE_OBJECT (OPEN, new_container, ARG_OBJECT (this))) 2634 if (INVOKE_OBJECT (OPEN, new_container, ARG_OBJECT (this)))
2669 new_container->flag [FLAG_APPLIED] = 1; 2650 new_container->flag [FLAG_APPLIED] = 1;
2670 container = new_container; 2651 container = new_container;
2671 2652
2672 esrv_update_item (UPD_FLAGS, this, new_container); 2653 esrv_update_item (UPD_FLAGS, this, new_container);
2673 esrv_send_inventory (this, new_container); 2654 esrv_send_inventory (this, new_container);
2655 play_sound (sound_find ("chest_open"));
2656 }
2657}
2658
2659object *
2660object::force_find (const shstr name)
2661{
2662 /* cycle through his inventory to look for the MARK we want to
2663 * place
2664 */
2665 for (object *tmp = inv; tmp; tmp = tmp->below)
2666 if (tmp->type == FORCE && tmp->slaying == name)
2667 return splay (tmp);
2668
2669 return 0;
2670}
2671
2672void
2673object::force_add (const shstr name, int duration)
2674{
2675 if (object *force = force_find (name))
2676 force->destroy ();
2677
2678 object *force = get_archetype (FORCE_NAME);
2679
2680 force->slaying = name;
2681 force->stats.food = 1;
2682 force->speed_left = -1.f;
2683
2684 force->set_speed (duration ? 1.f / duration : 0.f);
2685 force->flag [FLAG_IS_USED_UP] = true;
2686 force->flag [FLAG_APPLIED] = true;
2687
2688 insert (force);
2689}
2690
2691void
2692object::play_sound (faceidx sound)
2693{
2694 if (!sound)
2695 return;
2696
2697 if (flag [FLAG_REMOVED])
2698 return;
2699
2700 if (env)
2674 } 2701 {
2702 if (object *pl = in_player ())
2703 pl->contr->play_sound (sound);
2704 }
2705 else
2706 map->play_sound (sound, x, y);
2675} 2707}
2676 2708
2677

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines