ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/include/object.h
Revision: 1.121
Committed: Mon May 14 19:08:26 2007 UTC (17 years, 1 month ago) by root
Content type: text/plain
Branch: MAIN
Changes since 1.120: +8 -0 lines
Log Message:
*** empty log message ***

File Contents

# User Rev Content
1 root 1.92 /*
2 root 1.86 * CrossFire, A Multiplayer Online RPG
3     *
4     * Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
5     * Copyright (C) 2001 Mark Wedel & Crossfire Development Team
6     * Copyright (C) 1992 Frank Tore Johansen
7     *
8     * This program is free software; you can redistribute it and/or modify
9     * it under the terms of the GNU General Public License as published by
10     * the Free Software Foundation; either version 2 of the License, or
11     * (at your option) any later version.
12     *
13     * This program is distributed in the hope that it will be useful,
14     * but WITHOUT ANY WARRANTY; without even the implied warranty of
15     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16     * GNU General Public License for more details.
17     *
18     * You should have received a copy of the GNU General Public License
19     * along with this program; if not, write to the Free Software
20     * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21     *
22     * The authors can be reached via e-mail at crossfire@schmorp.de
23     */
24 root 1.1
25     #ifndef OBJECT_H
26     #define OBJECT_H
27    
28 root 1.56 #include <bitset>
29    
30 root 1.6 #include "cfperl.h"
31 root 1.7 #include "shstr.h"
32 root 1.6
33 root 1.81 typedef int tag_t;
34 root 1.109
35 root 1.118 enum {
36     body_range,
37     body_shield,
38     body_combat,
39     body_arm,
40     body_torso,
41     body_head,
42     body_neck,
43     body_skill,
44     body_finger,
45     body_shoulder,
46     body_foot,
47     body_hand,
48     body_wrist,
49     body_waist,
50     NUM_BODY_LOCATIONS
51     };
52 root 1.1
53 root 1.121 enum slottype_t
54     {
55     slot_none,
56     slot_combat,
57     slot_ranged,
58     };
59    
60 root 1.1 /* See common/item.c */
61    
62 root 1.20 typedef struct Body_Locations
63     {
64     const char *save_name; /* Name used to load/save it to disk */
65     const char *use_name; /* Name used when describing an item we can use */
66     const char *nonuse_name; /* Name to describe objects we can't use */
67 root 1.1 } Body_Locations;
68    
69     extern Body_Locations body_locations[NUM_BODY_LOCATIONS];
70    
71     /*
72     * Each object (this also means archetypes!) could have a few of these
73     * "dangling" from it; this could also end up containing 'parse errors'.
74     *
75     * key and value are shared-strings.
76     *
77     * Please use get_ob_key_value(), set_ob_key_value() from object.c rather than
78     * accessing the list directly.
79     * Exception is if you want to walk this list for some reason.
80     */
81 root 1.20 struct key_value
82     {
83     key_value *next;
84     shstr key, value;
85 root 1.15 };
86 root 1.1
87 root 1.34 struct UUID
88     {
89     uint64 seq;
90 root 1.53
91     UUID () { }
92     UUID (uint64 seq) : seq(seq) { }
93     operator uint64() { return seq; }
94     void operator =(uint64 seq) { this->seq = seq; }
95 root 1.34 };
96    
97     extern void init_uuid ();
98     extern UUID gen_uuid ();
99 elmex 1.45 extern const uint64 UUID_SKIP;
100 root 1.1
101     /* Definition for WILL_APPLY values. Replaces having harcoded values
102     * sprinkled in the code. Note that some of these also replace fields
103     * that were in the can_apply area. What is the point of having both
104     * can_apply and will_apply?
105     */
106 root 1.27 #define WILL_APPLY_HANDLE 0x01
107     #define WILL_APPLY_TREASURE 0x02
108     #define WILL_APPLY_EARTHWALL 0x04
109     #define WILL_APPLY_DOOR 0x08
110 root 1.14 #define WILL_APPLY_FOOD 0x10
111 root 1.1
112 root 1.14 /* However, if you're keeping a pointer of some sort, you probably
113     * don't just want it copied, so you'll need to add to common/object.C,
114 root 1.49 * e.g. ->copy_to ()
115 root 1.1 */
116 elmex 1.4
117 root 1.116 struct body_slot
118     {
119 root 1.117 signed char info:4; /* body info as loaded from the file */
120     signed char used:4; /* Calculated value based on items equipped */
121 root 1.116 };
122    
123 root 1.68 INTERFACE_CLASS (object)
124 root 1.65 // these are being copied
125 root 1.68 struct object_copy : attachable
126 root 1.18 {
127 root 1.65 typedef bitset<NUM_FLAGS> flags_t;
128 root 1.1
129 root 1.68 sint16 ACC (RW, x), ACC (RW, y); /* Position in the map for this object */
130 root 1.117
131     uint8 ACC (RW, type); /* PLAYER, BULLET, etc. See define.h */
132     uint8 ACC (RW, subtype); /* subtype of object */
133 root 1.68 sint8 ACC (RW, direction); /* Means the object is moving that way. */
134     sint8 ACC (RW, facing); /* Object is oriented/facing that way. */
135 root 1.117
136 root 1.20 shstr ACC (RW, name); /* The name of the object, obviously... */
137     shstr ACC (RW, name_pl); /* The plural name of the object */
138 root 1.46 shstr ACC (RW, title); /* Of foo, etc */
139 root 1.20 shstr ACC (RW, race); /* human, goblin, dragon, etc */
140     shstr ACC (RW, slaying); /* Which race to do double damage to */
141 root 1.68 /* If this is an exit, this is the filename */
142 root 1.46 shstr ACC (RW, skill); /* Name of the skill this object uses/grants */
143 root 1.20 shstr ACC (RW, msg); /* If this is a book/sign/magic mouth/etc */
144     shstr ACC (RW, lore); /* Obscure information about this object, */
145 root 1.68 /* To get put into books and the like. */
146 root 1.20 shstr ACC (RW, materialname); /* specific material name */
147     shstr ACC (RW, custom_name); /* Custom name assigned by player */
148 root 1.96 // materialtype_t *ACC (RW, material); /* What material this object consists of */
149 root 1.41 object_ptr ACC (RW, owner); /* Pointer to the object which controls this one */
150     object_ptr ACC (RW, enemy); /* Monster/player to follow even if not closest */
151     object_ptr ACC (RW, attacked_by); /* This object start to attack us! only player & monster */
152     object_ptr ACC (RW, chosen_skill); /* the skill chosen to use */
153     object_ptr ACC (RW, spellitem); /* Spell ability monster is choosing to use */
154     object_ptr ACC (RW, spell); /* Spell that was being cast */
155     object_ptr ACC (RW, current_weapon); /* Pointer to the weapon currently used */
156 root 1.62 arch_ptr ACC (RW, arch); /* Pointer to archetype */
157     arch_ptr ACC (RW, other_arch);/* Pointer used for various things - mostly used for what */
158 elmex 1.63
159 root 1.46 float ACC (RW, speed); /* The overall speed of this object */
160 root 1.20 float ACC (RW, speed_left); /* How much speed is left to spend this round */
161 root 1.46 uint32 ACC (RW, nrof); /* How many of the objects */
162 root 1.18
163     /* This next big block are basically used for monsters and equipment */
164 root 1.20 uint16 ACC (RW, client_type); /* Public type information. see doc/Developers/objects */
165 root 1.117
166 root 1.67 sint16 ACC (RW, resist[NROFATTACKS]); /* Resistance adjustments for attacks */
167 root 1.20 uint32 ACC (RW, attacktype); /* Bitmask of attacks this object does */
168 root 1.46 uint32 ACC (RW, path_attuned);/* Paths the object is attuned to */
169 root 1.20 uint32 ACC (RW, path_repelled); /* Paths the object is repelled from */
170     uint32 ACC (RW, path_denied); /* Paths the object is denied access to */
171 root 1.96 uint16 ACC (RW, materials); /* What materials this object consists of */
172 root 1.46 sint8 ACC (RW, magic); /* Any magical bonuses to this item */
173     uint8 ACC (RW, state); /* How the object was last drawn (animation) */
174 root 1.20 sint32 ACC (RW, value); /* How much money it is worth (or contains) */
175 root 1.18 /* Note that the last_.. values are sometimes used for non obvious
176     * meanings by some objects, eg, sp penalty, permanent exp.
177     */
178 root 1.20 sint32 ACC (RW, last_heal); /* Last healed. Depends on constitution */
179     sint32 ACC (RW, last_sp); /* As last_heal, but for spell points */
180     sint16 ACC (RW, last_grace); /* as last_sp, except for grace */
181     sint16 ACC (RW, last_eat); /* How long since we last ate */
182     sint16 ACC (RW, invisible); /* How much longer the object will be invis */
183 root 1.26 sint16 ACC (RW, level); /* Level of creature or object */
184 root 1.20 uint8 ACC (RW, pick_up); /* See crossfire.doc */
185     sint8 ACC (RW, item_power); /* power rating of the object */
186 root 1.46 sint8 ACC (RW, gen_sp_armour);/* sp regen penalty this object has (was last_heal) */
187 root 1.26 sint8 ACC (RW, glow_radius); /* indicates the glow radius of the object */
188 root 1.20 sint32 ACC (RW, weight); /* Attributes of the object */
189 root 1.46 sint32 ACC (RW, weight_limit);/* Weight-limit of object */
190 root 1.20 sint32 ACC (RW, carrying); /* How much weight this object contains */
191     sint64 ACC (RW, perm_exp); /* Permanent exp */
192     uint32 ACC (RW, weapontype); /* type of weapon */
193     uint32 ACC (RW, tooltype); /* type of tool or build facility */
194 root 1.116 body_slot slot [NUM_BODY_LOCATIONS];
195 root 1.104 faceidx ACC (RW, face); /* Face with colors */
196 root 1.36 living ACC (RO, stats); /* Str, Con, Dex, etc */
197 root 1.68 /* See the pod/objects.pod for more info about body locations */
198 root 1.18
199     /* Following mostly refers to fields only used for monsters */
200 root 1.46 uint32 ACC (RW, hide); /* The object is hidden, not invisible */
201 root 1.68
202 root 1.18 /* allows different movement patterns for attackers */
203 root 1.20 sint32 ACC (RW, move_status); /* What stage in attack mode */
204     uint16 ACC (RW, attack_movement); /* What kind of attack movement */
205 root 1.26 uint16 ACC (RW, run_away); /* Monster runs away if it's hp goes below this percentage. */
206     float ACC (RW, expmul); /* needed experience = (calc_exp*expmul) - means some */
207 root 1.68 /* races/classes can need less/more exp to gain levels */
208 root 1.18
209     /* Spell related information, may be useful elsewhere
210     * Note that other fields are used - these files are basically
211     * only used in spells.
212     */
213 root 1.20 sint16 ACC (RW, duration); /* How long the spell lasts */
214 root 1.46 sint16 ACC (RW, casting_time);/* time left before spell goes off */
215 root 1.117
216 root 1.26 uint16 ACC (RW, start_holding);
217     uint8 ACC (RW, duration_modifier); /* how level modifies duration */
218 root 1.20 uint8 ACC (RW, dam_modifier); /* How going up in level effects damage */
219 root 1.117
220 root 1.46 sint8 ACC (RW, range); /* Range of the spell */
221 root 1.20 uint8 ACC (RW, range_modifier); /* How going up in level effects range */
222 root 1.68 MoveType ACC (RW, move_type); /* Type of movement this object uses */
223     MoveType ACC (RW, move_block);/* What movement types this blocks */
224 root 1.117
225 root 1.68 MoveType ACC (RW, move_allow);/* What movement types explicitly allowd */
226     MoveType ACC (RW, move_on); /* Move types affected moving on to this space */
227     MoveType ACC (RW, move_off); /* Move types affected moving off this space */
228     MoveType ACC (RW, move_slow); /* Movement types this slows down */
229 root 1.117
230 root 1.68 float ACC (RW, move_slow_penalty); /* How much this slows down the object */
231    
232 root 1.36 char *ACC (RW, spellarg);
233 root 1.18
234     /* Following are values used by any object */
235 root 1.56 /* this objects turns into or what this object creates */
236 root 1.40 treasurelist *ACC (RW, randomitems); /* Items to be generated */
237 root 1.66 flags_t flag; /* various flags */
238 root 1.67 #if FOR_PERL
239     bool ACC (RW, flag[NUM_FLAGS]);
240     #endif
241 root 1.46 uint16 ACC (RW, animation_id);/* An index into the animation array */
242     uint8 ACC (RW, anim_speed); /* ticks between animation-frames */
243     uint8 ACC (RW, last_anim); /* last sequence used to draw face */
244 root 1.68 sint16 ACC (RW, elevation); /* elevation of this terrain - not currently used */
245 root 1.46 uint8 ACC (RW, smoothlevel); /* how to smooth this square around */
246 root 1.32 uint8 ACC (RW, will_apply); /* See crossfire.doc */
247 elmex 1.4 };
248    
249 root 1.68 struct object : zero_initialised, object_copy
250 root 1.18 {
251 root 1.65 // These variables are not changed by ->copy_to
252 root 1.68 maptile_ptr ACC (RW, map); /* Pointer to the map in which this object is present */
253 root 1.65
254     UUID ACC (RW, uuid); // Unique Identifier, survives saves etc.
255 root 1.82 int ACC (RO, count);
256     int ACC (RO, index); // index into objects
257 root 1.81 int ACC (RO, active); // index into actives
258 root 1.65
259     player_ptr ACC (RW, contr); /* Pointer to the player which control this object */
260 root 1.81
261 root 1.65 object *ACC (RW, below); /* Pointer to the object stacked below this one */
262     object *ACC (RW, above); /* Pointer to the object stacked above this one */
263     /* Note: stacked in the *same* environment */
264     object *inv; /* Pointer to the first object in the inventory */
265 root 1.83
266     //TODO: container must move into client
267 root 1.99 object_ptr ACC (RW, container); /* Current container being used. I think this
268 root 1.65 * is only used by the player right now.
269     */
270     object *ACC (RW, env); /* Pointer to the object which is the environment.
271     * This is typically the container that the object is in.
272     */
273     object *ACC (RW, more); /* Pointer to the rest of a large body of objects */
274     object *head; /* Points to the main object of a large body */ // NO ACC, perl semantics are different
275     client_container *seen_by; // seen by which player/container currently?
276 root 1.105 key_value *key_values; /* Fields not explictly known by the loader. */
277 root 1.65
278 root 1.100 bool parse_kv (object_thawer &f); // parse kv pairs, (ab-)used by archetypes, which should not exist at all
279 root 1.118 void post_load_check (); // do some adjustments after parsing
280 root 1.101 static object *read (object_thawer &f, maptile *map = 0); // map argument due to toal design bogosity, must go.
281 root 1.100 bool write (object_freezer &f);
282    
283 root 1.121 MTH int slottype () const;
284 root 1.69 MTH static object *create ();
285 root 1.105 object &operator =(const object &src);
286 root 1.69 MTH void copy_to (object *dst);
287     MTH object *clone (); // create + copy_to
288 root 1.68 void do_destroy ();
289     void gather_callbacks (AV *&callbacks, event_type event) const;
290 root 1.69 MTH void destroy (bool destroy_inventory = false);
291 root 1.68
292     // recursively destroy all objects in inventory, optionally dropping them to the ground instead
293 root 1.69 MTH void destroy_inv (bool drop_to_ground = false);
294     MTH object *insert (object *item); // insert into inventory
295 root 1.95 void do_remove ();
296 root 1.88 MTH void remove ()
297     {
298     if (!flag [FLAG_REMOVED])
299 root 1.95 do_remove ();
300 root 1.88 }
301 root 1.22
302 root 1.119 // move this object to the top of its env's inventory to speed up
303     // searches for it.
304     MTH void inv_splay ()
305     {
306     if (env && env->inv != this)
307     {
308     if (above) above->below = below;
309     if (below) below->above = above;
310    
311     above = 0;
312     below = env->inv;
313     below->above = this;
314     env->inv = this;
315     }
316     }
317    
318 root 1.51 static bool can_merge_slow (object *op1, object *op2);
319    
320     // this is often used in time-critical code, so optimise
321 root 1.69 MTH static bool can_merge (object *op1, object *op2)
322 root 1.51 {
323 root 1.52 return op1->value == op2->value
324     && op1->name == op2->name
325 root 1.51 && can_merge_slow (op1, op2);
326     }
327 root 1.19
328 root 1.69 MTH void set_owner (object *owner);
329 root 1.70 MTH void set_speed (float speed);
330 root 1.120 MTH bool change_weapon (object *ob);
331 root 1.51
332 root 1.99 MTH void open_container (object *new_container);
333     MTH void close_container ()
334     {
335     open_container (0);
336     }
337    
338 root 1.100 MTH void instantiate ();
339 root 1.34
340 root 1.62 // recalculate all stats
341 root 1.69 MTH void update_stats ();
342     MTH void roll_stats ();
343     MTH void swap_stats (int a, int b);
344     MTH void add_statbonus ();
345     MTH void remove_statbonus ();
346     MTH void drain_stat ();
347     MTH void drain_specific_stat (int deplete_stats);
348     MTH void change_luck (int value);
349 root 1.62
350 root 1.33 // info must hold 256 * 3 bytes currently
351 root 1.73 const char *debug_desc (char *info) const;
352 root 1.113 MTH const char *debug_desc () const; // uses at least 3 round-robin buffers
353 root 1.75 const char *flag_desc (char *desc, int len) const;
354 root 1.33
355 root 1.96 int number_of () const
356     {
357     return nrof ? nrof : 1;
358     }
359    
360     uint64 total_weight () const
361     {
362     return weight * number_of ();
363     }
364    
365     // return the dominant material of this item, always return something
366 root 1.97 const materialtype_t *dominant_material () const;
367 root 1.96
368 root 1.98 // return the volume of this object in cm³
369 root 1.96 uint64 volume () const
370     {
371 root 1.98 return total_weight ()
372     * 1000
373     * (type == CONTAINER ? 1000 : 1)
374     / dominant_material ()->density;
375 root 1.96 }
376    
377 root 1.69 MTH bool is_weapon () const { return type == ARROW || type == BOW || type == WEAPON; }
378     MTH bool is_armor () const { return type == ARMOUR || type == SHIELD || type == HELMET
379     || type == CLOAK || type == BOOTS || type == GLOVES
380     || type == BRACERS || type == GIRDLE; }
381     MTH bool is_alive () const { return (type == PLAYER
382     || flag [FLAG_MONSTER]
383     || (flag [FLAG_ALIVE] && !flag [FLAG_GENERATOR] && type != DOOR))
384     && !flag [FLAG_IS_A_TEMPLATE]; }
385     MTH bool is_arrow () const { return type == ARROW
386     || (type == SPELL_EFFECT
387     && (subtype == SP_BULLET || subtype == SP_MAGIC_MISSILE)); }
388 root 1.114 MTH bool is_range () const { return type == BOW || type == ROD || type == WAND || type == HORN; }
389 root 1.57
390 elmex 1.74 MTH bool has_active_speed () const { return FABS(speed) >= MIN_ACTIVE_SPEED; }
391    
392 root 1.76 // temporary: wether the object can be saved in a map file
393 root 1.72 // contr => is a player
394     // head => only save head of a multitile object
395     // owner => can not reference owner yet
396 root 1.90 MTH bool can_map_save () const { return !contr && !head && !owner && !flag [FLAG_NO_MAP_SAVE]; }
397 root 1.72
398 root 1.57 /* This return true if object has still randomitems which
399     * could be expanded.
400     */
401 root 1.69 MTH bool has_random_items () const { return randomitems && !flag [FLAG_IS_A_TEMPLATE]; }
402 root 1.57
403 root 1.60 // returns the player that has this object in his inventory, or 0
404 root 1.69 MTH object *in_player () const
405 root 1.60 {
406     for (object *op = env; op; op = op->env)
407     if (op->type == PLAYER)
408     return op;
409    
410     return 0;
411     }
412    
413 root 1.71 // "temporary" helper function
414     MTH object *head_ ()
415     {
416     return head ? head : this;
417     }
418    
419 root 1.110 MTH std::string long_desc (object *who = 0);
420     MTH std::string describe_monster (object *who = 0);
421     MTH std::string describe_item (object *who = 0);
422     MTH std::string describe (object *who = 0);
423    
424 root 1.109 // If this object has no extra parts but should have them,
425     // add them, effectively expanding heads into multipart
426     // objects. This method only works on objects not inserted
427     // anywhere.
428 root 1.111 MTH void expand_tail ();
429    
430     MTH void create_treasure (treasurelist *tl, int flags = 0);
431 root 1.109
432 root 1.71 // insert object at same map position as 'where'
433     // handles both inventory and map "positions"
434     MTH object *insert_at (object *where, object *originator = 0, int flags = 0);
435    
436 root 1.78 MTH void activate ();
437     MTH void deactivate ();
438     MTH void activate_recursive ();
439     MTH void deactivate_recursive ();
440 root 1.73
441 root 1.79 // set the givne flag on all objects in the inventory recursively
442     MTH void set_flag_inv (int flag, int value = 1);
443    
444 root 1.112 void enter_exit (object *exit);//Perl
445 root 1.73 MTH void enter_map (maptile *newmap, int x, int y);
446    
447 root 1.61 // returns the mapspace this object is in
448     mapspace &ms () const;
449    
450 root 1.29 // fully recursive iterator
451     struct iterator_base
452     {
453     object *item;
454    
455 root 1.30 iterator_base (object *container)
456     : item (container)
457 root 1.29 {
458     }
459    
460     operator object *() const { return item; }
461    
462     object *operator ->() const { return item; }
463     object &operator * () const { return *item; }
464     };
465    
466 root 1.77 MTH unsigned int random_seed () const
467     {
468     return (unsigned int)uuid.seq;
469     }
470    
471 root 1.30 // depth-first recursive iterator
472     struct depth_iterator : iterator_base
473 root 1.29 {
474 root 1.30 depth_iterator (object *container);
475 root 1.29 void next ();
476     object *operator ++( ) { next (); return item; }
477     object *operator ++(int) { object *i = item; next (); return i; }
478     };
479    
480     object *begin ()
481     {
482 root 1.30 return this;
483 root 1.29 }
484    
485     object *end ()
486     {
487 root 1.30 return this;
488 root 1.29 }
489    
490 root 1.84 /* This returns TRUE if the object is something that
491     * should be displayed in the floorbox/inventory window
492     */
493     MTH bool client_visible () const
494     {
495     return !invisible && type != PLAYER;
496     }
497    
498 root 1.93 MTH struct region *region () const;
499    
500 root 1.23 protected:
501     friend struct archetype;
502    
503 root 1.24 void link ();
504     void unlink ();
505    
506 root 1.23 object ();
507     ~object ();
508 elmex 1.4 };
509 root 1.1
510 root 1.82 typedef object_vector<object, &object::index > objectvec;
511 root 1.81 typedef object_vector<object, &object::active> activevec;
512    
513     extern objectvec objects;
514     extern activevec actives;
515    
516     #define for_all_objects(var) \
517 pippijn 1.102 for (unsigned _i = 0; _i < objects.size (); ++_i) \
518 root 1.81 declvar (object *, var, objects [_i])
519    
520     #define for_all_actives(var) \
521 pippijn 1.102 for (unsigned _i = 0; _i < actives.size (); ++_i) \
522 root 1.81 declvar (object *, var, actives [_i])
523    
524 root 1.20 typedef struct oblnk
525     { /* Used to link together several objects */
526 root 1.43 object_ptr ob;
527 root 1.1 struct oblnk *next;
528     } objectlink;
529    
530 root 1.20 typedef struct oblinkpt
531     { /* Used to link together several object links */
532 root 1.1 struct oblnk *link;
533 root 1.20 long value; /* Used as connected value in buttons/gates */
534 root 1.1 struct oblinkpt *next;
535     } oblinkpt;
536    
537     /*
538     * The archetype structure is a set of rules on how to generate and manipulate
539     * objects which point to archetypes.
540     * This probably belongs in arch.h, but there really doesn't appear to
541     * be much left in the archetype - all it really is is a holder for the
542     * object and pointers. This structure should get removed, and just replaced
543     * by the object structure
544     */
545    
546 root 1.68 INTERFACE_CLASS (archetype)
547     struct archetype : zero_initialised, attachable
548 root 1.15 {
549 root 1.22 archetype ();
550     ~archetype ();
551 root 1.68 void gather_callbacks (AV *&callbacks, event_type event) const;
552 root 1.22
553 root 1.108 static archetype *read (object_thawer &f);
554     static archetype *get (const char *name); // find or create
555 root 1.94 static archetype *find (const char *name);
556 root 1.38
557 root 1.68 void hash_add (); // add to hashtable
558 root 1.44 void hash_del (); // remove from hashtable
559    
560 root 1.38 shstr ACC (RW, name); /* More definite name, like "generate_kobold" */
561     struct archetype *ACC (RW, next); /* Next archetype in a linked list */
562     struct archetype *ACC (RW, head); /* The main part of a linked object */
563     struct archetype *ACC (RW, more); /* Next part of a linked object */
564 root 1.49 object ACC (RO, clone); /* An object from which to do ->copy_to () */
565 root 1.38 uint32 ACC (RW, editable); /* editable flags (mainly for editor) */
566 root 1.107 bool ACC (RW, linked); // linked into list of heads
567 root 1.38 sint8 ACC (RW, tail_x), ACC (RW, tail_y); /* Where the lower right most portion of the object is
568     * in comparison to the head.
569     */
570 root 1.21 };
571 root 1.1
572     /* Used by update_object to know if the object being passed is
573     * being added or removed.
574     */
575     #define UP_OBJ_INSERT 1
576     #define UP_OBJ_REMOVE 2
577     #define UP_OBJ_CHANGE 3
578 root 1.20 #define UP_OBJ_FACE 4 /* Only thing that changed was the face */
579 root 1.1
580     /* These are flags passed to insert_ob_in_map and
581     * insert_ob_in_ob. Note that all flags may not be meaningful
582     * for both functions.
583     * Most are fairly explanatory:
584     * INS_NO_MERGE: don't try to merge inserted object with ones alrady
585     * on space.
586     * INS_ABOVE_FLOOR_ONLY: Put object immediatly above the floor.
587     * INS_NO_WALK_ON: Don't call check_walk_on against the
588     * originator - saves cpu time if you know the inserted object
589     * is not meaningful in terms of having an effect.
590     * INS_ON_TOP: Always put object on top. Generally only needed when loading
591     * files from disk and ordering needs to be preserved.
592     * INS_BELOW_ORIGINATOR: Insert new object immediately below originator -
593     * Use for treasure chests so the new object is the highest thing
594     * beneath the player, but not actually above it. Note - the
595     * map and x,y coordinates for the object to be inserted must
596     * match the originator.
597     * INS_MAP_LOAD: disable lots of checkings done at insertion to
598     * speed up map loading process, as we assume the ordering in
599     * loaded map is correct.
600     *
601     * Note that INS_BELOW_ORIGINATOR, INS_ON_TOP, INS_ABOVE_FLOOR_ONLY
602     * are mutually exclusive. The behaviour for passing more than one
603     * should be considered undefined - while you may notice what happens
604     * right now if you pass more than one, that could very well change
605     * in future revisions of the code.
606     */
607 root 1.14 #define INS_NO_MERGE 0x0001
608     #define INS_ABOVE_FLOOR_ONLY 0x0002
609     #define INS_NO_WALK_ON 0x0004
610     #define INS_ON_TOP 0x0008
611     #define INS_BELOW_ORIGINATOR 0x0010
612     #define INS_MAP_LOAD 0x0020
613 root 1.1
614     #define ARCH_SINGULARITY "singularity"
615     #define ARCH_DETECT_MAGIC "detect_magic"
616     #define ARCH_DEPLETION "depletion"
617     #define ARCH_SYMPTOM "symptom"
618    
619     #endif
620 root 1.44