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.8 by root, Tue Aug 29 08:01:35 2006 UTC vs.
Revision 1.77 by root, Thu Dec 21 23:37:05 2006 UTC

1/*
2 * static char *rcsid_object_c =
3 * "$Id: object.C,v 1.8 2006/08/29 08:01:35 root Exp $";
4 */
5
6/* 1/*
7 CrossFire, A Multiplayer game for X-windows 2 CrossFire, A Multiplayer game for X-windows
8 3
9 Copyright (C) 2001 Mark Wedel & Crossfire Development Team 4 Copyright (C) 2001 Mark Wedel & Crossfire Development Team
10 Copyright (C) 1992 Frank Tore Johansen 5 Copyright (C) 1992 Frank Tore Johansen
… …
21 16
22 You should have received a copy of the GNU General Public License 17 You should have received a copy of the GNU General Public License
23 along with this program; if not, write to the Free Software 18 along with this program; if not, write to the Free Software
24 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 20
26 The authors can be reached via e-mail at crossfire-devel@real-time.com 21 The authors can be reached via e-mail at <crossfire@schmorp.de>
27*/ 22*/
28 23
29/* Eneq(@csd.uu.se): Added weight-modifiers in environment of objects. 24/* Eneq(@csd.uu.se): Added weight-modifiers in environment of objects.
30 sub/add_weight will transcend the environment updating the carrying 25 sub/add_weight will transcend the environment updating the carrying
31 variable. */ 26 variable. */
32#include <global.h> 27#include <global.h>
33#ifndef WIN32 /* ---win32 exclude headers */
34#include <stdio.h> 28#include <stdio.h>
35#include <sys/types.h> 29#include <sys/types.h>
36#include <sys/uio.h> 30#include <sys/uio.h>
37#endif /* win32 */
38#include <object.h> 31#include <object.h>
39#include <funcpoint.h> 32#include <funcpoint.h>
40#include <skills.h>
41#include <loader.h> 33#include <loader.h>
42#ifdef MEMORY_DEBUG 34
43int nroffreeobjects = 0; 35#include <bitset>
36
44int nrofallocobjects = 0; 37int nrofallocobjects = 0;
45#undef OBJ_EXPAND 38static UUID uuid;
46#define OBJ_EXPAND 1 39const uint64 UUID_SKIP = 1<<19;
47#else
48object objarray[STARTMAX]; /* All objects, allocated this way at first */
49int nroffreeobjects = STARTMAX; /* How many OBs allocated and free (free) */
50int nrofallocobjects = STARTMAX; /* How many OBs allocated (free + used) */
51#endif
52 40
53object *objects; /* Pointer to the list of used objects */
54object *free_objects; /* Pointer to the list of unused objects */
55object *active_objects; /* List of active objects that need to be processed */ 41object *active_objects; /* List of active objects that need to be processed */
56 42
57short freearr_x[SIZEOFFREE]= 43short 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,
58 {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,
59 0,1,2,3,3,3,3,3,3,3,2,1,0,-1,-2,-3,-3,-3,-3,-3,-3,-3,-2,-1}; 44 0, 1, 2, 3, 3, 3, 3, 3, 3, 3, 2, 1, 0, -1, -2, -3, -3, -3, -3, -3, -3, -3, -2, -1
60short freearr_y[SIZEOFFREE]= 45};
61 {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, 46short 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,
62 -3,-3,-3,-3,-2,-1,0,1,2,3,3,3,3,3,3,3,2,1,0,-1,-2,-3,-3,-3}; 47 -3, -3, -3, -3, -2, -1, 0, 1, 2, 3, 3, 3, 3, 3, 3, 3, 2, 1, 0, -1, -2, -3, -3, -3
63int maxfree[SIZEOFFREE]= 48};
64 {0,9,10,13,14,17,18,21,22,25,26,27,30,31,32,33,36,37,39,39,42,43,44,45, 49int 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,
65 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}; 50 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
51};
66int freedir[SIZEOFFREE]= { 52int freedir[SIZEOFFREE] = {
67 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, 53 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,
68 1,2,2,2,2,2,3,4,4,4,4,4,5,6,6,6,6,6,7,8,8,8,8,8}; 54 1, 2, 2, 2, 2, 2, 3, 4, 4, 4, 4, 4, 5, 6, 6, 6, 6, 6, 7, 8, 8, 8, 8, 8
55};
69 56
57static void
58write_uuid (void)
59{
60 char filename1[MAX_BUF], filename2[MAX_BUF];
61
62 sprintf (filename1, "%s/uuid", settings.localdir);
63 sprintf (filename2, "%s/uuid~", settings.localdir);
64
65 FILE *fp;
66
67 if (!(fp = fopen (filename2, "w")))
68 {
69 LOG (llevError, "ERROR: cannot open %s for writing, unable to write UUID!\n", filename2);
70 return;
71 }
72
73 fprintf (fp, "<1,%llx>\n", (unsigned long long)uuid.seq + UUID_SKIP * 2);
74 fclose (fp);
75 rename (filename2, filename1);
76}
77
78static void
79read_uuid (void)
80{
81 char filename[MAX_BUF];
82
83 sprintf (filename, "%s/uuid", settings.localdir);
84
85 FILE *fp;
86
87 if (!(fp = fopen (filename, "r")))
88 {
89 if (errno == ENOENT)
90 {
91 LOG (llevInfo, "RESET uid to 1\n");
92 uuid.seq = 0;
93 write_uuid ();
94 return;
95 }
96
97 LOG (llevError, "FATAL: cannot open %s for reading!\n", filename);
98 _exit (1);
99 }
100
101 int version;
102 unsigned long long uid;
103 if (2 != fscanf (fp, "<%d,%llx>\n", &version, &uid) || version != 1)
104 {
105 LOG (llevError, "FATAL: error reading uid from %s!\n", filename);
106 _exit (1);
107 }
108
109 uuid.seq = uid;
110 write_uuid ();
111 LOG (llevDebug, "read UID: %" PRId64 "\n", uid);
112 fclose (fp);
113}
114
115UUID
116gen_uuid ()
117{
118 UUID uid;
119
120 uid.seq = ++uuid.seq;
121
122 if (!(uuid.seq & (UUID_SKIP - 1)))
123 write_uuid ();
124
125 return uid;
126}
127
128void
129init_uuid ()
130{
131 read_uuid ();
132}
70 133
71/* Returns TRUE if every key_values in wants has a partner with the same value in has. */ 134/* Returns TRUE if every key_values in wants has a partner with the same value in has. */
135static int
72static int compare_ob_value_lists_one(const object * wants, const object * has) { 136compare_ob_value_lists_one (const object *wants, const object *has)
137{
73 key_value * wants_field; 138 key_value *wants_field;
74 139
75 /* n-squared behaviour (see get_ob_key_link()), but I'm hoping both 140 /* n-squared behaviour (see get_ob_key_link()), but I'm hoping both
76 * objects with lists are rare, and lists stay short. If not, use a 141 * objects with lists are rare, and lists stay short. If not, use a
77 * different structure or at least keep the lists sorted... 142 * different structure or at least keep the lists sorted...
78 */ 143 */
79 144
80 /* For each field in wants, */ 145 /* For each field in wants, */
81 for (wants_field = wants->key_values; wants_field != NULL; wants_field = wants_field->next) { 146 for (wants_field = wants->key_values; wants_field != NULL; wants_field = wants_field->next)
147 {
82 key_value * has_field; 148 key_value *has_field;
83 149
84 /* Look for a field in has with the same key. */ 150 /* Look for a field in has with the same key. */
85 has_field = get_ob_key_link(has, wants_field->key); 151 has_field = get_ob_key_link (has, wants_field->key);
152
153 if (has_field == NULL)
86 154 {
87 if (has_field == NULL) {
88 /* No field with that name. */ 155 /* No field with that name. */
89 return FALSE; 156 return FALSE;
90 } 157 }
91 158
92 /* Found the matching field. */ 159 /* Found the matching field. */
93 if (has_field->value != wants_field->value) { 160 if (has_field->value != wants_field->value)
161 {
94 /* Values don't match, so this half of the comparison is false. */ 162 /* Values don't match, so this half of the comparison is false. */
95 return FALSE; 163 return FALSE;
96 } 164 }
97 165
98 /* 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. */
99 }
100 167 }
168
101 /* 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. */
102 return TRUE; 170 return TRUE;
103} 171}
104 172
105/* Returns TRUE if ob1 has the same key_values as ob2. */ 173/* Returns TRUE if ob1 has the same key_values as ob2. */
174static int
106static int compare_ob_value_lists(const object * ob1, const object * ob2) { 175compare_ob_value_lists (const object *ob1, const object *ob2)
176{
107 /* 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,
108 * so we need to run the comparison *twice*. :( 178 * so we need to run the comparison *twice*. :(
109 */ 179 */
110 return compare_ob_value_lists_one(ob1, ob2) && compare_ob_value_lists_one(ob2, ob1); 180 return compare_ob_value_lists_one (ob1, ob2) && compare_ob_value_lists_one (ob2, ob1);
111} 181}
112 182
113/* Function examines the 2 objects given to it, and returns true if 183/* Function examines the 2 objects given to it, and returns true if
114 * they can be merged together. 184 * they can be merged together.
115 * 185 *
116 * Note that this function appears a lot longer than the macro it 186 * Note that this function appears a lot longer than the macro it
117 * replaces - this is mostly for clarity - a decent compiler should hopefully 187 * replaces - this is mostly for clarity - a decent compiler should hopefully
118 * reduce this to the same efficiency. 188 * reduce this to the same efficiency.
119 * 189 *
120 * Check nrof variable *before* calling CAN_MERGE() 190 * Check nrof variable *before* calling can_merge()
121 * 191 *
122 * Improvements made with merge: Better checking on potion, and also 192 * Improvements made with merge: Better checking on potion, and also
123 * check weight 193 * check weight
124 */ 194 */
125 195
126int CAN_MERGE(object *ob1, object *ob2) { 196bool object::can_merge_slow (object *ob1, object *ob2)
127 197{
128 /* A couple quicksanity checks */ 198 /* A couple quicksanity checks */
129 if ((ob1 == ob2) || (ob1->type != ob2->type)) return 0; 199 if (ob1 == ob2
200 || ob1->type != ob2->type
201 || ob1->speed != ob2->speed
202 || ob1->value != ob2->value
203 || ob1->name != ob2->name)
204 return 0;
130 205
131 if (ob1->speed != ob2->speed) return 0; 206 //TODO: this ain't working well, use nicer and correct overflow check
132 /* Note sure why the following is the case - either the object has to 207 /* Do not merge objects if nrof would overflow. We use 1UL<<31 since that
133 * be animated or have a very low speed. Is this an attempted monster 208 * value could not be stored in a sint32 (which unfortunately sometimes is
134 * check? 209 * used to store nrof).
135 */ 210 */
136 if (!QUERY_FLAG(ob1,FLAG_ANIMATE) && FABS((ob1)->speed) > MIN_ACTIVE_SPEED) 211 if (ob1->nrof + ob2->nrof >= 1UL << 31)
212 return 0;
213
214 /* If the objects have been identified, set the BEEN_APPLIED flag.
215 * This is to the comparison of the flags below will be OK. We
216 * just can't ignore the been applied or identified flags, as they
217 * are not equal - just if it has been identified, the been_applied
218 * flags lose any meaning.
219 */
220 if (QUERY_FLAG (ob1, FLAG_IDENTIFIED))
221 SET_FLAG (ob1, FLAG_BEEN_APPLIED);
222
223 if (QUERY_FLAG (ob2, FLAG_IDENTIFIED))
224 SET_FLAG (ob2, FLAG_BEEN_APPLIED);
225
226 if ((ob1->flags ^ ob2->flags).reset (FLAG_INV_LOCKED).reset (FLAG_CLIENT_SENT).any ()
227 || ob1->arch != ob2->arch
228 || ob1->name != ob2->name
229 || ob1->title != ob2->title
230 || ob1->msg != ob2->msg
231 || ob1->weight != ob2->weight
232 || memcmp (&ob1->resist, &ob2->resist, sizeof (ob1->resist))
233 || memcmp (&ob1->stats , &ob2->stats , sizeof (ob1->stats) )
234 || ob1->attacktype != ob2->attacktype
235 || ob1->magic != ob2->magic
236 || ob1->slaying != ob2->slaying
237 || ob1->skill != ob2->skill
238 || ob1->value != ob2->value
239 || ob1->animation_id != ob2->animation_id
240 || ob1->client_type != ob2->client_type
241 || ob1->materialname != ob2->materialname
242 || ob1->lore != ob2->lore
243 || ob1->subtype != ob2->subtype
244 || ob1->move_type != ob2->move_type
245 || ob1->move_block != ob2->move_block
246 || ob1->move_allow != ob2->move_allow
247 || ob1->move_on != ob2->move_on
248 || ob1->move_off != ob2->move_off
249 || ob1->move_slow != ob2->move_slow
250 || ob1->move_slow_penalty != ob2->move_slow_penalty)
251 return 0;
252
253 /* This is really a spellbook check - really, we should
254 * check all objects in the inventory.
255 */
256 if (ob1->inv || ob2->inv)
257 {
258 /* if one object has inventory but the other doesn't, not equiv */
259 if ((ob1->inv && !ob2->inv) || (ob2->inv && !ob1->inv))
137 return 0; 260 return 0;
138 261
139 /* Do not merge objects if nrof would overflow. We use 1UL<<31 since that 262 /* Now check to see if the two inventory objects could merge */
140 * value could not be stored in a sint32 (which unfortunately sometimes is 263 if (!object::can_merge (ob1->inv, ob2->inv))
141 * used to store nrof).
142 */
143 if (ob1->nrof+ob2->nrof >= 1UL<<31)
144 return 0; 264 return 0;
145 265
146 /* This is really a spellbook check - really, we should
147 * check all objects in the inventory.
148 */
149 if (ob1->inv || ob2->inv) {
150 /* if one object has inventory but the other doesn't, not equiv */
151 if ((ob1->inv && !ob2->inv) || (ob2->inv && !ob1->inv)) return 0;
152
153 /* Now check to see if the two inventory objects could merge */
154 if (!CAN_MERGE(ob1->inv, ob2->inv)) return 0;
155
156 /* inventory ok - still need to check rest of this object to see 266 /* inventory ok - still need to check rest of this object to see
157 * if it is valid. 267 * if it is valid.
158 */ 268 */
159 } 269 }
160 270
161 /* If the objects have been identified, set the BEEN_APPLIED flag.
162 * This is to the comparison of the flags below will be OK. We
163 * just can't ignore the been applied or identified flags, as they
164 * are not equal - just if it has been identified, the been_applied
165 * flags lose any meaning.
166 */
167 if (QUERY_FLAG(ob1, FLAG_IDENTIFIED))
168 SET_FLAG(ob1, FLAG_BEEN_APPLIED);
169
170 if (QUERY_FLAG(ob2, FLAG_IDENTIFIED))
171 SET_FLAG(ob2, FLAG_BEEN_APPLIED);
172
173
174 /* the 0x400000 on flags2 is FLAG_INV_LOCK. I don't think something
175 * being locked in inventory should prevent merging.
176 * 0x4 in flags3 is CLIENT_SENT
177 */
178 if ((ob1->arch != ob2->arch) ||
179 (ob1->flags[0] != ob2->flags[0]) ||
180 (ob1->flags[1] != ob2->flags[1]) ||
181 ((ob1->flags[2] & ~0x400000) != (ob2->flags[2] & ~ 0x400000)) ||
182 ((ob1->flags[3] & ~0x4) != (ob2->flags[3] & ~0x4)) ||
183 (ob1->name != ob2->name) ||
184 (ob1->title != ob2->title) ||
185 (ob1->msg != ob2->msg) ||
186 (ob1->weight != ob2->weight) ||
187 (memcmp(&ob1->resist, &ob2->resist, sizeof(ob1->resist))!=0) ||
188 (memcmp(&ob1->stats, &ob2->stats, sizeof(ob1->stats))!=0) ||
189 (ob1->attacktype != ob2->attacktype) ||
190 (ob1->magic != ob2->magic) ||
191 (ob1->slaying != ob2->slaying) ||
192 (ob1->skill != ob2->skill) ||
193 (ob1->value != ob2->value) ||
194 (ob1->animation_id != ob2->animation_id) ||
195 (ob1->client_type != ob2->client_type) ||
196 (ob1->materialname != ob2->materialname) ||
197 (ob1->lore != ob2->lore) ||
198 (ob1->subtype != ob2->subtype) ||
199 (ob1->move_type != ob2->move_type) ||
200 (ob1->move_block != ob2->move_block) ||
201 (ob1->move_allow != ob2->move_allow) ||
202 (ob1->move_on != ob2->move_on) ||
203 (ob1->move_off != ob2->move_off) ||
204 (ob1->move_slow != ob2->move_slow) ||
205 (ob1->move_slow_penalty != ob2->move_slow_penalty)
206 )
207 return 0;
208
209 /* Don't merge objects that are applied. With the new 'body' code, 271 /* Don't merge objects that are applied. With the new 'body' code,
210 * it is possible for most any character to have more than one of 272 * it is possible for most any character to have more than one of
211 * some items equipped, and we don't want those to merge. 273 * some items equipped, and we don't want those to merge.
212 */ 274 */
213 if (QUERY_FLAG(ob1, FLAG_APPLIED) || QUERY_FLAG(ob2, FLAG_APPLIED)) 275 if (QUERY_FLAG (ob1, FLAG_APPLIED) || QUERY_FLAG (ob2, FLAG_APPLIED))
276 return 0;
277
278 /* Note sure why the following is the case - either the object has to
279 * be animated or have a very low speed. Is this an attempted monster
280 * check?
281 */
282 if (!QUERY_FLAG (ob1, FLAG_ANIMATE) && FABS ((ob1)->speed) > MIN_ACTIVE_SPEED)
283 return 0;
284
285 switch (ob1->type)
286 {
287 case SCROLL:
288 if (ob1->level != ob2->level)
289 return 0;
290 break;
291 }
292
293 if (ob1->key_values != NULL || ob2->key_values != NULL)
294 {
295 /* At least one of these has key_values. */
296 if ((ob1->key_values == NULL) != (ob2->key_values == NULL))
297 /* One has fields, but the other one doesn't. */
214 return 0; 298 return 0;
215
216 switch (ob1->type) {
217 case SCROLL:
218 if (ob1->level != ob2->level) return 0;
219 break;
220
221 }
222 if (ob1->key_values != NULL || ob2->key_values != NULL) {
223 /* At least one of these has key_values. */
224 if ((ob1->key_values == NULL) != (ob2->key_values == NULL)) {
225 /* One has fields, but the other one doesn't. */
226 return 0;
227 } else if (!compare_ob_value_lists(ob1, ob2)) { 299 else if (!compare_ob_value_lists (ob1, ob2))
228 return 0; 300 return 0;
229 } 301 }
302
303 //TODO: generate an event or call into perl for additional checks
304 if (ob1->self || ob2->self)
230 } 305 {
306 ob1->optimise ();
307 ob2->optimise ();
231 308
309 if (ob1->self || ob2->self)
310 return 0;
311 }
312
232 /* Everything passes, must be OK. */ 313 /* Everything passes, must be OK. */
233 return 1; 314 return 1;
234} 315}
235 316
236/* 317/*
237 * sum_weight() is a recursive function which calculates the weight 318 * sum_weight() is a recursive function which calculates the weight
238 * an object is carrying. It goes through in figures out how much 319 * an object is carrying. It goes through in figures out how much
239 * containers are carrying, and sums it up. 320 * containers are carrying, and sums it up.
240 */ 321 */
241signed long sum_weight(object *op) { 322long
323sum_weight (object *op)
324{
242 signed long sum; 325 long sum;
243 object *inv; 326 object *inv;
327
244 for(sum = 0, inv = op->inv; inv != NULL; inv = inv->below) { 328 for (sum = 0, inv = op->inv; inv != NULL; inv = inv->below)
329 {
245 if (inv->inv) 330 if (inv->inv)
246 sum_weight(inv); 331 sum_weight (inv);
247 sum += inv->carrying + inv->weight * (inv->nrof ? inv->nrof : 1); 332 sum += inv->carrying + inv->weight * (inv->nrof ? inv->nrof : 1);
248 } 333 }
334
249 if (op->type == CONTAINER && op->stats.Str) 335 if (op->type == CONTAINER && op->stats.Str)
250 sum = (sum * (100 - op->stats.Str))/100; 336 sum = (sum * (100 - op->stats.Str)) / 100;
337
251 if(op->carrying != sum) 338 if (op->carrying != sum)
252 op->carrying = sum; 339 op->carrying = sum;
340
253 return sum; 341 return sum;
254} 342}
255 343
256/** 344/**
257 * Return the outermost environment object for a given object. 345 * Return the outermost environment object for a given object.
258 */ 346 */
259 347
348object *
260object *object_get_env_recursive (object *op) { 349object_get_env_recursive (object *op)
350{
261 while (op->env != NULL) 351 while (op->env != NULL)
262 op = op->env; 352 op = op->env;
263 return op; 353 return op;
264}
265
266/*
267 * Eneq(@csd.uu.se): Since we can have items buried in a character we need
268 * a better check. We basically keeping traversing up until we can't
269 * or find a player.
270 */
271
272object *is_player_inv (object *op) {
273 for (;op!=NULL&&op->type!=PLAYER; op=op->env)
274 if (op->env==op)
275 op->env = NULL;
276 return op;
277} 354}
278 355
279/* 356/*
280 * Used by: Crossedit: dump. Server DM commands: dumpbelow, dump. 357 * Used by: Crossedit: dump. Server DM commands: dumpbelow, dump.
281 * Some error messages. 358 * Some error messages.
282 * The result of the dump is stored in the static global errmsg array. 359 * The result of the dump is stored in the static global errmsg array.
283 */ 360 */
284 361
285void dump_object2(object *op) { 362char *
286 char *cp;
287/* object *tmp;*/
288
289 if(op->arch!=NULL) {
290 strcat(errmsg,"arch ");
291 strcat(errmsg,op->arch->name?op->arch->name:"(null)");
292 strcat(errmsg,"\n");
293 if((cp=get_ob_diff(op,&empty_archetype->clone))!=NULL)
294 strcat(errmsg,cp);
295#if 0
296 /* Don't dump player diffs - they are too long, mostly meaningless, and
297 * will overflow the buffer.
298 * Changed so that we don't dump inventory either. This may
299 * also overflow the buffer.
300 */
301 if(op->type!=PLAYER && (cp=get_ob_diff(op,&empty_archetype->clone))!=NULL)
302 strcat(errmsg,cp);
303 for (tmp=op->inv; tmp; tmp=tmp->below)
304 dump_object2(tmp);
305#endif
306 strcat(errmsg,"end\n");
307 } else {
308 strcat(errmsg,"Object ");
309 if (op->name==NULL) strcat(errmsg, "(null)");
310 else strcat(errmsg,op->name);
311 strcat(errmsg,"\n");
312#if 0
313 if((cp=get_ob_diff(op,&empty_archetype->clone))!=NULL)
314 strcat(errmsg,cp);
315 for (tmp=op->inv; tmp; tmp=tmp->below)
316 dump_object2(tmp);
317#endif
318 strcat(errmsg,"end\n");
319 }
320}
321
322/*
323 * Dumps an object. Returns output in the static global errmsg array.
324 */
325
326void dump_object(object *op) { 363dump_object (object *op)
327 if(op==NULL) {
328 strcpy(errmsg,"[NULL pointer]");
329 return;
330 }
331 errmsg[0]='\0';
332 dump_object2(op);
333}
334
335/* GROS - Dumps an object. Return the result into a string */
336/* Note that no checking is done for the validity of the target string, so */
337/* you need to be sure that you allocated enough space for it. */
338void dump_me(object *op, char *outstr)
339{ 364{
340 char *cp; 365 if (!op)
366 return strdup ("[NULLOBJ]");
341 367
342 if(op==NULL) 368 object_freezer freezer;
343 { 369 save_object (freezer, op, 3);
344 strcpy(outstr,"[NULL pointer]"); 370 return freezer.as_string ();
345 return;
346 }
347 outstr[0]='\0';
348
349 if(op->arch!=NULL)
350 {
351 strcat(outstr,"arch ");
352 strcat(outstr,op->arch->name?op->arch->name:"(null)");
353 strcat(outstr,"\n");
354 if((cp=get_ob_diff(op,&empty_archetype->clone))!=NULL)
355 strcat(outstr,cp);
356 strcat(outstr,"end\n");
357 }
358 else
359 {
360 strcat(outstr,"Object ");
361 if (op->name==NULL)
362 strcat(outstr, "(null)");
363 else
364 strcat(outstr,op->name);
365 strcat(outstr,"\n");
366 strcat(outstr,"end\n");
367 }
368}
369
370/*
371 * This is really verbose...Can be triggered by the P key while in DM mode.
372 * All objects are dumped to stderr (or alternate logfile, if in server-mode)
373 */
374
375void dump_all_objects(void) {
376 object *op;
377 for(op=objects;op!=NULL;op=op->next) {
378 dump_object(op);
379 fprintf(logfile, "Object %d\n:%s\n", op->count, errmsg);
380 }
381} 371}
382 372
383/* 373/*
384 * get_nearest_part(multi-object, object 2) returns the part of the 374 * get_nearest_part(multi-object, object 2) returns the part of the
385 * multi-object 1 which is closest to the second object. 375 * multi-object 1 which is closest to the second object.
386 * If it's not a multi-object, it is returned. 376 * If it's not a multi-object, it is returned.
387 */ 377 */
388 378
379object *
389object *get_nearest_part(object *op, const object *pl) { 380get_nearest_part (object *op, const object *pl)
381{
390 object *tmp,*closest; 382 object *tmp, *closest;
391 int last_dist,i; 383 int last_dist, i;
384
392 if(op->more==NULL) 385 if (op->more == NULL)
393 return op; 386 return op;
394 for(last_dist=distance(op,pl),closest=op,tmp=op->more;tmp!=NULL;tmp=tmp->more) 387 for (last_dist = distance (op, pl), closest = op, tmp = op->more; tmp != NULL; tmp = tmp->more)
395 if((i=distance(tmp,pl))<last_dist) 388 if ((i = distance (tmp, pl)) < last_dist)
396 closest=tmp,last_dist=i; 389 closest = tmp, last_dist = i;
397 return closest; 390 return closest;
398} 391}
399 392
400/* 393/*
401 * Returns the object which has the count-variable equal to the argument. 394 * Returns the object which has the count-variable equal to the argument.
402 */ 395 */
403 396
397object *
404object *find_object(tag_t i) { 398find_object (tag_t i)
405 object *op; 399{
406 for(op=objects;op!=NULL;op=op->next) 400 for (object *op = object::first; op; op = op->next)
407 if(op->count==i) 401 if (op->count == i)
408 break; 402 return op;
403
409 return op; 404 return 0;
410} 405}
411 406
412/* 407/*
413 * Returns the first object which has a name equal to the argument. 408 * Returns the first object which has a name equal to the argument.
414 * Used only by the patch command, but not all that useful. 409 * Used only by the patch command, but not all that useful.
415 * Enables features like "patch <name-of-other-player> food 999" 410 * Enables features like "patch <name-of-other-player> food 999"
416 */ 411 */
417 412
413object *
418object *find_object_name(const char *str) { 414find_object_name (const char *str)
419 const char *name=add_string(str); 415{
416 shstr_cmp str_ (str);
420 object *op; 417 object *op;
418
421 for(op=objects;op!=NULL;op=op->next) 419 for (op = object::first; op != NULL; op = op->next)
422 if(op->name==name) 420 if (op->name == str_)
423 break; 421 break;
424 free_string(name); 422
425 return op; 423 return op;
426} 424}
427 425
426void
428void free_all_object_data(void) { 427free_all_object_data ()
429#ifdef MEMORY_DEBUG
430 object *op, *next;
431
432 for (op=free_objects; op!=NULL; ) {
433 next=op->next;
434 free(op);
435 nrofallocobjects--;
436 nroffreeobjects--;
437 op=next;
438 }
439#endif
440 LOG(llevDebug,"%d allocated objects, %d free objects, STARMAX=%d\n",
441 nrofallocobjects, nroffreeobjects,STARTMAX);
442}
443
444/*
445 * Returns the object which this object marks as being the owner.
446 * A id-scheme is used to avoid pointing to objects which have been
447 * freed and are now reused. If this is detected, the owner is
448 * set to NULL, and NULL is returned.
449 * Changed 2004-02-12 - if the player is setting at the play again
450 * prompt, he is removed, and we don't want to treat him as an owner of
451 * anything, so check removed flag. I don't expect that this should break
452 * anything - once an object is removed, it is basically dead anyways.
453 */
454
455object *get_owner(object *op) {
456 if(op->owner==NULL)
457 return NULL;
458
459 if (!QUERY_FLAG(op->owner,FLAG_FREED) && !QUERY_FLAG(op->owner, FLAG_REMOVED) &&
460 op->owner->count==op->ownercount)
461 return op->owner;
462
463 op->owner=NULL;
464 op->ownercount=0;
465 return NULL;
466}
467
468void clear_owner(object *op)
469{ 428{
470 if (!op) return; 429 LOG (llevDebug, "%d allocated objects\n", nrofallocobjects);
471
472 if (op->owner && op->ownercount == op->owner->count)
473 op->owner->refcount--;
474
475 op->owner = NULL;
476 op->ownercount = 0;
477} 430}
478
479
480 431
481/* 432/*
482 * Sets the owner and sets the skill and exp pointers to owner's current 433 * Sets the owner and sets the skill and exp pointers to owner's current
483 * skill and experience objects. 434 * skill and experience objects.
484 */ 435 */
485void set_owner (object *op, object *owner) 436void
437object::set_owner (object *owner)
486{ 438{
487 if(owner==NULL||op==NULL) 439 if (!owner)
488 return; 440 return;
489 441
490 /* next line added to allow objects which own objects */ 442 /* next line added to allow objects which own objects */
491 /* Add a check for ownercounts in here, as I got into an endless loop 443 /* Add a check for ownercounts in here, as I got into an endless loop
492 * with the fireball owning a poison cloud which then owned the 444 * with the fireball owning a poison cloud which then owned the
493 * fireball. I believe that was caused by one of the objects getting 445 * fireball. I believe that was caused by one of the objects getting
494 * freed and then another object replacing it. Since the ownercounts 446 * freed and then another object replacing it. Since the ownercounts
495 * didn't match, this check is valid and I believe that cause is valid. 447 * didn't match, this check is valid and I believe that cause is valid.
496 */ 448 */
497 while (owner->owner && owner!=owner->owner && 449 while (owner->owner)
498 owner->ownercount==owner->owner->count) owner=owner->owner; 450 owner = owner->owner;
499 451
500 /* IF the owner still has an owner, we did not resolve to a final owner.
501 * so lets not add to that.
502 */
503 if (owner->owner) return;
504
505 op->owner=owner; 452 this->owner = owner;
506
507 op->ownercount=owner->count;
508 owner->refcount++;
509
510}
511
512/* Set the owner to clone's current owner and set the skill and experience
513 * objects to clone's objects (typically those objects that where the owner's
514 * current skill and experience objects at the time when clone's owner was
515 * set - not the owner's current skill and experience objects).
516 *
517 * Use this function if player created an object (e.g. fire bullet, swarm
518 * spell), and this object creates further objects whose kills should be
519 * accounted for the player's original skill, even if player has changed
520 * skills meanwhile.
521 */
522void copy_owner (object *op, object *clone)
523{
524 object *owner = get_owner (clone);
525 if (owner == NULL) {
526 /* players don't have owners - they own themselves. Update
527 * as appropriate.
528 */
529 if (clone->type == PLAYER) owner=clone;
530 else return;
531 }
532 set_owner(op, owner);
533
534}
535
536/*
537 * Resets vital variables in an object
538 */
539
540void reset_object(object *op) {
541
542 op->name = NULL;
543 op->name_pl = NULL;
544 op->title = NULL;
545 op->race = NULL;
546 op->slaying = NULL;
547 op->skill = NULL;
548 op->msg = NULL;
549 op->materialname = NULL;
550 op->lore = NULL;
551 clear_object(op);
552} 453}
553 454
554/* Zero the key_values on op, decrementing the shared-string 455/* Zero the key_values on op, decrementing the shared-string
555 * refcounts and freeing the links. 456 * refcounts and freeing the links.
556 */ 457 */
458static void
557static void free_key_values(object * op) { 459free_key_values (object *op)
558 key_value * i; 460{
559 key_value * next = NULL; 461 for (key_value *i = op->key_values; i != 0;)
560 462 {
561 if (op->key_values == NULL) return; 463 key_value *next = i->next;
464 delete i;
465
466 i = next;
562 467 }
563 for (i = op->key_values; i != NULL; i = next) { 468
564 /* Store next *first*. */
565 next = i->next;
566
567 if (i->key) FREE_AND_CLEAR_STR(i->key);
568 if (i->value) FREE_AND_CLEAR_STR(i->value);
569 i->next = NULL;
570 free(i);
571 }
572
573 op->key_values = NULL; 469 op->key_values = 0;
574} 470}
575 471
472void object::clear ()
473{
474 attachable_base::clear ();
576 475
577/*
578 * clear_object() frees everything allocated by an object, and also
579 * clears all variables and flags to default settings.
580 */
581
582void clear_object(object *op) {
583 op->clear ();
584
585 event *evt;
586 event *evt2;
587
588 /* redo this to be simpler/more efficient. Was also seeing
589 * crashes in the old code. Move this to the top - am
590 * seeing periodic crashes in this code, and would like to have
591 * as much info available as possible (eg, object name).
592 */
593 for (evt = op->events; evt; evt=evt2) {
594 evt2 = evt->next;
595
596 if (evt->hook != NULL) FREE_AND_CLEAR_STR(evt->hook);
597 if (evt->plugin != NULL) FREE_AND_CLEAR_STR(evt->plugin);
598 if (evt->options != NULL) FREE_AND_CLEAR_STR(evt->options);
599
600 free(evt);
601 }
602 op->events = NULL;
603
604 free_key_values(op); 476 free_key_values (this);
605 477
606 /* the memset will clear all these values for us, but we need 478 owner = 0;
607 * to reduce the refcount on them. 479 name = 0;
608 */ 480 name_pl = 0;
609 if (op->name!=NULL) FREE_AND_CLEAR_STR(op->name); 481 title = 0;
610 if (op->name_pl!=NULL) FREE_AND_CLEAR_STR(op->name_pl); 482 race = 0;
611 if (op->title != NULL) FREE_AND_CLEAR_STR(op->title); 483 slaying = 0;
612 if (op->race!=NULL) FREE_AND_CLEAR_STR(op->race); 484 skill = 0;
613 if (op->slaying!=NULL) FREE_AND_CLEAR_STR(op->slaying); 485 msg = 0;
614 if (op->skill!=NULL) FREE_AND_CLEAR_STR(op->skill); 486 lore = 0;
615 if (op->msg!=NULL) FREE_AND_CLEAR_STR(op->msg); 487 custom_name = 0;
616 if (op->lore!=NULL) FREE_AND_CLEAR_STR(op->lore); 488 materialname = 0;
617 if (op->materialname!= NULL) FREE_AND_CLEAR_STR(op->materialname); 489 contr = 0;
490 below = 0;
491 above = 0;
492 inv = 0;
493 container = 0;
494 env = 0;
495 more = 0;
496 head = 0;
497 map = 0;
498 active_next = 0;
499 active_prev = 0;
618 500
501 memset (static_cast<object_pod *>(this), 0, sizeof (object_pod));
619 502
620 memset((void*)op, 0, sizeof (object_special));
621 /* Below here, we clear things that are not done by the memset,
622 * or set default values that are not zero.
623 */
624 /* This is more or less true */
625 SET_FLAG(op, FLAG_REMOVED); 503 SET_FLAG (this, FLAG_REMOVED);
626 504
627
628 op->contr = NULL;
629 op->below=NULL;
630 op->above=NULL;
631 op->inv=NULL;
632 op->events=NULL;
633 op->container=NULL;
634 op->env=NULL;
635 op->more=NULL;
636 op->head=NULL;
637 op->map=NULL;
638 op->refcount=0;
639 op->active_next = NULL;
640 op->active_prev = NULL;
641 /* What is not cleared is next, prev, and count */ 505 /* What is not cleared is next, prev, and count */
642 506
643 op->expmul=1.0; 507 expmul = 1.0;
644 op->face = blank_face; 508 face = blank_face;
645 op->attacked_by_count = (tag_t) -1; 509
646 if (settings.casting_time) 510 if (settings.casting_time)
647 op->casting_time = -1; 511 casting_time = -1;
648
649} 512}
650 513
651/* 514/*
652 * copy object first frees everything allocated by the second object, 515 * copy_to first frees everything allocated by the dst object,
653 * and then copies the contends of the first object into the second 516 * and then copies the contents of itself into the second
654 * object, allocating what needs to be allocated. Basically, any 517 * object, allocating what needs to be allocated. Basically, any
655 * data that is malloc'd needs to be re-malloc/copied. Otherwise, 518 * data that is malloc'd needs to be re-malloc/copied. Otherwise,
656 * if the first object is freed, the pointers in the new object 519 * if the first object is freed, the pointers in the new object
657 * will point at garbage. 520 * will point at garbage.
658 */ 521 */
522void
523object::copy_to (object *dst)
524{
525 bool is_freed = QUERY_FLAG (dst, FLAG_FREED);
526 bool is_removed = QUERY_FLAG (dst, FLAG_REMOVED);
659 527
660void copy_object(object *op2, object *op) { 528 *(object_copy *)dst = *this;
661 int is_freed=QUERY_FLAG(op,FLAG_FREED),is_removed=QUERY_FLAG(op,FLAG_REMOVED); 529 *(object_pod *)dst = *this;
662 event *evt, *evt2, *evt_new;
663 530
664 op->clear (); 531 if (self || cb)
532 INVOKE_OBJECT (CLONE, this, ARG_OBJECT (dst));
665 533
666 /* Decrement the refcounts, but don't bother zeroing the fields; 534 if (is_freed)
667 they'll be overwritten by memcpy. */ 535 SET_FLAG (dst, FLAG_FREED);
668 if(op->name!=NULL) free_string(op->name);
669 if(op->name_pl!=NULL) free_string(op->name_pl);
670 if(op->title!=NULL) free_string(op->title);
671 if(op->race!=NULL) free_string(op->race);
672 if(op->slaying!=NULL) free_string(op->slaying);
673 if(op->skill!=NULL) free_string(op->skill);
674 if(op->msg!=NULL) free_string(op->msg);
675 if(op->lore!=NULL) free_string(op->lore);
676 if(op->materialname != NULL) free_string(op->materialname);
677 if(op->custom_name != NULL) free_string(op->custom_name);
678 536
679 /* Basically, same code as from clear_object() */ 537 if (is_removed)
680 for (evt = op->events; evt; evt=evt2) { 538 SET_FLAG (dst, FLAG_REMOVED);
681 evt2 = evt->next;
682 539
683 if (evt->hook != NULL) FREE_AND_CLEAR_STR(evt->hook); 540 if (speed < 0)
684 if (evt->plugin != NULL) FREE_AND_CLEAR_STR(evt->plugin);
685 if (evt->options != NULL) FREE_AND_CLEAR_STR(evt->options);
686
687 free(evt);
688 }
689 op->events = NULL;
690
691 free_key_values(op);
692
693 *(object_special *)op = *(object_special *)op2;
694 op2->clone (op);
695
696 if(is_freed) SET_FLAG(op,FLAG_FREED);
697 if(is_removed) SET_FLAG(op,FLAG_REMOVED);
698 if(op->name!=NULL) add_refcount(op->name);
699 if(op->name_pl!=NULL) add_refcount(op->name_pl);
700 if(op->title!=NULL) add_refcount(op->title);
701 if(op->race!=NULL) add_refcount(op->race);
702 if(op->slaying!=NULL) add_refcount(op->slaying);
703 if(op->skill!=NULL) add_refcount(op->skill);
704 if(op->lore!=NULL) add_refcount(op->lore);
705 if(op->msg!=NULL) add_refcount(op->msg);
706 if(op->custom_name!=NULL) add_refcount(op->custom_name);
707 if (op->materialname != NULL) add_refcount(op->materialname);
708
709 if((op2->speed<0) && !editor)
710 op->speed_left=op2->speed_left-RANDOM()%200/100.0; 541 dst->speed_left = speed_left - RANDOM () % 200 / 100.0;
711 542
712 /* Copy over event information */
713 evt2 = NULL;
714 for (evt = op2->events; evt; evt=evt->next) {
715 evt_new = (event *) malloc(sizeof(event));
716 memcpy(evt_new, evt, sizeof(event));
717 if (evt_new->hook) add_refcount(evt_new->hook);
718 if (evt_new->plugin) add_refcount(evt_new->plugin);
719 if (evt_new->options) add_refcount(evt_new->options);
720 evt_new->next = NULL;
721
722 /* Try to be a little clever here, and store away the
723 * last event we copied, so that its simpler to update the
724 * pointer.
725 */
726 if (evt2)
727 evt2->next = evt_new;
728 else
729 op->events = evt_new;
730
731 evt2 = evt_new;
732 }
733 /* Copy over key_values, if any. */ 543 /* Copy over key_values, if any. */
734 if (op2->key_values != NULL) { 544 if (key_values)
545 {
735 key_value * tail = NULL; 546 key_value *tail = 0;
736 key_value * i; 547 key_value *i;
737 548
738 op->key_values = NULL; 549 dst->key_values = 0;
739 550
740 for (i = op2->key_values; i != NULL; i = i->next) { 551 for (i = key_values; i; i = i->next)
741 key_value * new_link = (key_value *) malloc(sizeof(key_value)); 552 {
553 key_value *new_link = new key_value;
742 554
743 new_link->next = NULL; 555 new_link->next = 0;
744 new_link->key = add_refcount(i->key); 556 new_link->key = i->key;
745 if (i->value)
746 new_link->value = add_refcount(i->value); 557 new_link->value = i->value;
747 else
748 new_link->value = NULL;
749 558
750 /* Try and be clever here, too. */ 559 /* Try and be clever here, too. */
751 if (op->key_values == NULL) { 560 if (!dst->key_values)
561 {
752 op->key_values = new_link; 562 dst->key_values = new_link;
753 tail = new_link; 563 tail = new_link;
564 }
754 } else { 565 else
566 {
755 tail->next = new_link; 567 tail->next = new_link;
756 tail = new_link; 568 tail = new_link;
757 } 569 }
758 } 570 }
759 } 571 }
760 572
761 update_ob_speed(op); 573 update_ob_speed (dst);
762} 574}
763 575
764/*
765 * expand_objects() allocates more objects for the list of unused objects.
766 * It is called from get_object() if the unused list is empty.
767 */
768
769void expand_objects(void) {
770 int i;
771 object *obj;
772 obj = (object *) CALLOC(OBJ_EXPAND,sizeof(object));
773
774 if(obj==NULL)
775 fatal(OUT_OF_MEMORY);
776 free_objects=obj;
777 obj[0].prev=NULL;
778 obj[0].next= &obj[1],
779 SET_FLAG(&(obj[0]), FLAG_REMOVED);
780 SET_FLAG(&(obj[0]), FLAG_FREED);
781
782 for(i=1;i<OBJ_EXPAND-1;i++) {
783 obj[i].next= &obj[i+1],
784 obj[i].prev= &obj[i-1],
785 SET_FLAG(&(obj[i]), FLAG_REMOVED);
786 SET_FLAG(&(obj[i]), FLAG_FREED);
787 }
788 obj[OBJ_EXPAND-1].prev= &obj[OBJ_EXPAND-2],
789 obj[OBJ_EXPAND-1].next=NULL,
790 SET_FLAG(&(obj[OBJ_EXPAND-1]), FLAG_REMOVED);
791 SET_FLAG(&(obj[OBJ_EXPAND-1]), FLAG_FREED);
792
793 nrofallocobjects += OBJ_EXPAND;
794 nroffreeobjects += OBJ_EXPAND;
795}
796
797/*
798 * get_object() grabs an object from the list of unused objects, makes
799 * sure it is initialised, and returns it.
800 * If there are no free objects, expand_objects() is called to get more.
801 */
802
803object *get_object(void) {
804 object *op; 576object *
805 577object::clone ()
806 if(free_objects==NULL) { 578{
807 expand_objects(); 579 object *neu = create ();
808 } 580 copy_to (neu);
809 op=free_objects;
810#ifdef MEMORY_DEBUG
811 /* The idea is hopefully by doing a realloc, the memory
812 * debugging program will now use the current stack trace to
813 * report leaks.
814 */
815 op = realloc(op, sizeof(object));
816 SET_FLAG(op, FLAG_REMOVED);
817 SET_FLAG(op, FLAG_FREED);
818#endif
819
820 if(!QUERY_FLAG(op,FLAG_FREED)) {
821 LOG(llevError,"Fatal: Getting busy object.\n");
822 }
823 free_objects=op->next;
824 if(free_objects!=NULL)
825 free_objects->prev=NULL;
826 op->count= ++ob_count;
827 op->name=NULL;
828 op->name_pl=NULL;
829 op->title=NULL;
830 op->race=NULL;
831 op->slaying=NULL;
832 op->skill = NULL;
833 op->lore=NULL;
834 op->msg=NULL;
835 op->materialname=NULL;
836 op->next=objects;
837 op->prev=NULL;
838 op->active_next = NULL;
839 op->active_prev = NULL;
840 if(objects!=NULL)
841 objects->prev=op;
842 objects=op;
843 clear_object(op);
844 SET_FLAG(op,FLAG_REMOVED);
845 nroffreeobjects--;
846 return op; 581 return neu;
847} 582}
848 583
849/* 584/*
850 * If an object with the IS_TURNABLE() flag needs to be turned due 585 * If an object with the IS_TURNABLE() flag needs to be turned due
851 * to the closest player being on the other side, this function can 586 * to the closest player being on the other side, this function can
852 * be called to update the face variable, _and_ how it looks on the map. 587 * be called to update the face variable, _and_ how it looks on the map.
853 */ 588 */
854 589
590void
855void update_turn_face(object *op) { 591update_turn_face (object *op)
592{
856 if(!QUERY_FLAG(op,FLAG_IS_TURNABLE)||op->arch==NULL) 593 if (!QUERY_FLAG (op, FLAG_IS_TURNABLE) || op->arch == NULL)
857 return; 594 return;
858 SET_ANIMATION(op, op->direction); 595 SET_ANIMATION (op, op->direction);
859 update_object(op,UP_OBJ_FACE); 596 update_object (op, UP_OBJ_FACE);
860} 597}
861 598
862/* 599/*
863 * Updates the speed of an object. If the speed changes from 0 to another 600 * Updates the speed of an object. If the speed changes from 0 to another
864 * value, or vice versa, then add/remove the object from the active list. 601 * value, or vice versa, then add/remove the object from the active list.
865 * This function needs to be called whenever the speed of an object changes. 602 * This function needs to be called whenever the speed of an object changes.
866 */ 603 */
867 604void
868void update_ob_speed(object *op) { 605update_ob_speed (object *op)
606{
869 extern int arch_init; 607 extern int arch_init;
870 608
871 /* No reason putting the archetypes objects on the speed list, 609 /* No reason putting the archetypes objects on the speed list,
872 * since they never really need to be updated. 610 * since they never really need to be updated.
873 */ 611 */
874 612
875 if (QUERY_FLAG(op, FLAG_FREED) && op->speed) { 613 if (QUERY_FLAG (op, FLAG_FREED) && op->speed)
614 {
876 LOG(llevError,"Object %s is freed but has speed.\n", op->name); 615 LOG (llevError, "Object %s is freed but has speed.\n", &op->name);
877#ifdef MANY_CORES 616#ifdef MANY_CORES
878 abort(); 617 abort ();
879#else 618#else
880 op->speed = 0; 619 op->speed = 0;
881#endif 620#endif
882 } 621 }
622
883 if (arch_init) { 623 if (arch_init)
624 return;
625
626 if (FABS (op->speed) > MIN_ACTIVE_SPEED)
627 {
628 /* If already on active list, don't do anything */
629 if (op->active_next || op->active_prev || op == active_objects)
884 return; 630 return;
885 }
886 if (FABS(op->speed)>MIN_ACTIVE_SPEED) {
887 /* If already on active list, don't do anything */
888 if (op->active_next || op->active_prev || op==active_objects)
889 return;
890 631
891 /* process_events() expects us to insert the object at the beginning 632 /* process_events() expects us to insert the object at the beginning
892 * of the list. */ 633 * of the list. */
893 op->active_next = active_objects; 634 op->active_next = active_objects;
635
894 if (op->active_next!=NULL) 636 if (op->active_next != NULL)
895 op->active_next->active_prev = op; 637 op->active_next->active_prev = op;
638
896 active_objects = op; 639 active_objects = op;
640 }
641 else
897 } 642 {
898 else {
899 /* If not on the active list, nothing needs to be done */ 643 /* If not on the active list, nothing needs to be done */
900 if (!op->active_next && !op->active_prev && op!=active_objects) 644 if (!op->active_next && !op->active_prev && op != active_objects)
901 return; 645 return;
902 646
903 if (op->active_prev==NULL) { 647 if (op->active_prev == NULL)
648 {
904 active_objects = op->active_next; 649 active_objects = op->active_next;
650
905 if (op->active_next!=NULL) 651 if (op->active_next != NULL)
906 op->active_next->active_prev = NULL; 652 op->active_next->active_prev = NULL;
907 } 653 }
908 else { 654 else
655 {
909 op->active_prev->active_next = op->active_next; 656 op->active_prev->active_next = op->active_next;
657
910 if (op->active_next) 658 if (op->active_next)
911 op->active_next->active_prev = op->active_prev; 659 op->active_next->active_prev = op->active_prev;
912 } 660 }
661
913 op->active_next = NULL; 662 op->active_next = NULL;
914 op->active_prev = NULL; 663 op->active_prev = NULL;
915 } 664 }
916} 665}
917 666
918/* This function removes object 'op' from the list of active 667/* This function removes object 'op' from the list of active
919 * objects. 668 * objects.
… …
921 * reference maps where you don't want an object that isn't 670 * reference maps where you don't want an object that isn't
922 * in play chewing up cpu time getting processed. 671 * in play chewing up cpu time getting processed.
923 * The reverse of this is to call update_ob_speed, which 672 * The reverse of this is to call update_ob_speed, which
924 * will do the right thing based on the speed of the object. 673 * will do the right thing based on the speed of the object.
925 */ 674 */
675void
926void remove_from_active_list(object *op) 676remove_from_active_list (object *op)
927{ 677{
928 /* If not on the active list, nothing needs to be done */ 678 /* If not on the active list, nothing needs to be done */
929 if (!op->active_next && !op->active_prev && op!=active_objects) 679 if (!op->active_next && !op->active_prev && op != active_objects)
930 return; 680 return;
931 681
932 if (op->active_prev==NULL) { 682 if (op->active_prev == NULL)
683 {
933 active_objects = op->active_next; 684 active_objects = op->active_next;
934 if (op->active_next!=NULL) 685 if (op->active_next != NULL)
935 op->active_next->active_prev = NULL; 686 op->active_next->active_prev = NULL;
687 }
688 else
936 } 689 {
937 else {
938 op->active_prev->active_next = op->active_next; 690 op->active_prev->active_next = op->active_next;
939 if (op->active_next) 691 if (op->active_next)
940 op->active_next->active_prev = op->active_prev; 692 op->active_next->active_prev = op->active_prev;
941 } 693 }
942 op->active_next = NULL; 694 op->active_next = NULL;
943 op->active_prev = NULL; 695 op->active_prev = NULL;
944} 696}
945 697
946/* 698/*
947 * update_object() updates the array which represents the map. 699 * update_object() updates the the map.
948 * It takes into account invisible objects (and represent squares covered 700 * It takes into account invisible objects (and represent squares covered
949 * by invisible objects by whatever is below them (unless it's another 701 * by invisible objects by whatever is below them (unless it's another
950 * invisible object, etc...) 702 * invisible object, etc...)
951 * If the object being updated is beneath a player, the look-window 703 * If the object being updated is beneath a player, the look-window
952 * of that player is updated (this might be a suboptimal way of 704 * of that player is updated (this might be a suboptimal way of
953 * updating that window, though, since update_object() is called _often_) 705 * updating that window, though, since update_object() is called _often_)
954 * 706 *
955 * action is a hint of what the caller believes need to be done. 707 * action is a hint of what the caller believes need to be done.
956 * For example, if the only thing that has changed is the face (due to
957 * an animation), we don't need to call update_position until that actually
958 * comes into view of a player. OTOH, many other things, like addition/removal
959 * of walls or living creatures may need us to update the flags now.
960 * current action are: 708 * current action are:
961 * UP_OBJ_INSERT: op was inserted 709 * UP_OBJ_INSERT: op was inserted
962 * UP_OBJ_REMOVE: op was removed 710 * UP_OBJ_REMOVE: op was removed
963 * UP_OBJ_CHANGE: object has somehow changed. In this case, we always update 711 * UP_OBJ_CHANGE: object has somehow changed. In this case, we always update
964 * as that is easier than trying to look at what may have changed. 712 * as that is easier than trying to look at what may have changed.
965 * UP_OBJ_FACE: only the objects face has changed. 713 * UP_OBJ_FACE: only the objects face has changed.
966 */ 714 */
967 715void
968void update_object(object *op, int action) { 716update_object (object *op, int action)
969 int update_now=0, flags; 717{
970 MoveType move_on, move_off, move_block, move_slow; 718 MoveType move_on, move_off, move_block, move_slow;
971 719
972 if (op == NULL) { 720 if (op == NULL)
721 {
973 /* this should never happen */ 722 /* this should never happen */
974 LOG(llevDebug,"update_object() called for NULL object.\n"); 723 LOG (llevDebug, "update_object() called for NULL object.\n");
975 return; 724 return;
976 }
977 725 }
978 if(op->env!=NULL) { 726
727 if (op->env)
728 {
979 /* Animation is currently handled by client, so nothing 729 /* Animation is currently handled by client, so nothing
980 * to do in this case. 730 * to do in this case.
981 */ 731 */
982 return; 732 return;
983 } 733 }
984 734
985 /* If the map is saving, don't do anything as everything is 735 /* If the map is saving, don't do anything as everything is
986 * going to get freed anyways. 736 * going to get freed anyways.
987 */ 737 */
988 if (!op->map || op->map->in_memory == MAP_SAVING) return; 738 if (!op->map || op->map->in_memory == MAP_SAVING)
989 739 return;
740
990 /* make sure the object is within map boundaries */ 741 /* make sure the object is within map boundaries */
991 if (op->x < 0 || op->x >= MAP_WIDTH(op->map) || 742 if (op->x < 0 || op->x >= MAP_WIDTH (op->map) || op->y < 0 || op->y >= MAP_HEIGHT (op->map))
992 op->y < 0 || op->y >= MAP_HEIGHT(op->map)) { 743 {
993 LOG(llevError,"update_object() called for object out of map!\n"); 744 LOG (llevError, "update_object() called for object out of map!\n");
994#ifdef MANY_CORES 745#ifdef MANY_CORES
995 abort(); 746 abort ();
996#endif 747#endif
997 return; 748 return;
998 }
999 749 }
1000 flags = GET_MAP_FLAGS(op->map, op->x, op->y);
1001 SET_MAP_FLAGS(op->map, op->x, op->y, flags | P_NEED_UPDATE);
1002 move_slow = GET_MAP_MOVE_SLOW(op->map, op->x, op->y);
1003 move_on = GET_MAP_MOVE_ON(op->map, op->x, op->y);
1004 move_block = GET_MAP_MOVE_BLOCK(op->map, op->x, op->y);
1005 move_off = GET_MAP_MOVE_OFF(op->map, op->x, op->y);
1006 750
751 mapspace &m = op->ms ();
752
753 if (m.flags_ & P_NEED_UPDATE)
754 /* nop */;
1007 if (action == UP_OBJ_INSERT) { 755 else if (action == UP_OBJ_INSERT)
756 {
757 // this is likely overkill, TODO: revisit (schmorp)
1008 if (QUERY_FLAG(op, FLAG_BLOCKSVIEW) && !(flags & P_BLOCKSVIEW)) 758 if ((QUERY_FLAG (op, FLAG_BLOCKSVIEW) && !(m.flags_ & P_BLOCKSVIEW))
1009 update_now=1;
1010
1011 if (QUERY_FLAG(op, FLAG_NO_MAGIC) && !(flags & P_NO_MAGIC)) 759 || (QUERY_FLAG (op, FLAG_NO_MAGIC) && !(m.flags_ & P_NO_MAGIC))
1012 update_now=1; 760 || (op->type == PLAYER && !(m.flags_ & P_PLAYER))
1013 761 || (op->type == SAFE_GROUND && !(m.flags_ & P_SAFE))
762 || (QUERY_FLAG (op, FLAG_ALIVE) && !(m.flags_ & P_IS_ALIVE))
1014 if (QUERY_FLAG(op, FLAG_DAMNED) && !(flags & P_NO_CLERIC)) 763 || (QUERY_FLAG (op, FLAG_DAMNED) && !(m.flags_ & P_NO_CLERIC))
1015 update_now=1; 764 || (m.move_on | op->move_on ) != m.move_on
1016
1017 if (QUERY_FLAG(op, FLAG_ALIVE) && !(flags & P_IS_ALIVE))
1018 update_now=1;
1019
1020 if ((move_on | op->move_on) != move_on) update_now=1;
1021 if ((move_off | op->move_off) != move_off) update_now=1; 765 || (m.move_off | op->move_off ) != m.move_off
766 || (m.move_slow | op->move_slow) != m.move_slow
1022 /* This isn't perfect, but I don't expect a lot of objects to 767 /* This isn't perfect, but I don't expect a lot of objects to
1023 * to have move_allow right now. 768 * to have move_allow right now.
1024 */ 769 */
1025 if (((move_block | op->move_block) & ~op->move_allow) != move_block) 770 || ((m.move_block | op->move_block) & ~op->move_allow) != m.move_block
1026 update_now=1; 771 || 1) // the above is not strong enough a test to skip updating. los maybe? TODO (Schmorp)
1027 if ((move_slow | op->move_slow) != move_slow) update_now=1; 772 m.flags_ = P_NEED_UPDATE;
1028 } 773 }
1029 /* if the object is being removed, we can't make intelligent 774 /* if the object is being removed, we can't make intelligent
1030 * decisions, because remove_ob can't really pass the object 775 * decisions, because remove_ob can't really pass the object
1031 * that is being removed. 776 * that is being removed.
1032 */ 777 */
1033 else if (action == UP_OBJ_CHANGE || action == UP_OBJ_REMOVE) { 778 else if (action == UP_OBJ_CHANGE || action == UP_OBJ_REMOVE)
1034 update_now=1; 779 m.flags_ = P_NEED_UPDATE;
1035 } else if (action == UP_OBJ_FACE) { 780 else if (action == UP_OBJ_FACE)
1036 /* Nothing to do for that case */ 781 /* Nothing to do for that case */ ;
1037 }
1038 else { 782 else
1039 LOG(llevError,"update_object called with invalid action: %d\n", action); 783 LOG (llevError, "update_object called with invalid action: %d\n", action);
1040 }
1041 784
1042 if (update_now) {
1043 SET_MAP_FLAGS(op->map, op->x, op->y, flags | P_NO_ERROR | P_NEED_UPDATE);
1044 update_position(op->map, op->x, op->y);
1045 }
1046
1047 if(op->more!=NULL) 785 if (op->more)
1048 update_object(op->more, action); 786 update_object (op->more, action);
1049} 787}
1050 788
789object::vector object::mortals;
790object::vector object::objects; // not yet used
791object *object::first;
792
793void object::free_mortals ()
794{
795 for (AUTODECL (i, mortals.begin ()); i != mortals.end ();)
796 if ((*i)->refcnt)
797 ++i; // further delay freeing
798 else
799 {
800 delete *i;
801 mortals.erase (i);
802 }
803}
804
805object::object ()
806{
807 SET_FLAG (this, FLAG_REMOVED);
808
809 expmul = 1.0;
810 face = blank_face;
811}
812
813object::~object ()
814{
815 free_key_values (this);
816}
817
818void object::link ()
819{
820 count = ++ob_count;
821 uuid = gen_uuid ();
822
823 prev = 0;
824 next = object::first;
825
826 if (object::first)
827 object::first->prev = this;
828
829 object::first = this;
830}
831
832void object::unlink ()
833{
834 if (this == object::first)
835 object::first = next;
836
837 /* Remove this object from the list of used objects */
838 if (prev) prev->next = next;
839 if (next) next->prev = prev;
840
841 prev = 0;
842 next = 0;
843}
844
845object *object::create ()
846{
847 object *op = new object;
848 op->link ();
849 return op;
850}
1051 851
1052/* 852/*
1053 * free_object() frees everything allocated by an object, removes 853 * free_object() frees everything allocated by an object, removes
1054 * it from the list of used objects, and puts it on the list of 854 * it from the list of used objects, and puts it on the list of
1055 * free objects. The IS_FREED() flag is set in the object. 855 * free objects. The IS_FREED() flag is set in the object.
1056 * The object must have been removed by remove_ob() first for 856 * The object must have been removed by remove_ob() first for
1057 * this function to succeed. 857 * this function to succeed.
1058 * 858 *
1059 * If free_inventory is set, free inventory as well. Else drop items in 859 * If destroy_inventory is set, free inventory as well. Else drop items in
1060 * inventory to the ground. 860 * inventory to the ground.
1061 */ 861 */
1062 862void object::destroy (bool destroy_inventory)
1063void free_object(object *ob) { 863{
1064 free_object2(ob, 0);
1065}
1066void free_object2(object *ob, int free_inventory) {
1067 object *tmp,*op;
1068
1069 ob->clear ();
1070
1071 if (!QUERY_FLAG(ob,FLAG_REMOVED)) {
1072 LOG(llevDebug,"Free object called with non removed object\n");
1073 dump_object(ob);
1074#ifdef MANY_CORES
1075 abort();
1076#endif
1077 }
1078 if(QUERY_FLAG(ob,FLAG_FRIENDLY)) {
1079 LOG(llevMonster,"Warning: tried to free friendly object.\n");
1080 remove_friendly_object(ob);
1081 }
1082 if(QUERY_FLAG(ob,FLAG_FREED)) { 864 if (QUERY_FLAG (this, FLAG_FREED))
1083 dump_object(ob);
1084 LOG(llevError,"Trying to free freed object.\n%s\n",errmsg);
1085 return; 865 return;
866
867 if (QUERY_FLAG (this, FLAG_FRIENDLY))
868 remove_friendly_object (this);
869
870 if (!QUERY_FLAG (this, FLAG_REMOVED))
871 remove ();
872
873 SET_FLAG (this, FLAG_FREED);
874
875 if (more)
1086 } 876 {
1087 if(ob->more!=NULL) { 877 more->destroy (destroy_inventory);
1088 free_object2(ob->more, free_inventory); 878 more = 0;
1089 ob->more=NULL; 879 }
880
881 if (inv)
1090 } 882 {
1091 if (ob->inv) {
1092 /* Only if the space blocks everything do we not process - 883 /* Only if the space blocks everything do we not process -
1093 * if some form of movemnt is allowed, let objects 884 * if some form of movement is allowed, let objects
1094 * drop on that space. 885 * drop on that space.
1095 */ 886 */
1096 if (free_inventory || ob->map==NULL || ob->map->in_memory!=MAP_IN_MEMORY || 887 if (destroy_inventory || !map || map->in_memory != MAP_IN_MEMORY || GET_MAP_MOVE_BLOCK (map, x, y) == MOVE_ALL)
1097 (GET_MAP_MOVE_BLOCK(ob->map, ob->x, ob->y) == MOVE_ALL))
1098 { 888 {
1099 op=ob->inv; 889 object *op = inv;
890
1100 while(op!=NULL) { 891 while (op)
892 {
1101 tmp=op->below; 893 object *tmp = op->below;
1102 remove_ob(op); 894 op->destroy (destroy_inventory);
1103 free_object2(op, free_inventory);
1104 op=tmp; 895 op = tmp;
1105 } 896 }
1106 } 897 }
898 else
1107 else { /* Put objects in inventory onto this space */ 899 { /* Put objects in inventory onto this space */
1108 op=ob->inv; 900 object *op = inv;
901
1109 while(op!=NULL) { 902 while (op)
903 {
1110 tmp=op->below; 904 object *tmp = op->below;
905
1111 remove_ob(op); 906 op->remove ();
1112 if(QUERY_FLAG(op,FLAG_STARTEQUIP)||QUERY_FLAG(op,FLAG_NO_DROP) || 907
1113 op->type==RUNE || op->type==TRAP || QUERY_FLAG(op,FLAG_IS_A_TEMPLATE)) 908 if (QUERY_FLAG (op, FLAG_STARTEQUIP)
1114 free_object(op); 909 || QUERY_FLAG (op, FLAG_NO_DROP) || op->type == RUNE || op->type == TRAP || QUERY_FLAG (op, FLAG_IS_A_TEMPLATE))
910 op->destroy ();
1115 else { 911 else
912 {
1116 op->x=ob->x; 913 op->x = x;
1117 op->y=ob->y; 914 op->y = y;
1118 insert_ob_in_map(op,ob->map,NULL,0); /* Insert in same map as the envir */ 915 insert_ob_in_map (op, map, 0, 0); /* Insert in same map as the envir */
1119 } 916 }
917
1120 op=tmp; 918 op = tmp;
1121 } 919 }
1122 } 920 }
1123 } 921 }
922
923 // hack to ensure that freed objects still have a valid map
924 {
925 static maptile *freed_map; // freed objects are moved here to avoid crashes
926
927 if (!freed_map)
928 {
929 freed_map = new maptile;
930
931 freed_map->name = "/internal/freed_objects_map";
932 freed_map->width = 3;
933 freed_map->height = 3;
934
935 freed_map->allocate ();
936 }
937
938 map = freed_map;
939 x = 1;
940 y = 1;
941 }
942
943 // clear those pointers that likely might have circular references to us
944 owner = 0;
945 enemy = 0;
946 attacked_by = 0;
947
948 // only relevant for players(?), but make sure of it anyways
949 contr = 0;
950
1124 /* Remove object from the active list */ 951 /* Remove object from the active list */
1125 ob->speed = 0; 952 speed = 0;
1126 update_ob_speed(ob); 953 update_ob_speed (this);
1127 954
1128 SET_FLAG(ob, FLAG_FREED); 955 unlink ();
1129 ob->count = 0;
1130 956
1131 /* Remove this object from the list of used objects */ 957 mortals.push_back (this);
1132 if(ob->prev==NULL) {
1133 objects=ob->next;
1134 if(objects!=NULL)
1135 objects->prev=NULL;
1136 }
1137 else {
1138 ob->prev->next=ob->next;
1139 if(ob->next!=NULL)
1140 ob->next->prev=ob->prev;
1141 }
1142
1143 if(ob->name!=NULL) FREE_AND_CLEAR_STR(ob->name);
1144 if(ob->name_pl!=NULL) FREE_AND_CLEAR_STR(ob->name_pl);
1145 if(ob->title!=NULL) FREE_AND_CLEAR_STR(ob->title);
1146 if(ob->race!=NULL) FREE_AND_CLEAR_STR(ob->race);
1147 if(ob->slaying!=NULL) FREE_AND_CLEAR_STR(ob->slaying);
1148 if(ob->skill!=NULL) FREE_AND_CLEAR_STR(ob->skill);
1149 if(ob->lore!=NULL) FREE_AND_CLEAR_STR(ob->lore);
1150 if(ob->msg!=NULL) FREE_AND_CLEAR_STR(ob->msg);
1151 if(ob->materialname!=NULL) FREE_AND_CLEAR_STR(ob->materialname);
1152
1153
1154 /* Why aren't events freed? */
1155 free_key_values(ob);
1156
1157#if 0 /* MEMORY_DEBUG*/
1158 /* This is a nice idea. Unfortunately, a lot of the code in crossfire
1159 * presumes the freed_object will stick around for at least a little
1160 * bit
1161 */
1162 /* this is necessary so that memory debugging programs will
1163 * be able to accurately report source of malloc. If we recycle
1164 * objects, then some other area may be doing the get_object
1165 * and not freeing it, but the original one that malloc'd the
1166 * object will get the blame.
1167 */
1168 free(ob);
1169#else
1170
1171 /* Now link it with the free_objects list: */
1172 ob->prev=NULL;
1173 ob->next=free_objects;
1174 if(free_objects!=NULL)
1175 free_objects->prev=ob;
1176 free_objects=ob;
1177 nroffreeobjects++;
1178#endif
1179}
1180
1181/*
1182 * count_free() returns the number of objects on the list of free objects.
1183 */
1184
1185int count_free(void) {
1186 int i=0;
1187 object *tmp=free_objects;
1188 while(tmp!=NULL)
1189 tmp=tmp->next, i++;
1190 return i;
1191}
1192
1193/*
1194 * count_used() returns the number of objects on the list of used objects.
1195 */
1196
1197int count_used(void) {
1198 int i=0;
1199 object *tmp=objects;
1200 while(tmp!=NULL)
1201 tmp=tmp->next, i++;
1202 return i;
1203}
1204
1205/*
1206 * count_active() returns the number of objects on the list of active objects.
1207 */
1208
1209int count_active(void) {
1210 int i=0;
1211 object *tmp=active_objects;
1212 while(tmp!=NULL)
1213 tmp=tmp->active_next, i++;
1214 return i;
1215} 958}
1216 959
1217/* 960/*
1218 * sub_weight() recursively (outwards) subtracts a number from the 961 * sub_weight() recursively (outwards) subtracts a number from the
1219 * weight of an object (and what is carried by it's environment(s)). 962 * weight of an object (and what is carried by it's environment(s)).
1220 */ 963 */
1221 964void
1222void sub_weight (object *op, signed long weight) { 965sub_weight (object *op, signed long weight)
966{
1223 while (op != NULL) { 967 while (op != NULL)
968 {
1224 if (op->type == CONTAINER) { 969 if (op->type == CONTAINER)
1225 weight=(signed long)(weight*(100-op->stats.Str)/100); 970 weight = (signed long) (weight * (100 - op->stats.Str) / 100);
1226 } 971
1227 op->carrying-=weight; 972 op->carrying -= weight;
1228 op = op->env; 973 op = op->env;
1229 } 974 }
1230} 975}
1231 976
1232/* remove_ob(op): 977/* op->remove ():
1233 * This function removes the object op from the linked list of objects 978 * This function removes the object op from the linked list of objects
1234 * which it is currently tied to. When this function is done, the 979 * which it is currently tied to. When this function is done, the
1235 * object will have no environment. If the object previously had an 980 * object will have no environment. If the object previously had an
1236 * environment, the x and y coordinates will be updated to 981 * environment, the x and y coordinates will be updated to
1237 * the previous environment. 982 * the previous environment.
1238 * Beware: This function is called from the editor as well! 983 * Beware: This function is called from the editor as well!
1239 */ 984 */
1240 985void
1241void remove_ob(object *op) { 986object::remove ()
987{
1242 object *tmp,*last=NULL; 988 object *tmp, *last = 0;
1243 object *otmp; 989 object *otmp;
1244 tag_t tag; 990
1245 int check_walk_off; 991 int check_walk_off;
1246 mapstruct *m;
1247 sint16 x,y;
1248
1249 992
1250 if(QUERY_FLAG(op,FLAG_REMOVED)) { 993 if (QUERY_FLAG (this, FLAG_REMOVED))
1251 dump_object(op); 994 return;
1252 LOG(llevError,"Trying to remove removed object.\n%s\n",errmsg);
1253 995
1254 /* Changed it to always dump core in this case. As has been learned
1255 * in the past, trying to recover from errors almost always
1256 * make things worse, and this is a real error here - something
1257 * that should not happen.
1258 * Yes, if this was a mission critical app, trying to do something
1259 * to recover may make sense, but that is because failure of the app
1260 * may have other disastrous problems. Cf runs out of a script
1261 * so is easily enough restarted without any real problems.
1262 * MSW 2001-07-01
1263 */
1264 abort();
1265 }
1266 if(op->more!=NULL)
1267 remove_ob(op->more);
1268
1269 SET_FLAG(op, FLAG_REMOVED); 996 SET_FLAG (this, FLAG_REMOVED);
1270 997
998 if (more)
999 more->remove ();
1000
1271 /* 1001 /*
1272 * In this case, the object to be removed is in someones 1002 * In this case, the object to be removed is in someones
1273 * inventory. 1003 * inventory.
1274 */ 1004 */
1275 if(op->env!=NULL) { 1005 if (env)
1006 {
1276 if(op->nrof) 1007 if (nrof)
1277 sub_weight(op->env, op->weight*op->nrof); 1008 sub_weight (env, weight * nrof);
1278 else 1009 else
1279 sub_weight(op->env, op->weight+op->carrying); 1010 sub_weight (env, weight + carrying);
1280 1011
1281 /* NO_FIX_PLAYER is set when a great many changes are being 1012 /* NO_FIX_PLAYER is set when a great many changes are being
1282 * made to players inventory. If set, avoiding the call 1013 * made to players inventory. If set, avoiding the call
1283 * to save cpu time. 1014 * to save cpu time.
1284 */ 1015 */
1285 if ((otmp=is_player_inv(op->env))!=NULL && otmp->contr && 1016 if ((otmp = in_player ()) && otmp->contr && !QUERY_FLAG (otmp, FLAG_NO_FIX_PLAYER))
1286 !QUERY_FLAG(otmp,FLAG_NO_FIX_PLAYER))
1287 fix_player(otmp); 1017 fix_player (otmp);
1288 1018
1289 if(op->above!=NULL) 1019 if (above != NULL)
1290 op->above->below=op->below; 1020 above->below = below;
1291 else 1021 else
1292 op->env->inv=op->below; 1022 env->inv = below;
1293 1023
1294 if(op->below!=NULL) 1024 if (below != NULL)
1295 op->below->above=op->above; 1025 below->above = above;
1296 1026
1297 /* we set up values so that it could be inserted into 1027 /* we set up values so that it could be inserted into
1298 * the map, but we don't actually do that - it is up 1028 * the map, but we don't actually do that - it is up
1299 * to the caller to decide what we want to do. 1029 * to the caller to decide what we want to do.
1030 */
1031 x = env->x, y = env->y;
1032 map = env->map;
1033 above = 0, below = 0;
1034 env = 0;
1035 }
1036 else if (map)
1037 {
1038 /* Re did the following section of code - it looks like it had
1039 * lots of logic for things we no longer care about
1040 */
1041
1042 /* link the object above us */
1043 if (above)
1044 above->below = below;
1045 else
1046 map->at (x, y).top = below; /* we were top, set new top */
1047
1048 /* Relink the object below us, if there is one */
1049 if (below)
1050 below->above = above;
1051 else
1052 {
1053 /* Nothing below, which means we need to relink map object for this space
1054 * use translated coordinates in case some oddness with map tiling is
1055 * evident
1300 */ 1056 */
1301 op->x=op->env->x,op->y=op->env->y; 1057 if (GET_MAP_OB (map, x, y) != this)
1302 op->ox=op->x,op->oy=op->y; 1058 {
1303 op->map=op->env->map; 1059 char *dump = dump_object (this);
1304 op->above=NULL,op->below=NULL; 1060 LOG (llevError,
1305 op->env=NULL; 1061 "remove_ob: GET_MAP_OB does not return object to be removed even though it appears to be on the bottom?\n%s\n", dump);
1062 free (dump);
1063 dump = dump_object (GET_MAP_OB (map, x, y));
1064 LOG (llevError, "%s\n", dump);
1065 free (dump);
1066 }
1067
1068 map->at (x, y).bottom = above; /* goes on above it. */
1069 }
1070
1071 above = 0;
1072 below = 0;
1073
1074 if (map->in_memory == MAP_SAVING)
1306 return; 1075 return;
1307 }
1308 1076
1309 /* If we get here, we are removing it from a map */ 1077 check_walk_off = !QUERY_FLAG (this, FLAG_NO_APPLY);
1310 if (op->map == NULL) return;
1311 1078
1312 x = op->x; 1079 for (tmp = GET_MAP_OB (map, x, y); tmp; tmp = tmp->above)
1313 y = op->y; 1080 {
1314 m = get_map_from_coord(op->map, &x, &y); 1081 /* No point updating the players look faces if he is the object
1315 1082 * being removed.
1316 if (!m) {
1317 LOG(llevError,"remove_ob called when object was on map but appears to not be within valid coordinates? %s (%d,%d)\n",
1318 op->map->path, op->x, op->y);
1319 /* in old days, we used to set x and y to 0 and continue.
1320 * it seems if we get into this case, something is probablye
1321 * screwed up and should be fixed.
1322 */ 1083 */
1323 abort();
1324 }
1325 if (op->map != m) {
1326 LOG(llevDebug,"remove_ob: Object not really on map it claimed to be on? %s != %s, %d,%d != %d,%d\n",
1327 op->map->path, m->path, op->x, op->y, x, y);
1328 }
1329 1084
1330 /* Re did the following section of code - it looks like it had 1085 if (tmp->type == PLAYER && tmp != this)
1331 * lots of logic for things we no longer care about 1086 {
1332 */ 1087 /* If a container that the player is currently using somehow gets
1333 1088 * removed (most likely destroyed), update the player view
1334 /* link the object above us */ 1089 * appropriately.
1335 if (op->above)
1336 op->above->below=op->below;
1337 else
1338 SET_MAP_TOP(m,x,y,op->below); /* we were top, set new top */
1339
1340 /* Relink the object below us, if there is one */
1341 if(op->below) {
1342 op->below->above=op->above;
1343 } else {
1344 /* Nothing below, which means we need to relink map object for this space
1345 * use translated coordinates in case some oddness with map tiling is
1346 * evident
1347 */ 1090 */
1348 if(GET_MAP_OB(m,x,y)!=op) { 1091 if (tmp->container == this)
1349 dump_object(op); 1092 {
1350 LOG(llevError,"remove_ob: GET_MAP_OB does not return object to be removed even though it appears to be on the bottom?\n%s\n", errmsg); 1093 CLEAR_FLAG (this, FLAG_APPLIED);
1351 dump_object(GET_MAP_OB(m,x,y)); 1094 tmp->container = 0;
1352 LOG(llevError,"%s\n",errmsg); 1095 }
1096
1097 tmp->contr->ns->floorbox_update ();
1098 }
1099
1100 /* See if player moving off should effect something */
1101 if (check_walk_off
1102 && ((move_type & tmp->move_off)
1103 && (move_type & ~tmp->move_off & ~tmp->move_block) == 0))
1104 {
1105 move_apply (tmp, this, 0);
1106
1107 if (destroyed ())
1108 LOG (llevError, "BUG: remove_ob(): name %s, destroyed leaving object\n", tmp->debug_desc ());
1109 }
1110
1111 /* Eneq(@csd.uu.se): Fixed this to skip tmp->above=tmp */
1112
1113 if (tmp->above == tmp)
1114 tmp->above = 0;
1115
1116 last = tmp;
1353 } 1117 }
1354 SET_MAP_OB(m,x,y,op->above); /* goes on above it. */
1355 }
1356 op->above=NULL;
1357 op->below=NULL;
1358 1118
1359 if (op->map->in_memory == MAP_SAVING)
1360 return;
1361
1362 tag = op->count;
1363 check_walk_off = ! QUERY_FLAG (op, FLAG_NO_APPLY);
1364 for(tmp=GET_MAP_OB(m,x,y);tmp!=NULL;tmp=tmp->above) {
1365 /* No point updating the players look faces if he is the object
1366 * being removed.
1367 */
1368
1369 if(tmp->type==PLAYER && tmp!=op) {
1370 /* If a container that the player is currently using somehow gets
1371 * removed (most likely destroyed), update the player view
1372 * appropriately.
1373 */
1374 if (tmp->container==op) {
1375 CLEAR_FLAG(op, FLAG_APPLIED);
1376 tmp->container=NULL;
1377 }
1378 tmp->contr->socket.update_look=1;
1379 }
1380 /* See if player moving off should effect something */
1381 if (check_walk_off && ((op->move_type & tmp->move_off) &&
1382 (op->move_type & ~tmp->move_off & ~tmp->move_block)==0)) {
1383
1384 move_apply(tmp, op, NULL);
1385 if (was_destroyed (op, tag)) {
1386 LOG (llevError, "BUG: remove_ob(): name %s, archname %s destroyed "
1387 "leaving object\n", tmp->name, tmp->arch->name);
1388 }
1389 }
1390
1391 /* Eneq(@csd.uu.se): Fixed this to skip tmp->above=tmp */
1392
1393 if(tmp->above == tmp)
1394 tmp->above = NULL;
1395 last=tmp;
1396 }
1397 /* last == NULL of there are no objects on this space */ 1119 /* last == NULL of there are no objects on this space */
1398 if (last==NULL) { 1120 if (!last)
1399 /* set P_NEED_UPDATE, otherwise update_position will complain. In theory, 1121 map->at (x, y).flags_ = P_NEED_UPDATE;
1400 * we could preserve the flags (GET_MAP_FLAGS), but update_position figures
1401 * those out anyways, and if there are any flags set right now, they won't
1402 * be correct anyways.
1403 */
1404 SET_MAP_FLAGS(op->map, op->x, op->y, P_NEED_UPDATE);
1405 update_position(op->map, op->x, op->y);
1406 }
1407 else 1122 else
1408 update_object(last, UP_OBJ_REMOVE); 1123 update_object (last, UP_OBJ_REMOVE);
1409 1124
1410 if(QUERY_FLAG(op,FLAG_BLOCKSVIEW)|| (op->glow_radius != 0)) 1125 if (QUERY_FLAG (this, FLAG_BLOCKSVIEW) || glow_radius)
1411 update_all_los(op->map, op->x, op->y); 1126 update_all_los (map, x, y);
1412 1127 }
1413} 1128}
1414 1129
1415/* 1130/*
1416 * merge_ob(op,top): 1131 * merge_ob(op,top):
1417 * 1132 *
1418 * This function goes through all objects below and including top, and 1133 * This function goes through all objects below and including top, and
1419 * merges op to the first matching object. 1134 * merges op to the first matching object.
1420 * If top is NULL, it is calculated. 1135 * If top is NULL, it is calculated.
1421 * Returns pointer to object if it succeded in the merge, otherwise NULL 1136 * Returns pointer to object if it succeded in the merge, otherwise NULL
1422 */ 1137 */
1423 1138object *
1424object *merge_ob(object *op, object *top) { 1139merge_ob (object *op, object *top)
1140{
1425 if(!op->nrof) 1141 if (!op->nrof)
1426 return 0; 1142 return 0;
1143
1427 if(top==NULL) 1144 if (top == NULL)
1428 for(top=op;top!=NULL&&top->above!=NULL;top=top->above); 1145 for (top = op; top != NULL && top->above != NULL; top = top->above);
1146
1429 for(;top!=NULL;top=top->below) { 1147 for (; top != NULL; top = top->below)
1148 {
1430 if(top==op) 1149 if (top == op)
1431 continue; 1150 continue;
1432 if (CAN_MERGE(op,top)) 1151
1433 { 1152 if (object::can_merge (op, top))
1153 {
1434 top->nrof+=op->nrof; 1154 top->nrof += op->nrof;
1155
1435/* CLEAR_FLAG(top,FLAG_STARTEQUIP);*/ 1156/* CLEAR_FLAG(top,FLAG_STARTEQUIP);*/
1436 op->weight = 0; /* Don't want any adjustements now */ 1157 op->weight = 0; /* Don't want any adjustements now */
1437 remove_ob(op); 1158 op->destroy ();
1438 free_object(op);
1439 return top; 1159 return top;
1440 } 1160 }
1441 } 1161 }
1162
1442 return NULL; 1163 return 0;
1443} 1164}
1444 1165
1445/* 1166/*
1446 * same as insert_ob_in_map except it handle separate coordinates and do a clean 1167 * same as insert_ob_in_map except it handle separate coordinates and do a clean
1447 * job preparing multi-part monsters 1168 * job preparing multi-part monsters
1448 */ 1169 */
1170object *
1449object *insert_ob_in_map_at(object *op, mapstruct *m, object *originator, int flag, int x, int y){ 1171insert_ob_in_map_at (object *op, maptile *m, object *originator, int flag, int x, int y)
1172{
1450 object* tmp; 1173 object *tmp;
1174
1451 if (op->head) 1175 if (op->head)
1452 op=op->head; 1176 op = op->head;
1177
1453 for (tmp=op;tmp;tmp=tmp->more){ 1178 for (tmp = op; tmp; tmp = tmp->more)
1179 {
1454 tmp->x=x+tmp->arch->clone.x; 1180 tmp->x = x + tmp->arch->clone.x;
1455 tmp->y=y+tmp->arch->clone.y; 1181 tmp->y = y + tmp->arch->clone.y;
1456 } 1182 }
1183
1457 return insert_ob_in_map (op, m, originator, flag); 1184 return insert_ob_in_map (op, m, originator, flag);
1458} 1185}
1459 1186
1460/* 1187/*
1461 * insert_ob_in_map (op, map, originator, flag): 1188 * insert_ob_in_map (op, map, originator, flag):
1462 * This function inserts the object in the two-way linked list 1189 * This function inserts the object in the two-way linked list
… …
1476 * new object if 'op' was merged with other object 1203 * new object if 'op' was merged with other object
1477 * NULL if 'op' was destroyed 1204 * NULL if 'op' was destroyed
1478 * just 'op' otherwise 1205 * just 'op' otherwise
1479 */ 1206 */
1480 1207
1208object *
1481object *insert_ob_in_map (object *op, mapstruct *m, object *originator, int flag) 1209insert_ob_in_map (object *op, maptile *m, object *originator, int flag)
1482{ 1210{
1483 object *tmp, *top, *floor=NULL; 1211 object *tmp, *top, *floor = NULL;
1484 sint16 x,y; 1212 sint16 x, y;
1485 1213
1486 if (QUERY_FLAG (op, FLAG_FREED)) { 1214 if (QUERY_FLAG (op, FLAG_FREED))
1215 {
1487 LOG (llevError, "Trying to insert freed object!\n"); 1216 LOG (llevError, "Trying to insert freed object!\n");
1217 return NULL;
1218 }
1219
1220 if (m == NULL)
1221 {
1222 char *dump = dump_object (op);
1223 LOG (llevError, "Trying to insert in null-map!\n%s\n", dump);
1224 free (dump);
1225 return op;
1226 }
1227
1228 if (out_of_map (m, op->x, op->y))
1229 {
1230 char *dump = dump_object (op);
1231 LOG (llevError, "Trying to insert object outside the map.\n%s\n", dump);
1232#ifdef MANY_CORES
1233 /* Better to catch this here, as otherwise the next use of this object
1234 * is likely to cause a crash. Better to find out where it is getting
1235 * improperly inserted.
1236 */
1237 abort ();
1238#endif
1239 free (dump);
1240 return op;
1241 }
1242
1243 if (!QUERY_FLAG (op, FLAG_REMOVED))
1244 {
1245 char *dump = dump_object (op);
1246 LOG (llevError, "Trying to insert (map) inserted object.\n%s\n", dump);
1247 free (dump);
1248 return op;
1249 }
1250
1251 if (op->more != NULL)
1252 {
1253 /* The part may be on a different map. */
1254
1255 object *more = op->more;
1256
1257 /* We really need the caller to normalize coordinates - if
1258 * we set the map, that doesn't work if the location is within
1259 * a map and this is straddling an edge. So only if coordinate
1260 * is clear wrong do we normalize it.
1261 */
1262 if (OUT_OF_REAL_MAP (more->map, more->x, more->y))
1263 more->map = get_map_from_coord (m, &more->x, &more->y);
1264 else if (!more->map)
1265 {
1266 /* For backwards compatibility - when not dealing with tiled maps,
1267 * more->map should always point to the parent.
1268 */
1269 more->map = m;
1270 }
1271
1272 if (insert_ob_in_map (more, more->map, originator, flag) == NULL)
1273 {
1274 if (!op->head)
1275 LOG (llevError, "BUG: insert_ob_in_map(): inserting op->more killed op\n");
1276
1277 return NULL;
1278 }
1279 }
1280
1281 CLEAR_FLAG (op, FLAG_REMOVED);
1282
1283 /* Ideally, the caller figures this out. However, it complicates a lot
1284 * of areas of callers (eg, anything that uses find_free_spot would now
1285 * need extra work
1286 */
1287 op->map = get_map_from_coord (m, &op->x, &op->y);
1288 x = op->x;
1289 y = op->y;
1290
1291 /* this has to be done after we translate the coordinates.
1292 */
1293 if (op->nrof && !(flag & INS_NO_MERGE))
1294 for (tmp = GET_MAP_OB (op->map, x, y); tmp != NULL; tmp = tmp->above)
1295 if (object::can_merge (op, tmp))
1296 {
1297 op->nrof += tmp->nrof;
1298 tmp->destroy ();
1299 }
1300
1301 CLEAR_FLAG (op, FLAG_APPLIED); /* hack for fixing F_APPLIED in items of dead people */
1302 CLEAR_FLAG (op, FLAG_INV_LOCKED);
1303
1304 if (!QUERY_FLAG (op, FLAG_ALIVE))
1305 CLEAR_FLAG (op, FLAG_NO_STEAL);
1306
1307 if (flag & INS_BELOW_ORIGINATOR)
1308 {
1309 if (originator->map != op->map || originator->x != op->x || originator->y != op->y)
1310 {
1311 LOG (llevError, "insert_ob_in_map called with INS_BELOW_ORIGINATOR when originator not on same space!\n");
1312 abort ();
1313 }
1314
1315 op->above = originator;
1316 op->below = originator->below;
1317
1318 if (op->below)
1319 op->below->above = op;
1320 else
1321 op->ms ().bottom = op;
1322
1323 /* since *below* originator, no need to update top */
1324 originator->below = op;
1325 }
1326 else
1327 {
1328 /* If there are other objects, then */
1329 if ((!(flag & INS_MAP_LOAD)) && ((top = GET_MAP_OB (op->map, op->x, op->y)) != NULL))
1330 {
1331 object *last = NULL;
1332
1333 /*
1334 * If there are multiple objects on this space, we do some trickier handling.
1335 * We've already dealt with merging if appropriate.
1336 * Generally, we want to put the new object on top. But if
1337 * flag contains INS_ABOVE_FLOOR_ONLY, once we find the last
1338 * floor, we want to insert above that and no further.
1339 * Also, if there are spell objects on this space, we stop processing
1340 * once we get to them. This reduces the need to traverse over all of
1341 * them when adding another one - this saves quite a bit of cpu time
1342 * when lots of spells are cast in one area. Currently, it is presumed
1343 * that flying non pickable objects are spell objects.
1344 */
1345
1346 while (top != NULL)
1347 {
1348 if (QUERY_FLAG (top, FLAG_IS_FLOOR) || QUERY_FLAG (top, FLAG_OVERLAY_FLOOR))
1349 floor = top;
1350
1351 if (QUERY_FLAG (top, FLAG_NO_PICK) && (top->move_type & (MOVE_FLY_LOW | MOVE_FLY_HIGH)) && !QUERY_FLAG (top, FLAG_IS_FLOOR))
1352 {
1353 /* We insert above top, so we want this object below this */
1354 top = top->below;
1355 break;
1356 }
1357
1358 last = top;
1359 top = top->above;
1360 }
1361
1362 /* Don't want top to be NULL, so set it to the last valid object */
1363 top = last;
1364
1365 /* We let update_position deal with figuring out what the space
1366 * looks like instead of lots of conditions here.
1367 * makes things faster, and effectively the same result.
1368 */
1369
1370 /* Have object 'fall below' other objects that block view.
1371 * Unless those objects are exits, type 66
1372 * If INS_ON_TOP is used, don't do this processing
1373 * Need to find the object that in fact blocks view, otherwise
1374 * stacking is a bit odd.
1375 */
1376 if (!(flag & INS_ON_TOP) &&
1377 (get_map_flags (op->map, 0, op->x, op->y, 0, 0) & P_BLOCKSVIEW) && (op->face && !op->face->visibility))
1378 {
1379 for (last = top; last != floor; last = last->below)
1380 if (QUERY_FLAG (last, FLAG_BLOCKSVIEW) && (last->type != EXIT))
1381 break;
1382 /* Check to see if we found the object that blocks view,
1383 * and make sure we have a below pointer for it so that
1384 * we can get inserted below this one, which requires we
1385 * set top to the object below us.
1386 */
1387 if (last && last->below && last != floor)
1388 top = last->below;
1389 }
1390 } /* If objects on this space */
1391
1392 if (flag & INS_MAP_LOAD)
1393 top = GET_MAP_TOP (op->map, op->x, op->y);
1394
1395 if (flag & INS_ABOVE_FLOOR_ONLY)
1396 top = floor;
1397
1398 /* Top is the object that our object (op) is going to get inserted above.
1399 */
1400
1401 /* First object on this space */
1402 if (!top)
1403 {
1404 op->above = GET_MAP_OB (op->map, op->x, op->y);
1405
1406 if (op->above)
1407 op->above->below = op;
1408
1409 op->below = NULL;
1410 op->ms ().bottom = op;
1411 }
1412 else
1413 { /* get inserted into the stack above top */
1414 op->above = top->above;
1415
1416 if (op->above)
1417 op->above->below = op;
1418
1419 op->below = top;
1420 top->above = op;
1421 }
1422
1423 if (op->above == NULL)
1424 op->ms ().top = op;
1425 } /* else not INS_BELOW_ORIGINATOR */
1426
1427 if (op->type == PLAYER)
1428 op->contr->do_los = 1;
1429
1430 /* If we have a floor, we know the player, if any, will be above
1431 * it, so save a few ticks and start from there.
1432 */
1433 if (!(flag & INS_MAP_LOAD))
1434 if (object *pl = op->ms ().player ())
1435 pl->contr->ns->floorbox_update ();
1436
1437 /* If this object glows, it may affect lighting conditions that are
1438 * visible to others on this map. But update_all_los is really
1439 * an inefficient way to do this, as it means los for all players
1440 * on the map will get recalculated. The players could very well
1441 * be far away from this change and not affected in any way -
1442 * this should get redone to only look for players within range,
1443 * or just updating the P_NEED_UPDATE for spaces within this area
1444 * of effect may be sufficient.
1445 */
1446 if (MAP_DARKNESS (op->map) && (op->glow_radius != 0))
1447 update_all_los (op->map, op->x, op->y);
1448
1449 /* updates flags (blocked, alive, no magic, etc) for this map space */
1450 update_object (op, UP_OBJ_INSERT);
1451
1452 /* Don't know if moving this to the end will break anything. However,
1453 * we want to have floorbox_update called before calling this.
1454 *
1455 * check_move_on() must be after this because code called from
1456 * check_move_on() depends on correct map flags (so functions like
1457 * blocked() and wall() work properly), and these flags are updated by
1458 * update_object().
1459 */
1460
1461 /* if this is not the head or flag has been passed, don't check walk on status */
1462 if (!(flag & INS_NO_WALK_ON) && !op->head)
1463 {
1464 if (check_move_on (op, originator))
1488 return NULL; 1465 return NULL;
1489 }
1490 if(m==NULL) {
1491 dump_object(op);
1492 LOG(llevError,"Trying to insert in null-map!\n%s\n",errmsg);
1493 return op;
1494 }
1495 if(out_of_map(m,op->x,op->y)) {
1496 dump_object(op);
1497 LOG(llevError,"Trying to insert object outside the map.\n%s\n", errmsg);
1498#ifdef MANY_CORES
1499 /* Better to catch this here, as otherwise the next use of this object
1500 * is likely to cause a crash. Better to find out where it is getting
1501 * improperly inserted.
1502 */
1503 abort();
1504#endif
1505 return op;
1506 }
1507 if(!QUERY_FLAG(op,FLAG_REMOVED)) {
1508 dump_object(op);
1509 LOG(llevError,"Trying to insert (map) inserted object.\n%s\n", errmsg);
1510 return op;
1511 }
1512 if(op->more!=NULL) {
1513 /* The part may be on a different map. */
1514 1466
1515 object *more = op->more;
1516
1517 /* We really need the caller to normalize coordinates - if
1518 * we set the map, that doesn't work if the location is within
1519 * a map and this is straddling an edge. So only if coordinate
1520 * is clear wrong do we normalize it.
1521 */
1522 if (OUT_OF_REAL_MAP(more->map, more->x, more->y)) {
1523 /* Debugging information so you can see the last coordinates this object had */
1524 more->ox = more->x;
1525 more->oy = more->y;
1526 more->map = get_map_from_coord(m, &more->x, &more->y);
1527 } else if (!more->map) {
1528 /* For backwards compatibility - when not dealing with tiled maps,
1529 * more->map should always point to the parent.
1530 */
1531 more->map = m;
1532 }
1533
1534 if (insert_ob_in_map(more, more->map, originator, flag) == NULL) {
1535 if ( ! op->head)
1536 LOG (llevError, "BUG: insert_ob_in_map(): inserting op->more killed op\n");
1537 return NULL;
1538 }
1539 }
1540 CLEAR_FLAG(op,FLAG_REMOVED);
1541
1542 /* Debugging information so you can see the last coordinates this object had */
1543 op->ox=op->x;
1544 op->oy=op->y;
1545
1546 /* Ideally, the caller figures this out. However, it complicates a lot
1547 * of areas of callers (eg, anything that uses find_free_spot would now
1548 * need extra work
1549 */
1550 op->map=get_map_from_coord(m, &op->x, &op->y);
1551 x = op->x;
1552 y = op->y;
1553
1554 /* this has to be done after we translate the coordinates.
1555 */
1556 if(op->nrof && !(flag & INS_NO_MERGE)) {
1557 for(tmp=GET_MAP_OB(op->map,x,y);tmp!=NULL;tmp=tmp->above)
1558 if (CAN_MERGE(op,tmp)) {
1559 op->nrof+=tmp->nrof;
1560 remove_ob(tmp);
1561 free_object(tmp);
1562 }
1563 }
1564
1565 CLEAR_FLAG(op,FLAG_APPLIED); /* hack for fixing F_APPLIED in items of dead people */
1566 CLEAR_FLAG(op, FLAG_INV_LOCKED);
1567 if (!QUERY_FLAG(op, FLAG_ALIVE))
1568 CLEAR_FLAG(op, FLAG_NO_STEAL);
1569
1570 if (flag & INS_BELOW_ORIGINATOR) {
1571 if (originator->map != op->map || originator->x != op->x ||
1572 originator->y != op->y) {
1573 LOG(llevError,"insert_ob_in_map called with INS_BELOW_ORIGINATOR when originator not on same space!\n");
1574 abort();
1575 }
1576 op->above = originator;
1577 op->below = originator->below;
1578 if (op->below) op->below->above = op;
1579 else SET_MAP_OB(op->map, op->x, op->y, op);
1580 /* since *below* originator, no need to update top */
1581 originator->below = op;
1582 } else {
1583 /* If there are other objects, then */
1584 if((! (flag & INS_MAP_LOAD)) && ((top=GET_MAP_OB(op->map,op->x,op->y))!=NULL)) {
1585 object *last=NULL;
1586 /*
1587 * If there are multiple objects on this space, we do some trickier handling.
1588 * We've already dealt with merging if appropriate.
1589 * Generally, we want to put the new object on top. But if
1590 * flag contains INS_ABOVE_FLOOR_ONLY, once we find the last
1591 * floor, we want to insert above that and no further.
1592 * Also, if there are spell objects on this space, we stop processing
1593 * once we get to them. This reduces the need to traverse over all of
1594 * them when adding another one - this saves quite a bit of cpu time
1595 * when lots of spells are cast in one area. Currently, it is presumed
1596 * that flying non pickable objects are spell objects.
1597 */
1598
1599 while (top != NULL) {
1600 if (QUERY_FLAG(top, FLAG_IS_FLOOR) ||
1601 QUERY_FLAG(top, FLAG_OVERLAY_FLOOR)) floor = top;
1602 if (QUERY_FLAG(top, FLAG_NO_PICK)
1603 && (top->move_type & (MOVE_FLY_LOW |MOVE_FLY_HIGH))
1604 && !QUERY_FLAG(top, FLAG_IS_FLOOR))
1605 {
1606 /* We insert above top, so we want this object below this */
1607 top=top->below;
1608 break;
1609 }
1610 last = top;
1611 top = top->above;
1612 }
1613 /* Don't want top to be NULL, so set it to the last valid object */
1614 top = last;
1615
1616 /* We let update_position deal with figuring out what the space
1617 * looks like instead of lots of conditions here.
1618 * makes things faster, and effectively the same result.
1619 */
1620
1621 /* Have object 'fall below' other objects that block view.
1622 * Unless those objects are exits, type 66
1623 * If INS_ON_TOP is used, don't do this processing
1624 * Need to find the object that in fact blocks view, otherwise
1625 * stacking is a bit odd.
1626 */
1627 if (!(flag & INS_ON_TOP) &&
1628 (get_map_flags(op->map, NULL, op->x, op->y, NULL, NULL) & P_BLOCKSVIEW) &&
1629 (op->face && !op->face->visibility)) {
1630 for (last=top; last != floor; last=last->below)
1631 if (QUERY_FLAG(last, FLAG_BLOCKSVIEW)&&(last->type != EXIT)) break;
1632 /* Check to see if we found the object that blocks view,
1633 * and make sure we have a below pointer for it so that
1634 * we can get inserted below this one, which requires we
1635 * set top to the object below us.
1636 */
1637 if (last && last->below && last != floor) top=last->below;
1638 }
1639 } /* If objects on this space */
1640 if (flag & INS_MAP_LOAD)
1641 top = GET_MAP_TOP(op->map,op->x,op->y);
1642 if (flag & INS_ABOVE_FLOOR_ONLY) top = floor;
1643
1644 /* Top is the object that our object (op) is going to get inserted above.
1645 */
1646
1647 /* First object on this space */
1648 if (!top) {
1649 op->above = GET_MAP_OB(op->map, op->x, op->y);
1650 if (op->above) op->above->below = op;
1651 op->below = NULL;
1652 SET_MAP_OB(op->map, op->x, op->y, op);
1653 } else { /* get inserted into the stack above top */
1654 op->above = top->above;
1655 if (op->above) op->above->below = op;
1656 op->below = top;
1657 top->above = op;
1658 }
1659 if (op->above==NULL)
1660 SET_MAP_TOP(op->map,op->x, op->y, op);
1661 } /* else not INS_BELOW_ORIGINATOR */
1662
1663 if(op->type==PLAYER)
1664 op->contr->do_los=1;
1665
1666 /* If we have a floor, we know the player, if any, will be above
1667 * it, so save a few ticks and start from there.
1668 */
1669 if (!(flag & INS_MAP_LOAD))
1670 for(tmp=floor?floor:GET_MAP_OB(op->map,op->x,op->y);tmp!=NULL;tmp=tmp->above) {
1671 if (tmp->type == PLAYER)
1672 tmp->contr->socket.update_look=1;
1673 }
1674
1675 /* If this object glows, it may affect lighting conditions that are
1676 * visible to others on this map. But update_all_los is really
1677 * an inefficient way to do this, as it means los for all players
1678 * on the map will get recalculated. The players could very well
1679 * be far away from this change and not affected in any way -
1680 * this should get redone to only look for players within range,
1681 * or just updating the P_NEED_UPDATE for spaces within this area
1682 * of effect may be sufficient.
1683 */
1684 if(MAP_DARKNESS(op->map) && (op->glow_radius != 0))
1685 update_all_los(op->map, op->x, op->y);
1686
1687
1688 /* updates flags (blocked, alive, no magic, etc) for this map space */
1689 update_object(op,UP_OBJ_INSERT);
1690
1691
1692 /* Don't know if moving this to the end will break anything. However,
1693 * we want to have update_look set above before calling this.
1694 *
1695 * check_move_on() must be after this because code called from
1696 * check_move_on() depends on correct map flags (so functions like
1697 * blocked() and wall() work properly), and these flags are updated by
1698 * update_object().
1699 */
1700
1701 /* if this is not the head or flag has been passed, don't check walk on status */
1702
1703 if (!(flag & INS_NO_WALK_ON) && !op->head) {
1704 if (check_move_on(op, originator))
1705 return NULL;
1706
1707 /* If we are a multi part object, lets work our way through the check 1467 /* If we are a multi part object, lets work our way through the check
1708 * walk on's. 1468 * walk on's.
1709 */ 1469 */
1710 for (tmp=op->more; tmp!=NULL; tmp=tmp->more) 1470 for (tmp = op->more; tmp != NULL; tmp = tmp->more)
1711 if (check_move_on (tmp, originator)) 1471 if (check_move_on (tmp, originator))
1712 return NULL; 1472 return NULL;
1713 } 1473 }
1474
1714 return op; 1475 return op;
1715} 1476}
1716 1477
1717/* this function inserts an object in the map, but if it 1478/* this function inserts an object in the map, but if it
1718 * finds an object of its own type, it'll remove that one first. 1479 * finds an object of its own type, it'll remove that one first.
1719 * op is the object to insert it under: supplies x and the map. 1480 * op is the object to insert it under: supplies x and the map.
1720 */ 1481 */
1482void
1721void replace_insert_ob_in_map(const char *arch_string, object *op) { 1483replace_insert_ob_in_map (const char *arch_string, object *op)
1722 object *tmp; 1484{
1723 object *tmp1; 1485 object *tmp, *tmp1;
1724 1486
1725 /* first search for itself and remove any old instances */ 1487 /* first search for itself and remove any old instances */
1726 1488
1727 for(tmp=GET_MAP_OB(op->map,op->x,op->y); tmp!=NULL; tmp=tmp->above) { 1489 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)
1728 if(!strcmp(tmp->arch->name,arch_string)) /* same archetype */ { 1490 if (!strcmp (tmp->arch->name, arch_string)) /* same archetype */
1729 remove_ob(tmp); 1491 tmp->destroy ();
1730 free_object(tmp);
1731 }
1732 }
1733 1492
1734 tmp1=arch_to_object(find_archetype(arch_string)); 1493 tmp1 = arch_to_object (archetype::find (arch_string));
1735 1494
1736 1495 tmp1->x = op->x;
1737 tmp1->x = op->x; tmp1->y = op->y; 1496 tmp1->y = op->y;
1738 insert_ob_in_map(tmp1,op->map,op,0); 1497 insert_ob_in_map (tmp1, op->map, op, 0);
1739} 1498}
1740 1499
1741/* 1500/*
1742 * get_split_ob(ob,nr) splits up ob into two parts. The part which 1501 * get_split_ob(ob,nr) splits up ob into two parts. The part which
1743 * is returned contains nr objects, and the remaining parts contains 1502 * is returned contains nr objects, and the remaining parts contains
1744 * the rest (or is removed and freed if that number is 0). 1503 * the rest (or is removed and freed if that number is 0).
1745 * On failure, NULL is returned, and the reason put into the 1504 * On failure, NULL is returned, and the reason put into the
1746 * global static errmsg array. 1505 * global static errmsg array.
1747 */ 1506 */
1748 1507
1508object *
1749object *get_split_ob(object *orig_ob, uint32 nr) { 1509get_split_ob (object *orig_ob, uint32 nr)
1510{
1750 object *newob; 1511 object *newob;
1751 int is_removed = (QUERY_FLAG (orig_ob, FLAG_REMOVED) != 0); 1512 int is_removed = (QUERY_FLAG (orig_ob, FLAG_REMOVED) != 0);
1752 1513
1753 if(orig_ob->nrof<nr) { 1514 if (orig_ob->nrof < nr)
1754 sprintf(errmsg,"There are only %d %ss.", 1515 {
1755 orig_ob->nrof?orig_ob->nrof:1, orig_ob->name); 1516 sprintf (errmsg, "There are only %d %ss.", orig_ob->nrof ? orig_ob->nrof : 1, &orig_ob->name);
1756 return NULL; 1517 return NULL;
1757 } 1518 }
1519
1758 newob = object_create_clone(orig_ob); 1520 newob = object_create_clone (orig_ob);
1521
1759 if((orig_ob->nrof-=nr)<1) { 1522 if ((orig_ob->nrof -= nr) < 1)
1760 if ( ! is_removed) 1523 orig_ob->destroy (1);
1761 remove_ob(orig_ob);
1762 free_object2(orig_ob, 1);
1763 }
1764 else if ( ! is_removed) { 1524 else if (!is_removed)
1525 {
1765 if(orig_ob->env!=NULL) 1526 if (orig_ob->env != NULL)
1766 sub_weight (orig_ob->env,orig_ob->weight*nr); 1527 sub_weight (orig_ob->env, orig_ob->weight * nr);
1767 if (orig_ob->env == NULL && orig_ob->map->in_memory!=MAP_IN_MEMORY) { 1528 if (orig_ob->env == NULL && orig_ob->map->in_memory != MAP_IN_MEMORY)
1529 {
1768 strcpy(errmsg, "Tried to split object whose map is not in memory."); 1530 strcpy (errmsg, "Tried to split object whose map is not in memory.");
1769 LOG(llevDebug,
1770 "Error, Tried to split object whose map is not in memory.\n"); 1531 LOG (llevDebug, "Error, Tried to split object whose map is not in memory.\n");
1771 return NULL; 1532 return NULL;
1772 } 1533 }
1773 } 1534 }
1535
1774 newob->nrof=nr; 1536 newob->nrof = nr;
1775 1537
1776 return newob; 1538 return newob;
1777} 1539}
1778 1540
1779/* 1541/*
1780 * decrease_ob_nr(object, number) decreases a specified number from 1542 * decrease_ob_nr(object, number) decreases a specified number from
1781 * the amount of an object. If the amount reaches 0, the object 1543 * the amount of an object. If the amount reaches 0, the object
1782 * is subsequently removed and freed. 1544 * is subsequently removed and freed.
1783 * 1545 *
1784 * Return value: 'op' if something is left, NULL if the amount reached 0 1546 * Return value: 'op' if something is left, NULL if the amount reached 0
1785 */ 1547 */
1786 1548
1549object *
1787object *decrease_ob_nr (object *op, uint32 i) 1550decrease_ob_nr (object *op, uint32 i)
1788{ 1551{
1789 object *tmp; 1552 object *tmp;
1790 player *pl; 1553 player *pl;
1791 1554
1792 if (i == 0) /* objects with op->nrof require this check */ 1555 if (i == 0) /* objects with op->nrof require this check */
1793 return op; 1556 return op;
1794 1557
1795 if (i > op->nrof) 1558 if (i > op->nrof)
1796 i = op->nrof; 1559 i = op->nrof;
1797 1560
1798 if (QUERY_FLAG (op, FLAG_REMOVED)) 1561 if (QUERY_FLAG (op, FLAG_REMOVED))
1562 op->nrof -= i;
1563 else if (op->env)
1564 {
1565 /* is this object in the players inventory, or sub container
1566 * therein?
1567 */
1568 tmp = op->in_player ();
1569 /* nope. Is this a container the player has opened?
1570 * If so, set tmp to that player.
1571 * IMO, searching through all the players will mostly
1572 * likely be quicker than following op->env to the map,
1573 * and then searching the map for a player.
1574 */
1575 if (!tmp)
1576 {
1577 for (pl = first_player; pl; pl = pl->next)
1578 if (pl->ob->container == op->env)
1579 {
1580 tmp = pl->ob;
1581 break;
1582 }
1583 }
1584
1585 if (i < op->nrof)
1586 {
1587 sub_weight (op->env, op->weight * i);
1588 op->nrof -= i;
1589 if (tmp)
1590 esrv_send_item (tmp, op);
1591 }
1592 else
1593 {
1594 op->remove ();
1595 op->nrof = 0;
1596 if (tmp)
1597 esrv_del_item (tmp->contr, op->count);
1598 }
1799 { 1599 }
1600 else
1601 {
1602 object *above = op->above;
1603
1604 if (i < op->nrof)
1800 op->nrof -= i; 1605 op->nrof -= i;
1801 } 1606 else
1802 else if (op->env != NULL)
1803 {
1804 /* is this object in the players inventory, or sub container
1805 * therein?
1806 */ 1607 {
1807 tmp = is_player_inv (op->env); 1608 op->remove ();
1808 /* nope. Is this a container the player has opened? 1609 op->nrof = 0;
1809 * If so, set tmp to that player.
1810 * IMO, searching through all the players will mostly
1811 * likely be quicker than following op->env to the map,
1812 * and then searching the map for a player.
1813 */
1814 if (!tmp) {
1815 for (pl=first_player; pl; pl=pl->next)
1816 if (pl->ob->container == op->env) break;
1817 if (pl) tmp=pl->ob;
1818 else tmp=NULL;
1819 } 1610 }
1820 1611
1821 if (i < op->nrof) {
1822 sub_weight (op->env, op->weight * i);
1823 op->nrof -= i;
1824 if (tmp) {
1825 esrv_send_item(tmp, op);
1826 }
1827 } else {
1828 remove_ob (op);
1829 op->nrof = 0;
1830 if (tmp) {
1831 esrv_del_item(tmp->contr, op->count);
1832 }
1833 }
1834 }
1835 else
1836 {
1837 object *above = op->above;
1838
1839 if (i < op->nrof) {
1840 op->nrof -= i;
1841 } else {
1842 remove_ob (op);
1843 op->nrof = 0;
1844 }
1845 /* Since we just removed op, op->above is null */ 1612 /* Since we just removed op, op->above is null */
1846 for (tmp = above; tmp != NULL; tmp = tmp->above) 1613 for (tmp = above; tmp; tmp = tmp->above)
1847 if (tmp->type == PLAYER) { 1614 if (tmp->type == PLAYER)
1615 {
1848 if (op->nrof) 1616 if (op->nrof)
1849 esrv_send_item(tmp, op); 1617 esrv_send_item (tmp, op);
1850 else 1618 else
1851 esrv_del_item(tmp->contr, op->count); 1619 esrv_del_item (tmp->contr, op->count);
1852 } 1620 }
1853 } 1621 }
1854 1622
1855 if (op->nrof) { 1623 if (op->nrof)
1856 return op; 1624 return op;
1857 } else { 1625 else
1858 free_object (op); 1626 {
1627 op->destroy ();
1859 return NULL; 1628 return 0;
1860 } 1629 }
1861} 1630}
1862 1631
1863/* 1632/*
1864 * add_weight(object, weight) adds the specified weight to an object, 1633 * add_weight(object, weight) adds the specified weight to an object,
1865 * and also updates how much the environment(s) is/are carrying. 1634 * and also updates how much the environment(s) is/are carrying.
1866 */ 1635 */
1867 1636
1637void
1868void add_weight (object *op, signed long weight) { 1638add_weight (object *op, signed long weight)
1639{
1869 while (op!=NULL) { 1640 while (op != NULL)
1641 {
1870 if (op->type == CONTAINER) { 1642 if (op->type == CONTAINER)
1871 weight=(signed long)(weight*(100-op->stats.Str)/100); 1643 weight = (signed long) (weight * (100 - op->stats.Str) / 100);
1872 } 1644
1873 op->carrying+=weight; 1645 op->carrying += weight;
1874 op=op->env; 1646 op = op->env;
1875 } 1647 }
1876} 1648}
1877 1649
1650object *
1651insert_ob_in_ob (object *op, object *where)
1652{
1653 if (!where)
1654 {
1655 char *dump = dump_object (op);
1656 LOG (llevError, "Trying to put object in NULL.\n%s\n", dump);
1657 free (dump);
1658 return op;
1659 }
1660
1661 if (where->head)
1662 {
1663 LOG (llevDebug, "Warning: Tried to insert object into wrong part of multipart object.\n");
1664 where = where->head;
1665 }
1666
1667 return where->insert (op);
1668}
1669
1878/* 1670/*
1879 * insert_ob_in_ob(op,environment): 1671 * env->insert (op)
1880 * This function inserts the object op in the linked list 1672 * This function inserts the object op in the linked list
1881 * inside the object environment. 1673 * inside the object environment.
1882 * 1674 *
1883 * Eneq(@csd.uu.se): Altered insert_ob_in_ob to make things picked up enter
1884 * the inventory at the last position or next to other objects of the same
1885 * type.
1886 * Frank: Now sorted by type, archetype and magic!
1887 *
1888 * The function returns now pointer to inserted item, and return value can 1675 * The function returns now pointer to inserted item, and return value can
1889 * be != op, if items are merged. -Tero 1676 * be != op, if items are merged. -Tero
1890 */ 1677 */
1891 1678
1892object *insert_ob_in_ob(object *op,object *where) { 1679object *
1680object::insert (object *op)
1681{
1893 object *tmp, *otmp; 1682 object *tmp, *otmp;
1894 1683
1895 if(!QUERY_FLAG(op,FLAG_REMOVED)) { 1684 if (!QUERY_FLAG (op, FLAG_REMOVED))
1896 dump_object(op); 1685 op->remove ();
1897 LOG(llevError,"Trying to insert (ob) inserted object.\n%s\n", errmsg); 1686
1898 return op;
1899 }
1900 if(where==NULL) {
1901 dump_object(op);
1902 LOG(llevError,"Trying to put object in NULL.\n%s\n", errmsg);
1903 return op;
1904 }
1905 if (where->head) {
1906 LOG(llevDebug,
1907 "Warning: Tried to insert object wrong part of multipart object.\n");
1908 where = where->head;
1909 }
1910 if (op->more) { 1687 if (op->more)
1688 {
1911 LOG(llevError, "Tried to insert multipart object %s (%d)\n", 1689 LOG (llevError, "Tried to insert multipart object %s (%d)\n", &op->name, op->count);
1912 op->name, op->count);
1913 return op; 1690 return op;
1914 } 1691 }
1692
1915 CLEAR_FLAG(op, FLAG_OBJ_ORIGINAL); 1693 CLEAR_FLAG (op, FLAG_OBJ_ORIGINAL);
1916 CLEAR_FLAG(op, FLAG_REMOVED); 1694 CLEAR_FLAG (op, FLAG_REMOVED);
1917 if(op->nrof) { 1695 if (op->nrof)
1696 {
1918 for(tmp=where->inv;tmp!=NULL;tmp=tmp->below) 1697 for (tmp = inv; tmp != NULL; tmp = tmp->below)
1919 if ( CAN_MERGE(tmp,op) ) { 1698 if (object::can_merge (tmp, op))
1699 {
1920 /* return the original object and remove inserted object 1700 /* return the original object and remove inserted object
1921 (client needs the original object) */ 1701 (client needs the original object) */
1922 tmp->nrof += op->nrof; 1702 tmp->nrof += op->nrof;
1923 /* Weight handling gets pretty funky. Since we are adding to 1703 /* Weight handling gets pretty funky. Since we are adding to
1924 * tmp->nrof, we need to increase the weight. 1704 * tmp->nrof, we need to increase the weight.
1925 */ 1705 */
1926 add_weight (where, op->weight*op->nrof); 1706 add_weight (this, op->weight * op->nrof);
1927 SET_FLAG(op, FLAG_REMOVED); 1707 SET_FLAG (op, FLAG_REMOVED);
1928 free_object(op); /* free the inserted object */ 1708 op->destroy (); /* free the inserted object */
1929 op = tmp; 1709 op = tmp;
1930 remove_ob (op); /* and fix old object's links */ 1710 op->remove (); /* and fix old object's links */
1931 CLEAR_FLAG(op, FLAG_REMOVED); 1711 CLEAR_FLAG (op, FLAG_REMOVED);
1932 break; 1712 break;
1933 } 1713 }
1934 1714
1935 /* I assume combined objects have no inventory 1715 /* I assume combined objects have no inventory
1936 * We add the weight - this object could have just been removed 1716 * We add the weight - this object could have just been removed
1937 * (if it was possible to merge). calling remove_ob will subtract 1717 * (if it was possible to merge). calling remove_ob will subtract
1938 * the weight, so we need to add it in again, since we actually do 1718 * the weight, so we need to add it in again, since we actually do
1939 * the linking below 1719 * the linking below
1940 */ 1720 */
1941 add_weight (where, op->weight*op->nrof); 1721 add_weight (this, op->weight * op->nrof);
1722 }
1942 } else 1723 else
1943 add_weight (where, (op->weight+op->carrying)); 1724 add_weight (this, (op->weight + op->carrying));
1944 1725
1945 otmp=is_player_inv(where); 1726 otmp = this->in_player ();
1946 if (otmp&&otmp->contr!=NULL) { 1727 if (otmp && otmp->contr)
1947 if (!QUERY_FLAG(otmp,FLAG_NO_FIX_PLAYER)) 1728 if (!QUERY_FLAG (otmp, FLAG_NO_FIX_PLAYER))
1948 fix_player(otmp); 1729 fix_player (otmp);
1949 }
1950 1730
1951 op->map=NULL; 1731 op->map = 0;
1952 op->env=where; 1732 op->env = this;
1953 op->above=NULL; 1733 op->above = 0;
1954 op->below=NULL; 1734 op->below = 0;
1955 op->x=0,op->y=0; 1735 op->x = 0, op->y = 0;
1956 op->ox=0,op->oy=0;
1957 1736
1958 /* reset the light list and los of the players on the map */ 1737 /* reset the light list and los of the players on the map */
1959 if((op->glow_radius!=0)&&where->map) 1738 if ((op->glow_radius != 0) && map)
1960 { 1739 {
1961#ifdef DEBUG_LIGHTS 1740#ifdef DEBUG_LIGHTS
1962 LOG(llevDebug, " insert_ob_in_ob(): got %s to insert in map/op\n", 1741 LOG (llevDebug, " insert_ob_in_ob(): got %s to insert in map/op\n", op->name);
1963 op->name);
1964#endif /* DEBUG_LIGHTS */ 1742#endif /* DEBUG_LIGHTS */
1965 if (MAP_DARKNESS(where->map)) update_all_los(where->map, where->x, where->y); 1743 if (MAP_DARKNESS (map))
1744 update_all_los (map, x, y);
1966 } 1745 }
1967 1746
1968 /* Client has no idea of ordering so lets not bother ordering it here. 1747 /* Client has no idea of ordering so lets not bother ordering it here.
1969 * It sure simplifies this function... 1748 * It sure simplifies this function...
1970 */ 1749 */
1971 if (where->inv==NULL) 1750 if (!inv)
1972 where->inv=op; 1751 inv = op;
1973 else { 1752 else
1753 {
1974 op->below = where->inv; 1754 op->below = inv;
1975 op->below->above = op; 1755 op->below->above = op;
1976 where->inv = op; 1756 inv = op;
1977 } 1757 }
1758
1978 return op; 1759 return op;
1979} 1760}
1980 1761
1981/* 1762/*
1982 * Checks if any objects has a move_type that matches objects 1763 * Checks if any objects has a move_type that matches objects
… …
1997 * MSW 2001-07-08: Check all objects on space, not just those below 1778 * MSW 2001-07-08: Check all objects on space, not just those below
1998 * object being inserted. insert_ob_in_map may not put new objects 1779 * object being inserted. insert_ob_in_map may not put new objects
1999 * on top. 1780 * on top.
2000 */ 1781 */
2001 1782
1783int
2002int check_move_on (object *op, object *originator) 1784check_move_on (object *op, object *originator)
2003{ 1785{
2004 object *tmp; 1786 object *tmp;
2005 tag_t tag;
2006 mapstruct *m=op->map; 1787 maptile *m = op->map;
2007 int x=op->x, y=op->y; 1788 int x = op->x, y = op->y;
1789
2008 MoveType move_on, move_slow, move_block; 1790 MoveType move_on, move_slow, move_block;
2009 1791
2010 if(QUERY_FLAG(op,FLAG_NO_APPLY)) 1792 if (QUERY_FLAG (op, FLAG_NO_APPLY))
2011 return 0; 1793 return 0;
2012 1794
2013 tag = op->count;
2014
2015 move_on = GET_MAP_MOVE_ON(op->map, op->x, op->y); 1795 move_on = GET_MAP_MOVE_ON (op->map, op->x, op->y);
2016 move_slow = GET_MAP_MOVE_SLOW(op->map, op->x, op->y); 1796 move_slow = GET_MAP_MOVE_SLOW (op->map, op->x, op->y);
2017 move_block = GET_MAP_MOVE_BLOCK(op->map, op->x, op->y); 1797 move_block = GET_MAP_MOVE_BLOCK (op->map, op->x, op->y);
2018 1798
2019 /* if nothing on this space will slow op down or be applied, 1799 /* if nothing on this space will slow op down or be applied,
2020 * no need to do checking below. have to make sure move_type 1800 * no need to do checking below. have to make sure move_type
2021 * is set, as lots of objects don't have it set - we treat that 1801 * is set, as lots of objects don't have it set - we treat that
2022 * as walking. 1802 * as walking.
2023 */ 1803 */
2024 if (op->move_type && !(op->move_type & move_on) && !(op->move_type & move_slow)) 1804 if (op->move_type && !(op->move_type & move_on) && !(op->move_type & move_slow))
2025 return 0; 1805 return 0;
2026 1806
2027 /* This is basically inverse logic of that below - basically, 1807 /* This is basically inverse logic of that below - basically,
2028 * if the object can avoid the move on or slow move, they do so, 1808 * if the object can avoid the move on or slow move, they do so,
2029 * but can't do it if the alternate movement they are using is 1809 * but can't do it if the alternate movement they are using is
2030 * blocked. Logic on this seems confusing, but does seem correct. 1810 * blocked. Logic on this seems confusing, but does seem correct.
2031 */ 1811 */
2032 if ((op->move_type & ~move_on & ~move_block) != 0 && 1812 if ((op->move_type & ~move_on & ~move_block) != 0 && (op->move_type & ~move_slow & ~move_block) != 0)
2033 (op->move_type & ~move_slow & ~move_block) != 0) return 0; 1813 return 0;
2034 1814
2035 /* The objects have to be checked from top to bottom. 1815 /* The objects have to be checked from top to bottom.
2036 * Hence, we first go to the top: 1816 * Hence, we first go to the top:
2037 */ 1817 */
2038 1818
2039 for (tmp=GET_MAP_OB(op->map, op->x, op->y); tmp!=NULL && 1819 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL && tmp->above != NULL; tmp = tmp->above)
2040 tmp->above!=NULL; tmp=tmp->above) { 1820 {
2041 /* Trim the search when we find the first other spell effect 1821 /* Trim the search when we find the first other spell effect
2042 * this helps performance so that if a space has 50 spell objects, 1822 * this helps performance so that if a space has 50 spell objects,
2043 * we don't need to check all of them. 1823 * we don't need to check all of them.
2044 */ 1824 */
2045 if ((tmp->move_type & MOVE_FLY_LOW) && QUERY_FLAG(tmp, FLAG_NO_PICK)) break; 1825 if ((tmp->move_type & MOVE_FLY_LOW) && QUERY_FLAG (tmp, FLAG_NO_PICK))
1826 break;
1827 }
1828
1829 for (; tmp; tmp = tmp->below)
2046 } 1830 {
2047 for(;tmp!=NULL; tmp=tmp->below) { 1831 if (tmp == op)
2048 if (tmp == op) continue; /* Can't apply yourself */ 1832 continue; /* Can't apply yourself */
2049 1833
2050 /* Check to see if one of the movement types should be slowed down. 1834 /* Check to see if one of the movement types should be slowed down.
2051 * Second check makes sure that the movement types not being slowed 1835 * Second check makes sure that the movement types not being slowed
2052 * (~slow_move) is not blocked on this space - just because the 1836 * (~slow_move) is not blocked on this space - just because the
2053 * space doesn't slow down swimming (for example), if you can't actually 1837 * space doesn't slow down swimming (for example), if you can't actually
2054 * swim on that space, can't use it to avoid the penalty. 1838 * swim on that space, can't use it to avoid the penalty.
2055 */ 1839 */
2056 if (!QUERY_FLAG(op, FLAG_WIZPASS)) { 1840 if (!QUERY_FLAG (op, FLAG_WIZPASS))
1841 {
2057 if ((!op->move_type && tmp->move_slow & MOVE_WALK) || 1842 if ((!op->move_type && tmp->move_slow & MOVE_WALK) ||
2058 ((op->move_type & tmp->move_slow) &&
2059 (op->move_type & ~tmp->move_slow & ~tmp->move_block) == 0)) { 1843 ((op->move_type & tmp->move_slow) && (op->move_type & ~tmp->move_slow & ~tmp->move_block) == 0))
1844 {
2060 1845
2061 float diff; 1846 float
2062
2063 diff = tmp->move_slow_penalty*FABS(op->speed); 1847 diff = tmp->move_slow_penalty * FABS (op->speed);
1848
2064 if (op->type == PLAYER) { 1849 if (op->type == PLAYER)
2065 if ((QUERY_FLAG(tmp, FLAG_IS_HILLY) && find_skill_by_number(op, SK_CLIMBING)) || 1850 if ((QUERY_FLAG (tmp, FLAG_IS_HILLY) && find_skill_by_number (op, SK_CLIMBING)) ||
2066 (QUERY_FLAG(tmp, FLAG_IS_WOODED) && find_skill_by_number(op, SK_WOODSMAN))) { 1851 (QUERY_FLAG (tmp, FLAG_IS_WOODED) && find_skill_by_number (op, SK_WOODSMAN)))
2067 diff /= 4.0; 1852 diff /= 4.0;
2068 } 1853
2069 }
2070 op->speed_left -= diff; 1854 op->speed_left -= diff;
2071 } 1855 }
2072 } 1856 }
2073 1857
2074 /* Basically same logic as above, except now for actual apply. */ 1858 /* Basically same logic as above, except now for actual apply. */
2075 if ((!op->move_type && tmp->move_on & MOVE_WALK) || 1859 if ((!op->move_type && tmp->move_on & MOVE_WALK) ||
2076 ((op->move_type & tmp->move_on) &&
2077 (op->move_type & ~tmp->move_on & ~tmp->move_block)==0)) { 1860 ((op->move_type & tmp->move_on) && (op->move_type & ~tmp->move_on & ~tmp->move_block) == 0))
2078 1861 {
2079 move_apply(tmp, op, originator); 1862 move_apply (tmp, op, originator);
1863
2080 if (was_destroyed (op, tag)) 1864 if (op->destroyed ())
2081 return 1; 1865 return 1;
2082 1866
2083 /* what the person/creature stepped onto has moved the object 1867 /* what the person/creature stepped onto has moved the object
2084 * someplace new. Don't process any further - if we did, 1868 * someplace new. Don't process any further - if we did,
2085 * have a feeling strange problems would result. 1869 * have a feeling strange problems would result.
2086 */ 1870 */
2087 if (op->map != m || op->x != x || op->y != y) return 0; 1871 if (op->map != m || op->x != x || op->y != y)
1872 return 0;
2088 } 1873 }
2089 } 1874 }
1875
2090 return 0; 1876 return 0;
2091} 1877}
2092 1878
2093/* 1879/*
2094 * present_arch(arch, map, x, y) searches for any objects with 1880 * present_arch(arch, map, x, y) searches for any objects with
2095 * a matching archetype at the given map and coordinates. 1881 * a matching archetype at the given map and coordinates.
2096 * The first matching object is returned, or NULL if none. 1882 * The first matching object is returned, or NULL if none.
2097 */ 1883 */
2098 1884
1885object *
2099object *present_arch(const archetype *at, mapstruct *m, int x, int y) { 1886present_arch (const archetype *at, maptile *m, int x, int y)
1887{
2100 object *tmp; 1888 object *
1889 tmp;
1890
2101 if(m==NULL || out_of_map(m,x,y)) { 1891 if (m == NULL || out_of_map (m, x, y))
1892 {
2102 LOG(llevError,"Present_arch called outside map.\n"); 1893 LOG (llevError, "Present_arch called outside map.\n");
2103 return NULL; 1894 return NULL;
2104 } 1895 }
2105 for(tmp=GET_MAP_OB(m,x,y); tmp != NULL; tmp = tmp->above) 1896 for (tmp = GET_MAP_OB (m, x, y); tmp != NULL; tmp = tmp->above)
2106 if(tmp->arch == at) 1897 if (tmp->arch == at)
2107 return tmp; 1898 return tmp;
2108 return NULL; 1899 return NULL;
2109} 1900}
2110 1901
2111/* 1902/*
2112 * present(type, map, x, y) searches for any objects with 1903 * present(type, map, x, y) searches for any objects with
2113 * a matching type variable at the given map and coordinates. 1904 * a matching type variable at the given map and coordinates.
2114 * The first matching object is returned, or NULL if none. 1905 * The first matching object is returned, or NULL if none.
2115 */ 1906 */
2116 1907
1908object *
2117object *present(unsigned char type,mapstruct *m, int x,int y) { 1909present (unsigned char type, maptile *m, int x, int y)
1910{
2118 object *tmp; 1911 object *
1912 tmp;
1913
2119 if(out_of_map(m,x,y)) { 1914 if (out_of_map (m, x, y))
1915 {
2120 LOG(llevError,"Present called outside map.\n"); 1916 LOG (llevError, "Present called outside map.\n");
2121 return NULL; 1917 return NULL;
2122 } 1918 }
2123 for(tmp=GET_MAP_OB(m,x,y);tmp!=NULL;tmp=tmp->above) 1919 for (tmp = GET_MAP_OB (m, x, y); tmp != NULL; tmp = tmp->above)
2124 if(tmp->type==type) 1920 if (tmp->type == type)
2125 return tmp; 1921 return tmp;
2126 return NULL; 1922 return NULL;
2127} 1923}
2128 1924
2129/* 1925/*
2130 * present_in_ob(type, object) searches for any objects with 1926 * present_in_ob(type, object) searches for any objects with
2131 * a matching type variable in the inventory of the given object. 1927 * a matching type variable in the inventory of the given object.
2132 * The first matching object is returned, or NULL if none. 1928 * The first matching object is returned, or NULL if none.
2133 */ 1929 */
2134 1930
1931object *
2135object *present_in_ob(unsigned char type, const object *op) { 1932present_in_ob (unsigned char type, const object *op)
1933{
2136 object *tmp; 1934 object *
1935 tmp;
1936
2137 for(tmp=op->inv;tmp!=NULL;tmp=tmp->below) 1937 for (tmp = op->inv; tmp != NULL; tmp = tmp->below)
2138 if(tmp->type==type) 1938 if (tmp->type == type)
2139 return tmp; 1939 return tmp;
2140 return NULL; 1940 return NULL;
2141} 1941}
2142 1942
2143/* 1943/*
… …
2153 * the object name, not the archetype name. this is so that the 1953 * the object name, not the archetype name. this is so that the
2154 * spell code can use one object type (force), but change it's name 1954 * spell code can use one object type (force), but change it's name
2155 * to be unique. 1955 * to be unique.
2156 */ 1956 */
2157 1957
1958object *
2158object *present_in_ob_by_name(int type, const char *str, const object *op) { 1959present_in_ob_by_name (int type, const char *str, const object *op)
1960{
2159 object *tmp; 1961 object *
1962 tmp;
2160 1963
2161 for(tmp=op->inv; tmp!=NULL; tmp=tmp->below) { 1964 for (tmp = op->inv; tmp != NULL; tmp = tmp->below)
1965 {
2162 if ((type==-1 || tmp->type==type) && (!strcmp(str, tmp->name))) 1966 if ((type == -1 || tmp->type == type) && (!strcmp (str, tmp->name)))
2163 return tmp; 1967 return tmp;
2164 } 1968 }
2165 return NULL; 1969 return NULL;
2166} 1970}
2167 1971
2168/* 1972/*
2169 * present_arch_in_ob(archetype, object) searches for any objects with 1973 * present_arch_in_ob(archetype, object) searches for any objects with
2170 * a matching archetype in the inventory of the given object. 1974 * a matching archetype in the inventory of the given object.
2171 * The first matching object is returned, or NULL if none. 1975 * The first matching object is returned, or NULL if none.
2172 */ 1976 */
2173 1977
1978object *
2174object *present_arch_in_ob(const archetype *at, const object *op) { 1979present_arch_in_ob (const archetype *at, const object *op)
1980{
2175 object *tmp; 1981 object *
1982 tmp;
1983
2176 for(tmp=op->inv;tmp!=NULL;tmp=tmp->below) 1984 for (tmp = op->inv; tmp != NULL; tmp = tmp->below)
2177 if( tmp->arch == at) 1985 if (tmp->arch == at)
2178 return tmp; 1986 return tmp;
2179 return NULL; 1987 return NULL;
2180} 1988}
2181 1989
2182/* 1990/*
2183 * activate recursively a flag on an object inventory 1991 * activate recursively a flag on an object inventory
2184 */ 1992 */
1993void
2185void flag_inv(object*op, int flag){ 1994flag_inv (object *op, int flag)
1995{
2186 object *tmp; 1996 object *
1997 tmp;
1998
2187 if(op->inv) 1999 if (op->inv)
2188 for(tmp = op->inv; tmp != NULL; tmp = tmp->below){ 2000 for (tmp = op->inv; tmp != NULL; tmp = tmp->below)
2001 {
2189 SET_FLAG(tmp, flag); 2002 SET_FLAG (tmp, flag);
2190 flag_inv(tmp,flag); 2003 flag_inv (tmp, flag);
2191 } 2004 }
2192}/* 2005} /*
2193 * desactivate recursively a flag on an object inventory 2006 * desactivate recursively a flag on an object inventory
2194 */ 2007 */
2008void
2195void unflag_inv(object*op, int flag){ 2009unflag_inv (object *op, int flag)
2010{
2196 object *tmp; 2011 object *
2012 tmp;
2013
2197 if(op->inv) 2014 if (op->inv)
2198 for(tmp = op->inv; tmp != NULL; tmp = tmp->below){ 2015 for (tmp = op->inv; tmp != NULL; tmp = tmp->below)
2016 {
2199 CLEAR_FLAG(tmp, flag); 2017 CLEAR_FLAG (tmp, flag);
2200 unflag_inv(tmp,flag); 2018 unflag_inv (tmp, flag);
2201 } 2019 }
2202} 2020}
2203 2021
2204/* 2022/*
2205 * set_cheat(object) sets the cheat flag (WAS_WIZ) in the object and in 2023 * set_cheat(object) sets the cheat flag (WAS_WIZ) in the object and in
2206 * all it's inventory (recursively). 2024 * all it's inventory (recursively).
2207 * If checksums are used, a player will get set_cheat called for 2025 * If checksums are used, a player will get set_cheat called for
2208 * him/her-self and all object carried by a call to this function. 2026 * him/her-self and all object carried by a call to this function.
2209 */ 2027 */
2210 2028
2029void
2211void set_cheat(object *op) { 2030set_cheat (object *op)
2031{
2212 SET_FLAG(op, FLAG_WAS_WIZ); 2032 SET_FLAG (op, FLAG_WAS_WIZ);
2213 flag_inv(op, FLAG_WAS_WIZ); 2033 flag_inv (op, FLAG_WAS_WIZ);
2214} 2034}
2215 2035
2216/* 2036/*
2217 * find_free_spot(object, map, x, y, start, stop) will search for 2037 * find_free_spot(object, map, x, y, start, stop) will search for
2218 * a spot at the given map and coordinates which will be able to contain 2038 * a spot at the given map and coordinates which will be able to contain
… …
2233 * to know if the space in question will block the object. We can't use 2053 * to know if the space in question will block the object. We can't use
2234 * the archetype because that isn't correct if the monster has been 2054 * the archetype because that isn't correct if the monster has been
2235 * customized, changed states, etc. 2055 * customized, changed states, etc.
2236 */ 2056 */
2237 2057
2058int
2238int find_free_spot(const object *ob, mapstruct *m,int x,int y,int start,int stop) { 2059find_free_spot (const object *ob, maptile *m, int x, int y, int start, int stop)
2060{
2061 int
2062 i,
2239 int i,index=0, flag; 2063 index = 0, flag;
2064 static int
2240 static int altern[SIZEOFFREE]; 2065 altern[SIZEOFFREE];
2241 2066
2242 for(i=start;i<stop;i++) { 2067 for (i = start; i < stop; i++)
2068 {
2243 flag = ob_blocked(ob,m,x+freearr_x[i],y+freearr_y[i]); 2069 flag = ob_blocked (ob, m, x + freearr_x[i], y + freearr_y[i]);
2244 if(!flag) 2070 if (!flag)
2245 altern[index++]=i; 2071 altern[index++] = i;
2246 2072
2247 /* Basically, if we find a wall on a space, we cut down the search size. 2073 /* Basically, if we find a wall on a space, we cut down the search size.
2248 * In this way, we won't return spaces that are on another side of a wall. 2074 * In this way, we won't return spaces that are on another side of a wall.
2249 * This mostly work, but it cuts down the search size in all directions - 2075 * This mostly work, but it cuts down the search size in all directions -
2250 * if the space being examined only has a wall to the north and empty 2076 * if the space being examined only has a wall to the north and empty
2251 * spaces in all the other directions, this will reduce the search space 2077 * spaces in all the other directions, this will reduce the search space
2252 * to only the spaces immediately surrounding the target area, and 2078 * to only the spaces immediately surrounding the target area, and
2253 * won't look 2 spaces south of the target space. 2079 * won't look 2 spaces south of the target space.
2254 */ 2080 */
2255 else if ((flag & AB_NO_PASS) && maxfree[i]<stop) 2081 else if ((flag & P_NO_PASS) && maxfree[i] < stop)
2256 stop=maxfree[i]; 2082 stop = maxfree[i];
2257 } 2083 }
2258 if(!index) return -1; 2084
2085 if (!index)
2086 return -1;
2087
2259 return altern[RANDOM()%index]; 2088 return altern[RANDOM () % index];
2260} 2089}
2261 2090
2262/* 2091/*
2263 * find_first_free_spot(archetype, mapstruct, x, y) works like 2092 * find_first_free_spot(archetype, maptile, x, y) works like
2264 * find_free_spot(), but it will search max number of squares. 2093 * find_free_spot(), but it will search max number of squares.
2265 * But it will return the first available spot, not a random choice. 2094 * But it will return the first available spot, not a random choice.
2266 * Changed 0.93.2: Have it return -1 if there is no free spot available. 2095 * Changed 0.93.2: Have it return -1 if there is no free spot available.
2267 */ 2096 */
2268 2097
2098int
2269int find_first_free_spot(const object *ob, mapstruct *m,int x,int y) { 2099find_first_free_spot (const object *ob, maptile *m, int x, int y)
2100{
2101 int
2270 int i; 2102 i;
2103
2271 for(i=0;i<SIZEOFFREE;i++) { 2104 for (i = 0; i < SIZEOFFREE; i++)
2105 {
2272 if(!ob_blocked(ob,m,x+freearr_x[i],y+freearr_y[i])) 2106 if (!ob_blocked (ob, m, x + freearr_x[i], y + freearr_y[i]))
2273 return i; 2107 return i;
2274 } 2108 }
2275 return -1; 2109 return -1;
2276} 2110}
2277 2111
2278/* 2112/*
2279 * The function permute(arr, begin, end) randomly reorders the array 2113 * The function permute(arr, begin, end) randomly reorders the array
2280 * arr[begin..end-1]. 2114 * arr[begin..end-1].
2281 */ 2115 */
2116static void
2282static void permute(int *arr, int begin, int end) 2117permute (int *arr, int begin, int end)
2283{ 2118{
2284 int i, j, tmp, len; 2119 int
2120 i,
2121 j,
2122 tmp,
2123 len;
2285 2124
2286 len = end-begin; 2125 len = end - begin;
2287 for(i = begin; i < end; i++) 2126 for (i = begin; i < end; i++)
2288 { 2127 {
2289 j = begin+RANDOM()%len; 2128 j = begin + RANDOM () % len;
2290 2129
2291 tmp = arr[i]; 2130 tmp = arr[i];
2292 arr[i] = arr[j]; 2131 arr[i] = arr[j];
2293 arr[j] = tmp; 2132 arr[j] = tmp;
2294 } 2133 }
2295} 2134}
2296 2135
2297/* new function to make monster searching more efficient, and effective! 2136/* new function to make monster searching more efficient, and effective!
2298 * This basically returns a randomized array (in the passed pointer) of 2137 * This basically returns a randomized array (in the passed pointer) of
2299 * the spaces to find monsters. In this way, it won't always look for 2138 * the spaces to find monsters. In this way, it won't always look for
2300 * monsters to the north first. However, the size of the array passed 2139 * monsters to the north first. However, the size of the array passed
2301 * covers all the spaces, so within that size, all the spaces within 2140 * covers all the spaces, so within that size, all the spaces within
2302 * the 3x3 area will be searched, just not in a predictable order. 2141 * the 3x3 area will be searched, just not in a predictable order.
2303 */ 2142 */
2143void
2304void get_search_arr(int *search_arr) 2144get_search_arr (int *search_arr)
2305{ 2145{
2146 int
2306 int i; 2147 i;
2307 2148
2308 for(i = 0; i < SIZEOFFREE; i++) 2149 for (i = 0; i < SIZEOFFREE; i++)
2309 { 2150 {
2310 search_arr[i] = i; 2151 search_arr[i] = i;
2311 } 2152 }
2312 2153
2313 permute(search_arr, 1, SIZEOFFREE1+1); 2154 permute (search_arr, 1, SIZEOFFREE1 + 1);
2314 permute(search_arr, SIZEOFFREE1+1, SIZEOFFREE2+1); 2155 permute (search_arr, SIZEOFFREE1 + 1, SIZEOFFREE2 + 1);
2315 permute(search_arr, SIZEOFFREE2+1, SIZEOFFREE); 2156 permute (search_arr, SIZEOFFREE2 + 1, SIZEOFFREE);
2316} 2157}
2317 2158
2318/* 2159/*
2319 * find_dir(map, x, y, exclude) will search some close squares in the 2160 * find_dir(map, x, y, exclude) will search some close squares in the
2320 * given map at the given coordinates for live objects. 2161 * given map at the given coordinates for live objects.
… …
2326 * is actually want is going to try and move there. We need this info 2167 * is actually want is going to try and move there. We need this info
2327 * because we have to know what movement the thing looking to move 2168 * because we have to know what movement the thing looking to move
2328 * there is capable of. 2169 * there is capable of.
2329 */ 2170 */
2330 2171
2172int
2331int find_dir(mapstruct *m, int x, int y, object *exclude) { 2173find_dir (maptile *m, int x, int y, object *exclude)
2174{
2175 int
2176 i,
2332 int i,max=SIZEOFFREE, mflags; 2177 max = SIZEOFFREE, mflags;
2178
2333 sint16 nx, ny; 2179 sint16 nx, ny;
2334 object *tmp; 2180 object *
2335 mapstruct *mp; 2181 tmp;
2182 maptile *
2183 mp;
2184
2336 MoveType blocked, move_type; 2185 MoveType blocked, move_type;
2337 2186
2338 if (exclude && exclude->head) { 2187 if (exclude && exclude->head)
2188 {
2339 exclude = exclude->head; 2189 exclude = exclude->head;
2340 move_type = exclude->move_type; 2190 move_type = exclude->move_type;
2341 } else { 2191 }
2192 else
2193 {
2342 /* If we don't have anything, presume it can use all movement types. */ 2194 /* If we don't have anything, presume it can use all movement types. */
2343 move_type=MOVE_ALL; 2195 move_type = MOVE_ALL;
2196 }
2197
2198 for (i = 1; i < max; i++)
2344 } 2199 {
2345
2346 for(i=1;i<max;i++) {
2347 mp = m; 2200 mp = m;
2348 nx = x + freearr_x[i]; 2201 nx = x + freearr_x[i];
2349 ny = y + freearr_y[i]; 2202 ny = y + freearr_y[i];
2350 2203
2351 mflags = get_map_flags(m, &mp, nx, ny, &nx, &ny); 2204 mflags = get_map_flags (m, &mp, nx, ny, &nx, &ny);
2205
2352 if (mflags & P_OUT_OF_MAP) { 2206 if (mflags & P_OUT_OF_MAP)
2207 max = maxfree[i];
2208 else
2209 {
2210 blocked = GET_MAP_MOVE_BLOCK (mp, nx, ny);
2211
2212 if ((move_type & blocked) == move_type)
2353 max = maxfree[i]; 2213 max = maxfree[i];
2354 } else {
2355 blocked = GET_MAP_MOVE_BLOCK(mp, nx, ny);
2356
2357 if ((move_type & blocked) == move_type) {
2358 max=maxfree[i];
2359 } else if (mflags & P_IS_ALIVE) { 2214 else if (mflags & P_IS_ALIVE)
2215 {
2360 for (tmp=GET_MAP_OB(mp,nx,ny); tmp!= NULL; tmp=tmp->above) { 2216 for (tmp = GET_MAP_OB (mp, nx, ny); tmp; tmp = tmp->above)
2361 if ((QUERY_FLAG(tmp,FLAG_MONSTER) || tmp->type==PLAYER) && 2217 if ((QUERY_FLAG (tmp, FLAG_MONSTER) || tmp->type == PLAYER) && (tmp != exclude || (tmp->head && tmp->head != exclude)))
2362 (tmp != exclude ||(tmp->head && tmp->head != exclude))) {
2363 break; 2218 break;
2364 } 2219
2365 }
2366 if(tmp) { 2220 if (tmp)
2367 return freedir[i]; 2221 return freedir[i];
2368 }
2369 } 2222 }
2370 } 2223 }
2371 } 2224 }
2225
2372 return 0; 2226 return 0;
2373} 2227}
2374 2228
2375/* 2229/*
2376 * distance(object 1, object 2) will return the square of the 2230 * distance(object 1, object 2) will return the square of the
2377 * distance between the two given objects. 2231 * distance between the two given objects.
2378 */ 2232 */
2379 2233
2234int
2380int distance(const object *ob1, const object *ob2) { 2235distance (const object *ob1, const object *ob2)
2236{
2381 int i; 2237 int i;
2382 i= (ob1->x - ob2->x)*(ob1->x - ob2->x)+ 2238
2383 (ob1->y - ob2->y)*(ob1->y - ob2->y); 2239 i = (ob1->x - ob2->x) * (ob1->x - ob2->x) + (ob1->y - ob2->y) * (ob1->y - ob2->y);
2384 return i; 2240 return i;
2385} 2241}
2386 2242
2387/* 2243/*
2388 * find_dir_2(delta-x,delta-y) will return a direction in which 2244 * find_dir_2(delta-x,delta-y) will return a direction in which
2389 * an object which has subtracted the x and y coordinates of another 2245 * an object which has subtracted the x and y coordinates of another
2390 * object, needs to travel toward it. 2246 * object, needs to travel toward it.
2391 */ 2247 */
2392 2248
2249int
2393int find_dir_2(int x, int y) { 2250find_dir_2 (int x, int y)
2251{
2394 int q; 2252 int q;
2395 2253
2396 if(y) 2254 if (y)
2397 q=x*100/y; 2255 q = x * 100 / y;
2398 else if (x) 2256 else if (x)
2399 q= -300*x; 2257 q = -300 * x;
2400 else 2258 else
2401 return 0; 2259 return 0;
2402 2260
2403 if(y>0) { 2261 if (y > 0)
2262 {
2404 if(q < -242) 2263 if (q < -242)
2405 return 3 ; 2264 return 3;
2406 if (q < -41) 2265 if (q < -41)
2407 return 2 ; 2266 return 2;
2408 if (q < 41) 2267 if (q < 41)
2409 return 1 ; 2268 return 1;
2410 if (q < 242) 2269 if (q < 242)
2411 return 8 ; 2270 return 8;
2412 return 7 ; 2271 return 7;
2413 } 2272 }
2414 2273
2415 if (q < -242) 2274 if (q < -242)
2416 return 7 ; 2275 return 7;
2417 if (q < -41) 2276 if (q < -41)
2418 return 6 ; 2277 return 6;
2419 if (q < 41) 2278 if (q < 41)
2420 return 5 ; 2279 return 5;
2421 if (q < 242) 2280 if (q < 242)
2422 return 4 ; 2281 return 4;
2423 2282
2424 return 3 ; 2283 return 3;
2425} 2284}
2426 2285
2427/* 2286/*
2428 * absdir(int): Returns a number between 1 and 8, which represent 2287 * absdir(int): Returns a number between 1 and 8, which represent
2429 * the "absolute" direction of a number (it actually takes care of 2288 * the "absolute" direction of a number (it actually takes care of
2430 * "overflow" in previous calculations of a direction). 2289 * "overflow" in previous calculations of a direction).
2431 */ 2290 */
2432 2291
2292int
2433int absdir(int d) { 2293absdir (int d)
2434 while(d<1) d+=8; 2294{
2435 while(d>8) d-=8; 2295 while (d < 1)
2296 d += 8;
2297 while (d > 8)
2298 d -= 8;
2436 return d; 2299 return d;
2437} 2300}
2438 2301
2439/* 2302/*
2440 * dirdiff(dir1, dir2) returns how many 45-degrees differences there is 2303 * dirdiff(dir1, dir2) returns how many 45-degrees differences there is
2441 * between two directions (which are expected to be absolute (see absdir()) 2304 * between two directions (which are expected to be absolute (see absdir())
2442 */ 2305 */
2443 2306
2307int
2444int dirdiff(int dir1, int dir2) { 2308dirdiff (int dir1, int dir2)
2309{
2445 int d; 2310 int
2311 d;
2312
2446 d = abs(dir1 - dir2); 2313 d = abs (dir1 - dir2);
2447 if(d>4) 2314 if (d > 4)
2448 d = 8 - d; 2315 d = 8 - d;
2449 return d; 2316 return d;
2450} 2317}
2451 2318
2452/* peterm: 2319/* peterm:
… …
2457 * direction 4, 14, or 16 to get back to where we are. 2324 * direction 4, 14, or 16 to get back to where we are.
2458 * Moved from spell_util.c to object.c with the other related direction 2325 * Moved from spell_util.c to object.c with the other related direction
2459 * functions. 2326 * functions.
2460 */ 2327 */
2461 2328
2329int
2462int reduction_dir[SIZEOFFREE][3] = { 2330 reduction_dir[SIZEOFFREE][3] = {
2463 {0,0,0}, /* 0 */ 2331 {0, 0, 0}, /* 0 */
2464 {0,0,0}, /* 1 */ 2332 {0, 0, 0}, /* 1 */
2465 {0,0,0}, /* 2 */ 2333 {0, 0, 0}, /* 2 */
2466 {0,0,0}, /* 3 */ 2334 {0, 0, 0}, /* 3 */
2467 {0,0,0}, /* 4 */ 2335 {0, 0, 0}, /* 4 */
2468 {0,0,0}, /* 5 */ 2336 {0, 0, 0}, /* 5 */
2469 {0,0,0}, /* 6 */ 2337 {0, 0, 0}, /* 6 */
2470 {0,0,0}, /* 7 */ 2338 {0, 0, 0}, /* 7 */
2471 {0,0,0}, /* 8 */ 2339 {0, 0, 0}, /* 8 */
2472 {8,1,2}, /* 9 */ 2340 {8, 1, 2}, /* 9 */
2473 {1,2,-1}, /* 10 */ 2341 {1, 2, -1}, /* 10 */
2474 {2,10,12}, /* 11 */ 2342 {2, 10, 12}, /* 11 */
2475 {2,3,-1}, /* 12 */ 2343 {2, 3, -1}, /* 12 */
2476 {2,3,4}, /* 13 */ 2344 {2, 3, 4}, /* 13 */
2477 {3,4,-1}, /* 14 */ 2345 {3, 4, -1}, /* 14 */
2478 {4,14,16}, /* 15 */ 2346 {4, 14, 16}, /* 15 */
2479 {5,4,-1}, /* 16 */ 2347 {5, 4, -1}, /* 16 */
2480 {4,5,6}, /* 17 */ 2348 {4, 5, 6}, /* 17 */
2481 {6,5,-1}, /* 18 */ 2349 {6, 5, -1}, /* 18 */
2482 {6,20,18}, /* 19 */ 2350 {6, 20, 18}, /* 19 */
2483 {7,6,-1}, /* 20 */ 2351 {7, 6, -1}, /* 20 */
2484 {6,7,8}, /* 21 */ 2352 {6, 7, 8}, /* 21 */
2485 {7,8,-1}, /* 22 */ 2353 {7, 8, -1}, /* 22 */
2486 {8,22,24}, /* 23 */ 2354 {8, 22, 24}, /* 23 */
2487 {8,1,-1}, /* 24 */ 2355 {8, 1, -1}, /* 24 */
2488 {24,9,10}, /* 25 */ 2356 {24, 9, 10}, /* 25 */
2489 {9,10,-1}, /* 26 */ 2357 {9, 10, -1}, /* 26 */
2490 {10,11,-1}, /* 27 */ 2358 {10, 11, -1}, /* 27 */
2491 {27,11,29}, /* 28 */ 2359 {27, 11, 29}, /* 28 */
2492 {11,12,-1}, /* 29 */ 2360 {11, 12, -1}, /* 29 */
2493 {12,13,-1}, /* 30 */ 2361 {12, 13, -1}, /* 30 */
2494 {12,13,14}, /* 31 */ 2362 {12, 13, 14}, /* 31 */
2495 {13,14,-1}, /* 32 */ 2363 {13, 14, -1}, /* 32 */
2496 {14,15,-1}, /* 33 */ 2364 {14, 15, -1}, /* 33 */
2497 {33,15,35}, /* 34 */ 2365 {33, 15, 35}, /* 34 */
2498 {16,15,-1}, /* 35 */ 2366 {16, 15, -1}, /* 35 */
2499 {17,16,-1}, /* 36 */ 2367 {17, 16, -1}, /* 36 */
2500 {18,17,16}, /* 37 */ 2368 {18, 17, 16}, /* 37 */
2501 {18,17,-1}, /* 38 */ 2369 {18, 17, -1}, /* 38 */
2502 {18,19,-1}, /* 39 */ 2370 {18, 19, -1}, /* 39 */
2503 {41,19,39}, /* 40 */ 2371 {41, 19, 39}, /* 40 */
2504 {19,20,-1}, /* 41 */ 2372 {19, 20, -1}, /* 41 */
2505 {20,21,-1}, /* 42 */ 2373 {20, 21, -1}, /* 42 */
2506 {20,21,22}, /* 43 */ 2374 {20, 21, 22}, /* 43 */
2507 {21,22,-1}, /* 44 */ 2375 {21, 22, -1}, /* 44 */
2508 {23,22,-1}, /* 45 */ 2376 {23, 22, -1}, /* 45 */
2509 {45,47,23}, /* 46 */ 2377 {45, 47, 23}, /* 46 */
2510 {23,24,-1}, /* 47 */ 2378 {23, 24, -1}, /* 47 */
2511 {24,9,-1}}; /* 48 */ 2379 {24, 9, -1}
2380}; /* 48 */
2512 2381
2513/* Recursive routine to step back and see if we can 2382/* Recursive routine to step back and see if we can
2514 * find a path to that monster that we found. If not, 2383 * find a path to that monster that we found. If not,
2515 * we don't bother going toward it. Returns 1 if we 2384 * we don't bother going toward it. Returns 1 if we
2516 * can see a direct way to get it 2385 * can see a direct way to get it
2517 * Modified to be map tile aware -.MSW 2386 * Modified to be map tile aware -.MSW
2518 */ 2387 */
2519 2388int
2520
2521int can_see_monsterP(mapstruct *m, int x, int y,int dir) { 2389can_see_monsterP (maptile *m, int x, int y, int dir)
2390{
2522 sint16 dx, dy; 2391 sint16 dx, dy;
2523 int mflags; 2392 int mflags;
2524 2393
2394 if (dir < 0)
2525 if(dir<0) return 0; /* exit condition: invalid direction */ 2395 return 0; /* exit condition: invalid direction */
2526 2396
2527 dx = x + freearr_x[dir]; 2397 dx = x + freearr_x[dir];
2528 dy = y + freearr_y[dir]; 2398 dy = y + freearr_y[dir];
2529 2399
2530 mflags = get_map_flags(m, &m, dx, dy, &dx, &dy); 2400 mflags = get_map_flags (m, &m, dx, dy, &dx, &dy);
2531 2401
2532 /* This functional arguably was incorrect before - it was 2402 /* This functional arguably was incorrect before - it was
2533 * checking for P_WALL - that was basically seeing if 2403 * checking for P_WALL - that was basically seeing if
2534 * we could move to the monster - this is being more 2404 * we could move to the monster - this is being more
2535 * literal on if we can see it. To know if we can actually 2405 * literal on if we can see it. To know if we can actually
2536 * move to the monster, we'd need the monster passed in or 2406 * move to the monster, we'd need the monster passed in or
2537 * at least its move type. 2407 * at least its move type.
2538 */ 2408 */
2539 if (mflags & (P_OUT_OF_MAP | P_BLOCKSVIEW)) return 0; 2409 if (mflags & (P_OUT_OF_MAP | P_BLOCKSVIEW))
2410 return 0;
2540 2411
2541 /* yes, can see. */ 2412 /* yes, can see. */
2542 if(dir < 9) return 1; 2413 if (dir < 9)
2414 return 1;
2415
2543 return can_see_monsterP(m, x, y, reduction_dir[dir][0]) | 2416 return can_see_monsterP (m, x, y, reduction_dir[dir][0])
2544 can_see_monsterP(m,x,y, reduction_dir[dir][1]) | 2417 | can_see_monsterP (m, x, y, reduction_dir[dir][1])
2545 can_see_monsterP(m,x,y, reduction_dir[dir][2]); 2418 | can_see_monsterP (m, x, y, reduction_dir[dir][2]);
2546} 2419}
2547 2420
2548
2549
2550/* 2421/*
2551 * can_pick(picker, item): finds out if an object is possible to be 2422 * can_pick(picker, item): finds out if an object is possible to be
2552 * picked up by the picker. Returnes 1 if it can be 2423 * picked up by the picker. Returnes 1 if it can be
2553 * picked up, otherwise 0. 2424 * picked up, otherwise 0.
2554 * 2425 *
… …
2556 * core dumps if they do. 2427 * core dumps if they do.
2557 * 2428 *
2558 * Add a check so we can't pick up invisible objects (0.93.8) 2429 * Add a check so we can't pick up invisible objects (0.93.8)
2559 */ 2430 */
2560 2431
2432int
2561int can_pick(const object *who, const object *item) { 2433can_pick (const object *who, const object *item)
2434{
2562 return /*QUERY_FLAG(who,FLAG_WIZ)||*/ 2435 return /*QUERY_FLAG(who,FLAG_WIZ)|| */
2563 (item->weight>0&&!QUERY_FLAG(item,FLAG_NO_PICK)&& 2436 (item->weight > 0 && !QUERY_FLAG (item, FLAG_NO_PICK) &&
2564 !QUERY_FLAG(item,FLAG_ALIVE)&&!item->invisible && 2437 !QUERY_FLAG (item, FLAG_ALIVE) && !item->invisible && (who->type == PLAYER || item->weight < who->weight / 3));
2565 (who->type==PLAYER||item->weight<who->weight/3));
2566} 2438}
2567
2568 2439
2569/* 2440/*
2570 * create clone from object to another 2441 * create clone from object to another
2571 */ 2442 */
2443object *
2572object *object_create_clone (object *asrc) { 2444object_create_clone (object *asrc)
2445{
2573 object *dst = NULL,*tmp,*src,*part,*prev, *item; 2446 object *dst = 0, *tmp, *src, *part, *prev, *item;
2574 2447
2575 if(!asrc) return NULL; 2448 if (!asrc)
2449 return 0;
2450
2576 src = asrc; 2451 src = asrc;
2577 if(src->head) 2452 if (src->head)
2578 src = src->head; 2453 src = src->head;
2579 2454
2580 prev = NULL; 2455 prev = 0;
2581 for(part = src; part; part = part->more) { 2456 for (part = src; part; part = part->more)
2582 tmp = get_object(); 2457 {
2583 copy_object(part,tmp); 2458 tmp = part->clone ();
2584 tmp->x -= src->x; 2459 tmp->x -= src->x;
2585 tmp->y -= src->y; 2460 tmp->y -= src->y;
2461
2586 if(!part->head) { 2462 if (!part->head)
2463 {
2587 dst = tmp; 2464 dst = tmp;
2588 tmp->head = NULL;
2589 } else {
2590 tmp->head = dst; 2465 tmp->head = 0;
2591 } 2466 }
2467 else
2468 tmp->head = dst;
2469
2592 tmp->more = NULL; 2470 tmp->more = 0;
2471
2593 if(prev) 2472 if (prev)
2594 prev->more = tmp; 2473 prev->more = tmp;
2474
2595 prev = tmp; 2475 prev = tmp;
2596 } 2476 }
2597 /*** copy inventory ***/ 2477
2598 for(item = src->inv; item; item = item->below) { 2478 for (item = src->inv; item; item = item->below)
2599 (void) insert_ob_in_ob(object_create_clone(item),dst); 2479 insert_ob_in_ob (object_create_clone (item), dst);
2600 }
2601 2480
2602 return dst; 2481 return dst;
2603}
2604
2605/* return true if the object was destroyed, 0 otherwise */
2606int was_destroyed (const object *op, tag_t old_tag)
2607{
2608 /* checking for FLAG_FREED isn't necessary, but makes this function more
2609 * robust */
2610 return op->count != old_tag || QUERY_FLAG (op, FLAG_FREED);
2611} 2482}
2612 2483
2613/* GROS - Creates an object using a string representing its content. */ 2484/* GROS - Creates an object using a string representing its content. */
2614/* Basically, we save the content of the string to a temp file, then call */ 2485/* Basically, we save the content of the string to a temp file, then call */
2615/* load_object on it. I admit it is a highly inefficient way to make things, */ 2486/* load_object on it. I admit it is a highly inefficient way to make things, */
2616/* but it was simple to make and allows reusing the load_object function. */ 2487/* but it was simple to make and allows reusing the load_object function. */
2617/* Remember not to use load_object_str in a time-critical situation. */ 2488/* Remember not to use load_object_str in a time-critical situation. */
2618/* Also remember that multiparts objects are not supported for now. */ 2489/* Also remember that multiparts objects are not supported for now. */
2619 2490
2491object *
2620object* load_object_str(const char *obstr) 2492load_object_str (const char *obstr)
2621{ 2493{
2622 object *op; 2494 object *op;
2623 FILE *tempfile;
2624 char filename[MAX_BUF]; 2495 char filename[MAX_BUF];
2496
2625 sprintf(filename,"%s/cfloadobstr2044",settings.tmpdir); 2497 sprintf (filename, "%s/cfloadobstr2044", settings.tmpdir);
2498
2626 tempfile=fopen(filename,"w"); 2499 FILE *tempfile = fopen (filename, "w");
2500
2627 if (tempfile == NULL) 2501 if (tempfile == NULL)
2628 { 2502 {
2629 LOG(llevError,"Error - Unable to access load object temp file\n"); 2503 LOG (llevError, "Error - Unable to access load object temp file\n");
2630 return NULL; 2504 return NULL;
2631 }; 2505 }
2506
2632 fprintf(tempfile,obstr); 2507 fprintf (tempfile, obstr);
2633 fclose(tempfile); 2508 fclose (tempfile);
2634 2509
2635 op=get_object(); 2510 op = object::create ();
2636 2511
2637 tempfile=fopen(filename,"r");
2638 if (tempfile == NULL)
2639 {
2640 LOG(llevError,"Error - Unable to read object temp file\n");
2641 return NULL;
2642 };
2643 object_thawer thawer (tempfile); 2512 object_thawer thawer (filename);
2513
2514 if (thawer)
2644 load_object(thawer,op,LO_NEWFILE,0); 2515 load_object (thawer, op, 0);
2516
2645 LOG(llevDebug," load str completed, object=%s\n",op->name); 2517 LOG (llevDebug, " load str completed, object=%s\n", &op->name);
2646 CLEAR_FLAG(op,FLAG_REMOVED); 2518 CLEAR_FLAG (op, FLAG_REMOVED);
2647 fclose(tempfile); 2519
2648 return op; 2520 return op;
2649} 2521}
2650 2522
2651/* This returns the first object in who's inventory that 2523/* This returns the first object in who's inventory that
2652 * has the same type and subtype match. 2524 * has the same type and subtype match.
2653 * returns NULL if no match. 2525 * returns NULL if no match.
2654 */ 2526 */
2527object *
2655object *find_obj_by_type_subtype(const object *who, int type, int subtype) 2528find_obj_by_type_subtype (const object *who, int type, int subtype)
2656{ 2529{
2657 object *tmp; 2530 object *tmp;
2658 2531
2659 for (tmp=who->inv; tmp; tmp=tmp->below) 2532 for (tmp = who->inv; tmp; tmp = tmp->below)
2660 if (tmp->type == type && tmp->subtype == subtype) return tmp; 2533 if (tmp->type == type && tmp->subtype == subtype)
2534 return tmp;
2661 2535
2662 return NULL; 2536 return NULL;
2663} 2537}
2664 2538
2665/* If ob has a field named key, return the link from the list, 2539/* If ob has a field named key, return the link from the list,
2666 * otherwise return NULL. 2540 * otherwise return NULL.
2667 * 2541 *
2668 * key must be a passed in shared string - otherwise, this won't 2542 * key must be a passed in shared string - otherwise, this won't
2669 * do the desired thing. 2543 * do the desired thing.
2670 */ 2544 */
2545key_value *
2671key_value * get_ob_key_link(const object * ob, const char * key) { 2546get_ob_key_link (const object *ob, const char *key)
2547{
2672 key_value * link; 2548 key_value *link;
2673 2549
2674 for (link = ob->key_values; link != NULL; link = link->next) { 2550 for (link = ob->key_values; link != NULL; link = link->next)
2675 if (link->key == key) { 2551 if (link->key == key)
2676 return link; 2552 return link;
2677 } 2553
2678 }
2679
2680 return NULL; 2554 return NULL;
2681} 2555}
2682 2556
2683/* 2557/*
2684 * Returns the value of op has an extra_field for key, or NULL. 2558 * Returns the value of op has an extra_field for key, or NULL.
2685 * 2559 *
2686 * The argument doesn't need to be a shared string. 2560 * The argument doesn't need to be a shared string.
2687 * 2561 *
2688 * The returned string is shared. 2562 * The returned string is shared.
2689 */ 2563 */
2564const char *
2690const char * get_ob_key_value(const object * op, const char * const key) { 2565get_ob_key_value (const object *op, const char *const key)
2566{
2691 key_value * link; 2567 key_value *link;
2692 const char * canonical_key; 2568 shstr_cmp canonical_key (key);
2569
2570 if (!canonical_key)
2693 2571 {
2694 canonical_key = find_string(key);
2695
2696 if (canonical_key == NULL) {
2697 /* 1. There being a field named key on any object 2572 /* 1. There being a field named key on any object
2698 * implies there'd be a shared string to find. 2573 * implies there'd be a shared string to find.
2699 * 2. Since there isn't, no object has this field. 2574 * 2. Since there isn't, no object has this field.
2700 * 3. Therefore, *this* object doesn't have this field. 2575 * 3. Therefore, *this* object doesn't have this field.
2701 */ 2576 */
2702 return NULL; 2577 return 0;
2703 } 2578 }
2704 2579
2705 /* This is copied from get_ob_key_link() above - 2580 /* This is copied from get_ob_key_link() above -
2706 * only 4 lines, and saves the function call overhead. 2581 * only 4 lines, and saves the function call overhead.
2707 */ 2582 */
2708 for (link = op->key_values; link != NULL; link = link->next) { 2583 for (link = op->key_values; link; link = link->next)
2709 if (link->key == canonical_key) { 2584 if (link->key == canonical_key)
2710 return link->value; 2585 return link->value;
2711 } 2586
2712 } 2587 return 0;
2713 return NULL;
2714} 2588}
2715 2589
2716 2590
2717/* 2591/*
2718 * Updates the canonical_key in op to value. 2592 * Updates the canonical_key in op to value.
… …
2722 * Unless add_key is TRUE, it won't add fields, only change the value of existing 2596 * Unless add_key is TRUE, it won't add fields, only change the value of existing
2723 * keys. 2597 * keys.
2724 * 2598 *
2725 * Returns TRUE on success. 2599 * Returns TRUE on success.
2726 */ 2600 */
2601int
2727int set_ob_key_value_s(object * op, const char * canonical_key, const char * value, int add_key) { 2602set_ob_key_value_s (object *op, const shstr & canonical_key, const char *value, int add_key)
2603{
2604 key_value *
2728 key_value * field = NULL, *last=NULL; 2605 field = NULL, *last = NULL;
2729 2606
2730 for (field=op->key_values; field != NULL; field=field->next) { 2607 for (field = op->key_values; field != NULL; field = field->next)
2608 {
2731 if (field->key != canonical_key) { 2609 if (field->key != canonical_key)
2610 {
2732 last = field; 2611 last = field;
2733 continue; 2612 continue;
2734 } 2613 }
2735 2614
2736 if (field->value) FREE_AND_CLEAR_STR(field->value);
2737 if (value) 2615 if (value)
2738 field->value = add_string(value); 2616 field->value = value;
2739 else { 2617 else
2618 {
2740 /* Basically, if the archetype has this key set, 2619 /* Basically, if the archetype has this key set,
2741 * we need to store the null value so when we save 2620 * we need to store the null value so when we save
2742 * it, we save the empty value so that when we load, 2621 * it, we save the empty value so that when we load,
2743 * we get this value back again. 2622 * we get this value back again.
2744 */ 2623 */
2745 if (get_ob_key_link(&op->arch->clone, canonical_key)) 2624 if (get_ob_key_link (&op->arch->clone, canonical_key))
2746 field->value = NULL; 2625 field->value = 0;
2747 else { 2626 else
2748 /* Delete this link */ 2627 {
2749 if (field->key) FREE_AND_CLEAR_STR(field->key); 2628 if (last)
2750 if (field->value) FREE_AND_CLEAR_STR(field->value);
2751 if (last) last->next = field->next; 2629 last->next = field->next;
2630 else
2752 else op->key_values = field->next; 2631 op->key_values = field->next;
2632
2753 free(field); 2633 delete field;
2754 } 2634 }
2755 } 2635 }
2756 return TRUE; 2636 return TRUE;
2757 } 2637 }
2758 /* IF we get here, key doesn't exist */ 2638 /* IF we get here, key doesn't exist */
2759 2639
2760 /* No field, we'll have to add it. */ 2640 /* No field, we'll have to add it. */
2641
2642 if (!add_key)
2761 2643 {
2762 if (!add_key) {
2763 return FALSE; 2644 return FALSE;
2764 } 2645 }
2765 /* There isn't any good reason to store a null 2646 /* There isn't any good reason to store a null
2766 * value in the key/value list. If the archetype has 2647 * value in the key/value list. If the archetype has
2767 * this key, then we should also have it, so shouldn't 2648 * this key, then we should also have it, so shouldn't
2768 * be here. If user wants to store empty strings, 2649 * be here. If user wants to store empty strings,
2769 * should pass in "" 2650 * should pass in ""
2770 */ 2651 */
2771 if (value == NULL) return TRUE; 2652 if (value == NULL)
2772
2773 field = (key_value *) malloc(sizeof(key_value));
2774
2775 field->key = add_refcount(canonical_key);
2776 field->value = add_string(value);
2777 /* Usual prepend-addition. */
2778 field->next = op->key_values;
2779 op->key_values = field;
2780
2781 return TRUE; 2653 return TRUE;
2654
2655 field = new key_value;
2656
2657 field->key = canonical_key;
2658 field->value = value;
2659 /* Usual prepend-addition. */
2660 field->next = op->key_values;
2661 op->key_values = field;
2662
2663 return TRUE;
2782} 2664}
2783 2665
2784/* 2666/*
2785 * Updates the key in op to value. 2667 * Updates the key in op to value.
2786 * 2668 *
… …
2788 * and not add new ones. 2670 * and not add new ones.
2789 * In general, should be little reason FALSE is ever passed in for add_key 2671 * In general, should be little reason FALSE is ever passed in for add_key
2790 * 2672 *
2791 * Returns TRUE on success. 2673 * Returns TRUE on success.
2792 */ 2674 */
2675int
2793int set_ob_key_value(object * op, const char * key, const char * value, int add_key) { 2676set_ob_key_value (object *op, const char *key, const char *value, int add_key)
2794 const char * canonical_key = NULL; 2677{
2795 int floating_ref = FALSE; 2678 shstr key_ (key);
2796 int ret; 2679
2680 return set_ob_key_value_s (op, key_, value, add_key);
2681}
2682
2683object::depth_iterator::depth_iterator (object *container)
2684: iterator_base (container)
2685{
2686 while (item->inv)
2687 item = item->inv;
2688}
2689
2690void
2691object::depth_iterator::next ()
2692{
2693 if (item->below)
2797 2694 {
2798 /* HACK This mess is to make sure set_ob_value() passes a shared string 2695 item = item->below;
2799 * to get_ob_key_link(), without leaving a leaked refcount. 2696
2800 */ 2697 while (item->inv)
2698 item = item->inv;
2801 2699 }
2802 canonical_key = find_string(key); 2700 else
2803 if (canonical_key == NULL) { 2701 item = item->env;
2804 canonical_key = add_string(key);
2805 floating_ref = TRUE;
2806 }
2807
2808 ret = set_ob_key_value_s(op, canonical_key, value, add_key);
2809
2810 if (floating_ref) {
2811 free_string(canonical_key);
2812 }
2813
2814 return ret;
2815} 2702}
2703
2704// return a suitable string describing an objetc in enough detail to find it
2705const char *
2706object::debug_desc (char *info) const
2707{
2708 char info2[256 * 3];
2709 char *p = info;
2710
2711 p += snprintf (p, 256, "%d=\"%s%s%s\"",
2712 count,
2713 &name,
2714 title ? " " : "",
2715 title ? (const char *)title : "");
2716
2717 if (env)
2718 p += snprintf (p, 256, "(in %s)", env->debug_desc (info2));
2719
2720 if (map)
2721 p += snprintf (p, 256, "(on %s@%d+%d)", map->path, x, y);
2722
2723 return info;
2724}
2725
2726const char *
2727object::debug_desc () const
2728{
2729 static char info[256 * 3];
2730 return debug_desc (info);
2731}
2732

Diff Legend

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