ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/common/loader.C
(Generate patch)

Comparing deliantra/server/common/loader.C (file contents):
Revision 1.11 by root, Fri Sep 8 17:14:07 2006 UTC vs.
Revision 1.40 by pippijn, Sat Jan 6 14:42:29 2007 UTC

1/* 1/*
2 CrossFire, A Multiplayer game for X-windows 2 CrossFire, A Multiplayer game for X-windows
3 3
4 Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
4 Copyright (C) 2002 Mark Wedel & Crossfire Development Team 5 Copyright (C) 2002 Mark Wedel & Crossfire Development Team
5 Copyright (C) 1992 Frank Tore Johansen 6 Copyright (C) 1992 Frank Tore Johansen
6 7
7 This program is free software; you can redistribute it and/or modify 8 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by 9 it under the terms of the GNU General Public License as published by
… …
16 17
17 You should have received a copy of the GNU General Public License 18 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software 19 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 21
21 The authors can be reached via e-mail at crossfire-devel@real-time.com 22 The authors can be reached via e-mail at <crossfire@schmorp.de>
22*/ 23*/
23 24
24/* Eneq(@csd.uu.se): Added weight-modifiers in environment of objects. 25/* Eneq(@csd.uu.se): Added weight-modifiers in environment of objects.
25 sub/add_weight will transcend the environment updating the carrying 26 sub/add_weight will transcend the environment updating the carrying
26 variable. */ 27 variable. */
27 28
28 29
29#include <global.h> 30#include <global.h>
30#include <loader.h> 31#include <loader.h>
31#include <newserver.h>
32#include <sproto.h> 32#include <sproto.h>
33 33
34/* Maps the MOVE_* values to names */ 34/* Maps the MOVE_* values to names */
35static const char *const move_name[] = {"walk", "fly_low", "fly_high", "swim", "boat", NULL}; 35static const char *const move_name[] = { "walk", "fly_low", "fly_high", "swim", "boat", NULL };
36 36
37/* This table is only necessary to convert objects that existed before the 37/* This table is only necessary to convert objects that existed before the
38 * spell object conversion to the new object. It was not practical 38 * spell object conversion to the new object. It was not practical
39 * to go through every mapping looking for every potion, rod, wand, etc 39 * to go through every mapping looking for every potion, rod, wand, etc
40 * that had a sp set and update to the new value. So this maps the 40 * that had a sp set and update to the new value. So this maps the
… …
43 * new spell won't have been used, and thus won't have any legacy object. 43 * new spell won't have been used, and thus won't have any legacy object.
44 * NULL entries in this table are valid - to denote objects that should 44 * NULL entries in this table are valid - to denote objects that should
45 * not be updated for whatever reason. 45 * not be updated for whatever reason.
46 */ 46 */
47const char *spell_mapping[] = { 47const char *spell_mapping[] = {
48"spell_magic_bullet", /* 0 */ 48 "spell_magic_bullet", /* 0 */
49"spell_small_fireball", /* 1 */ 49 "spell_small_fireball", /* 1 */
50"spell_medium_fireball", /* 2 */ 50 "spell_medium_fireball", /* 2 */
51"spell_large_fireball", /* 3 */ 51 "spell_large_fireball", /* 3 */
52"spell_burning_hands", /* 4 */ 52 "spell_burning_hands", /* 4 */
53"spell_sm_lightning", /* 5 */ 53 "spell_sm_lightning", /* 5 */
54"spell_large_lightning", /* 6 */ 54 "spell_large_lightning", /* 6 */
55"spell_magic_missile", /* 7 */ 55 "spell_magic_missile", /* 7 */
56"spell_create_bomb", /* 8 */ 56 "spell_create_bomb", /* 8 */
57"spell_summon_golem", /* 9 */ 57 "spell_summon_golem", /* 9 */
58"spell_summon_fire_elemental", /* 10 */ 58 "spell_summon_fire_elemental", /* 10 */
59"spell_summon_earth_elemental", /* 11 */ 59 "spell_summon_earth_elemental", /* 11 */
60"spell_summon_water_elemental", /* 12 */ 60 "spell_summon_water_elemental", /* 12 */
61"spell_summon_air_elemental", /* 13 */ 61 "spell_summon_air_elemental", /* 13 */
62"spell_dimension_door", /* 14 */ 62 "spell_dimension_door", /* 14 */
63"spell_create_earth_wall", /* 15 */ 63 "spell_create_earth_wall", /* 15 */
64"spell_paralyze", /* 16 */ 64 "spell_paralyze", /* 16 */
65"spell_icestorm", /* 17 */ 65 "spell_icestorm", /* 17 */
66"spell_magic_mapping", /* 18 */ 66 "spell_magic_mapping", /* 18 */
67"spell_turn_undead", /* 19 */ 67 "spell_turn_undead", /* 19 */
68"spell_fear", /* 20 */ 68 "spell_fear", /* 20 */
69"spell_poison_cloud", /* 21 */ 69 "spell_poison_cloud", /* 21 */
70"spell_wonder", /* 22 */ 70 "spell_wonder", /* 22 */
71"spell_destruction", /* 23 */ 71 "spell_destruction", /* 23 */
72"spell_perceive_self", /* 24 */ 72 "spell_perceive_self", /* 24 */
73"spell_word_of_recall", /* 25 */ 73 "spell_word_of_recall", /* 25 */
74"spell_invisible", /* 26 */ 74 "spell_invisible", /* 26 */
75"spell_invisible_to_undead", /* 27 */ 75 "spell_invisible_to_undead", /* 27 */
76"spell_probe", /* 28 */ 76 "spell_probe", /* 28 */
77"spell_lg_magic_bullet", /* 29 */ 77 "spell_lg_magic_bullet", /* 29 */
78"spell_improved_invisibility", /* 30 */ 78 "spell_improved_invisibility", /* 30 */
79"spell_holy_word", /* 31 */ 79 "spell_holy_word", /* 31 */
80"spell_minor_healing", /* 32 */ 80 "spell_minor_healing", /* 32 */
81"spell_medium_healing", /* 33 */ 81 "spell_medium_healing", /* 33 */
82"spell_major_healing", /* 34 */ 82 "spell_major_healing", /* 34 */
83"spell_heal", /* 35 */ 83 "spell_heal", /* 35 */
84"spell_create_food", /* 36 */ 84 "spell_create_food", /* 36 */
85"spell_earth_to_dust", /* 37 */ 85 "spell_earth_to_dust", /* 37 */
86"spell_armour", /* 38 */ 86 "spell_armour", /* 38 */
87"spell_strength", /* 39 */ 87 "spell_strength", /* 39 */
88"spell_dexterity", /* 40 */ 88 "spell_dexterity", /* 40 */
89"spell_constitution", /* 41 */ 89 "spell_constitution", /* 41 */
90"spell_charisma", /* 42 */ 90 "spell_charisma", /* 42 */
91"spell_create_fire_wall", /* 43 */ 91 "spell_create_fire_wall", /* 43 */
92"spell_create_frost_wall", /* 44 */ 92 "spell_create_frost_wall", /* 44 */
93"spell_protection_from_cold", /* 45 */ 93 "spell_protection_from_cold", /* 45 */
94"spell_protection_from_electricity", /* 46 */ 94 "spell_protection_from_electricity", /* 46 */
95"spell_protection_from_fire", /* 47 */ 95 "spell_protection_from_fire", /* 47 */
96"spell_protection_from_poison", /* 48 */ 96 "spell_protection_from_poison", /* 48 */
97"spell_protection_from_slow", /* 49 */ 97 "spell_protection_from_slow", /* 49 */
98"spell_protection_from_paralysis", /* 50 */ 98 "spell_protection_from_paralysis", /* 50 */
99"spell_protection_from_draining", /* 51 */ 99 "spell_protection_from_draining", /* 51 */
100"spell_protection_from_magic", /* 52 */ 100 "spell_protection_from_magic", /* 52 */
101"spell_protection_from_attack", /* 53 */ 101 "spell_protection_from_attack", /* 53 */
102"spell_levitate", /* 54 */ 102 "spell_levitate", /* 54 */
103"spell_small_speedball", /* 55 */ 103 "spell_small_speedball", /* 55 */
104"spell_large_speedball", /* 56 */ 104 "spell_large_speedball", /* 56 */
105"spell_hellfire", /* 57 */ 105 "spell_hellfire", /* 57 */
106"spell_dragonbreath", /* 58 */ 106 "spell_dragonbreath", /* 58 */
107"spell_large_icestorm", /* 59 */ 107 "spell_large_icestorm", /* 59 */
108"spell_charging", /* 60 */ 108 "spell_charging", /* 60 */
109"spell_polymorph", /* 61 */ 109 "spell_polymorph", /* 61 */
110"spell_cancellation", /* 62 */ 110 "spell_cancellation", /* 62 */
111"spell_confusion", /* 63 */ 111 "spell_confusion", /* 63 */
112"spell_mass_confusion", /* 64 */ 112 "spell_mass_confusion", /* 64 */
113"spell_summon_pet_monster", /* 65 */ 113 "spell_summon_pet_monster", /* 65 */
114"spell_slow", /* 66 */ 114 "spell_slow", /* 66 */
115"spell_regenerate_spellpoints", /* 67 */ 115 "spell_regenerate_spellpoints", /* 67 */
116"spell_cure_poison", /* 68 */ 116 "spell_cure_poison", /* 68 */
117"spell_protection_from_confusion", /* 69 */ 117 "spell_protection_from_confusion", /* 69 */
118"spell_protection_from_cancellation", /* 70 */ 118 "spell_protection_from_cancellation", /* 70 */
119"spell_protection_from_depletion", /* 71 */ 119 "spell_protection_from_depletion", /* 71 */
120"spell_alchemy", /* 72 */ 120 "spell_alchemy", /* 72 */
121"spell_remove_curse", /* 73 */ 121 "spell_remove_curse", /* 73 */
122"spell_remove_damnation", /* 74 */ 122 "spell_remove_damnation", /* 74 */
123"spell_identify", /* 75*/ 123 "spell_identify", /* 75 */
124"spell_detect_magic", /* 76 */ 124 "spell_detect_magic", /* 76 */
125"spell_detect_monster", /* 77 */ 125 "spell_detect_monster", /* 77 */
126"spell_detect_evil", /* 78 */ 126 "spell_detect_evil", /* 78 */
127"spell_detect_curse", /* 79 */ 127 "spell_detect_curse", /* 79 */
128"spell_heroism", /* 80 */ 128 "spell_heroism", /* 80 */
129"spell_aggravation", /* 81 */ 129 "spell_aggravation", /* 81 */
130"spell_firebolt", /* 82 */ 130 "spell_firebolt", /* 82 */
131"spell_frostbolt", /* 83 */ 131 "spell_frostbolt", /* 83 */
132"spell_shockwave", /* 84 */ 132 "spell_shockwave", /* 84 */
133"spell_color_spray", /* 85 */ 133 "spell_color_spray", /* 85 */
134"spell_haste", /* 86 */ 134 "spell_haste", /* 86 */
135"spell_face_of_death", /* 87 */ 135 "spell_face_of_death", /* 87 */
136"spell_ball_lightning", /* 88 */ 136 "spell_ball_lightning", /* 88 */
137"spell_meteor_swarm", /* 89 */ 137 "spell_meteor_swarm", /* 89 */
138"spell_comet", /* 90 */ 138 "spell_comet", /* 90 */
139"spell_mystic_fist", /* 91 */ 139 "spell_mystic_fist", /* 91 */
140"spell_raise_dead", /* 92 */ 140 "spell_raise_dead", /* 92 */
141"spell_resurrection", /* 93 */ 141 "spell_resurrection", /* 93 */
142"spell_reincarnation", /* 94 */ 142 "spell_reincarnation", /* 94 */
143"spell_immunity_to_cold", /* 95 */ 143 "spell_immunity_to_cold", /* 95 */
144"spell_immunity_to_electricity",/* 96 */ 144 "spell_immunity_to_electricity", /* 96 */
145"spell_immunity_to_fire", /* 97 */ 145 "spell_immunity_to_fire", /* 97 */
146"spell_immunity_to_poison", /* 98 */ 146 "spell_immunity_to_poison", /* 98 */
147"spell_immunity_to_slow", /* 99 */ 147 "spell_immunity_to_slow", /* 99 */
148"spell_immunity_to_paralysis", /* 100 */ 148 "spell_immunity_to_paralysis", /* 100 */
149"spell_immunity_to_draining", /* 101 */ 149 "spell_immunity_to_draining", /* 101 */
150"spell_immunity_to_magic", /* 102 */ 150 "spell_immunity_to_magic", /* 102 */
151"spell_immunity_to_attack", /* 103 */ 151 "spell_immunity_to_attack", /* 103 */
152"spell_invulnerability", /* 104 */ 152 "spell_invulnerability", /* 104 */
153"spell_defense", /* 105 */ 153 "spell_defense", /* 105 */
154"spell_rune_of_fire", /* 106 */ 154 "spell_rune_of_fire", /* 106 */
155"spell_rune_of_frost", /* 107 */ 155 "spell_rune_of_frost", /* 107 */
156"spell_rune_of_shocking", /* 108 */ 156 "spell_rune_of_shocking", /* 108 */
157"spell_rune_of_blasting", /* 109 */ 157 "spell_rune_of_blasting", /* 109 */
158"spell_rune_of_death", /* 110 */ 158 "spell_rune_of_death", /* 110 */
159"spell_marking_rune", /* 111 */ 159 "spell_marking_rune", /* 111 */
160"spell_build_director", /* 112 */ 160 "spell_build_director", /* 112 */
161"spell_create_pool_of_chaos", /* 113 */ 161 "spell_create_pool_of_chaos", /* 113 */
162"spell_build_bullet_wall", /* 114 */ 162 "spell_build_bullet_wall", /* 114 */
163"spell_build_lightning_wall", /* 115 */ 163 "spell_build_lightning_wall", /* 115 */
164"spell_build_fireball_wall", /* 116 */ 164 "spell_build_fireball_wall", /* 116 */
165"spell_magic_rune", /* 117 */ 165 "spell_magic_rune", /* 117 */
166"spell_rune_of_magic_drain", /* 118 */ 166 "spell_rune_of_magic_drain", /* 118 */
167"spell_antimagic_rune", /* 119 */ 167 "spell_antimagic_rune", /* 119 */
168"spell_rune_of_transference", /* 120 */ 168 "spell_rune_of_transference", /* 120 */
169"spell_transference", /* 121 */ 169 "spell_transference", /* 121 */
170"spell_magic_drain", /* 122 */ 170 "spell_magic_drain", /* 122 */
171"spell_counterspell", /* 123 */ 171 "spell_counterspell", /* 123 */
172"spell_disarm", /* 124 */ 172 "spell_disarm", /* 124 */
173"spell_cure_confusion", /* 125 */ 173 "spell_cure_confusion", /* 125 */
174"spell_restoration", /* 126 */ 174 "spell_restoration", /* 126 */
175"was summon evil monster", /* 127 */ /* Not implenented as nothing used it */ 175 "was summon evil monster", /* 127 *//* Not implenented as nothing used it */
176"spell_counterwall", /* 128 */ 176 "spell_counterwall", /* 128 */
177"spell_cause_light_wounds", /* 129 */ 177 "spell_cause_light_wounds", /* 129 */
178"spell_cause_medium_wounds", /* 130 */ 178 "spell_cause_medium_wounds", /* 130 */
179"spell_cause_heavy_wounds", /* 131 */ 179 "spell_cause_heavy_wounds", /* 131 */
180"spell_charm_monsters", /* 132 */ 180 "spell_charm_monsters", /* 132 */
181"spell_banishment", /* 133 */ 181 "spell_banishment", /* 133 */
182"spell_create_missile", /* 134 */ 182 "spell_create_missile", /* 134 */
183"spell_show_invisible", /* 135 */ 183 "spell_show_invisible", /* 135 */
184"spell_xray", /* 136 */ 184 "spell_xray", /* 136 */
185"spell_pacify", /* 137 */ 185 "spell_pacify", /* 137 */
186"spell_summon_fog", /* 138 */ 186 "spell_summon_fog", /* 138 */
187"spell_steambolt", /* 139 */ 187 "spell_steambolt", /* 139 */
188"spell_command_undead", /* 140 */ 188 "spell_command_undead", /* 140 */
189"spell_holy_orb", /* 141 */ 189 "spell_holy_orb", /* 141 */
190"spell_summon_avatar", /* 142 */ 190 "spell_summon_avatar", /* 142 */
191"spell_holy_possession", /* 143 */ 191 "spell_holy_possession", /* 143 */
192"spell_bless", /* 144 */ 192 "spell_bless", /* 144 */
193"spell_curse", /* 145 */ 193 "spell_curse", /* 145 */
194"spell_regeneration", /* 146 */ 194 "spell_regeneration", /* 146 */
195"spell_consecrate", /* 147 */ 195 "spell_consecrate", /* 147 */
196"spell_summon_cult_monsters", /* 148 */ 196 "spell_summon_cult_monsters", /* 148 */
197"spell_cause_critical_wounds", /* 149 */ 197 "spell_cause_critical_wounds", /* 149 */
198"spell_holy_wrath", /* 150 */ 198 "spell_holy_wrath", /* 150 */
199"spell_retributive_strike", /* 151 */ 199 "spell_retributive_strike", /* 151 */
200"spell_finger_of_death", /* 152 */ 200 "spell_finger_of_death", /* 152 */
201"spell_insect_plague", /* 153 */ 201 "spell_insect_plague", /* 153 */
202"spell_call_holy_servant", /* 154 */ 202 "spell_call_holy_servant", /* 154 */
203"spell_wall_of_thorns", /* 155 */ 203 "spell_wall_of_thorns", /* 155 */
204"spell_staff_to_snake", /* 156 */ 204 "spell_staff_to_snake", /* 156 */
205"spell_light", /* 157 */ 205 "spell_light", /* 157 */
206"spell_darkness", /* 158 */ 206 "spell_darkness", /* 158 */
207"spell_nightfall", /* 159 */ 207 "spell_nightfall", /* 159 */
208"spell_daylight", /* 160 */ 208 "spell_daylight", /* 160 */
209"spell_sunspear", /* 161 */ 209 "spell_sunspear", /* 161 */
210"spell_faery_fire", /* 162 */ 210 "spell_faery_fire", /* 162 */
211"spell_cure_blindness", /* 163 */ 211 "spell_cure_blindness", /* 163 */
212"spell_dark_vision", /* 164 */ 212 "spell_dark_vision", /* 164 */
213"spell_bullet_swarm", /* 165 */ 213 "spell_bullet_swarm", /* 165 */
214"spell_bullet_storm", /* 166 */ 214 "spell_bullet_storm", /* 166 */
215"spell_cause_many_wounds", /* 167 */ 215 "spell_cause_many_wounds", /* 167 */
216"spell_small_snowstorm", /* 168 */ 216 "spell_small_snowstorm", /* 168 */
217"spell_medium_snowstorm", /* 169 */ 217 "spell_medium_snowstorm", /* 169 */
218"spell_large_snowstorm", /* 170 */ 218 "spell_large_snowstorm", /* 170 */
219"spell_cure_disease", /* 171 */ 219 "spell_cure_disease", /* 171 */
220"spell_cause_red_death", /* 172 */ 220 "spell_cause_red_death", /* 172 */
221"spell_cause_flu", /* 173 */ 221 "spell_cause_flu", /* 173 */
222"spell_cause_black_death", /* 174 */ 222 "spell_cause_black_death", /* 174 */
223"spell_cause_leprosy", /* 175 */ 223 "spell_cause_leprosy", /* 175 */
224"spell_cause_smallpox", /* 176 */ 224 "spell_cause_smallpox", /* 176 */
225"spell_cause_white_death", /* 177 */ 225 "spell_cause_white_death", /* 177 */
226"spell_cause_anthrax", /* 178 */ 226 "spell_cause_anthrax", /* 178 */
227"spell_cause_typhoid", /* 179 */ 227 "spell_cause_typhoid", /* 179 */
228"spell_mana_blast", /* 180 */ 228 "spell_mana_blast", /* 180 */
229"spell_small_manaball", /* 181 */ 229 "spell_small_manaball", /* 181 */
230"spell_medium_manaball", /* 182 */ 230 "spell_medium_manaball", /* 182 */
231"spell_large_manaball", /* 183 */ 231 "spell_large_manaball", /* 183 */
232"spell_manabolt", /* 184 */ 232 "spell_manabolt", /* 184 */
233"spell_dancing_sword", /* 185 */ 233 "spell_dancing_sword", /* 185 */
234"spell_animate_weapon", /* 186 */ 234 "spell_animate_weapon", /* 186 */
235"spell_cause_cold", /* 187 */ 235 "spell_cause_cold", /* 187 */
236"spell_divine_shock", /* 188 */ 236 "spell_divine_shock", /* 188 */
237"spell_windstorm", /* 189 */ 237 "spell_windstorm", /* 189 */
238"spell_sanctuary", /* 190 */ 238 "spell_sanctuary", /* 190 */
239"spell_peace", /* 191 */ 239 "spell_peace", /* 191 */
240"spell_spiderweb", /* 192 */ 240 "spell_spiderweb", /* 192 */
241"spell_conflict", /* 193 */ 241 "spell_conflict", /* 193 */
242"spell_rage", /* 194 */ 242 "spell_rage", /* 194 */
243"spell_forked_lightning", /* 195 */ 243 "spell_forked_lightning", /* 195 */
244"spell_poison_fog", /* 196 */ 244 "spell_poison_fog", /* 196 */
245"spell_flaming_aura", /* 197 */ 245 "spell_flaming_aura", /* 197 */
246"spell_vitriol", /* 198 */ 246 "spell_vitriol", /* 198 */
247"spell_vitriol_splash", /* 199 */ 247 "spell_vitriol_splash", /* 199 */
248"spell_iron_skin", /* 200 */ 248 "spell_iron_skin", /* 200 */
249"spell_wrathful_eye", /* 201 */ 249 "spell_wrathful_eye", /* 201 */
250"spell_town_portal", /* 202 */ 250 "spell_town_portal", /* 202 */
251"spell_missile_swarm", /* 203 */ 251 "spell_missile_swarm", /* 203 */
252"spell_cause_rabies", /* 204 */ 252 "spell_cause_rabies", /* 204 */
253"spell_glyph", /* 205 */ 253 "spell_glyph", /* 205 */
254NULL 254 NULL
255}; 255};
256 256
257extern int arch_init; 257extern int arch_init;
258
259// return a suitable strign describign an objetc in enough detail to find it
260// used only in check_loaded_object: TODO remove static, move it elsewhere and
261// use it in more log messages.
262static char *op_debug_info_ (object *op, char *info)
263{
264 char info2[256 * 3];
265 char *p = info;
266
267 p += snprintf (p, 256, "%d=\"%s%s%s\"",
268 op->count,
269 op->name ? (const char *)op->name : "(anon)",
270 op->title ? " " : "",
271 op->title ? (const char *)op->title : "");
272
273 if (op->env)
274 p += snprintf (p, 256, "(in %s)", op_debug_info_ (op->env, info2));
275
276 if (op->map)
277 p += snprintf (p, 256, "(on %s@%d+%d)", op->map->path, op->x, op->y);
278
279 return info;
280}
281
282static char *op_debug_info (object *op)
283{
284 static char info[256 * 3];
285
286 return op_debug_info_ (op, info);
287}
288 258
289/* This function checks the object after it has been loaded (when we 259/* This function checks the object after it has been loaded (when we
290 * get the 'end' in the input stream). This function can be used to 260 * get the 'end' in the input stream). This function can be used to
291 * deal with legacy objects where fields may have changed. It can also be used 261 * deal with legacy objects where fields may have changed. It can also be used
292 * to check for objects to make sure there are no common errors. 262 * to check for objects to make sure there are no common errors.
293 */ 263 */
264static void
294static void check_loaded_object(object *op) { 265check_loaded_object (object *op)
266{
295 int ip; 267 int ip;
296 268
297 /* We do some specialized handling to handle legacy cases of name_pl. 269 /* We do some specialised handling to handle legacy cases of name_pl.
298 * If the object doesn't have a name_pl, we just use the object name - 270 * If the object doesn't have a name_pl, we just use the object name -
299 * this isn't perfect (things won't be properly pluralized), but works to 271 * this isn't perfect (things won't be properly pluralised), but works to
300 * that degree (5 heart is still quite understandable). But the case we 272 * that degree (5 heart is still quite understandable). But the case we
301 * also have to catch is if this object is not using the normal name for 273 * also have to catch is if this object is not using the normal name for
302 * the object. In that case, we also want to use the loaded name. 274 * the object. In that case, we also want to use the loaded name.
303 * Otherwise, what happens is that the the plural name will lose 275 * Otherwise, what happens is that the the plural name will lose
304 * information (appear as just 'hearts' and not 'goblins heart') 276 * information (appear as just 'hearts' and not 'goblins heart')
305 */ 277 */
306 if (op->arch && op->name != op->arch->clone.name && op->name_pl == op->arch->clone.name_pl) 278 if (op->arch && op->name != op->arch->clone.name && op->name_pl == op->arch->clone.name_pl)
307 op->name_pl = NULL; 279 op->name_pl = NULL;
308 280
281 if (!op->name_pl)
309 if (!op->name_pl) op->name_pl = op->name; 282 op->name_pl = op->name;
310 283
311 /* objects now have a materialname. try to patch it in */ 284 /* objects now have a materialname. try to patch it in */
312 if (!(IS_WEAPON(op) && op->level > 0)) { 285 if (!(op->is_weapon () && op->level > 0))
286 {
313 if (op->map != NULL) 287 if (op->map != NULL)
314 set_materialname(op, op->map->difficulty, NULL); 288 set_materialname (op, op->map->difficulty, NULL);
315 else 289 else
316 set_materialname(op, 5, NULL); 290 set_materialname (op, 5, NULL);
317 } 291 }
318 /* only do these when program is first run - a bit 292 /* only do these when program is first run - a bit
319 * excessive to do this at every run - most of this is 293 * excessive to do this at every run - most of this is
320 * really just to catch any errors - program will still run, but 294 * really just to catch any errors - program will still run, but
321 * not in the ideal fashion. 295 * not in the ideal fashion.
322 */ 296 */
323 if ((op->type == WEAPON || op->type==BOW) && arch_init) { 297 if ((op->type == WEAPON || op->type == BOW) && arch_init)
298 {
324 if (!op->skill) { 299 if (!op->skill)
300 {
325 LOG(llevError,"Weapon %s lacks a skill.\n", op_debug_info (op)); 301 LOG (llevError, "Weapon %s lacks a skill.\n", op->debug_desc ());
302 }
326 } else if ((!strcmp(op->skill,"one handed weapons") && op->body_info[1] != -1) || 303 else if ((!strcmp (op->skill, "one handed weapons") && op->body_info[1] != -1) ||
327 (!strcmp(op->skill,"two handed weapons") && op->body_info[1] != -2)) { 304 (!strcmp (op->skill, "two handed weapons") && op->body_info[1] != -2))
328 LOG(llevError,"weapon %s arm usage does not match skill: %d, %s\n", 305 {
329 op_debug_info (op), op->body_info[1], &op->skill); 306 LOG (llevError, "weapon %s arm usage does not match skill: %d, %s\n", op->debug_desc (), op->body_info[1], &op->skill);
330 } 307 }
331 } 308 }
332 309
333 /* We changed last_heal to gen_sp_armour, which is what it 310 /* We changed last_heal to gen_sp_armour, which is what it
334 * really does for many objects. Need to catch any in maps 311 * really does for many objects. Need to catch any in maps
335 * that may have an old value. 312 * that may have an old value.
336 */ 313 */
337 if ((op->type == WEAPON) || 314 if ((op->type == WEAPON) ||
338 (op->type == ARMOUR) || (op->type == HELMET) || 315 (op->type == ARMOUR) || (op->type == HELMET) ||
339 (op->type == SHIELD) || (op->type == RING) || 316 (op->type == SHIELD) || (op->type == RING) ||
340 (op->type == BOOTS) || (op->type == GLOVES) || 317 (op->type == BOOTS) || (op->type == GLOVES) ||
341 (op->type == AMULET ) || (op->type == GIRDLE) || 318 (op->type == AMULET) || (op->type == GIRDLE) || (op->type == BRACERS) || (op->type == CLOAK))
342 (op->type == BRACERS ) || (op->type == CLOAK)) { 319 {
343 if (op->last_heal) { 320 if (op->last_heal)
321 {
344 LOG(llevDebug,"Object %s still has last_heal set, not gen_sp_armour\n", op_debug_info (op)); 322 LOG (llevDebug, "Object %s still has last_heal set, not gen_sp_armour\n", op->debug_desc ());
345 op->gen_sp_armour = op->last_heal; 323 op->gen_sp_armour = op->last_heal;
346 op->last_heal = 0; 324 op->last_heal = 0;
347 } 325 }
348 if (editor) ip =0; 326
349 else ip = calc_item_power(op, 0); 327 ip = calc_item_power (op, 0);
350 /* Legacy objects from before item power was in the game */ 328 /* Legacy objects from before item power was in the game */
351 if (!op->item_power && ip) { 329 if (!op->item_power && ip)
330 {
352 if (ip > 3) { 331 if (ip > 3)
332 {
353 LOG(llevDebug,"Object %s had no item power, using %d\n", op_debug_info (op), ip); 333 LOG (llevDebug, "Object %s had no item power, using %d\n", op->debug_desc (), ip);
354 } 334 }
355 op->item_power = ip; 335 op->item_power = ip;
356 } 336 }
357 /* Check for possibly bogus values. Has to meet both these criteria - 337 /* Check for possibly bogus values. Has to meet both these criteria -
358 * something that has item_power 1 is probably just fine if our calculated 338 * something that has item_power 1 is probably just fine if our calculated
359 * value is 1 or 2 - these values are small enough that hard to be precise. 339 * value is 1 or 2 - these values are small enough that hard to be precise.
360 * similarly, it item_power is 0, the first check will always pass, 340 * similarly, it item_power is 0, the first check will always pass,
361 * but not the second one. 341 * but not the second one.
362 */ 342 */
363 if (ip > 2 *op->item_power && ip > (op->item_power + 3)) { 343 if (ip > 2 * op->item_power && ip > (op->item_power + 3))
344 {
364 LOG(llevDebug,"Object %s seems to have too low item power? %d > %d\n", 345 LOG (llevDebug, "Object %s seems to have too low item power? %d > %d\n", op->debug_desc (), ip, op->item_power);
365 op_debug_info (op), ip, op->item_power);
366 } 346 }
367 347
368 } 348 }
369 /* Old spellcasting object - need to load in the appropiate object */ 349 /* Old spellcasting object - need to load in the appropiate object */
370 if ((op->type == ROD || op->type == WAND || op->type == SCROLL || op->type == HORN 350 if ((op->type == ROD || op->type == WAND || op->type == SCROLL || op->type == HORN || op->type == FIREWALL ||
371 || op->type == FIREWALL ||
372 /* POTIONS and ALTARS don't always cast spells, but if they do, update them */ 351 /* POTIONS and ALTARS don't always cast spells, but if they do, update them */
373 ((op->type == POTION || op->type == ALTAR) && op->stats.sp)) && !op->inv && !arch_init) { 352 ((op->type == POTION || op->type == ALTAR) && op->stats.sp)) && !op->inv && !arch_init)
353 {
374 object *tmp; 354 object *tmp;
375 355
376 /* Fireall is bizarre in that spell type was stored in dam. Rest are 'normal' 356 /* Fireall is bizarre in that spell type was stored in dam. Rest are 'normal'
377 * in that spell was stored in sp. 357 * in that spell was stored in sp.
378 */ 358 */
379 tmp = get_archetype(spell_mapping[op->type == FIREWALL?op->stats.dam:op->stats.sp]); 359 tmp = get_archetype (spell_mapping[op->type == FIREWALL ? op->stats.dam : op->stats.sp]);
380 insert_ob_in_ob(tmp, op); 360 insert_ob_in_ob (tmp, op);
381 op->randomitems = NULL; /* So another spell isn't created for this object */ 361 op->randomitems = NULL; /* So another spell isn't created for this object */
382 } 362 }
383 /* spellbooks & runes use slaying. But not to arch name, but to spell name */ 363 /* spellbooks & runes use slaying. But not to arch name, but to spell name */
384 364
385 if ((op->type == SPELLBOOK || op->type == RUNE) && op->slaying && !op->inv && !arch_init) { 365 if ((op->type == SPELLBOOK || op->type == RUNE) && op->slaying && !op->inv && !arch_init)
366 {
386 object *tmp; 367 object *tmp;
387 368
388 tmp = get_archetype_by_object_name(op->slaying); 369 tmp = get_archetype_by_object_name (op->slaying);
389 insert_ob_in_ob(tmp, op); 370 insert_ob_in_ob (tmp, op);
390 op->randomitems = NULL; /* So another spell isn't created for this object */ 371 op->randomitems = NULL; /* So another spell isn't created for this object */
391 /* without this, value is all screwed up */ 372 /* without this, value is all screwed up */
392 op->value = op->arch->clone.value * op->inv->value; 373 op->value = op->arch->clone.value * op->inv->value;
393 } 374 }
394 375
395 if (QUERY_FLAG(op, FLAG_MONSTER)) { 376 if (QUERY_FLAG (op, FLAG_MONSTER))
377 {
396 if (op->stats.hp > op->stats.maxhp) 378 if (op->stats.hp > op->stats.maxhp)
397 LOG(llevDebug,"Monster %s has hp set higher than maxhp (%d>%d)\n", 379 LOG (llevDebug, "Monster %s has hp set higher than maxhp (%d>%d)\n", op->debug_desc (), op->stats.hp, op->stats.maxhp);
398 op_debug_info (op),
399 op->stats.hp, op->stats.maxhp);
400 380
401 /* The archs just need to be updated for this */ 381 /* The archs just need to be updated for this */
402 if (op->move_type ==0) op->move_type = MOVE_WALK; 382 if (op->move_type == 0)
383 op->move_type = MOVE_WALK;
403 } 384 }
404 if ((QUERY_FLAG(op,FLAG_GENERATOR) && QUERY_FLAG(op,FLAG_CONTENT_ON_GEN)) 385
405 || op->type == CREATOR 386 if ((QUERY_FLAG (op, FLAG_GENERATOR) && QUERY_FLAG (op, FLAG_CONTENT_ON_GEN)) || op->type == CREATOR || op->type == CONVERTER)
406 || op->type == CONVERTER) { 387 {
407 /* Object will duplicate it's content as part of the 388 /* Object will duplicate it's content as part of the
408 * generation process. To do this, we must flag inventory 389 * generation process. To do this, we must flag inventory
409 * so it remains unevaluated concerning the randomitems and 390 * so it remains unevaluated concerning the randomitems and
410 * the living (a demonlord shouldn't cast from inside generator!) 391 * the living (a demonlord shouldn't cast from inside generator!)
411 */ 392 */
412 flag_inv(op,FLAG_IS_A_TEMPLATE); 393 flag_inv (op, FLAG_IS_A_TEMPLATE);
413 } 394 }
414 395
415 /* Handle player movers. We use move_type for player movers 396 /* Handle player movers. We use move_type for player movers
416 * because they operate on their own time (move_on 397 * because they operate on their own time (move_on
417 * would potentially cause them to be triggered when someone steps 398 * would potentially cause them to be triggered when someone steps
418 * on them). If move_type is set, presume person knows what they 399 * on them). If move_type is set, presume person knows what they
419 * are doing, otherwise, set move_type based on maxhp value. 400 * are doing, otherwise, set move_type based on maxhp value.
420 */ 401 */
421 if (op->type == PLAYERMOVER) { 402 if (op->type == PLAYERMOVER)
403 {
422 if (!op->move_type) { 404 if (!op->move_type)
405 {
423 if (op->stats.maxhp) { 406 if (op->stats.maxhp)
407 {
424 op->move_type = MOVE_ALL; 408 op->move_type = MOVE_ALL;
425 op->stats.maxhp=0; 409 op->stats.maxhp = 0;
410 }
426 } else { 411 else
412 {
427 op->move_type = MOVE_WALK; 413 op->move_type = MOVE_WALK;
428 } 414 }
429 } 415 }
430 } 416 }
431 417
432} 418}
433 419
434static void 420static void
435set_move (MoveType &mt, const char *str) 421set_move (MoveType & mt, const char *str)
436{ 422{
437 if (!str) 423 if (!str)
438 { 424 {
439 mt = 0; 425 mt = 0;
440 return; 426 return;
… …
446 return; 432 return;
447 } 433 }
448 434
449 mt = 0; 435 mt = 0;
450 436
451 for (str = strtok ((char *)str, " "); str; str = strtok (0, " ")) 437 for (str = strtok ((char *) str, " "); str; str = strtok (0, " "))
452 { 438 {
453 if (!strcasecmp (str, "all")) 439 if (!strcasecmp (str, "all"))
454 mt |= MOVE_ALL; 440 mt |= MOVE_ALL;
455 else 441 else
456 { 442 {
… …
460 { 446 {
461 negate = 1; 447 negate = 1;
462 str++; 448 str++;
463 } 449 }
464 450
465 for (i = 0; move_name [i]; i++) 451 for (i = 0; move_name[i]; i++)
466 { 452 {
467 if (!strcasecmp (move_name [i], str)) 453 if (!strcasecmp (move_name[i], str))
468 { 454 {
469 if (negate) 455 if (negate)
470 mt &= ~(1 << i); 456 mt &= ~(1 << i);
471 else 457 else
472 mt |= (1 << i); 458 mt |= (1 << i);
473 459
474 break; 460 break;
475 } 461 }
476 } 462 }
477 463
478 if (!move_name [i]) 464 if (!move_name[i])
479 { 465 {
480 /* fly is a special case - covers both fly_low and 466 /* fly is a special case - covers both fly_low and
481 * fly_high - since it doesn't match to a specific 467 * fly_high - since it doesn't match to a specific
482 * single bit, have to special case it. 468 * single bit, have to special case it.
483 */ 469 */
… …
499 if (thawer.get_sint32 ()) \ 485 if (thawer.get_sint32 ()) \
500 SET_FLAG (op, flag); \ 486 SET_FLAG (op, flag); \
501 else \ 487 else \
502 CLEAR_FLAG (op, flag) \ 488 CLEAR_FLAG (op, flag) \
503 489
490int
504int parse_object (object *op, object_thawer &thawer, int map_flags) 491parse_object (object *op, object_thawer &thawer, int map_flags)
505{ 492{
506 bool ismore = 0; 493 bool ismore = 0;
507 object *op_inv = op->inv; 494 object *op_inv = op->inv;
508 495
509 for (;;) 496 for (;;)
510 { 497 {
511 keyword kw = thawer.get_kv (); 498 keyword kw = thawer.get_kv ();
512 499
513 switch (kw) 500 switch (kw)
514 { 501 {
515 case KW_Object: // uppercase alias 502 case KW_Object: // uppercase alias
516 case KW_object: 503 case KW_object:
517 thawer.get (op->name); 504 thawer.get (op->name);
518 505
519 if (op->arch != NULL) 506 if (op->arch)
520 op->arch->name = op->name; 507 op->arch->name = op->name;
521 508
522 break; 509 break;
523 510
511 case KW_uuid:
512 if (const char *s = thawer.get_str ())
513 {
514 unsigned int version;
515 unsigned long long seq;
516
517 if (2 == sscanf (s, "<%d.%llx>", &version, &seq) && version == 1)
518 {
519 op->uuid.seq = seq;
520 break;
521 }
522 }
523
524 op->uuid = gen_uuid ();
525 break;
526
527 case KW_oid:
524 case KW_oid: thawer.get (op, thawer.get_sint32 ()); break; 528 thawer.get (op, thawer.get_sint32 ());
529 break;
525 530
526 case KW_name: thawer.get (op->name); break; 531 case KW_name: thawer.get (op->name); break;
527 case KW_name_pl: thawer.get (op->name_pl); break; 532 case KW_name_pl: thawer.get (op->name_pl); break;
528 case KW_title: thawer.get (op->title); break; 533 case KW_title: thawer.get (op->title); break;
529 case KW_custom_name: thawer.get (op->custom_name); break; 534 case KW_custom_name: thawer.get (op->custom_name); break;
535
530 case KW_attach: thawer.get_ornull (op->attach); break; 536 case KW_attach: thawer.get_ornull (op->attach); break;
531 case KW_skill: thawer.get_ornull (op->skill); break; 537 case KW_skill: thawer.get_ornull (op->skill); break;
532 case KW_race: thawer.get_ornull (op->race); break; 538 case KW_race: thawer.get_ornull (op->race); break;
533 case KW_slaying: thawer.get_ornull (op->slaying); break; 539 case KW_slaying: thawer.get_ornull (op->slaying); break;
534 540
535 case KW_arch: 541 case KW_arch:
536 { 542 {
537 const char *str = thawer.get_str (); 543 const char *str = thawer.get_str ();
538 544
… …
540 { 546 {
541 /* If op->arch has been set, then this new object 547 /* If op->arch has been set, then this new object
542 * must be part of the inventory. So process 548 * must be part of the inventory. So process
543 * appropriately. 549 * appropriately.
544 */ 550 */
545 archetype *arch = find_archetype (str); 551 archetype *arch = archetype::find (str);
546 552
547 object *tmp; 553 object *tmp;
548 554
549 if (arch != NULL) 555 if (arch)
550 tmp = arch_to_object (arch); 556 tmp = arch_to_object (arch);
551 else 557 else
552 { 558 {
553 tmp = get_object (); 559 tmp = object::create ();
554 /* record the name of the broken object */ 560 /* record the name of the broken object */
555 tmp->name = str; 561 tmp->name = str;
556 } 562 }
563
564 // decativate the object we, as we are still going
565 // to read the speed value. Objects should be activated
566 // when the map, object or player is completly loaded.
567 tmp->deactivate ();
557 568
558 parse_object (tmp, thawer, map_flags); 569 parse_object (tmp, thawer, map_flags);
559 570
560 if (tmp->arch) 571 if (tmp->arch)
561 { 572 {
… …
568 579
569 if (!op_inv) 580 if (!op_inv)
570 { 581 {
571 op->inv = tmp; 582 op->inv = tmp;
572 tmp->above = 0; 583 tmp->above = 0;
573 } 584 }
574 else 585 else
575 { 586 {
576 while (op_inv->below) 587 while (op_inv->below)
577 op_inv = op_inv->below; 588 op_inv = op_inv->below;
578 589
… …
584 tmp->env = op; 595 tmp->env = op;
585 op_inv = tmp; 596 op_inv = tmp;
586 } 597 }
587 else 598 else
588 { 599 {
589 LOG (llevDebug, "Discarding object without arch: %s\n", 600 LOG (llevDebug, "Discarding object without arch: %s\n", tmp->name ? (const char *) tmp->name : "(null)");
590 tmp->name ? (const char *) tmp->name : "(null)"); 601 tmp->destroy ();
591 free_object (tmp);
592 } 602 }
593 } 603 }
594 else 604 else
595 { 605 {
596 /* This is the actual archetype definition then */ 606 /* This is the actual archetype definition then */
597 op->arch = find_archetype (str); 607 op->arch = archetype::find (str);
598 608
599 if (op->arch != NULL) 609 if (op->arch)
600 copy_object (&op->arch->clone, op); 610 {
611 op->arch->clone.copy_to (op);
612 // copy_to activates, this should be fixed properly
613 op->deactivate ();
614 }
601 else if (!arch_init) 615 else if (!arch_init)
602 /* record the name of the broken object */ 616 /* record the name of the broken object */
603 op->name = str; 617 op->name = str;
604 } 618 }
605 } 619 }
606 break; 620 break;
607 621
608 case KW_other_arch: 622 case KW_other_arch:
609 op->other_arch = find_archetype (thawer.get_str ()); 623 op->other_arch = archetype::find (thawer.get_str ());
610 break; 624 break;
611 625
612 case KW_animation: 626 case KW_animation:
613 { 627 {
614 const char *str = thawer.get_str (); 628 const char *str = thawer.get_str ();
615 629
616 if (!str) 630 if (!str)
617 { 631 {
618 op->animation_id = 0; 632 op->animation_id = 0;
619 CLEAR_FLAG (op, FLAG_ANIMATE); 633 CLEAR_FLAG (op, FLAG_ANIMATE);
620 } 634 }
621 else 635 else
622 { 636 {
623 op->animation_id = find_animation (str); 637 op->animation_id = find_animation (str);
624 SET_FLAG (op, FLAG_ANIMATE); 638 SET_FLAG (op, FLAG_ANIMATE);
625 } 639 }
626 } 640 }
627 641
628 break; 642 break;
629 643
630 case KW_last_heal: thawer.get (op->last_heal); break; 644 case KW_last_heal: thawer.get (op->last_heal); break;
631 case KW_last_sp: thawer.get (op->last_sp); break; 645 case KW_last_sp: thawer.get (op->last_sp); break;
632 case KW_last_grace: thawer.get (op->last_grace); break; 646 case KW_last_grace: thawer.get (op->last_grace); break;
633 case KW_last_eat: thawer.get (op->last_eat); break; 647 case KW_last_eat: thawer.get (op->last_eat); break;
634 case KW_speed_left: thawer.get (op->speed_left); break; 648 case KW_speed_left: thawer.get (op->speed_left); break;
635 649
636 case KW_speed: 650 case KW_speed:
637 thawer.get (op->speed); 651 thawer.get (op->speed);
638 652
639 //TODO: maybe do in check_object 653 //TODO: maybe do in check_object
640 if (!(map_flags & MAP_STYLE)) 654 // removed check for style maps
641 {
642 if (op->speed < 0) 655 if (op->speed < 0)
643 op->speed_left = op->speed_left - RANDOM () % 100 / 100.0; 656 op->speed_left = op->speed_left - RANDOM () % 100 / 100.0;
644
645 update_ob_speed (op);
646 }
647 657
648 break; 658 break;
649 659
650 case KW_slow_move: 660 case KW_slow_move:
651 op->move_slow |= MOVE_WALK; 661 op->move_slow |= MOVE_WALK;
… …
654 664
655 case KW_face: 665 case KW_face:
656 op->face = &new_faces[FindFace (thawer.get_str (), 0)]; 666 op->face = &new_faces[FindFace (thawer.get_str (), 0)];
657 break; 667 break;
658 668
659 case KW_x: thawer.get (op->x); break; 669 case KW_x: thawer.get (op->x); break;
660 case KW_y: thawer.get (op->y); break; 670 case KW_y: thawer.get (op->y); break;
671
661 case KW_Str: // uppercase alias 672 case KW_Str: // uppercase alias
662 case KW_str: thawer.get (op->stats.Str); break; 673 case KW_str: thawer.get (op->stats.Str); break;
663 case KW_Dex: // uppercase alias 674 case KW_Dex: // uppercase alias
664 case KW_dex: thawer.get (op->stats.Dex); break; 675 case KW_dex: thawer.get (op->stats.Dex); break;
665 case KW_Con: // uppercase alias 676 case KW_Con: // uppercase alias
666 case KW_con: thawer.get (op->stats.Con); break; 677 case KW_con: thawer.get (op->stats.Con); break;
667 case KW_Wis: // uppercase alias 678 case KW_Wis: // uppercase alias
668 case KW_wis: thawer.get (op->stats.Wis); break; 679 case KW_wis: thawer.get (op->stats.Wis); break;
669 case KW_Cha: // uppercase alias 680 case KW_Cha: // uppercase alias
670 case KW_cha: thawer.get (op->stats.Cha); break; 681 case KW_cha: thawer.get (op->stats.Cha); break;
671 case KW_Int: // uppercase alias 682 case KW_Int: // uppercase alias
672 case KW_int: thawer.get (op->stats.Int); break; 683 case KW_int: thawer.get (op->stats.Int); break;
673 case KW_Pow: // uppercase alias 684 case KW_Pow: // uppercase alias
674 case KW_pow: thawer.get (op->stats.Pow); break; 685 case KW_pow: thawer.get (op->stats.Pow); break;
686
675 case KW_hp: thawer.get (op->stats.hp); break; 687 case KW_hp: thawer.get (op->stats.hp); break;
676 case KW_maxhp: thawer.get (op->stats.maxhp); break; 688 case KW_maxhp: thawer.get (op->stats.maxhp); break;
677 case KW_sp: thawer.get (op->stats.sp); break; 689 case KW_sp: thawer.get (op->stats.sp); break;
678 case KW_maxsp: thawer.get (op->stats.maxsp); break; 690 case KW_maxsp: thawer.get (op->stats.maxsp); break;
679 case KW_grace: thawer.get (op->stats.grace); break; 691 case KW_grace: thawer.get (op->stats.grace); break;
680 case KW_maxgrace: thawer.get (op->stats.maxgrace); break; 692 case KW_maxgrace: thawer.get (op->stats.maxgrace); break;
681 693
682 case KW_exp: thawer.get (op->stats.exp); break; 694 case KW_exp: thawer.get (op->stats.exp); break;
683 case KW_perm_exp: thawer.get (op->perm_exp); break; 695 case KW_perm_exp: thawer.get (op->perm_exp); break;
684 case KW_food: thawer.get (op->stats.food); break; 696 case KW_food: thawer.get (op->stats.food); break;
685 case KW_dam: thawer.get (op->stats.dam); break; 697 case KW_dam: thawer.get (op->stats.dam); break;
686 case KW_wc: thawer.get (op->stats.wc); break; 698 case KW_wc: thawer.get (op->stats.wc); break;
687 case KW_ac: thawer.get (op->stats.ac); break; 699 case KW_ac: thawer.get (op->stats.ac); break;
688 case KW_nrof: thawer.get (op->nrof); break; 700 case KW_nrof: thawer.get (op->nrof); break;
689 case KW_level: thawer.get (op->level); break; 701 case KW_level: thawer.get (op->level); break;
690 case KW_direction: thawer.get (op->direction); break; 702 case KW_direction: thawer.get (op->direction); break;
691 case KW_type: thawer.get (op->type); break; 703 case KW_type: thawer.get (op->type); break;
692 case KW_subtype: thawer.get (op->subtype); break; 704 case KW_subtype: thawer.get (op->subtype); break;
693 case KW_value: thawer.get (op->value); break; 705 case KW_value: thawer.get (op->value); break;
694 case KW_weight: thawer.get (op->weight); break; 706 case KW_weight: thawer.get (op->weight); break;
695 case KW_carrying: thawer.get (op->carrying); break; 707 case KW_carrying: thawer.get (op->carrying); break;
696 case KW_attacktype: thawer.get (op->attacktype); break; 708 case KW_attacktype: thawer.get (op->attacktype); break;
697 case KW_path_attuned: thawer.get (op->path_attuned); break; 709 case KW_path_attuned: thawer.get (op->path_attuned); break;
698 case KW_path_repelled: thawer.get (op->path_repelled); break; 710 case KW_path_repelled: thawer.get (op->path_repelled); break;
699 case KW_path_denied: thawer.get (op->path_denied); break; 711 case KW_path_denied: thawer.get (op->path_denied); break;
700 case KW_invisible: thawer.get (op->invisible); break; 712 case KW_invisible: thawer.get (op->invisible); break;
701 case KW_magic: thawer.get (op->magic); break; 713 case KW_magic: thawer.get (op->magic); break;
702 case KW_state: thawer.get (op->state); break; 714 case KW_state: thawer.get (op->state); break;
703 case KW_move_slow_penalty:thawer.get (op->move_slow_penalty); break; 715 case KW_move_slow_penalty: thawer.get (op->move_slow_penalty); break;
704 case KW_material: thawer.get (op->material); break; 716 case KW_material: thawer.get (op->material); break;
705 case KW_materialname: thawer.get (op->materialname); break; 717 case KW_materialname: thawer.get (op->materialname); break;
706 718
707 /* These are the new values */ 719 /* These are the new values */
708 case KW_move_block: set_move (op->move_block, thawer.get_str ()); break; 720 case KW_move_block: set_move (op->move_block, thawer.get_str ()); break;
709 case KW_move_allow: set_move (op->move_allow, thawer.get_str ()); break; 721 case KW_move_allow: set_move (op->move_allow, thawer.get_str ()); break;
710 case KW_move_type: set_move (op->move_type, thawer.get_str ()); break; 722 case KW_move_type: set_move (op->move_type, thawer.get_str ()); break;
711 case KW_move_on: set_move (op->move_on, thawer.get_str ()); break; 723 case KW_move_on: set_move (op->move_on, thawer.get_str ()); break;
712 case KW_move_off: set_move (op->move_off, thawer.get_str ()); break; 724 case KW_move_off: set_move (op->move_off, thawer.get_str ()); break;
713 case KW_move_slow: set_move (op->move_slow, thawer.get_str ()); break; 725 case KW_move_slow: set_move (op->move_slow, thawer.get_str ()); break;
714 726
715 /* These are all legacy - any new objects should use the move_ .. values */ 727 /* These are all legacy - any new objects should use the move_ .. values */
716 case KW_no_pass: 728 case KW_no_pass:
717 { 729 {
718 if (thawer.get_sint32 ()) 730 if (thawer.get_sint32 ())
719 op->move_block = MOVE_ALL; 731 op->move_block = MOVE_ALL;
720 else 732 else
721 op->move_block = 0; 733 op->move_block = 0;
722 } 734 }
723 735
724 break; 736 break;
725 737
726 /* These are all legacy - any new objects should use the move_ .. values */ 738 /* These are all legacy - any new objects should use the move_ .. values */
727 case KW_walk_on: 739 case KW_walk_on:
728 { 740 {
729 if (thawer.get_sint32 ()) 741 if (thawer.get_sint32 ())
730 op->move_on |= MOVE_WALK; 742 op->move_on |= MOVE_WALK;
731 else 743 else
732 op->move_on &= ~MOVE_WALK; 744 op->move_on &= ~MOVE_WALK;
733 } 745 }
734 746
735 break; 747 break;
736 748
737 /* These are all legacy - any new objects should use the move_ .. values */ 749 /* These are all legacy - any new objects should use the move_ .. values */
738 case KW_walk_off: 750 case KW_walk_off:
739 { 751 {
740 if (thawer.get_sint32 ()) 752 if (thawer.get_sint32 ())
741 op->move_off |= MOVE_WALK; 753 op->move_off |= MOVE_WALK;
742 else 754 else
743 op->move_off &= ~MOVE_WALK; 755 op->move_off &= ~MOVE_WALK;
744 } 756 }
745 break; 757 break;
746 758
747 /* These are all legacy - any new objects should use the move_ .. values */ 759 /* These are all legacy - any new objects should use the move_ .. values */
748 case KW_fly_on: 760 case KW_fly_on:
749 { 761 {
750 if (thawer.get_sint32 ()) 762 if (thawer.get_sint32 ())
751 op->move_on |= MOVE_FLY_LOW; 763 op->move_on |= MOVE_FLY_LOW;
752 else 764 else
753 op->move_on &= ~MOVE_FLY_LOW; 765 op->move_on &= ~MOVE_FLY_LOW;
754 } 766 }
755 break; 767 break;
756 768
757 /* These are all legacy - any new objects should use the move_ .. values */ 769 /* These are all legacy - any new objects should use the move_ .. values */
758 case KW_fly_off: 770 case KW_fly_off:
759 { 771 {
760 if (thawer.get_sint32 ()) 772 if (thawer.get_sint32 ())
761 op->move_off |= MOVE_FLY_LOW; 773 op->move_off |= MOVE_FLY_LOW;
762 else 774 else
763 op->move_off &= ~MOVE_FLY_LOW; 775 op->move_off &= ~MOVE_FLY_LOW;
764 } 776 }
765 break; 777 break;
766 778
767 //TODO: remove these after convertign archetypes 779 //TODO: remove these after converting archetypes
768 case KW_can_use_wand: GET_FLAG (op, FLAG_USE_RANGE); break; 780 case KW_can_use_wand:
781 GET_FLAG (op, FLAG_USE_RANGE);
782 break;
769 783
770 /* These are all legacy - any new objects should use the move_ .. values */ 784 /* These are all legacy - any new objects should use the move_ .. values */
771 case KW_flying: 785 case KW_flying:
772 { 786 {
773 if (thawer.get_sint32 ()) 787 if (thawer.get_sint32 ())
774 op->move_type |= MOVE_FLY_LOW; 788 op->move_type |= MOVE_FLY_LOW;
775 else 789 else
… …
807 //TODO: move to check_object or so 821 //TODO: move to check_object or so
808 if (op->type != PLAYER && QUERY_FLAG (op, FLAG_FRIENDLY)) 822 if (op->type != PLAYER && QUERY_FLAG (op, FLAG_FRIENDLY))
809 add_friendly_object (op); 823 add_friendly_object (op);
810 break; 824 break;
811 825
812 case KW_monster: GET_FLAG (op, FLAG_MONSTER); break; 826 case KW_monster: GET_FLAG (op, FLAG_MONSTER); break;
813 case KW_neutral: GET_FLAG (op, FLAG_NEUTRAL); break; 827 case KW_neutral: GET_FLAG (op, FLAG_NEUTRAL); break;
814 case KW_no_attack: GET_FLAG (op, FLAG_NO_ATTACK); break; 828 case KW_no_attack: GET_FLAG (op, FLAG_NO_ATTACK); break;
815 case KW_no_damage: GET_FLAG (op, FLAG_NO_DAMAGE); break; 829 case KW_no_damage: GET_FLAG (op, FLAG_NO_DAMAGE); break;
816 case KW_generator: GET_FLAG (op, FLAG_GENERATOR); break; 830 case KW_generator: GET_FLAG (op, FLAG_GENERATOR); break;
817 case KW_use_content_on_gen: GET_FLAG (op, FLAG_CONTENT_ON_GEN); break; 831 case KW_use_content_on_gen: GET_FLAG (op, FLAG_CONTENT_ON_GEN); break;
818 case KW_is_thrown: GET_FLAG (op, FLAG_IS_THROWN); break; 832 case KW_is_thrown: GET_FLAG (op, FLAG_IS_THROWN); break;
819 case KW_auto_apply: GET_FLAG (op, FLAG_AUTO_APPLY); break; 833 case KW_auto_apply: GET_FLAG (op, FLAG_AUTO_APPLY); break;
820 case KW_treasure: GET_FLAG (op, FLAG_TREASURE); break;
821 case KW_see_invisible: GET_FLAG (op, FLAG_SEE_INVISIBLE); break; 834 case KW_see_invisible: GET_FLAG (op, FLAG_SEE_INVISIBLE); break;
822 case KW_can_roll: GET_FLAG (op, FLAG_CAN_ROLL); break; 835 case KW_can_roll: GET_FLAG (op, FLAG_CAN_ROLL); break;
823 case KW_overlay_floor: GET_FLAG (op, FLAG_OVERLAY_FLOOR); break; 836 case KW_overlay_floor: GET_FLAG (op, FLAG_OVERLAY_FLOOR); break;
824 case KW_is_turnable: GET_FLAG (op, FLAG_IS_TURNABLE); break; 837 case KW_is_turnable: GET_FLAG (op, FLAG_IS_TURNABLE); break;
825 case KW_is_used_up: GET_FLAG (op, FLAG_IS_USED_UP); break; 838 case KW_is_used_up: GET_FLAG (op, FLAG_IS_USED_UP); break;
826 case KW_alive: GET_FLAG (op, FLAG_ALIVE); break; 839 case KW_alive: GET_FLAG (op, FLAG_ALIVE); break;
827 case KW_applied: GET_FLAG (op, FLAG_APPLIED); break; 840 case KW_applied: GET_FLAG (op, FLAG_APPLIED); break;
828 case KW_unpaid: GET_FLAG (op, FLAG_UNPAID); break; 841 case KW_unpaid: GET_FLAG (op, FLAG_UNPAID); break;
829 case KW_is_animated: GET_FLAG (op, FLAG_ANIMATE); break; 842 case KW_is_animated: GET_FLAG (op, FLAG_ANIMATE); break;
830 case KW_no_pick: GET_FLAG (op, FLAG_NO_PICK); break; 843 case KW_no_pick: GET_FLAG (op, FLAG_NO_PICK); break;
831 case KW_reflecting: GET_FLAG (op, FLAG_REFLECTING); break; 844 case KW_reflecting: GET_FLAG (op, FLAG_REFLECTING); break;
832 case KW_changing: GET_FLAG (op, FLAG_CHANGING); break; 845 case KW_changing: GET_FLAG (op, FLAG_CHANGING); break;
833 case KW_splitting: GET_FLAG (op, FLAG_SPLITTING); break; 846 case KW_splitting: GET_FLAG (op, FLAG_SPLITTING); break;
834 case KW_hitback: GET_FLAG (op, FLAG_HITBACK); break; 847 case KW_hitback: GET_FLAG (op, FLAG_HITBACK); break;
835 case KW_startequip: GET_FLAG (op, FLAG_STARTEQUIP); break; 848 case KW_startequip: GET_FLAG (op, FLAG_STARTEQUIP); break;
836 case KW_blocksview: GET_FLAG (op, FLAG_BLOCKSVIEW); break; 849 case KW_blocksview: GET_FLAG (op, FLAG_BLOCKSVIEW); break;
837 case KW_undead: GET_FLAG (op, FLAG_UNDEAD); break; 850 case KW_undead: GET_FLAG (op, FLAG_UNDEAD); break;
838 case KW_scared: GET_FLAG (op, FLAG_SCARED); break; 851 case KW_scared: GET_FLAG (op, FLAG_SCARED); break;
839 case KW_unaggressive: GET_FLAG (op, FLAG_UNAGGRESSIVE); break; 852 case KW_unaggressive: GET_FLAG (op, FLAG_UNAGGRESSIVE); break;
840 case KW_reflect_missile: GET_FLAG (op, FLAG_REFL_MISSILE); break; 853 case KW_reflect_missile: GET_FLAG (op, FLAG_REFL_MISSILE); break;
841 case KW_reflect_spell: GET_FLAG (op, FLAG_REFL_SPELL); break; 854 case KW_reflect_spell: GET_FLAG (op, FLAG_REFL_SPELL); break;
842 case KW_no_magic: GET_FLAG (op, FLAG_NO_MAGIC); break; 855 case KW_no_magic: GET_FLAG (op, FLAG_NO_MAGIC); break;
843 case KW_no_drop: GET_FLAG (op, FLAG_NO_DROP); break; 856 case KW_no_drop: GET_FLAG (op, FLAG_NO_DROP); break;
844 case KW_random_movement: GET_FLAG (op, FLAG_RANDOM_MOVE); break; 857 case KW_random_movement: GET_FLAG (op, FLAG_RANDOM_MOVE); break;
845 case KW_was_wiz: GET_FLAG (op, FLAG_WAS_WIZ); break; 858 case KW_was_wiz: GET_FLAG (op, FLAG_WAS_WIZ); break;
846 case KW_no_fix_player: GET_FLAG (op, FLAG_NO_FIX_PLAYER); break; 859 case KW_no_fix_player: GET_FLAG (op, FLAG_NO_FIX_PLAYER); break;
847 case KW_is_lightable: GET_FLAG (op, FLAG_IS_LIGHTABLE); break; 860 case KW_is_lightable: GET_FLAG (op, FLAG_IS_LIGHTABLE); break;
848 case KW_tear_down: GET_FLAG (op, FLAG_TEAR_DOWN); break; 861 case KW_tear_down: GET_FLAG (op, FLAG_TEAR_DOWN); break;
849 case KW_can_use_shield: GET_FLAG (op, FLAG_USE_SHIELD); break; 862 case KW_can_use_shield: GET_FLAG (op, FLAG_USE_SHIELD); break;
850 case KW_can_cast_spell: GET_FLAG (op, FLAG_CAST_SPELL); break; 863 case KW_can_cast_spell: GET_FLAG (op, FLAG_CAST_SPELL); break;
851 case KW_can_use_scroll: GET_FLAG (op, FLAG_USE_SCROLL); break; 864 case KW_can_use_scroll: GET_FLAG (op, FLAG_USE_SCROLL); break;
852 case KW_can_use_range: GET_FLAG (op, FLAG_USE_RANGE); break; 865 case KW_can_use_range: GET_FLAG (op, FLAG_USE_RANGE); break;
853 case KW_can_use_bow: GET_FLAG (op, FLAG_USE_BOW); break; 866 case KW_can_use_bow: GET_FLAG (op, FLAG_USE_BOW); break;
854 case KW_can_use_armour: GET_FLAG (op, FLAG_USE_ARMOUR); break; 867 case KW_can_use_armour: GET_FLAG (op, FLAG_USE_ARMOUR); break;
855 case KW_can_use_weapon: GET_FLAG (op, FLAG_USE_WEAPON); break; 868 case KW_can_use_weapon: GET_FLAG (op, FLAG_USE_WEAPON); break;
856 case KW_can_use_ring: GET_FLAG (op, FLAG_USE_RING); break; 869 case KW_can_use_ring: GET_FLAG (op, FLAG_USE_RING); break;
857 case KW_has_ready_bow: GET_FLAG (op, FLAG_READY_BOW); break; 870 case KW_has_ready_bow: GET_FLAG (op, FLAG_READY_BOW); break;
871 case KW_has_ready_range: GET_FLAG (op, FLAG_READY_RANGE); break;
858 case KW_xrays: GET_FLAG (op, FLAG_XRAYS); break; 872 case KW_xrays: GET_FLAG (op, FLAG_XRAYS); break;
859 case KW_is_floor: GET_FLAG (op, FLAG_IS_FLOOR); break; 873 case KW_is_floor: GET_FLAG (op, FLAG_IS_FLOOR); break;
860 case KW_lifesave: GET_FLAG (op, FLAG_LIFESAVE); break; 874 case KW_lifesave: GET_FLAG (op, FLAG_LIFESAVE); break;
861 case KW_no_strength: GET_FLAG (op, FLAG_NO_STRENGTH); break; 875 case KW_no_strength: GET_FLAG (op, FLAG_NO_STRENGTH); break;
862 case KW_sleep: GET_FLAG (op, FLAG_SLEEP); break; 876 case KW_sleep: GET_FLAG (op, FLAG_SLEEP); break;
863 case KW_stand_still: GET_FLAG (op, FLAG_STAND_STILL); break; 877 case KW_stand_still: GET_FLAG (op, FLAG_STAND_STILL); break;
864 case KW_random_move: GET_FLAG (op, FLAG_RANDOM_MOVE); break; 878 case KW_random_move: GET_FLAG (op, FLAG_RANDOM_MOVE); break;
865 case KW_only_attack: GET_FLAG (op, FLAG_ONLY_ATTACK); break; 879 case KW_only_attack: GET_FLAG (op, FLAG_ONLY_ATTACK); break;
866 case KW_activate_on_push: GET_FLAG (op, FLAG_ACTIVATE_ON_PUSH); break; 880 case KW_activate_on_push: GET_FLAG (op, FLAG_ACTIVATE_ON_PUSH); break;
867 case KW_activate_on_release: GET_FLAG (op, FLAG_ACTIVATE_ON_RELEASE); break; 881 case KW_activate_on_release: GET_FLAG (op, FLAG_ACTIVATE_ON_RELEASE); break;
868 case KW_confused: GET_FLAG (op, FLAG_CONFUSED); break; 882 case KW_confused: GET_FLAG (op, FLAG_CONFUSED); break;
869 case KW_stealth: GET_FLAG (op, FLAG_STEALTH); break; 883 case KW_stealth: GET_FLAG (op, FLAG_STEALTH); break;
870 case KW_cursed: GET_FLAG (op, FLAG_CURSED); break; 884 case KW_cursed: GET_FLAG (op, FLAG_CURSED); break;
871 case KW_damned: GET_FLAG (op, FLAG_DAMNED); break; 885 case KW_damned: GET_FLAG (op, FLAG_DAMNED); break;
872 case KW_see_anywhere: GET_FLAG (op, FLAG_SEE_ANYWHERE); break; 886 case KW_see_anywhere: GET_FLAG (op, FLAG_SEE_ANYWHERE); break;
873 case KW_known_magical: GET_FLAG (op, FLAG_KNOWN_MAGICAL); break; 887 case KW_known_magical: GET_FLAG (op, FLAG_KNOWN_MAGICAL); break;
874 case KW_known_cursed: GET_FLAG (op, FLAG_KNOWN_CURSED); break; 888 case KW_known_cursed: GET_FLAG (op, FLAG_KNOWN_CURSED); break;
875 case KW_can_use_skill: GET_FLAG (op, FLAG_CAN_USE_SKILL); break; 889 case KW_can_use_skill: GET_FLAG (op, FLAG_CAN_USE_SKILL); break;
876 case KW_been_applied: GET_FLAG (op, FLAG_BEEN_APPLIED); break; 890 case KW_been_applied: GET_FLAG (op, FLAG_BEEN_APPLIED); break;
877 case KW_has_ready_scroll: GET_FLAG (op, FLAG_READY_SCROLL); break; 891 case KW_has_ready_scroll: GET_FLAG (op, FLAG_READY_SCROLL); break;
878 case KW_can_use_rod: GET_FLAG (op, FLAG_USE_ROD); break; 892 case KW_can_use_rod: GET_FLAG (op, FLAG_USE_ROD); break;
879 case KW_can_use_horn: GET_FLAG (op, FLAG_USE_HORN); break; 893 case KW_can_use_horn: GET_FLAG (op, FLAG_USE_HORN); break;
880 case KW_unique: GET_FLAG (op, FLAG_UNIQUE); break; 894 case KW_unique: GET_FLAG (op, FLAG_UNIQUE); break;
881 case KW_make_invisible: GET_FLAG (op, FLAG_MAKE_INVIS); break; 895 case KW_make_invisible: GET_FLAG (op, FLAG_MAKE_INVIS); break;
882 case KW_inv_locked: GET_FLAG (op, FLAG_INV_LOCKED); break; 896 case KW_inv_locked: GET_FLAG (op, FLAG_INV_LOCKED); break;
883 case KW_is_wooded: GET_FLAG (op, FLAG_IS_WOODED); break; 897 case KW_is_wooded: GET_FLAG (op, FLAG_IS_WOODED); break;
884 case KW_is_hilly: GET_FLAG (op, FLAG_IS_HILLY); break; 898 case KW_is_hilly: GET_FLAG (op, FLAG_IS_HILLY); break;
885 case KW_is_water: GET_FLAG (op, FLAG_IS_WATER); break; 899 case KW_is_water: GET_FLAG (op, FLAG_IS_WATER); break;
886 case KW_has_ready_skill: GET_FLAG (op, FLAG_READY_SKILL); break; 900 case KW_has_ready_skill: GET_FLAG (op, FLAG_READY_SKILL); break;
887 case KW_has_ready_weapon: GET_FLAG (op, FLAG_READY_WEAPON); break; 901 case KW_has_ready_weapon: GET_FLAG (op, FLAG_READY_WEAPON); break;
888 case KW_no_skill_ident: GET_FLAG (op, FLAG_NO_SKILL_IDENT); break; 902 case KW_no_skill_ident: GET_FLAG (op, FLAG_NO_SKILL_IDENT); break;
889 case KW_is_blind: GET_FLAG (op, FLAG_BLIND); break; 903 case KW_is_blind: GET_FLAG (op, FLAG_BLIND); break;
890 case KW_can_see_in_dark: GET_FLAG (op, FLAG_SEE_IN_DARK); break; 904 case KW_can_see_in_dark: GET_FLAG (op, FLAG_SEE_IN_DARK); break;
891 case KW_is_cauldron: GET_FLAG (op, FLAG_IS_CAULDRON); break; 905 case KW_is_cauldron: GET_FLAG (op, FLAG_IS_CAULDRON); break;
892 case KW_no_steal: GET_FLAG (op, FLAG_NO_STEAL); break; 906 case KW_no_steal: GET_FLAG (op, FLAG_NO_STEAL); break;
893 case KW_one_hit: GET_FLAG (op, FLAG_ONE_HIT); break; 907 case KW_one_hit: GET_FLAG (op, FLAG_ONE_HIT); break;
894 case KW_berserk: GET_FLAG (op, FLAG_BERSERK); break; 908 case KW_berserk: GET_FLAG (op, FLAG_BERSERK); break;
895 case KW_is_buildable: GET_FLAG (op, FLAG_IS_BUILDABLE); break; 909 case KW_is_buildable: GET_FLAG (op, FLAG_IS_BUILDABLE); break;
896 910
897 case KW_armour: thawer.get (op->resist [ATNR_PHYSICAL]); break; 911 case KW_armour: thawer.get (op->resist[ATNR_PHYSICAL]); break;
898 case KW_resist_physical: thawer.get (op->resist [ATNR_PHYSICAL]); break; 912 case KW_resist_physical: thawer.get (op->resist[ATNR_PHYSICAL]); break;
899 case KW_resist_magic: thawer.get (op->resist [ATNR_MAGIC]); break; 913 case KW_resist_magic: thawer.get (op->resist[ATNR_MAGIC]); break;
900 case KW_resist_fire: thawer.get (op->resist [ATNR_FIRE]); break; 914 case KW_resist_fire: thawer.get (op->resist[ATNR_FIRE]); break;
901 case KW_resist_electricity: thawer.get (op->resist [ATNR_ELECTRICITY]); break; 915 case KW_resist_electricity: thawer.get (op->resist[ATNR_ELECTRICITY]); break;
902 case KW_resist_cold: thawer.get (op->resist [ATNR_COLD]); break; 916 case KW_resist_cold: thawer.get (op->resist[ATNR_COLD]); break;
903 case KW_resist_confusion: thawer.get (op->resist [ATNR_CONFUSION]); break; 917 case KW_resist_confusion: thawer.get (op->resist[ATNR_CONFUSION]); break;
904 case KW_resist_acid: thawer.get (op->resist [ATNR_ACID]); break; 918 case KW_resist_acid: thawer.get (op->resist[ATNR_ACID]); break;
905 case KW_resist_drain: thawer.get (op->resist [ATNR_DRAIN]); break; 919 case KW_resist_drain: thawer.get (op->resist[ATNR_DRAIN]); break;
906 case KW_resist_weaponmagic: thawer.get (op->resist [ATNR_WEAPONMAGIC]); break; 920 case KW_resist_weaponmagic: thawer.get (op->resist[ATNR_WEAPONMAGIC]); break;
907 case KW_resist_ghosthit: thawer.get (op->resist [ATNR_GHOSTHIT]); break; 921 case KW_resist_ghosthit: thawer.get (op->resist[ATNR_GHOSTHIT]); break;
908 case KW_resist_poison: thawer.get (op->resist [ATNR_POISON]); break; 922 case KW_resist_poison: thawer.get (op->resist[ATNR_POISON]); break;
909 case KW_resist_slow: thawer.get (op->resist [ATNR_SLOW]); break; 923 case KW_resist_slow: thawer.get (op->resist[ATNR_SLOW]); break;
910 case KW_resist_paralyze: thawer.get (op->resist [ATNR_PARALYZE]); break; 924 case KW_resist_paralyze: thawer.get (op->resist[ATNR_PARALYZE]); break;
911 case KW_resist_turn_undead: thawer.get (op->resist [ATNR_TURN_UNDEAD]); break; 925 case KW_resist_turn_undead: thawer.get (op->resist[ATNR_TURN_UNDEAD]); break;
912 case KW_resist_fear: thawer.get (op->resist [ATNR_FEAR]); break; 926 case KW_resist_fear: thawer.get (op->resist[ATNR_FEAR]); break;
913 case KW_resist_cancellation: thawer.get (op->resist [ATNR_CANCELLATION]); break; 927 case KW_resist_cancellation: thawer.get (op->resist[ATNR_CANCELLATION]); break;
914 case KW_resist_deplete: thawer.get (op->resist [ATNR_DEPLETE]); break; 928 case KW_resist_deplete: thawer.get (op->resist[ATNR_DEPLETE]); break;
915 case KW_resist_death: thawer.get (op->resist [ATNR_DEATH]); break; 929 case KW_resist_death: thawer.get (op->resist[ATNR_DEATH]); break;
916 case KW_resist_chaos: thawer.get (op->resist [ATNR_CHAOS]); break; 930 case KW_resist_chaos: thawer.get (op->resist[ATNR_CHAOS]); break;
917 case KW_resist_counterspell: thawer.get (op->resist [ATNR_COUNTERSPELL]); break; 931 case KW_resist_counterspell: thawer.get (op->resist[ATNR_COUNTERSPELL]); break;
918 case KW_resist_godpower: thawer.get (op->resist [ATNR_GODPOWER]); break; 932 case KW_resist_godpower: thawer.get (op->resist[ATNR_GODPOWER]); break;
919 case KW_resist_holyword: thawer.get (op->resist [ATNR_HOLYWORD]); break; 933 case KW_resist_holyword: thawer.get (op->resist[ATNR_HOLYWORD]); break;
920 case KW_resist_blind: thawer.get (op->resist [ATNR_BLIND]); break; 934 case KW_resist_blind: thawer.get (op->resist[ATNR_BLIND]); break;
921 case KW_resist_internal: thawer.get (op->resist [ATNR_INTERNAL]); break; 935 case KW_resist_internal: thawer.get (op->resist[ATNR_INTERNAL]); break;
922 case KW_resist_life_stealing: thawer.get (op->resist [ATNR_LIFE_STEALING]); break; 936 case KW_resist_life_stealing: thawer.get (op->resist[ATNR_LIFE_STEALING]); break;
923 case KW_resist_disease: thawer.get (op->resist [ATNR_DISEASE]); break; 937 case KW_resist_disease: thawer.get (op->resist[ATNR_DISEASE]); break;
924 938
925 case KW_luck: thawer.get (op->stats.luck); break; 939 case KW_luck: thawer.get (op->stats.luck); break;
926 case KW_run_away: thawer.get (op->run_away); break; 940 case KW_run_away: thawer.get (op->run_away); break;
927 case KW_pick_up: thawer.get (op->pick_up); break; 941 case KW_pick_up: thawer.get (op->pick_up); break;
928 case KW_item_power: thawer.get (op->item_power); break; 942 case KW_item_power: thawer.get (op->item_power); break;
929 case KW_gen_sp_armour: thawer.get (op->gen_sp_armour); break; 943 case KW_gen_sp_armour: thawer.get (op->gen_sp_armour); break;
930 case KW_anim_speed: thawer.get (op->anim_speed); break; 944 case KW_anim_speed: thawer.get (op->anim_speed); break;
931 case KW_container: thawer.get (op->weight_limit); break; 945 case KW_container: thawer.get (op->weight_limit); break;
932 case KW_will_apply: thawer.get (op->will_apply); break; 946 case KW_will_apply: thawer.get (op->will_apply); break;
933 case KW_attack_movement: thawer.get (op->attack_movement); break; 947 case KW_attack_movement: thawer.get (op->attack_movement); break;
934 case KW_move_state: thawer.get (op->move_status); break; 948 case KW_move_state: thawer.get (op->move_status); break;
935 case KW_expmul: thawer.get (op->expmul); break; 949 case KW_expmul: thawer.get (op->expmul); break;
936 case KW_glow_radius: thawer.get (op->glow_radius); break; 950 case KW_glow_radius: thawer.get (op->glow_radius); break;
937 case KW_weapontype: thawer.get (op->weapontype); break; 951 case KW_weapontype: thawer.get (op->weapontype); break;
938 case KW_tooltype: thawer.get (op->tooltype); break; 952 case KW_tooltype: thawer.get (op->tooltype); break;
939 case KW_casting_time: thawer.get (op->casting_time); break; 953 case KW_casting_time: thawer.get (op->casting_time); break;
940 case KW_elevation: thawer.get (op->elevation); break; 954 case KW_elevation: thawer.get (op->elevation); break;
941 case KW_smoothlevel: thawer.get (op->smoothlevel); break; 955 case KW_smoothlevel: thawer.get (op->smoothlevel); break;
942 case KW_client_type: thawer.get (op->client_type); break; 956 case KW_client_type: thawer.get (op->client_type); break;
943 case KW_duration: thawer.get (op->duration); break; 957 case KW_duration: thawer.get (op->duration); break;
944 case KW_range: thawer.get (op->range); break; 958 case KW_range: thawer.get (op->range); break;
945 case KW_range_modifier: thawer.get (op->range_modifier); break; 959 case KW_range_modifier: thawer.get (op->range_modifier); break;
946 case KW_dam_modifier: thawer.get (op->dam_modifier); break; 960 case KW_dam_modifier: thawer.get (op->dam_modifier); break;
947 case KW_duration_modifier: thawer.get (op->duration_modifier); break; 961 case KW_duration_modifier: thawer.get (op->duration_modifier); break;
948 962
949 //TODO: mechanism to ensure that KW_xxx is consecutive needed from include/preprocess 963 //TODO: mechanism to ensure that KW_xxx is consecutive needed from include/preprocess
950 //TODO: parse from other include files 964 //TODO: parse from other include files
951 case KW_body_range: thawer.get (op->body_info [ 0]); break; 965 case KW_body_range: thawer.get (op->body_info[0]); break;
952 case KW_body_arm: thawer.get (op->body_info [ 1]); break; 966 case KW_body_arm: thawer.get (op->body_info[1]); break;
953 case KW_body_torso: thawer.get (op->body_info [ 2]); break; 967 case KW_body_torso: thawer.get (op->body_info[2]); break;
954 case KW_body_head: thawer.get (op->body_info [ 3]); break; 968 case KW_body_head: thawer.get (op->body_info[3]); break;
955 case KW_body_neck: thawer.get (op->body_info [ 4]); break; 969 case KW_body_neck: thawer.get (op->body_info[4]); break;
956 case KW_body_skill: thawer.get (op->body_info [ 5]); break; 970 case KW_body_skill: thawer.get (op->body_info[5]); break;
957 case KW_body_finger: thawer.get (op->body_info [ 6]); break; 971 case KW_body_finger: thawer.get (op->body_info[6]); break;
958 case KW_body_shoulder: thawer.get (op->body_info [ 7]); break; 972 case KW_body_shoulder: thawer.get (op->body_info[7]); break;
959 case KW_body_foot: thawer.get (op->body_info [ 8]); break; 973 case KW_body_foot: thawer.get (op->body_info[8]); break;
960 case KW_body_hand: thawer.get (op->body_info [ 9]); break; 974 case KW_body_hand: thawer.get (op->body_info[9]); break;
961 case KW_body_wrist: thawer.get (op->body_info [10]); break; 975 case KW_body_wrist: thawer.get (op->body_info[10]); break;
962 case KW_body_waist: thawer.get (op->body_info [11]); break; 976 case KW_body_waist: thawer.get (op->body_info[11]); break;
963 case KW_can_apply: 977 case KW_can_apply:
964 break; 978 break;
965 979
966 case KW_connected: 980 case KW_connected:
967 add_button_link (op, op->map, thawer.get_sint32 ()); 981 add_button_link (op, op->map, thawer.get_sint32 ());
… …
970 case KW_randomitems: 984 case KW_randomitems:
971 op->randomitems = find_treasurelist (thawer.get_str ()); 985 op->randomitems = find_treasurelist (thawer.get_str ());
972 break; 986 break;
973 987
974 case KW_msg: 988 case KW_msg:
975 {
976 thawer.get_ml (KW_endmsg, op->msg); 989 thawer.get_ml (KW_endmsg, op->msg);
977 //TODO: allow longer messages 990 //TODO: allow longer messages
978 if (strlen (op->msg) >= HUGE_BUF) 991 if (strlen (op->msg) >= HUGE_BUF)
979 { 992 {
980 LOG (llevDebug, "\n\tError message length >= %d: %d\n>%.80s<\n", HUGE_BUF, strlen (op->msg), &op->msg); 993 LOG (llevDebug, "\tError message length >= %d: %d\n>%.80s<\n", HUGE_BUF, strlen (op->msg), &op->msg);
981 op->msg = "ERROR, please report: string too long, winged.\n"; 994 op->msg = "ERROR, please report: string too long, winged.\n";
982 } 995 }
983 }
984 break; 996 break;
985 997
986 case KW_lore: 998 case KW_lore:
987 {
988 shstr msgbuf;
989 thawer.get_ml (KW_endlore, op->lore); 999 thawer.get_ml (KW_endlore, op->lore);
990 //TODO: allow longer messages 1000 //TODO: allow longer messages
991 /* Just print a warning so we can be reasonably safe 1001 /* Just print a warning so we can be reasonably safe
992 * about not overflowing the buffer. 1002 * about not overflowing the buffer.
993 */ 1003 */
994 if (strlen (op->lore) > (HUGE_BUF / 2)) 1004 if (strlen (op->lore) > (HUGE_BUF / 2))
995 LOG (llevDebug, "\n\tWarning lore length > %d (max allowed=%d): %d\n>%.80s<\n", 1005 LOG (llevDebug, "\tWarning lore length > %d (max allowed=%d): %d\n>%.80s<\n",
996 HUGE_BUF / 2, HUGE_BUF, strlen (op->lore), &op->lore); 1006 HUGE_BUF / 2, HUGE_BUF, strlen (op->lore), &op->lore);
997 }
998 break; 1007 break;
999 1008
1000 case KW_editable: 1009 case KW_editable:
1001 case KW_editor_folder: 1010 case KW_editor_folder:
1002 break; 1011 break;
1003 1012
1004 case KW_More: // uppercase alias 1013 case KW_More: // uppercase alias
1005 case KW_more: 1014 case KW_more:
1006 /* We need to record that this is a multipart object, 1015 /* We need to record that this is a multipart object,
1007 * so the calling function can glue things back together 1016 * so the calling function can glue things back together
1008 */ 1017 */
1009 ismore = 1; 1018 ismore = 1;
… …
1019 1028
1020 case KW_EOF: 1029 case KW_EOF:
1021 return LL_EOF; 1030 return LL_EOF;
1022 1031
1023 case KW_ERROR: 1032 case KW_ERROR:
1024 set_ob_key_value (op, thawer.line, thawer.last_value, true); 1033 set_ob_key_value (op, thawer.last_keyword, thawer.last_value, true);
1025 //printf ("addkv(%s,%s)\n", thawer.line, thawer.get_str());//D 1034 //fprintf (stderr, "addkv(%s,%s)\n", thawer.last_keyword, thawer.last_value);//D
1026
1027 //TODO: skip line, ugly, factor parsing better
1028 if (thawer.last_value)
1029 thawer.line = thawer.last_value;
1030
1031 thawer.line += strlen (thawer.line) + 1;
1032
1033 break; 1035 break;
1034 1036
1035 default: 1037 default:
1036 LOG (llevError, "UNSUPPORTED KEYWORD IN MAP: \"%s\", bug in normaliser. skipping.\n", keyword_str [kw]); 1038 LOG (llevError, "UNSUPPORTED KEYWORD IN MAP: \"%s\", bug in normaliser. skipping.\n", keyword_str[kw]);
1037 break; 1039 break;
1038 } 1040 }
1039 } 1041 }
1040} 1042}
1041 1043
… …
1051 * LO_NEWFILE (2): This is the first read from a particular file, so the buffers should 1053 * LO_NEWFILE (2): This is the first read from a particular file, so the buffers should
1052 * be reset. 1054 * be reset.
1053 * LO_NOREAD (3): Reset the buffers, but don't read from it. (op can be null) 1055 * LO_NOREAD (3): Reset the buffers, but don't read from it. (op can be null)
1054 * 1056 *
1055 */ 1057 */
1056 1058int
1057int load_object(object_thawer &fp, object *op, int map_flags) { 1059load_object (object_thawer &fp, object *op, int map_flags)
1060{
1061 coroapi::cede_every (1000); // cede once in a while
1062
1058 return parse_object(op, fp, map_flags); 1063 return parse_object (op, fp, map_flags);
1059} 1064}
1060
1061 1065
1062/* This takes a buffer, scans it for variables, and sets those variables 1066/* This takes a buffer, scans it for variables, and sets those variables
1063 * as appropriate in op. 1067 * as appropriate in op.
1064 * 1068 *
1065 * This function appears to be used in only 2 places - in crossedit to 1069 * This function appears to be used in only 2 places - in crossedit to
1066 * override values and in c_wiz to mutate values. 1070 * override values and in c_wiz to mutate values.
1067 */ 1071 */
1068int 1072int
1069set_variable(object *op, char *buf) 1073set_variable (object *op, char *buf)
1070{ 1074{
1071 return 0;
1072#if 0
1073 int retval;
1074 object_thawer thawer (0); 1075 object_thawer thawer (buf, (AV *)0);
1075 1076
1076 strcpy(msgbuf, "");
1077 strcpy(lorebuf, "");
1078 retval=parse_object(op,thawer,0); 1077 return parse_object (op, thawer, 0);
1079 yy_switch_to_buffer(yycurbuf);
1080 yy_delete_buffer(yybufstate);
1081 yy_pop_state();
1082 return retval;
1083#endif
1084} 1078}
1085
1086/* This array equates the FLAG_ values with the V_ values. Use -1 to
1087 * put gaps in the array that should not be processed.
1088 * The order matches the order of the define values in 'define.h'.
1089 */
1090/* This is a list of pointers that correspond to the FLAG_.. values.
1091 * This is a simple 1:1 mapping - if FLAG_FRIENDLY is 15, then
1092 * the 15'th element of this array should match that name.
1093 * If an entry is NULL, that is a flag not to loaded/saved.
1094 */
1095static const char *const flag_names[NUM_FLAGS+1] = {
1096"alive", "wiz", NULL, NULL, "was_wiz", "applied", "unpaid",
1097"can_use_shield", "no_pick", NULL /* walk_on*/, NULL /* no_pass */, /* 10 */
1098"is_animated", NULL /* slow_move */,
1099NULL /* flying */, "monster", "friendly", "generator",
1100"is_thrown", "auto_apply", "treasure", "player sold", /* 20 */
1101"see_invisible", "can_roll", "overlay_floor",
1102"is_turnable", NULL /* walk_off */, NULL /* fly_on */,
1103NULL /*fly_off*/, "is_used_up", "identified", "reflecting", /* 30 */
1104"changing", "splitting", "hitback", "startequip",
1105"blocksview", "undead", "scared", "unaggressive",
1106"reflect_missile", "reflect_spell", /* 40 */
1107"no_magic", "no_fix_player", "is_lightable", "tear_down",
1108"run_away", NULL /*pass_thru */, NULL /*can_pass_thru*/,
1109"pick_up", "unique", "no_drop", /* 50 */
1110NULL /* wizcast*/, "can_cast_spell", "can_use_scroll", "can_use_range",
1111"can_use_bow", "can_use_armour", "can_use_weapon",
1112"can_use_ring", "has_ready_range", "has_ready_bow", /* 60 */
1113"xrays", NULL, "is_floor", "lifesave", "no_strength", "sleep",
1114"stand_still", "random_move", "only_attack", "confused", /* 70 */
1115 "stealth", NULL, NULL, "cursed", "damned",
1116"see_anywhere", "known_magical", "known_cursed",
1117"can_use_skill", "been_applied", /* 80 */
1118"has_ready_scroll", "can_use_rod", NULL,
1119"can_use_horn", "make_invisible", "inv_locked", "is_wooded",
1120"is_hilly", "has_ready_skill", "has_ready_weapon", /* 90 */
1121"no_skill_ident", "is_blind", "can_see_in_dark", "is_cauldron",
1122"is_dust", "no_steal", "one_hit", NULL, "berserk", "neutral", /* 100 */
1123"no_attack", "no_damage", NULL, NULL, "activate_on_push",
1124"activate_on_release", "is_water", "use_content_on_gen", NULL, "is_buildable", /* 110 */
1125NULL
1126};
1127
1128 1079
1129/* 1080/*
1130 * Initialises the array of variable-names. Needed before any 1081 * Initialises the array of variable-names. Needed before any
1131 * objects can be loaded. Called by init_library(). 1082 * objects can be loaded. Called by init_library().
1132 */ 1083 */
1133 1084
1134void init_vars() { 1085void
1086init_vars ()
1087{
1135} 1088}
1136 1089
1137/* This returns a string of the integer movement type */ 1090/* This returns a string of the integer movement type */
1138#if 0 1091#if 0
1139// unused function 1092// unused function
1093static char *
1140static char* get_string_move_type(MoveType mt) 1094get_string_move_type (MoveType mt)
1141{ 1095{
1142 static char retbuf[MAX_BUF], retbuf_all[MAX_BUF]; 1096 static char retbuf[MAX_BUF], retbuf_all[MAX_BUF];
1143 int i, all_count=0, count; 1097 int i, all_count = 0, count;
1144 1098
1145 strcpy(retbuf,""); 1099 strcpy (retbuf, "");
1146 strcpy(retbuf_all," all"); 1100 strcpy (retbuf_all, " all");
1147 1101
1148 /* Quick check, and probably fairly common */ 1102 /* Quick check, and probably fairly common */
1149 if (mt == MOVE_ALL) return retbuf_all+1; 1103 if (mt == MOVE_ALL)
1104 return retbuf_all + 1;
1150 if (mt == 0) { 1105 if (mt == 0)
1106 {
1151 strcpy(retbuf,"0"); 1107 strcpy (retbuf, "0");
1152 return retbuf; 1108 return retbuf;
1153 } 1109 }
1154 1110
1155 /* We basically slide the bits down. Why look at MOVE_ALL? 1111 /* We basically slide the bits down. Why look at MOVE_ALL?
1156 * because we may want to return a string like 'all -swim', 1112 * because we may want to return a string like 'all -swim',
1157 * and if we just looked at mt, we couldn't get that. 1113 * and if we just looked at mt, we couldn't get that.
1158 */ 1114 */
1159 for (i=MOVE_ALL, count=0; i!=0; i >>= 1, count++) { 1115 for (i = MOVE_ALL, count = 0; i != 0; i >>= 1, count++)
1116 {
1160 if (mt & (1<<count)) { 1117 if (mt & (1 << count))
1118 {
1161 strcat(retbuf, " "); 1119 strcat (retbuf, " ");
1162 strcat(retbuf, move_name[count]); 1120 strcat (retbuf, move_name[count]);
1121 }
1163 } else { 1122 else
1123 {
1164 strcat(retbuf_all, " -"); 1124 strcat (retbuf_all, " -");
1165 strcat(retbuf_all, move_name[count]); 1125 strcat (retbuf_all, move_name[count]);
1166 all_count++; 1126 all_count++;
1167 } 1127 }
1168 } 1128 }
1169 /* Basically, if there is a single negation, return it, eg 1129 /* Basically, if there is a single negation, return it, eg
1170 * 'all -swim'. But more than that, just return the 1130 * 'all -swim'. But more than that, just return the
1171 * enumerated values. It doesn't make sense to return 1131 * enumerated values. It doesn't make sense to return
1172 * 'all -walk -fly_low' - it is shorter to return 'fly_high swim' 1132 * 'all -walk -fly_low' - it is shorter to return 'fly_high swim'
1173 */ 1133 */
1174 if (all_count <=1) return retbuf_all+1; 1134 if (all_count <= 1)
1135 return retbuf_all + 1;
1136 else
1175 else return retbuf+1; 1137 return retbuf + 1;
1176} 1138}
1177#endif 1139#endif
1178 1140
1179// compare *op against *tmp and output differences 1141// compare *op against *tmp and output differences
1180void 1142void
1181put (object_freezer &f, object *op, object *tmp) 1143put (object_freezer &f, object *op, object *tmp)
1182{ 1144{
1145 static const keyword resist_save[NROFATTACKS] = {
1146# define def(uc, lc, name, plus, change) KW_resist_ ## lc,
1147# include "attackinc.h"
1148# undef def
1149 };
1150
1151 /* This is a list of keywords that correspond to the FLAG_.. values.
1152 * This is a simple 1:1 mapping - if FLAG_FRIENDLY is 15, then
1153 * the 15'th element of this array should match that name.
1154 * If an entry is NULL, that is a flag not to loaded/saved.
1155 */
1156 static const keyword flag_names [NUM_FLAGS] = {
1157 KW_alive,
1158 KW_wiz,
1159 KW_NULL,
1160 KW_NULL,
1161 KW_was_wiz,
1162 KW_applied,
1163 KW_unpaid,
1164 KW_can_use_shield,
1165 KW_no_pick,
1166 KW_NULL, // walk_on
1167 KW_NULL, // no_pass
1168 /* 10 */
1169 KW_is_animated,
1170 KW_NULL, // slow_move
1171 KW_NULL, // flying
1172 KW_monster,
1173 KW_friendly,
1174 KW_generator,
1175 KW_is_thrown,
1176 KW_auto_apply,
1177 KW_NULL, // was KW_treasure
1178 KW_player_sold,
1179 /* 20 */
1180 KW_see_invisible,
1181 KW_can_roll,
1182 KW_overlay_floor,
1183 KW_is_turnable,
1184 KW_NULL, // walk_off
1185 KW_NULL, // fly_on
1186 KW_NULL, // fly_off
1187 KW_is_used_up,
1188 KW_identified,
1189 KW_reflecting,
1190 /* 30 */
1191 KW_changing,
1192 KW_splitting,
1193 KW_hitback,
1194 KW_startequip,
1195 KW_blocksview,
1196 KW_undead,
1197 KW_scared,
1198 KW_unaggressive,
1199 KW_reflect_missile,
1200 KW_reflect_spell,
1201 /* 40 */
1202 KW_no_magic,
1203 KW_no_fix_player,
1204 KW_is_lightable,
1205 KW_tear_down,
1206 KW_run_away,
1207 KW_NULL, // pass_thru
1208 KW_NULL, // an_pass_thru
1209 KW_pick_up,
1210 KW_unique,
1211 KW_no_drop,
1212 /* 50 */
1213 KW_NULL, // wizcast
1214 KW_can_cast_spell,
1215 KW_can_use_scroll,
1216 KW_can_use_range,
1217 KW_can_use_bow,
1218 KW_can_use_armour,
1219 KW_can_use_weapon,
1220 KW_can_use_ring,
1221 KW_has_ready_range,
1222 KW_has_ready_bow,
1223 /* 60 */
1224 KW_xrays,
1225 KW_NULL,
1226 KW_is_floor,
1227 KW_lifesave,
1228 KW_no_strength,
1229 KW_sleep,
1230 KW_stand_still,
1231 KW_random_move,
1232 KW_only_attack,
1233 KW_confused,
1234 /* 70 */
1235 KW_stealth,
1236 KW_NULL,
1237 KW_NULL,
1238 KW_cursed,
1239 KW_damned,
1240 KW_see_anywhere,
1241 KW_known_magical,
1242 KW_known_cursed,
1243 KW_can_use_skill,
1244 KW_been_applied,
1245 /* 80 */
1246 KW_has_ready_scroll,
1247 KW_can_use_rod,
1248 KW_NULL,
1249 KW_can_use_horn,
1250 KW_make_invisible,
1251 KW_inv_locked,
1252 KW_is_wooded,
1253 KW_is_hilly,
1254 KW_has_ready_skill,
1255 KW_has_ready_weapon,
1256 /* 90 */
1257 KW_no_skill_ident,
1258 KW_is_blind,
1259 KW_can_see_in_dark,
1260 KW_is_cauldron,
1261 KW_NULL,
1262 KW_no_steal,
1263 KW_one_hit,
1264 KW_NULL,
1265 KW_berserk,
1266 KW_neutral,
1267 /* 100 */
1268 KW_no_attack,
1269 KW_no_damage,
1270 KW_NULL,
1271 KW_NULL,
1272 KW_activate_on_push,
1273 KW_activate_on_release,
1274 KW_is_water,
1275 KW_use_content_on_gen,
1276 KW_NULL,
1277 KW_is_buildable,
1278 /* 110 */
1279 };
1280
1183 int i; 1281 int i;
1184 1282
1185 /* This saves the key/value lists. We do it first so that any 1283 /* This saves the key/value lists. We do it first so that any
1186 * keys that match field names will be overwritten by the loader. 1284 * keys that match field names will be overwritten by the loader.
1187 */ 1285 */
… …
1189 { 1287 {
1190 /* Find the field in the opposing member. */ 1288 /* Find the field in the opposing member. */
1191 key_value *arch_field = get_ob_key_link (tmp, my_field->key); 1289 key_value *arch_field = get_ob_key_link (tmp, my_field->key);
1192 1290
1193 /* If there's no partnering field, or it's got a different value, save our field. */ 1291 /* If there's no partnering field, or it's got a different value, save our field. */
1194 if (arch_field == NULL || my_field->value != arch_field->value) 1292 if (!arch_field || my_field->value != arch_field->value)
1195 f.put (my_field->key, my_field->value); 1293 f.put (my_field->key, my_field->value);
1196 } 1294 }
1197 1295
1198 /* We don't need to worry about the arch's extra fields - they 1296 /* We don't need to worry about the arch's extra fields - they
1199 * will get taken care of the copy_object function. 1297 * will get taken care of the copy_to method.
1200 */ 1298 */
1201 1299
1300 {
1301 char uids[64];
1302 snprintf (uids, sizeof (uids), "<1.%llx>", (unsigned long long)op->uuid.seq);
1303 f.put (KW_uuid, (const char *)uids);
1304 }
1305
1202# define CMP_OUT(v) if (op->v != tmp->v) f.put (KW_ ## v, op->v) 1306#define CMP_OUT(v) if (op->v != tmp->v) f.put (KW_ ## v, op->v)
1203# define CMP_OUT2(k,v) if (op->v != tmp->v) f.put (KW_ ## k, op->v) 1307#define CMP_OUT2(k,v) if (op->v != tmp->v) f.put (KW_ ## k, op->v)
1204 1308
1205 CMP_OUT (name); 1309 CMP_OUT (name);
1206 CMP_OUT (name_pl); 1310 CMP_OUT (name_pl);
1207 CMP_OUT (custom_name); 1311 CMP_OUT (custom_name);
1208 CMP_OUT (title); 1312 CMP_OUT (title);
1209 CMP_OUT (race); 1313 CMP_OUT (race);
1210 CMP_OUT (slaying); 1314 CMP_OUT (slaying);
1211 1315
1212 if (op->msg != tmp->msg ) f.put (KW_msg , KW_endmsg , op->msg); 1316 if (op->msg != tmp->msg)
1317 f.put (KW_msg, KW_endmsg, op->msg);
1318 if (op->lore != tmp->lore)
1213 if (op->lore != tmp->lore) f.put (KW_lore, KW_endlore, op->lore); 1319 f.put (KW_lore, KW_endlore, op->lore);
1214 1320
1215 CMP_OUT (other_arch); 1321 CMP_OUT (other_arch);
1216 CMP_OUT (face); 1322 CMP_OUT (face);
1217
1218 if (!op->face || !op->face->name)
1219 printf ("ERRFACE<%s,%s, face %p,%p, fname%s>\n", &tmp->name, &op->name, tmp->face, op->face, op->face ? &op->face->name : "<noface>");//D
1220 1323
1221 if (op->animation_id != tmp->animation_id) 1324 if (op->animation_id != tmp->animation_id)
1222 if (op->animation_id) 1325 if (op->animation_id)
1223 { 1326 {
1224 f.put (KW_animation, animations[GET_ANIM_ID (op)].name); 1327 f.put (KW_animation, animations[GET_ANIM_ID (op)].name);
1225 1328
1226 if (!QUERY_FLAG (op, FLAG_ANIMATE)) 1329 if (!QUERY_FLAG (op, FLAG_ANIMATE))
1227 f.put (KW_is_animated, (sint32)0); 1330 f.put (KW_is_animated, (sint32) 0);
1228 } 1331 }
1229 else 1332 else
1230 f.put (KW_animation, (const char *)0); 1333 f.put (KW_animation, (const char *) 0);
1231 1334
1232 CMP_OUT2 (str , stats.Str); 1335 CMP_OUT2 (str, stats.Str);
1233 CMP_OUT2 (dex , stats.Dex); 1336 CMP_OUT2 (dex, stats.Dex);
1234 CMP_OUT2 (con , stats.Con); 1337 CMP_OUT2 (con, stats.Con);
1235 CMP_OUT2 (wis , stats.Wis); 1338 CMP_OUT2 (wis, stats.Wis);
1236 CMP_OUT2 (pow , stats.Pow); 1339 CMP_OUT2 (pow, stats.Pow);
1237 CMP_OUT2 (cha , stats.Cha); 1340 CMP_OUT2 (cha, stats.Cha);
1238 CMP_OUT2 (int , stats.Int); 1341 CMP_OUT2 (int, stats.Int);
1342
1239 CMP_OUT2 (hp , stats.hp); 1343 CMP_OUT2 (hp, stats.hp);
1240 CMP_OUT2 (maxhp , stats.maxhp); 1344 CMP_OUT2 (maxhp, stats.maxhp);
1241 CMP_OUT2 (sp , stats.sp); 1345 CMP_OUT2 (sp, stats.sp);
1242 CMP_OUT2 (maxsp , stats.maxsp); 1346 CMP_OUT2 (maxsp, stats.maxsp);
1243 CMP_OUT2 (grace , stats.grace); 1347 CMP_OUT2 (grace, stats.grace);
1244 CMP_OUT2 (maxgrace, stats.maxgrace); 1348 CMP_OUT2 (maxgrace, stats.maxgrace);
1245 CMP_OUT2 (exp , stats.exp); 1349 CMP_OUT2 (exp, stats.exp);
1246 1350
1247 CMP_OUT (perm_exp); 1351 CMP_OUT (perm_exp);
1248 CMP_OUT (expmul); 1352 CMP_OUT (expmul);
1249 1353
1250 CMP_OUT2 (food , stats.food); 1354 CMP_OUT2 (food, stats.food);
1251 CMP_OUT2 (dam , stats.dam); 1355 CMP_OUT2 (dam, stats.dam);
1252 CMP_OUT2 (luck , stats.luck); 1356 CMP_OUT2 (luck, stats.luck);
1253 CMP_OUT2 (wc , stats.wc); 1357 CMP_OUT2 (wc, stats.wc);
1254 CMP_OUT2 (ac , stats.ac); 1358 CMP_OUT2 (ac, stats.ac);
1255 1359
1256 CMP_OUT (x); 1360 CMP_OUT (x);
1257 CMP_OUT (y); 1361 CMP_OUT (y);
1258 CMP_OUT (speed); 1362 CMP_OUT (speed);
1259 CMP_OUT (speed_left); 1363 CMP_OUT (speed_left);
… …
1265 CMP_OUT (type); 1369 CMP_OUT (type);
1266 CMP_OUT (subtype); 1370 CMP_OUT (subtype);
1267 CMP_OUT (attacktype); 1371 CMP_OUT (attacktype);
1268 1372
1269 for (i = 0; i < NROFATTACKS; i++) 1373 for (i = 0; i < NROFATTACKS; i++)
1270 if (op->resist [i] != tmp->resist [i]) 1374 if (op->resist[i] != tmp->resist[i])
1271 f.put (resist_save [i], op->resist [i]); 1375 f.put (resist_save[i], op->resist[i]);
1272 1376
1273 CMP_OUT (path_attuned); 1377 CMP_OUT (path_attuned);
1274 CMP_OUT (path_repelled); 1378 CMP_OUT (path_repelled);
1275 CMP_OUT (path_denied); 1379 CMP_OUT (path_denied);
1276 CMP_OUT (material); 1380 CMP_OUT (material);
… …
1315 CMP_OUT (move_on); 1419 CMP_OUT (move_on);
1316 CMP_OUT (move_off); 1420 CMP_OUT (move_off);
1317 CMP_OUT (move_slow); 1421 CMP_OUT (move_slow);
1318 CMP_OUT (move_slow_penalty); 1422 CMP_OUT (move_slow_penalty);
1319 1423
1320 if (!COMPARE_FLAGS (op, tmp)) 1424 if (op->flag != tmp->flag)
1321 for (i = 0; i <= NUM_FLAGS; i++) 1425 for (i = 0; i <= NUM_FLAGS; i++)
1322 if (flag_names [i] 1426 if (flag_names [i] && op->flag [i] != tmp->flag [i])
1323 && (QUERY_FLAG (op, i) != QUERY_FLAG (tmp, i)))
1324 f.put (flag_names [i], QUERY_FLAG (op, i) ? "1" : "0"); 1427 f.put (flag_names [i], op->flag [i] ? "1" : "0");
1325 1428
1326 /* Save body locations */ 1429 /* Save body locations */
1327 for (i = 0; i < NUM_BODY_LOCATIONS; i++) 1430 for (i = 0; i < NUM_BODY_LOCATIONS; i++)
1328 if (op->body_info[i] != tmp->body_info[i]) 1431 if (op->body_info[i] != tmp->body_info[i])
1329 f.put (body_locations[i].save_name, op->body_info[i]); 1432 f.put (body_locations[i].save_name, op->body_info[i]);
… …
1331 1434
1332/* 1435/*
1333 * Dumps all variables in an object to a file. 1436 * Dumps all variables in an object to a file.
1334 * If bit 0 of flag is set, unpaid objects will be saved. As of now, 1437 * If bit 0 of flag is set, unpaid objects will be saved. As of now,
1335 * the only place this is not set is when saving the player. 1438 * the only place this is not set is when saving the player.
1336 * If bit 1 of flag is set, don't remove the object after save. As of now,
1337 * all of the callers are setting this.
1338 */ 1439 */
1339
1340void 1440void
1341save_object (object_freezer &fp, object *op, int flag) 1441save_object (object_freezer &fp, object *op, int flag)
1342{ 1442{
1343 archetype *at;
1344 object *tmp, *old;
1345
1346 /* Even if the object does have an owner, it would seem that we should 1443 /* Even if the object does have an owner, it would seem that we should
1347 * still save it. 1444 * still save it.
1348 */ 1445 */
1349 if (op->owner != NULL) 1446 if (op->owner)
1350 return; 1447 return;
1351 1448
1352 /* If it is unpaid and we don't want to save those, just return. */ 1449 /* If it is unpaid and we don't want to save those, just return. */
1353 if (!(flag & 1) && (QUERY_FLAG (op, FLAG_UNPAID))) 1450 if (!(flag & 1) && op->flag [FLAG_UNPAID])
1354 return; 1451 return;
1355 1452
1356 if ((at = op->arch) == NULL) 1453 archetype *at = op->arch ? (archetype *)op->arch : empty_archetype;
1357 at = empty_archetype;
1358 1454
1359 fp.put (KW_arch, at->name); 1455 fp.put (KW_arch, at->name);
1360
1361 put (fp, op, &at->clone); 1456 put (fp, op, &at->clone);
1362 1457
1363 /* Eneq(@csd.uu.se): Added this to allow containers being saved with contents */ 1458 /* Eneq(@csd.uu.se): Added this to allow containers being saved with contents */
1364 1459
1365 old = NULL;
1366
1367 if (flag & 2)
1368 for (tmp = op->inv; tmp != NULL; tmp = tmp->below) 1460 for (object *tmp = op->inv; tmp; tmp = tmp->below)
1369 save_object (fp, tmp, flag); 1461 save_object (fp, tmp, flag);
1370 else
1371 /* Slightly different logic because tmp/op will be removed by
1372 * the save_object we call. So we just keep looking at op->inv
1373 * until there is nothing left. In theory, the variable old
1374 * should not be needed, as recursive loops shouldn't happen.
1375 */
1376 while ((tmp = op->inv) != NULL)
1377 {
1378 if (old == tmp)
1379 {
1380 LOG (llevError, " Recursive loop in inventory\n");
1381 break;
1382 }
1383
1384 save_object (fp, tmp, flag);
1385 old = tmp;
1386 }
1387
1388 if (!(flag & 2))
1389 {
1390 remove_ob (op);
1391 free_object (op);
1392 }
1393 1462
1394 fp.put (op); 1463 fp.put (op);
1395 fprintf (fp, "end\n"); 1464 fp.put (KW_end);
1396} 1465}
1397 1466

Diff Legend

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