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.5 by root, Mon Sep 4 16:46:32 2006 UTC vs.
Revision 1.45 by root, Sun Jan 14 23:15:57 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;
494 object *op_inv = op->inv;
507 495
508 for (;;) 496 for (;;)
509 { 497 {
510 keyword kw = thawer.get_kv (); 498 keyword kw = thawer.get_kv ();
511 499
512 switch (kw) 500 switch (kw)
513 { 501 {
514 case KW_Object: // uppercase alias 502 case KW_Object: // uppercase alias
515 case KW_object: 503 case KW_object:
516 thawer.get (op->name); 504 thawer.get (op->name);
517 505
518 if (op->arch != NULL) 506 if (op->arch)
519 op->arch->name = op->name; 507 op->arch->name = op->name;
520 508
521 break; 509 break;
522 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:
523 case KW_oid: thawer.get (op, thawer.get_sint32 ()); break; 528 thawer.get (op, thawer.get_sint32 ());
529 break;
524 530
525 case KW_name: thawer.get (op->name); break; 531 case KW_name: thawer.get (op->name); break;
526 case KW_name_pl: thawer.get (op->name_pl); break; 532 case KW_name_pl: thawer.get (op->name_pl); break;
527 case KW_title: thawer.get (op->title); break; 533 case KW_title: thawer.get (op->title); break;
528 case KW_custom_name: thawer.get (op->custom_name); break; 534 case KW_custom_name: thawer.get (op->custom_name); break;
535
529 case KW_attach: thawer.get_ornull (op->attach); break; 536 case KW_attach: thawer.get_ornull (op->attach); break;
530 case KW_skill: thawer.get_ornull (op->skill); break; 537 case KW_skill: thawer.get_ornull (op->skill); break;
531 case KW_race: thawer.get_ornull (op->race); break; 538 case KW_race: thawer.get_ornull (op->race); break;
532 case KW_slaying: thawer.get_ornull (op->slaying); break; 539 case KW_slaying: thawer.get_ornull (op->slaying); break;
533 540
534 case KW_arch: 541 case KW_arch:
535 { 542 {
536 const char *str = thawer.get_str (); 543 const char *str = thawer.get_str ();
537 544
… …
539 { 546 {
540 /* If op->arch has been set, then this new object 547 /* If op->arch has been set, then this new object
541 * must be part of the inventory. So process 548 * must be part of the inventory. So process
542 * appropriately. 549 * appropriately.
543 */ 550 */
544 archetype *arch = find_archetype (str); 551 archetype *arch = archetype::find (str);
545 552
546 object *tmp; 553 object *tmp;
547 554
548 if (arch != NULL) 555 if (arch)
549 tmp = arch_to_object (arch); 556 tmp = arch_to_object (arch);
550 else 557 else
551 { 558 {
552 tmp = get_object (); 559 tmp = object::create ();
553 /* record the name of the broken object */ 560 /* record the name of the broken object */
554 tmp->name = str; 561 tmp->name = str;
555 } 562 }
556 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 ();
568
557 parse_object (tmp, thawer, map_flags); 569 parse_object (tmp, thawer, map_flags);
558 570
559 if (tmp->arch) 571 if (tmp->arch)
560 { 572 {
561 // was: insert_ob_in_ob (tmp, op); 573 // was: insert_ob_in_ob (tmp, op);
562 // but manually addint it can improve map loading times a lot 574 // but manually adding it can improve map loading times a lot
563 tmp->env = op; 575 // also, appending instead of prepending keeps the
576 // save ordering the same between repeated load/saves.
577 CLEAR_FLAG (tmp, FLAG_OBJ_ORIGINAL);
578 CLEAR_FLAG (tmp, FLAG_REMOVED);
564 579
565 if (!op->inv) 580 if (!op_inv)
581 {
566 op->inv = tmp; 582 op->inv = tmp;
583 tmp->above = 0;
584 }
567 else 585 else
568 { 586 {
587 while (op_inv->below)
588 op_inv = op_inv->below;
589
590 op_inv->below = tmp;
569 tmp->below = op->inv; 591 tmp->above = op_inv;
570 tmp->below->above = tmp;
571 op->inv = tmp;
572 } 592 }
593
594 tmp->below = 0;
595 tmp->env = op;
596 op_inv = tmp;
573 } 597 }
574 else 598 else
575 { 599 {
576 LOG (llevDebug, "Discarding object without arch: %s\n", 600 LOG (llevDebug, "Discarding object without arch: %s\n", tmp->name ? (const char *) tmp->name : "(null)");
577 tmp->name ? (const char *) tmp->name : "(null)"); 601 tmp->destroy ();
578 free_object (tmp);
579 } 602 }
580 } 603 }
581 else 604 else
582 { 605 {
583 /* This is the actual archetype definition then */ 606 /* This is the actual archetype definition then */
584 op->arch = find_archetype (str); 607 op->arch = archetype::find (str);
585 608
586 if (op->arch != NULL) 609 if (op->arch)
587 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 }
588 else if (!arch_init) 615 else if (!arch_init)
589 /* record the name of the broken object */ 616 /* record the name of the broken object */
590 op->name = str; 617 op->name = str;
591 } 618 }
592 } 619 }
593 break; 620 break;
594 621
595 case KW_other_arch: 622 case KW_other_arch:
596 op->other_arch = find_archetype (thawer.get_str ()); 623 op->other_arch = archetype::find (thawer.get_str ());
597 break; 624 break;
598 625
599 case KW_animation: 626 case KW_animation:
600 { 627 {
601 const char *str = thawer.get_str (); 628 const char *str = thawer.get_str ();
602 629
603 if (!str) 630 if (!str)
604 { 631 {
605 op->animation_id = 0; 632 op->animation_id = 0;
606 CLEAR_FLAG (op, FLAG_ANIMATE); 633 CLEAR_FLAG (op, FLAG_ANIMATE);
607 } 634 }
608 else
609 {
610 op->animation_id = find_animation (str); 635 else if ((op->animation_id = find_animation (str)))
611 SET_FLAG (op, FLAG_ANIMATE); 636 SET_FLAG (op, FLAG_ANIMATE);
612 }
613 } 637 }
614 638
615 break; 639 break;
616 640
617 case KW_last_heal: thawer.get (op->last_heal); break; 641 case KW_last_heal: thawer.get (op->last_heal); break;
618 case KW_last_sp: thawer.get (op->last_sp); break; 642 case KW_last_sp: thawer.get (op->last_sp); break;
619 case KW_last_grace: thawer.get (op->last_grace); break; 643 case KW_last_grace: thawer.get (op->last_grace); break;
620 case KW_last_eat: thawer.get (op->last_eat); break; 644 case KW_last_eat: thawer.get (op->last_eat); break;
621 case KW_speed_left: thawer.get (op->speed_left); break; 645 case KW_speed_left: thawer.get (op->speed_left); break;
622 646
623 case KW_speed: 647 case KW_speed:
624 thawer.get (op->speed); 648 thawer.get (op->speed);
625 649
626 //TODO: maybe do in check_object 650 //TODO: maybe do in check_object
627 if (!(map_flags & MAP_STYLE)) 651 // removed check for style maps
628 {
629 if (op->speed < 0) 652 if (op->speed < 0)
630 op->speed_left = op->speed_left - RANDOM () % 100 / 100.0; 653 op->speed_left = op->speed_left - RANDOM () % 100 / 100.0;
631
632 update_ob_speed (op);
633 }
634 654
635 break; 655 break;
636 656
637 case KW_slow_move: 657 case KW_slow_move:
638 op->move_slow |= MOVE_WALK; 658 op->move_slow |= MOVE_WALK;
639 thawer.get (op->move_slow_penalty); 659 thawer.get (op->move_slow_penalty);
640 break; 660 break;
641 661
642 case KW_face: 662 case KW_face:
643 if (const char *str = thawer.get_str ())
644 op->face = &new_faces[FindFace (str, 0)]; 663 op->face = &new_faces[FindFace (thawer.get_str (), 0)];
645 else 664 break;
646 op->face = 0;
647 break;
648 665
649 case KW_x: thawer.get (op->x); break; 666 case KW_x: thawer.get (op->x); break;
650 case KW_y: thawer.get (op->y); break; 667 case KW_y: thawer.get (op->y); break;
668
651 case KW_Str: // uppercase alias 669 case KW_Str: // uppercase alias
652 case KW_str: thawer.get (op->stats.Str); break; 670 case KW_str: thawer.get (op->stats.Str); break;
653 case KW_Dex: // uppercase alias 671 case KW_Dex: // uppercase alias
654 case KW_dex: thawer.get (op->stats.Dex); break; 672 case KW_dex: thawer.get (op->stats.Dex); break;
655 case KW_Con: // uppercase alias 673 case KW_Con: // uppercase alias
656 case KW_con: thawer.get (op->stats.Con); break; 674 case KW_con: thawer.get (op->stats.Con); break;
657 case KW_Wis: // uppercase alias 675 case KW_Wis: // uppercase alias
658 case KW_wis: thawer.get (op->stats.Wis); break; 676 case KW_wis: thawer.get (op->stats.Wis); break;
659 case KW_Cha: // uppercase alias 677 case KW_Cha: // uppercase alias
660 case KW_cha: thawer.get (op->stats.Cha); break; 678 case KW_cha: thawer.get (op->stats.Cha); break;
661 case KW_Int: // uppercase alias 679 case KW_Int: // uppercase alias
662 case KW_int: thawer.get (op->stats.Int); break; 680 case KW_int: thawer.get (op->stats.Int); break;
663 case KW_Pow: // uppercase alias 681 case KW_Pow: // uppercase alias
664 case KW_pow: thawer.get (op->stats.Pow); break; 682 case KW_pow: thawer.get (op->stats.Pow); break;
683
665 case KW_hp: thawer.get (op->stats.hp); break; 684 case KW_hp: thawer.get (op->stats.hp); break;
666 case KW_maxhp: thawer.get (op->stats.maxhp); break; 685 case KW_maxhp: thawer.get (op->stats.maxhp); break;
667 case KW_sp: thawer.get (op->stats.sp); break; 686 case KW_sp: thawer.get (op->stats.sp); break;
668 case KW_maxsp: thawer.get (op->stats.maxsp); break; 687 case KW_maxsp: thawer.get (op->stats.maxsp); break;
669 case KW_grace: thawer.get (op->stats.grace); break; 688 case KW_grace: thawer.get (op->stats.grace); break;
670 case KW_maxgrace: thawer.get (op->stats.maxgrace); break; 689 case KW_maxgrace: thawer.get (op->stats.maxgrace); break;
671 690
672 case KW_exp: thawer.get (op->stats.exp); break; 691 case KW_exp: thawer.get (op->stats.exp); break;
673 case KW_perm_exp: thawer.get (op->perm_exp); break; 692 case KW_perm_exp: thawer.get (op->perm_exp); break;
674 case KW_food: thawer.get (op->stats.food); break; 693 case KW_food: thawer.get (op->stats.food); break;
675 case KW_dam: thawer.get (op->stats.dam); break; 694 case KW_dam: thawer.get (op->stats.dam); break;
676 case KW_wc: thawer.get (op->stats.wc); break; 695 case KW_wc: thawer.get (op->stats.wc); break;
677 case KW_ac: thawer.get (op->stats.ac); break; 696 case KW_ac: thawer.get (op->stats.ac); break;
678 case KW_nrof: thawer.get (op->nrof); break; 697 case KW_nrof: thawer.get (op->nrof); break;
679 case KW_level: thawer.get (op->level); break; 698 case KW_level: thawer.get (op->level); break;
680 case KW_direction: thawer.get (op->direction); break; 699 case KW_direction: thawer.get (op->direction); break;
681 case KW_type: thawer.get (op->type); break; 700 case KW_type: thawer.get (op->type); break;
682 case KW_subtype: thawer.get (op->subtype); break; 701 case KW_subtype: thawer.get (op->subtype); break;
683 case KW_value: thawer.get (op->value); break; 702 case KW_value: thawer.get (op->value); break;
684 case KW_weight: thawer.get (op->weight); break; 703 case KW_weight: thawer.get (op->weight); break;
685 case KW_carrying: thawer.get (op->carrying); break; 704 case KW_carrying: thawer.get (op->carrying); break;
686 case KW_attacktype: thawer.get (op->attacktype); break; 705 case KW_attacktype: thawer.get (op->attacktype); break;
687 case KW_path_attuned: thawer.get (op->path_attuned); break; 706 case KW_path_attuned: thawer.get (op->path_attuned); break;
688 case KW_path_repelled: thawer.get (op->path_repelled); break; 707 case KW_path_repelled: thawer.get (op->path_repelled); break;
689 case KW_path_denied: thawer.get (op->path_denied); break; 708 case KW_path_denied: thawer.get (op->path_denied); break;
690 case KW_invisible: thawer.get (op->invisible); break; 709 case KW_invisible: thawer.get (op->invisible); break;
691 case KW_magic: thawer.get (op->magic); break; 710 case KW_magic: thawer.get (op->magic); break;
692 case KW_state: thawer.get (op->state); break; 711 case KW_state: thawer.get (op->state); break;
693 case KW_move_slow_penalty:thawer.get (op->move_slow_penalty); break; 712 case KW_move_slow_penalty: thawer.get (op->move_slow_penalty); break;
694 case KW_material: thawer.get (op->material); break; 713 case KW_material: thawer.get (op->material); break;
695 case KW_materialname: thawer.get (op->materialname); break; 714 case KW_materialname: thawer.get (op->materialname); break;
696 715
697 /* These are the new values */ 716 /* These are the new values */
698 case KW_move_block: set_move (op->move_block, thawer.get_str ()); break; 717 case KW_move_block: set_move (op->move_block, thawer.get_str ()); break;
699 case KW_move_allow: set_move (op->move_allow, thawer.get_str ()); break; 718 case KW_move_allow: set_move (op->move_allow, thawer.get_str ()); break;
700 case KW_move_type: set_move (op->move_type, thawer.get_str ()); break; 719 case KW_move_type: set_move (op->move_type, thawer.get_str ()); break;
701 case KW_move_on: set_move (op->move_on, thawer.get_str ()); break; 720 case KW_move_on: set_move (op->move_on, thawer.get_str ()); break;
702 case KW_move_off: set_move (op->move_off, thawer.get_str ()); break; 721 case KW_move_off: set_move (op->move_off, thawer.get_str ()); break;
703 case KW_move_slow: set_move (op->move_slow, thawer.get_str ()); break; 722 case KW_move_slow: set_move (op->move_slow, thawer.get_str ()); break;
704 723
705 /* These are all legacy - any new objects should use the move_ .. values */ 724 /* These are all legacy - any new objects should use the move_ .. values */
706 case KW_no_pass: 725 case KW_no_pass:
707 { 726 {
708 if (thawer.get_sint32 ()) 727 if (thawer.get_sint32 ())
709 op->move_block = MOVE_ALL; 728 op->move_block = MOVE_ALL;
710 else 729 else
711 op->move_block = 0; 730 op->move_block = 0;
712 } 731 }
713 732
714 break; 733 break;
715 734
716 /* These are all legacy - any new objects should use the move_ .. values */ 735 /* These are all legacy - any new objects should use the move_ .. values */
717 case KW_walk_on: 736 case KW_walk_on:
718 { 737 {
719 if (thawer.get_sint32 ()) 738 if (thawer.get_sint32 ())
720 op->move_on |= MOVE_WALK; 739 op->move_on |= MOVE_WALK;
721 else 740 else
722 op->move_on &= ~MOVE_WALK; 741 op->move_on &= ~MOVE_WALK;
723 } 742 }
724 743
725 break; 744 break;
726 745
727 /* These are all legacy - any new objects should use the move_ .. values */ 746 /* These are all legacy - any new objects should use the move_ .. values */
728 case KW_walk_off: 747 case KW_walk_off:
729 { 748 {
730 if (thawer.get_sint32 ()) 749 if (thawer.get_sint32 ())
731 op->move_off |= MOVE_WALK; 750 op->move_off |= MOVE_WALK;
732 else 751 else
733 op->move_off &= ~MOVE_WALK; 752 op->move_off &= ~MOVE_WALK;
734 } 753 }
735 break; 754 break;
736 755
737 /* These are all legacy - any new objects should use the move_ .. values */ 756 /* These are all legacy - any new objects should use the move_ .. values */
738 case KW_fly_on: 757 case KW_fly_on:
739 { 758 {
740 if (thawer.get_sint32 ()) 759 if (thawer.get_sint32 ())
741 op->move_on |= MOVE_FLY_LOW; 760 op->move_on |= MOVE_FLY_LOW;
742 else 761 else
743 op->move_on &= ~MOVE_FLY_LOW; 762 op->move_on &= ~MOVE_FLY_LOW;
744 } 763 }
745 break; 764 break;
746 765
747 /* These are all legacy - any new objects should use the move_ .. values */ 766 /* These are all legacy - any new objects should use the move_ .. values */
748 case KW_fly_off: 767 case KW_fly_off:
749 { 768 {
750 if (thawer.get_sint32 ()) 769 if (thawer.get_sint32 ())
751 op->move_off |= MOVE_FLY_LOW; 770 op->move_off |= MOVE_FLY_LOW;
752 else 771 else
753 op->move_off &= ~MOVE_FLY_LOW; 772 op->move_off &= ~MOVE_FLY_LOW;
754 } 773 }
755 break; 774 break;
756 775
757 //TODO: remove these after convertign archetypes 776 //TODO: remove these after converting archetypes
758 case KW_can_use_wand: GET_FLAG (op, FLAG_USE_RANGE); break; 777 case KW_can_use_wand:
778 GET_FLAG (op, FLAG_USE_RANGE);
779 break;
759 780
760 /* These are all legacy - any new objects should use the move_ .. values */ 781 /* These are all legacy - any new objects should use the move_ .. values */
761 case KW_flying: 782 case KW_flying:
762 { 783 {
763 if (thawer.get_sint32 ()) 784 if (thawer.get_sint32 ())
764 op->move_type |= MOVE_FLY_LOW; 785 op->move_type |= MOVE_FLY_LOW;
765 else 786 else
… …
791 CLEAR_FLAG (op, FLAG_WIZCAST); 812 CLEAR_FLAG (op, FLAG_WIZCAST);
792 } 813 }
793 break; 814 break;
794 815
795 case KW_friendly: 816 case KW_friendly:
796 GET_FLAG (op, FLAG_FRIENDLY); 817 if (thawer.get_sint32 ())
797 //TODO: move to check_object or so 818 if (op->type != PLAYER)
798 if (op->type != PLAYER && QUERY_FLAG (op, FLAG_FRIENDLY))
799 add_friendly_object (op); 819 add_friendly_object (op);
800 break;
801 820
821 break;
822
802 case KW_monster: GET_FLAG (op, FLAG_MONSTER); break; 823 case KW_monster: GET_FLAG (op, FLAG_MONSTER); break;
803 case KW_neutral: GET_FLAG (op, FLAG_NEUTRAL); break; 824 case KW_neutral: GET_FLAG (op, FLAG_NEUTRAL); break;
804 case KW_no_attack: GET_FLAG (op, FLAG_NO_ATTACK); break; 825 case KW_no_attack: GET_FLAG (op, FLAG_NO_ATTACK); break;
805 case KW_no_damage: GET_FLAG (op, FLAG_NO_DAMAGE); break; 826 case KW_no_damage: GET_FLAG (op, FLAG_NO_DAMAGE); break;
827 case KW_obj_original: GET_FLAG (op, FLAG_OBJ_ORIGINAL); break;
806 case KW_generator: GET_FLAG (op, FLAG_GENERATOR); break; 828 case KW_generator: GET_FLAG (op, FLAG_GENERATOR); break;
807 case KW_use_content_on_gen: GET_FLAG (op, FLAG_CONTENT_ON_GEN); break; 829 case KW_use_content_on_gen: GET_FLAG (op, FLAG_CONTENT_ON_GEN); break;
808 case KW_is_thrown: GET_FLAG (op, FLAG_IS_THROWN); break; 830 case KW_is_thrown: GET_FLAG (op, FLAG_IS_THROWN); break;
809 case KW_auto_apply: GET_FLAG (op, FLAG_AUTO_APPLY); break; 831 case KW_auto_apply: GET_FLAG (op, FLAG_AUTO_APPLY); break;
810 case KW_treasure: GET_FLAG (op, FLAG_TREASURE); break;
811 case KW_see_invisible: GET_FLAG (op, FLAG_SEE_INVISIBLE); break; 832 case KW_see_invisible: GET_FLAG (op, FLAG_SEE_INVISIBLE); break;
812 case KW_can_roll: GET_FLAG (op, FLAG_CAN_ROLL); break; 833 case KW_can_roll: GET_FLAG (op, FLAG_CAN_ROLL); break;
813 case KW_overlay_floor: GET_FLAG (op, FLAG_OVERLAY_FLOOR); break; 834 case KW_overlay_floor: GET_FLAG (op, FLAG_OVERLAY_FLOOR); break;
814 case KW_is_turnable: GET_FLAG (op, FLAG_IS_TURNABLE); break; 835 case KW_is_turnable: GET_FLAG (op, FLAG_IS_TURNABLE); break;
815 case KW_is_used_up: GET_FLAG (op, FLAG_IS_USED_UP); break; 836 case KW_is_used_up: GET_FLAG (op, FLAG_IS_USED_UP); break;
816 case KW_alive: GET_FLAG (op, FLAG_ALIVE); break; 837 case KW_alive: GET_FLAG (op, FLAG_ALIVE); break;
817 case KW_applied: GET_FLAG (op, FLAG_APPLIED); break; 838 case KW_applied: GET_FLAG (op, FLAG_APPLIED); break;
818 case KW_unpaid: GET_FLAG (op, FLAG_UNPAID); break; 839 case KW_unpaid: GET_FLAG (op, FLAG_UNPAID); break;
819 case KW_is_animated: GET_FLAG (op, FLAG_ANIMATE); break; 840 case KW_is_animated: GET_FLAG (op, FLAG_ANIMATE); break;
820 case KW_no_pick: GET_FLAG (op, FLAG_NO_PICK); break; 841 case KW_no_pick: GET_FLAG (op, FLAG_NO_PICK); break;
821 case KW_reflecting: GET_FLAG (op, FLAG_REFLECTING); break; 842 case KW_reflecting: GET_FLAG (op, FLAG_REFLECTING); break;
822 case KW_changing: GET_FLAG (op, FLAG_CHANGING); break; 843 case KW_changing: GET_FLAG (op, FLAG_CHANGING); break;
823 case KW_splitting: GET_FLAG (op, FLAG_SPLITTING); break; 844 case KW_splitting: GET_FLAG (op, FLAG_SPLITTING); break;
824 case KW_hitback: GET_FLAG (op, FLAG_HITBACK); break; 845 case KW_hitback: GET_FLAG (op, FLAG_HITBACK); break;
825 case KW_startequip: GET_FLAG (op, FLAG_STARTEQUIP); break; 846 case KW_startequip: GET_FLAG (op, FLAG_STARTEQUIP); break;
826 case KW_blocksview: GET_FLAG (op, FLAG_BLOCKSVIEW); break; 847 case KW_blocksview: GET_FLAG (op, FLAG_BLOCKSVIEW); break;
827 case KW_undead: GET_FLAG (op, FLAG_UNDEAD); break; 848 case KW_undead: GET_FLAG (op, FLAG_UNDEAD); break;
828 case KW_scared: GET_FLAG (op, FLAG_SCARED); break; 849 case KW_scared: GET_FLAG (op, FLAG_SCARED); break;
829 case KW_unaggressive: GET_FLAG (op, FLAG_UNAGGRESSIVE); break; 850 case KW_unaggressive: GET_FLAG (op, FLAG_UNAGGRESSIVE); break;
830 case KW_reflect_missile: GET_FLAG (op, FLAG_REFL_MISSILE); break; 851 case KW_reflect_missile: GET_FLAG (op, FLAG_REFL_MISSILE); break;
831 case KW_reflect_spell: GET_FLAG (op, FLAG_REFL_SPELL); break; 852 case KW_reflect_spell: GET_FLAG (op, FLAG_REFL_SPELL); break;
832 case KW_no_magic: GET_FLAG (op, FLAG_NO_MAGIC); break; 853 case KW_no_magic: GET_FLAG (op, FLAG_NO_MAGIC); break;
833 case KW_no_drop: GET_FLAG (op, FLAG_NO_DROP); break; 854 case KW_no_drop: GET_FLAG (op, FLAG_NO_DROP); break;
834 case KW_random_movement: GET_FLAG (op, FLAG_RANDOM_MOVE); break; 855 case KW_random_movement: GET_FLAG (op, FLAG_RANDOM_MOVE); break;
835 case KW_was_wiz: GET_FLAG (op, FLAG_WAS_WIZ); break; 856 case KW_was_wiz: GET_FLAG (op, FLAG_WAS_WIZ); break;
836 case KW_no_fix_player: GET_FLAG (op, FLAG_NO_FIX_PLAYER); break; 857 case KW_no_fix_player: GET_FLAG (op, FLAG_NO_FIX_PLAYER); break;
837 case KW_is_lightable: GET_FLAG (op, FLAG_IS_LIGHTABLE); break; 858 case KW_is_lightable: GET_FLAG (op, FLAG_IS_LIGHTABLE); break;
838 case KW_tear_down: GET_FLAG (op, FLAG_TEAR_DOWN); break; 859 case KW_tear_down: GET_FLAG (op, FLAG_TEAR_DOWN); break;
839 case KW_can_use_shield: GET_FLAG (op, FLAG_USE_SHIELD); break; 860 case KW_can_use_shield: GET_FLAG (op, FLAG_USE_SHIELD); break;
840 case KW_can_cast_spell: GET_FLAG (op, FLAG_CAST_SPELL); break; 861 case KW_can_cast_spell: GET_FLAG (op, FLAG_CAST_SPELL); break;
841 case KW_can_use_scroll: GET_FLAG (op, FLAG_USE_SCROLL); break; 862 case KW_can_use_scroll: GET_FLAG (op, FLAG_USE_SCROLL); break;
842 case KW_can_use_range: GET_FLAG (op, FLAG_USE_RANGE); break; 863 case KW_can_use_range: GET_FLAG (op, FLAG_USE_RANGE); break;
843 case KW_can_use_bow: GET_FLAG (op, FLAG_USE_BOW); break; 864 case KW_can_use_bow: GET_FLAG (op, FLAG_USE_BOW); break;
844 case KW_can_use_armour: GET_FLAG (op, FLAG_USE_ARMOUR); break; 865 case KW_can_use_armour: GET_FLAG (op, FLAG_USE_ARMOUR); break;
845 case KW_can_use_weapon: GET_FLAG (op, FLAG_USE_WEAPON); break; 866 case KW_can_use_weapon: GET_FLAG (op, FLAG_USE_WEAPON); break;
846 case KW_can_use_ring: GET_FLAG (op, FLAG_USE_RING); break; 867 case KW_can_use_ring: GET_FLAG (op, FLAG_USE_RING); break;
847 case KW_has_ready_bow: GET_FLAG (op, FLAG_READY_BOW); break; 868 case KW_has_ready_bow: GET_FLAG (op, FLAG_READY_BOW); break;
869 case KW_has_ready_range: GET_FLAG (op, FLAG_READY_RANGE); break;
848 case KW_xrays: GET_FLAG (op, FLAG_XRAYS); break; 870 case KW_xrays: GET_FLAG (op, FLAG_XRAYS); break;
849 case KW_is_floor: GET_FLAG (op, FLAG_IS_FLOOR); break; 871 case KW_is_floor: GET_FLAG (op, FLAG_IS_FLOOR); break;
850 case KW_lifesave: GET_FLAG (op, FLAG_LIFESAVE); break; 872 case KW_lifesave: GET_FLAG (op, FLAG_LIFESAVE); break;
851 case KW_no_strength: GET_FLAG (op, FLAG_NO_STRENGTH); break; 873 case KW_no_strength: GET_FLAG (op, FLAG_NO_STRENGTH); break;
852 case KW_sleep: GET_FLAG (op, FLAG_SLEEP); break; 874 case KW_sleep: GET_FLAG (op, FLAG_SLEEP); break;
853 case KW_stand_still: GET_FLAG (op, FLAG_STAND_STILL); break; 875 case KW_stand_still: GET_FLAG (op, FLAG_STAND_STILL); break;
854 case KW_random_move: GET_FLAG (op, FLAG_RANDOM_MOVE); break; 876 case KW_random_move: GET_FLAG (op, FLAG_RANDOM_MOVE); break;
855 case KW_only_attack: GET_FLAG (op, FLAG_ONLY_ATTACK); break; 877 case KW_only_attack: GET_FLAG (op, FLAG_ONLY_ATTACK); break;
856 case KW_activate_on_push: GET_FLAG (op, FLAG_ACTIVATE_ON_PUSH); break; 878 case KW_activate_on_push: GET_FLAG (op, FLAG_ACTIVATE_ON_PUSH); break;
857 case KW_activate_on_release: GET_FLAG (op, FLAG_ACTIVATE_ON_RELEASE); break; 879 case KW_activate_on_release: GET_FLAG (op, FLAG_ACTIVATE_ON_RELEASE); break;
858 case KW_confused: GET_FLAG (op, FLAG_CONFUSED); break; 880 case KW_confused: GET_FLAG (op, FLAG_CONFUSED); break;
859 case KW_stealth: GET_FLAG (op, FLAG_STEALTH); break; 881 case KW_stealth: GET_FLAG (op, FLAG_STEALTH); break;
860 case KW_cursed: GET_FLAG (op, FLAG_CURSED); break; 882 case KW_cursed: GET_FLAG (op, FLAG_CURSED); break;
861 case KW_damned: GET_FLAG (op, FLAG_DAMNED); break; 883 case KW_damned: GET_FLAG (op, FLAG_DAMNED); break;
862 case KW_see_anywhere: GET_FLAG (op, FLAG_SEE_ANYWHERE); break; 884 case KW_see_anywhere: GET_FLAG (op, FLAG_SEE_ANYWHERE); break;
863 case KW_known_magical: GET_FLAG (op, FLAG_KNOWN_MAGICAL); break; 885 case KW_known_magical: GET_FLAG (op, FLAG_KNOWN_MAGICAL); break;
864 case KW_known_cursed: GET_FLAG (op, FLAG_KNOWN_CURSED); break; 886 case KW_known_cursed: GET_FLAG (op, FLAG_KNOWN_CURSED); break;
865 case KW_can_use_skill: GET_FLAG (op, FLAG_CAN_USE_SKILL); break; 887 case KW_can_use_skill: GET_FLAG (op, FLAG_CAN_USE_SKILL); break;
866 case KW_been_applied: GET_FLAG (op, FLAG_BEEN_APPLIED); break; 888 case KW_been_applied: GET_FLAG (op, FLAG_BEEN_APPLIED); break;
867 case KW_has_ready_scroll: GET_FLAG (op, FLAG_READY_SCROLL); break; 889 case KW_has_ready_scroll: GET_FLAG (op, FLAG_READY_SCROLL); break;
868 case KW_can_use_rod: GET_FLAG (op, FLAG_USE_ROD); break; 890 case KW_can_use_rod: GET_FLAG (op, FLAG_USE_ROD); break;
869 case KW_can_use_horn: GET_FLAG (op, FLAG_USE_HORN); break; 891 case KW_can_use_horn: GET_FLAG (op, FLAG_USE_HORN); break;
870 case KW_unique: GET_FLAG (op, FLAG_UNIQUE); break; 892 case KW_unique: GET_FLAG (op, FLAG_UNIQUE); break;
871 case KW_make_invisible: GET_FLAG (op, FLAG_MAKE_INVIS); break; 893 case KW_make_invisible: GET_FLAG (op, FLAG_MAKE_INVIS); break;
872 case KW_inv_locked: GET_FLAG (op, FLAG_INV_LOCKED); break; 894 case KW_inv_locked: GET_FLAG (op, FLAG_INV_LOCKED); break;
873 case KW_is_wooded: GET_FLAG (op, FLAG_IS_WOODED); break; 895 case KW_is_wooded: GET_FLAG (op, FLAG_IS_WOODED); break;
874 case KW_is_hilly: GET_FLAG (op, FLAG_IS_HILLY); break; 896 case KW_is_hilly: GET_FLAG (op, FLAG_IS_HILLY); break;
875 case KW_is_water: GET_FLAG (op, FLAG_IS_WATER); break; 897 case KW_is_water: GET_FLAG (op, FLAG_IS_WATER); break;
876 case KW_has_ready_skill: GET_FLAG (op, FLAG_READY_SKILL); break; 898 case KW_has_ready_skill: GET_FLAG (op, FLAG_READY_SKILL); break;
877 case KW_has_ready_weapon: GET_FLAG (op, FLAG_READY_WEAPON); break; 899 case KW_has_ready_weapon: GET_FLAG (op, FLAG_READY_WEAPON); break;
878 case KW_no_skill_ident: GET_FLAG (op, FLAG_NO_SKILL_IDENT); break; 900 case KW_no_skill_ident: GET_FLAG (op, FLAG_NO_SKILL_IDENT); break;
879 case KW_is_blind: GET_FLAG (op, FLAG_BLIND); break; 901 case KW_is_blind: GET_FLAG (op, FLAG_BLIND); break;
880 case KW_can_see_in_dark: GET_FLAG (op, FLAG_SEE_IN_DARK); break; 902 case KW_can_see_in_dark: GET_FLAG (op, FLAG_SEE_IN_DARK); break;
881 case KW_is_cauldron: GET_FLAG (op, FLAG_IS_CAULDRON); break; 903 case KW_is_cauldron: GET_FLAG (op, FLAG_IS_CAULDRON); break;
882 case KW_no_steal: GET_FLAG (op, FLAG_NO_STEAL); break; 904 case KW_no_steal: GET_FLAG (op, FLAG_NO_STEAL); break;
883 case KW_one_hit: GET_FLAG (op, FLAG_ONE_HIT); break; 905 case KW_one_hit: GET_FLAG (op, FLAG_ONE_HIT); break;
884 case KW_berserk: GET_FLAG (op, FLAG_BERSERK); break; 906 case KW_berserk: GET_FLAG (op, FLAG_BERSERK); break;
885 case KW_is_buildable: GET_FLAG (op, FLAG_IS_BUILDABLE); break; 907 case KW_is_buildable: GET_FLAG (op, FLAG_IS_BUILDABLE); break;
908 case KW_destroy_on_death: GET_FLAG (op, FLAG_DESTROY_ON_DEATH); break;
886 909
887 case KW_armour: thawer.get (op->resist [ATNR_PHYSICAL]); break; 910 case KW_armour: thawer.get (op->resist[ATNR_PHYSICAL]); break;
888 case KW_resist_physical: thawer.get (op->resist [ATNR_PHYSICAL]); break; 911 case KW_resist_physical: thawer.get (op->resist[ATNR_PHYSICAL]); break;
889 case KW_resist_magic: thawer.get (op->resist [ATNR_MAGIC]); break; 912 case KW_resist_magic: thawer.get (op->resist[ATNR_MAGIC]); break;
890 case KW_resist_fire: thawer.get (op->resist [ATNR_FIRE]); break; 913 case KW_resist_fire: thawer.get (op->resist[ATNR_FIRE]); break;
891 case KW_resist_electricity: thawer.get (op->resist [ATNR_ELECTRICITY]); break; 914 case KW_resist_electricity: thawer.get (op->resist[ATNR_ELECTRICITY]); break;
892 case KW_resist_cold: thawer.get (op->resist [ATNR_COLD]); break; 915 case KW_resist_cold: thawer.get (op->resist[ATNR_COLD]); break;
893 case KW_resist_confusion: thawer.get (op->resist [ATNR_CONFUSION]); break; 916 case KW_resist_confusion: thawer.get (op->resist[ATNR_CONFUSION]); break;
894 case KW_resist_acid: thawer.get (op->resist [ATNR_ACID]); break; 917 case KW_resist_acid: thawer.get (op->resist[ATNR_ACID]); break;
895 case KW_resist_drain: thawer.get (op->resist [ATNR_DRAIN]); break; 918 case KW_resist_drain: thawer.get (op->resist[ATNR_DRAIN]); break;
896 case KW_resist_weaponmagic: thawer.get (op->resist [ATNR_WEAPONMAGIC]); break; 919 case KW_resist_weaponmagic: thawer.get (op->resist[ATNR_WEAPONMAGIC]); break;
897 case KW_resist_ghosthit: thawer.get (op->resist [ATNR_GHOSTHIT]); break; 920 case KW_resist_ghosthit: thawer.get (op->resist[ATNR_GHOSTHIT]); break;
898 case KW_resist_poison: thawer.get (op->resist [ATNR_POISON]); break; 921 case KW_resist_poison: thawer.get (op->resist[ATNR_POISON]); break;
899 case KW_resist_slow: thawer.get (op->resist [ATNR_SLOW]); break; 922 case KW_resist_slow: thawer.get (op->resist[ATNR_SLOW]); break;
900 case KW_resist_paralyze: thawer.get (op->resist [ATNR_PARALYZE]); break; 923 case KW_resist_paralyze: thawer.get (op->resist[ATNR_PARALYZE]); break;
901 case KW_resist_turn_undead: thawer.get (op->resist [ATNR_TURN_UNDEAD]); break; 924 case KW_resist_turn_undead: thawer.get (op->resist[ATNR_TURN_UNDEAD]); break;
902 case KW_resist_fear: thawer.get (op->resist [ATNR_FEAR]); break; 925 case KW_resist_fear: thawer.get (op->resist[ATNR_FEAR]); break;
903 case KW_resist_cancellation: thawer.get (op->resist [ATNR_CANCELLATION]); break; 926 case KW_resist_cancellation: thawer.get (op->resist[ATNR_CANCELLATION]); break;
904 case KW_resist_deplete: thawer.get (op->resist [ATNR_DEPLETE]); break; 927 case KW_resist_deplete: thawer.get (op->resist[ATNR_DEPLETE]); break;
905 case KW_resist_death: thawer.get (op->resist [ATNR_DEATH]); break; 928 case KW_resist_death: thawer.get (op->resist[ATNR_DEATH]); break;
906 case KW_resist_chaos: thawer.get (op->resist [ATNR_CHAOS]); break; 929 case KW_resist_chaos: thawer.get (op->resist[ATNR_CHAOS]); break;
907 case KW_resist_counterspell: thawer.get (op->resist [ATNR_COUNTERSPELL]); break; 930 case KW_resist_counterspell: thawer.get (op->resist[ATNR_COUNTERSPELL]); break;
908 case KW_resist_godpower: thawer.get (op->resist [ATNR_GODPOWER]); break; 931 case KW_resist_godpower: thawer.get (op->resist[ATNR_GODPOWER]); break;
909 case KW_resist_holyword: thawer.get (op->resist [ATNR_HOLYWORD]); break; 932 case KW_resist_holyword: thawer.get (op->resist[ATNR_HOLYWORD]); break;
910 case KW_resist_blind: thawer.get (op->resist [ATNR_BLIND]); break; 933 case KW_resist_blind: thawer.get (op->resist[ATNR_BLIND]); break;
911 case KW_resist_internal: thawer.get (op->resist [ATNR_INTERNAL]); break; 934 case KW_resist_internal: thawer.get (op->resist[ATNR_INTERNAL]); break;
912 case KW_resist_life_stealing: thawer.get (op->resist [ATNR_LIFE_STEALING]); break; 935 case KW_resist_life_stealing: thawer.get (op->resist[ATNR_LIFE_STEALING]); break;
913 case KW_resist_disease: thawer.get (op->resist [ATNR_DISEASE]); break; 936 case KW_resist_disease: thawer.get (op->resist[ATNR_DISEASE]); break;
914 937
915 case KW_luck: thawer.get (op->stats.luck); break; 938 case KW_luck: thawer.get (op->stats.luck); break;
916 case KW_run_away: thawer.get (op->run_away); break; 939 case KW_run_away: thawer.get (op->run_away); break;
917 case KW_pick_up: thawer.get (op->pick_up); break; 940 case KW_pick_up: thawer.get (op->pick_up); break;
918 case KW_item_power: thawer.get (op->item_power); break; 941 case KW_item_power: thawer.get (op->item_power); break;
919 case KW_gen_sp_armour: thawer.get (op->gen_sp_armour); break; 942 case KW_gen_sp_armour: thawer.get (op->gen_sp_armour); break;
920 case KW_anim_speed: thawer.get (op->anim_speed); break; 943 case KW_anim_speed: thawer.get (op->anim_speed); break;
921 case KW_container: thawer.get (op->weight_limit); break; 944 case KW_container: thawer.get (op->weight_limit); break;
922 case KW_will_apply: thawer.get (op->will_apply); break; 945 case KW_will_apply: thawer.get (op->will_apply); break;
923 case KW_attack_movement: thawer.get (op->attack_movement); break; 946 case KW_attack_movement: thawer.get (op->attack_movement); break;
924 case KW_move_state: thawer.get (op->move_status); break; 947 case KW_move_state: thawer.get (op->move_status); break;
925 case KW_expmul: thawer.get (op->expmul); break; 948 case KW_expmul: thawer.get (op->expmul); break;
926 case KW_glow_radius: thawer.get (op->glow_radius); break; 949 case KW_glow_radius: thawer.get (op->glow_radius); break;
927 case KW_weapontype: thawer.get (op->weapontype); break; 950 case KW_weapontype: thawer.get (op->weapontype); break;
928 case KW_tooltype: thawer.get (op->tooltype); break; 951 case KW_tooltype: thawer.get (op->tooltype); break;
929 case KW_casting_time: thawer.get (op->casting_time); break; 952 case KW_casting_time: thawer.get (op->casting_time); break;
930 case KW_elevation: thawer.get (op->elevation); break; 953 case KW_elevation: thawer.get (op->elevation); break;
931 case KW_smoothlevel: thawer.get (op->smoothlevel); break; 954 case KW_smoothlevel: thawer.get (op->smoothlevel); break;
932 case KW_client_type: thawer.get (op->client_type); break; 955 case KW_client_type: thawer.get (op->client_type); break;
933 case KW_duration: thawer.get (op->duration); break; 956 case KW_duration: thawer.get (op->duration); break;
934 case KW_range: thawer.get (op->range); break; 957 case KW_range: thawer.get (op->range); break;
935 case KW_range_modifier: thawer.get (op->range_modifier); break; 958 case KW_range_modifier: thawer.get (op->range_modifier); break;
936 case KW_dam_modifier: thawer.get (op->dam_modifier); break; 959 case KW_dam_modifier: thawer.get (op->dam_modifier); break;
937 case KW_duration_modifier: thawer.get (op->duration_modifier); break; 960 case KW_duration_modifier: thawer.get (op->duration_modifier); break;
938 961
939 //TODO: mechanism to ensure that KW_xxx is consecutive needed from include/preprocess 962 //TODO: mechanism to ensure that KW_xxx is consecutive needed from include/preprocess
940 //TODO: parse from other include files 963 //TODO: parse from other include files
941 case KW_body_range: thawer.get (op->body_info [ 0]); break; 964 case KW_body_range: thawer.get (op->body_info[0]); break;
942 case KW_body_arm: thawer.get (op->body_info [ 1]); break; 965 case KW_body_arm: thawer.get (op->body_info[1]); break;
943 case KW_body_torso: thawer.get (op->body_info [ 2]); break; 966 case KW_body_torso: thawer.get (op->body_info[2]); break;
944 case KW_body_head: thawer.get (op->body_info [ 3]); break; 967 case KW_body_head: thawer.get (op->body_info[3]); break;
945 case KW_body_neck: thawer.get (op->body_info [ 4]); break; 968 case KW_body_neck: thawer.get (op->body_info[4]); break;
946 case KW_body_skill: thawer.get (op->body_info [ 5]); break; 969 case KW_body_skill: thawer.get (op->body_info[5]); break;
947 case KW_body_finger: thawer.get (op->body_info [ 6]); break; 970 case KW_body_finger: thawer.get (op->body_info[6]); break;
948 case KW_body_shoulder: thawer.get (op->body_info [ 7]); break; 971 case KW_body_shoulder: thawer.get (op->body_info[7]); break;
949 case KW_body_foot: thawer.get (op->body_info [ 8]); break; 972 case KW_body_foot: thawer.get (op->body_info[8]); break;
950 case KW_body_hand: thawer.get (op->body_info [ 9]); break; 973 case KW_body_hand: thawer.get (op->body_info[9]); break;
951 case KW_body_wrist: thawer.get (op->body_info [10]); break; 974 case KW_body_wrist: thawer.get (op->body_info[10]); break;
952 case KW_body_waist: thawer.get (op->body_info [11]); break; 975 case KW_body_waist: thawer.get (op->body_info[11]); break;
953 case KW_can_apply: 976 case KW_can_apply:
954 break; 977 break;
955 978
956 case KW_connected: 979 case KW_connected:
957 add_button_link (op, op->map, thawer.get_sint32 ()); 980 add_button_link (op, op->map, thawer.get_sint32 ());
… …
960 case KW_randomitems: 983 case KW_randomitems:
961 op->randomitems = find_treasurelist (thawer.get_str ()); 984 op->randomitems = find_treasurelist (thawer.get_str ());
962 break; 985 break;
963 986
964 case KW_msg: 987 case KW_msg:
965 {
966 thawer.get_ml (KW_endmsg, op->msg); 988 thawer.get_ml (KW_endmsg, op->msg);
967 //TODO: allow longer messages 989 //TODO: allow longer messages
968 if (strlen (op->msg) >= HUGE_BUF) 990 if (strlen (op->msg) >= HUGE_BUF)
969 { 991 {
970 LOG (llevDebug, "\n\tError message length >= %d: %d\n>%.80s<\n", HUGE_BUF, strlen (op->msg), &op->msg); 992 LOG (llevDebug, "\tError message length >= %d: %d\n>%.80s<\n", HUGE_BUF, strlen (op->msg), &op->msg);
971 op->msg = "ERROR, please report: string too long, winged.\n"; 993 op->msg = "ERROR, please report: string too long, winged.\n";
972 } 994 }
973 }
974 break; 995 break;
975 996
976 case KW_lore: 997 case KW_lore:
977 {
978 shstr msgbuf;
979 thawer.get_ml (KW_endlore, op->lore); 998 thawer.get_ml (KW_endlore, op->lore);
980 //TODO: allow longer messages 999 //TODO: allow longer messages
981 /* Just print a warning so we can be reasonably safe 1000 /* Just print a warning so we can be reasonably safe
982 * about not overflowing the buffer. 1001 * about not overflowing the buffer.
983 */ 1002 */
984 if (strlen (op->lore) > (HUGE_BUF / 2)) 1003 if (strlen (op->lore) > (HUGE_BUF / 2))
985 LOG (llevDebug, "\n\tWarning lore length > %d (max allowed=%d): %d\n>%.80s<\n", 1004 LOG (llevDebug, "\tWarning lore length > %d (max allowed=%d): %d\n>%.80s<\n",
986 HUGE_BUF / 2, HUGE_BUF, strlen (op->lore), &op->lore); 1005 HUGE_BUF / 2, HUGE_BUF, strlen (op->lore), &op->lore);
987 }
988 break; 1006 break;
989 1007
990 case KW_editable: 1008 case KW_editable:
991 case KW_editor_folder: 1009 case KW_editor_folder:
992 break; 1010 break;
993 1011
994 case KW_More: // uppercase alias 1012 case KW_More: // uppercase alias
995 case KW_more: 1013 case KW_more:
996 /* We need to record that this is a multipart object, 1014 /* We need to record that this is a multipart object,
997 * so the calling function can glue things back together 1015 * so the calling function can glue things back together
998 */ 1016 */
999 ismore = 1; 1017 ismore = 1;
… …
1009 1027
1010 case KW_EOF: 1028 case KW_EOF:
1011 return LL_EOF; 1029 return LL_EOF;
1012 1030
1013 case KW_ERROR: 1031 case KW_ERROR:
1014 set_ob_key_value (op, thawer.line, thawer.last_value, true); 1032 set_ob_key_value (op, thawer.last_keyword, thawer.last_value, true);
1015 //printf ("addkv(%s,%s)\n", thawer.line, thawer.get_str());//D 1033 //fprintf (stderr, "addkv(%s,%s)\n", thawer.last_keyword, thawer.last_value);//D
1016
1017 //TODO: skip line, ugly, factor parsing better
1018 if (thawer.last_value)
1019 thawer.line = thawer.last_value;
1020
1021 thawer.line += strlen (thawer.line) + 1;
1022
1023 break; 1034 break;
1024 1035
1025 default: 1036 default:
1026 printf ("kw abort %s\n", keyword_str [kw]);//D 1037 LOG (llevError, "UNSUPPORTED KEYWORD IN MAP: \"%s\", bug in normaliser. skipping.\n", keyword_str[kw]);
1027 abort (); 1038 break;
1028 } 1039 }
1029 } 1040 }
1030} 1041}
1031 1042
1032/* 1043/*
… …
1041 * LO_NEWFILE (2): This is the first read from a particular file, so the buffers should 1052 * LO_NEWFILE (2): This is the first read from a particular file, so the buffers should
1042 * be reset. 1053 * be reset.
1043 * LO_NOREAD (3): Reset the buffers, but don't read from it. (op can be null) 1054 * LO_NOREAD (3): Reset the buffers, but don't read from it. (op can be null)
1044 * 1055 *
1045 */ 1056 */
1046 1057int
1047int load_object(object_thawer &fp, object *op, int map_flags) { 1058load_object (object_thawer &fp, object *op, int map_flags)
1059{
1060 coroapi::cede_every (1000); // cede once in a while
1061
1048 return parse_object(op, fp, map_flags); 1062 return parse_object (op, fp, map_flags);
1049} 1063}
1050
1051 1064
1052/* This takes a buffer, scans it for variables, and sets those variables 1065/* This takes a buffer, scans it for variables, and sets those variables
1053 * as appropriate in op. 1066 * as appropriate in op.
1054 * 1067 *
1055 * This function appears to be used in only 2 places - in crossedit to 1068 * This function appears to be used in only 2 places - in crossedit to
1056 * override values and in c_wiz to mutate values. 1069 * override values and in c_wiz to mutate values.
1057 */ 1070 */
1071int
1058int set_variable(object *op,char *buf) { 1072set_variable (object *op, char *buf)
1059#if 0 1073{
1060 int retval;
1061 object_thawer thawer (0); 1074 object_thawer thawer (buf, (AV *)0);
1062 1075
1063 strcpy(msgbuf, "");
1064 strcpy(lorebuf, "");
1065 retval=parse_object(op,thawer,0); 1076 return parse_object (op, thawer, 0);
1066 yy_switch_to_buffer(yycurbuf);
1067 yy_delete_buffer(yybufstate);
1068 yy_pop_state();
1069 return retval;
1070#endif
1071} 1077}
1072
1073/* This array equates the FLAG_ values with the V_ values. Use -1 to
1074 * put gaps in the array that should not be processed.
1075 * The order matches the order of the define values in 'define.h'.
1076 */
1077/* This is a list of pointers that correspond to the FLAG_.. values.
1078 * This is a simple 1:1 mapping - if FLAG_FRIENDLY is 15, then
1079 * the 15'th element of this array should match that name.
1080 * If an entry is NULL, that is a flag not to loaded/saved.
1081 */
1082static const char *const flag_names[NUM_FLAGS+1] = {
1083"alive", "wiz", NULL, NULL, "was_wiz", "applied", "unpaid",
1084"can_use_shield", "no_pick", NULL /* walk_on*/, NULL /* no_pass */, /* 10 */
1085"is_animated", NULL /* slow_move */,
1086NULL /* flying */, "monster", "friendly", "generator",
1087"is_thrown", "auto_apply", "treasure", "player sold", /* 20 */
1088"see_invisible", "can_roll", "overlay_floor",
1089"is_turnable", NULL /* walk_off */, NULL /* fly_on */,
1090NULL /*fly_off*/, "is_used_up", "identified", "reflecting", /* 30 */
1091"changing", "splitting", "hitback", "startequip",
1092"blocksview", "undead", "scared", "unaggressive",
1093"reflect_missile", "reflect_spell", /* 40 */
1094"no_magic", "no_fix_player", "is_lightable", "tear_down",
1095"run_away", NULL /*pass_thru */, NULL /*can_pass_thru*/,
1096"pick_up", "unique", "no_drop", /* 50 */
1097NULL /* wizcast*/, "can_cast_spell", "can_use_scroll", "can_use_range",
1098"can_use_bow", "can_use_armour", "can_use_weapon",
1099"can_use_ring", "has_ready_range", "has_ready_bow", /* 60 */
1100"xrays", NULL, "is_floor", "lifesave", "no_strength", "sleep",
1101"stand_still", "random_move", "only_attack", "confused", /* 70 */
1102 "stealth", NULL, NULL, "cursed", "damned",
1103"see_anywhere", "known_magical", "known_cursed",
1104"can_use_skill", "been_applied", /* 80 */
1105"has_ready_scroll", "can_use_rod", NULL,
1106"can_use_horn", "make_invisible", "inv_locked", "is_wooded",
1107"is_hilly", "has_ready_skill", "has_ready_weapon", /* 90 */
1108"no_skill_ident", "is_blind", "can_see_in_dark", "is_cauldron",
1109"is_dust", "no_steal", "one_hit", NULL, "berserk", "neutral", /* 100 */
1110"no_attack", "no_damage", NULL, NULL, "activate_on_push",
1111"activate_on_release", "is_water", "use_content_on_gen", NULL, "is_buildable", /* 110 */
1112NULL
1113};
1114
1115 1078
1116/* 1079/*
1117 * Initialises the array of variable-names. Needed before any 1080 * Initialises the array of variable-names. Needed before any
1118 * objects can be loaded. Called by init_library(). 1081 * objects can be loaded. Called by init_library().
1119 */ 1082 */
1120 1083
1121void init_vars() { 1084void
1085init_vars ()
1086{
1122} 1087}
1123 1088
1124/* This returns a string of the integer movement type */ 1089/* This returns a string of the integer movement type */
1090#if 0
1091// unused function
1092static char *
1125static char* get_string_move_type(MoveType mt) 1093get_string_move_type (MoveType mt)
1126{ 1094{
1127 static char retbuf[MAX_BUF], retbuf_all[MAX_BUF]; 1095 static char retbuf[MAX_BUF], retbuf_all[MAX_BUF];
1128 int i, all_count=0, count; 1096 int i, all_count = 0, count;
1129 1097
1130 strcpy(retbuf,""); 1098 strcpy (retbuf, "");
1131 strcpy(retbuf_all," all"); 1099 strcpy (retbuf_all, " all");
1132 1100
1133 /* Quick check, and probably fairly common */ 1101 /* Quick check, and probably fairly common */
1134 if (mt == MOVE_ALL) return retbuf_all+1; 1102 if (mt == MOVE_ALL)
1103 return retbuf_all + 1;
1135 if (mt == 0) { 1104 if (mt == 0)
1105 {
1136 strcpy(retbuf,"0"); 1106 strcpy (retbuf, "0");
1137 return retbuf; 1107 return retbuf;
1138 } 1108 }
1139 1109
1140 /* We basically slide the bits down. Why look at MOVE_ALL? 1110 /* We basically slide the bits down. Why look at MOVE_ALL?
1141 * because we may want to return a string like 'all -swim', 1111 * because we may want to return a string like 'all -swim',
1142 * and if we just looked at mt, we couldn't get that. 1112 * and if we just looked at mt, we couldn't get that.
1143 */ 1113 */
1144 for (i=MOVE_ALL, count=0; i!=0; i >>= 1, count++) { 1114 for (i = MOVE_ALL, count = 0; i != 0; i >>= 1, count++)
1115 {
1145 if (mt & (1<<count)) { 1116 if (mt & (1 << count))
1117 {
1146 strcat(retbuf, " "); 1118 strcat (retbuf, " ");
1147 strcat(retbuf, move_name[count]); 1119 strcat (retbuf, move_name[count]);
1120 }
1148 } else { 1121 else
1122 {
1149 strcat(retbuf_all, " -"); 1123 strcat (retbuf_all, " -");
1150 strcat(retbuf_all, move_name[count]); 1124 strcat (retbuf_all, move_name[count]);
1151 all_count++; 1125 all_count++;
1152 } 1126 }
1153 } 1127 }
1154 /* Basically, if there is a single negation, return it, eg 1128 /* Basically, if there is a single negation, return it, eg
1155 * 'all -swim'. But more than that, just return the 1129 * 'all -swim'. But more than that, just return the
1156 * enumerated values. It doesn't make sense to return 1130 * enumerated values. It doesn't make sense to return
1157 * 'all -walk -fly_low' - it is shorter to return 'fly_high swim' 1131 * 'all -walk -fly_low' - it is shorter to return 'fly_high swim'
1158 */ 1132 */
1159 if (all_count <=1) return retbuf_all+1; 1133 if (all_count <= 1)
1134 return retbuf_all + 1;
1135 else
1160 else return retbuf+1; 1136 return retbuf + 1;
1161} 1137}
1162 1138#endif
1139
1163// compare *op against *tmp and output differences 1140// compare *op against *tmp and output differences
1164void 1141void
1165put (object_freezer &f, object *op, object *tmp) 1142put (object_freezer &f, object *op, object *tmp)
1166{ 1143{
1144 static const keyword resist_save[NROFATTACKS] = {
1145# define def(uc, lc, name, plus, change) KW_resist_ ## lc,
1146# include "attackinc.h"
1147# undef def
1148 };
1149
1150 /* This is a list of keywords that correspond to the FLAG_.. values.
1151 * This is a simple 1:1 mapping - if FLAG_FRIENDLY is 15, then
1152 * the 15'th element of this array should match that name.
1153 * If an entry is NULL, that is a flag not to loaded/saved.
1154 */
1155 static const keyword flag_names [NUM_FLAGS] = {
1156 KW_alive,
1157 KW_wiz,
1158 KW_NULL,
1159 KW_NULL,
1160 KW_was_wiz,
1161 KW_applied,
1162 KW_unpaid,
1163 KW_can_use_shield,
1164 KW_no_pick,
1165 KW_NULL, // walk_on
1166 KW_NULL, // no_pass
1167 /* 10 */
1168 KW_is_animated,
1169 KW_NULL, // slow_move
1170 KW_NULL, // flying
1171 KW_monster,
1172 KW_friendly,
1173 KW_generator,
1174 KW_is_thrown,
1175 KW_auto_apply,
1176 KW_NULL, // was KW_treasure
1177 KW_player_sold,
1178 /* 20 */
1179 KW_see_invisible,
1180 KW_can_roll,
1181 KW_overlay_floor,
1182 KW_is_turnable,
1183 KW_NULL, // walk_off
1184 KW_NULL, // fly_on
1185 KW_NULL, // fly_off
1186 KW_is_used_up,
1187 KW_identified,
1188 KW_reflecting,
1189 /* 30 */
1190 KW_changing,
1191 KW_splitting,
1192 KW_hitback,
1193 KW_startequip,
1194 KW_blocksview,
1195 KW_undead,
1196 KW_scared,
1197 KW_unaggressive,
1198 KW_reflect_missile,
1199 KW_reflect_spell,
1200 /* 40 */
1201 KW_no_magic,
1202 KW_no_fix_player,
1203 KW_is_lightable,
1204 KW_tear_down,
1205 KW_run_away,
1206 KW_NULL, // pass_thru
1207 KW_NULL, // an_pass_thru
1208 KW_pick_up,
1209 KW_unique,
1210 KW_no_drop,
1211 /* 50 */
1212 KW_NULL, // wizcast
1213 KW_can_cast_spell,
1214 KW_can_use_scroll,
1215 KW_can_use_range,
1216 KW_can_use_bow,
1217 KW_can_use_armour,
1218 KW_can_use_weapon,
1219 KW_can_use_ring,
1220 KW_has_ready_range,
1221 KW_has_ready_bow,
1222 /* 60 */
1223 KW_xrays,
1224 KW_NULL,
1225 KW_is_floor,
1226 KW_lifesave,
1227 KW_no_strength,
1228 KW_sleep,
1229 KW_stand_still,
1230 KW_random_move,
1231 KW_only_attack,
1232 KW_confused,
1233 /* 70 */
1234 KW_stealth,
1235 KW_NULL,
1236 KW_NULL,
1237 KW_cursed,
1238 KW_damned,
1239 KW_see_anywhere,
1240 KW_known_magical,
1241 KW_known_cursed,
1242 KW_can_use_skill,
1243 KW_been_applied,
1244 /* 80 */
1245 KW_has_ready_scroll,
1246 KW_can_use_rod,
1247 KW_NULL,
1248 KW_can_use_horn,
1249 KW_make_invisible,
1250 KW_inv_locked,
1251 KW_is_wooded,
1252 KW_is_hilly,
1253 KW_has_ready_skill,
1254 KW_has_ready_weapon,
1255 /* 90 */
1256 KW_no_skill_ident,
1257 KW_is_blind,
1258 KW_can_see_in_dark,
1259 KW_is_cauldron,
1260 KW_NULL,
1261 KW_no_steal,
1262 KW_one_hit,
1263 KW_NULL,
1264 KW_berserk,
1265 KW_neutral,
1266 /* 100 */
1267 KW_no_attack,
1268 KW_no_damage,
1269 KW_obj_original,
1270 KW_NULL,
1271 KW_activate_on_push,
1272 KW_activate_on_release,
1273 KW_is_water,
1274 KW_use_content_on_gen,
1275 KW_NULL,
1276 KW_is_buildable,
1277 /* 110 */
1278 KW_destroy_on_death,
1279 KW_NULL,
1280 };
1281
1167 int i; 1282 int i;
1168 1283
1169 /* This saves the key/value lists. We do it first so that any 1284 /* This saves the key/value lists. We do it first so that any
1170 * keys that match field names will be overwritten by the loader. 1285 * keys that match field names will be overwritten by the loader.
1171 */ 1286 */
1172 for (key_value *my_field = op->key_values; my_field != NULL; my_field = my_field->next) 1287 for (key_value *my_field = op->key_values; my_field; my_field = my_field->next)
1173 { 1288 {
1174 /* Find the field in the opposing member. */ 1289 /* Find the field in the opposing member. */
1175 key_value *arch_field = get_ob_key_link (tmp, my_field->key); 1290 key_value *arch_field = get_ob_key_link (tmp, my_field->key);
1176 1291
1177 /* If there's no partnering field, or it's got a different value, save our field. */ 1292 /* If there's no partnering field, or it's got a different value, save our field. */
1178 if (arch_field == NULL || my_field->value != arch_field->value) 1293 if (!arch_field || my_field->value != arch_field->value)
1179 f.put (my_field->key, my_field->value); 1294 f.put (my_field->key, my_field->value);
1180 } 1295 }
1181 1296
1182 /* We don't need to worry about the arch's extra fields - they 1297 /* We don't need to worry about the arch's extra fields - they
1183 * will get taken care of the copy_object function. 1298 * will get taken care of the copy_to method.
1184 */ 1299 */
1185 1300
1301 {
1302 char uids[64];
1303 snprintf (uids, sizeof (uids), "<1.%llx>", (unsigned long long)op->uuid.seq);
1304 f.put (KW_uuid, (const char *)uids);
1305 }
1306
1186# define CMP_OUT(v) if (op->v != tmp->v) f.put (KW_ ## v, op->v) 1307#define CMP_OUT(v) if (op->v != tmp->v) f.put (KW_ ## v, op->v)
1187# define CMP_OUT2(k,v) if (op->v != tmp->v) f.put (KW_ ## k, op->v) 1308#define CMP_OUT2(k,v) if (op->v != tmp->v) f.put (KW_ ## k, op->v)
1188 1309
1189 CMP_OUT (name); 1310 CMP_OUT (name);
1190 CMP_OUT (name_pl); 1311 CMP_OUT (name_pl);
1191 CMP_OUT (custom_name); 1312 CMP_OUT (custom_name);
1192 CMP_OUT (title); 1313 CMP_OUT (title);
1193 CMP_OUT (race); 1314 CMP_OUT (race);
1194 CMP_OUT (slaying); 1315 CMP_OUT (slaying);
1195 1316
1196 if (op->msg != tmp->msg ) f.put (KW_msg , KW_endmsg , op->msg); 1317 if (op->msg != tmp->msg)
1318 f.put (KW_msg, KW_endmsg, op->msg);
1319 if (op->lore != tmp->lore)
1197 if (op->lore != tmp->lore) f.put (KW_lore, KW_endlore, op->lore); 1320 f.put (KW_lore, KW_endlore, op->lore);
1198 1321
1199 CMP_OUT (other_arch); 1322 CMP_OUT (other_arch);
1200 CMP_OUT (face); 1323 CMP_OUT (face);
1201
1202 if (!op->face || !op->face->name)
1203 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
1204 1324
1205 if (op->animation_id != tmp->animation_id) 1325 if (op->animation_id != tmp->animation_id)
1206 if (op->animation_id) 1326 if (op->animation_id)
1207 { 1327 {
1208 f.put (KW_animation, animations[GET_ANIM_ID (op)].name); 1328 f.put (KW_animation, animations[GET_ANIM_ID (op)].name);
1209 1329
1210 if (!QUERY_FLAG (op, FLAG_ANIMATE)) 1330 if (!QUERY_FLAG (op, FLAG_ANIMATE))
1211 f.put (KW_is_animated, (sint32)0); 1331 f.put (KW_is_animated, (sint32) 0);
1212 } 1332 }
1213 else 1333 else
1214 f.put (KW_animation, (const char *)0); 1334 f.put (KW_animation, (const char *) 0);
1215 1335
1216 CMP_OUT2 (str , stats.Str); 1336 CMP_OUT2 (str, stats.Str);
1217 CMP_OUT2 (dex , stats.Dex); 1337 CMP_OUT2 (dex, stats.Dex);
1218 CMP_OUT2 (con , stats.Con); 1338 CMP_OUT2 (con, stats.Con);
1219 CMP_OUT2 (wis , stats.Wis); 1339 CMP_OUT2 (wis, stats.Wis);
1220 CMP_OUT2 (pow , stats.Pow); 1340 CMP_OUT2 (pow, stats.Pow);
1221 CMP_OUT2 (cha , stats.Cha); 1341 CMP_OUT2 (cha, stats.Cha);
1222 CMP_OUT2 (int , stats.Int); 1342 CMP_OUT2 (int, stats.Int);
1343
1223 CMP_OUT2 (hp , stats.hp); 1344 CMP_OUT2 (hp, stats.hp);
1224 CMP_OUT2 (maxhp , stats.maxhp); 1345 CMP_OUT2 (maxhp, stats.maxhp);
1225 CMP_OUT2 (sp , stats.sp); 1346 CMP_OUT2 (sp, stats.sp);
1226 CMP_OUT2 (maxsp , stats.maxsp); 1347 CMP_OUT2 (maxsp, stats.maxsp);
1227 CMP_OUT2 (grace , stats.grace); 1348 CMP_OUT2 (grace, stats.grace);
1228 CMP_OUT2 (maxgrace, stats.maxgrace); 1349 CMP_OUT2 (maxgrace, stats.maxgrace);
1229 CMP_OUT2 (exp , stats.exp); 1350 CMP_OUT2 (exp, stats.exp);
1230 1351
1231 CMP_OUT (perm_exp); 1352 CMP_OUT (perm_exp);
1232 CMP_OUT (expmul); 1353 CMP_OUT (expmul);
1233 1354
1234 CMP_OUT2 (food , stats.food); 1355 CMP_OUT2 (food, stats.food);
1235 CMP_OUT2 (dam , stats.dam); 1356 CMP_OUT2 (dam, stats.dam);
1236 CMP_OUT2 (luck , stats.luck); 1357 CMP_OUT2 (luck, stats.luck);
1237 CMP_OUT2 (wc , stats.wc); 1358 CMP_OUT2 (wc, stats.wc);
1238 CMP_OUT2 (ac , stats.ac); 1359 CMP_OUT2 (ac, stats.ac);
1239 1360
1240 CMP_OUT (x); 1361 CMP_OUT (x);
1241 CMP_OUT (y); 1362 CMP_OUT (y);
1242 CMP_OUT (speed); 1363 CMP_OUT (speed);
1243 CMP_OUT (speed_left); 1364 CMP_OUT (speed_left);
… …
1249 CMP_OUT (type); 1370 CMP_OUT (type);
1250 CMP_OUT (subtype); 1371 CMP_OUT (subtype);
1251 CMP_OUT (attacktype); 1372 CMP_OUT (attacktype);
1252 1373
1253 for (i = 0; i < NROFATTACKS; i++) 1374 for (i = 0; i < NROFATTACKS; i++)
1254 if (op->resist [i] != tmp->resist [i]) 1375 if (op->resist[i] != tmp->resist[i])
1255 f.put (resist_save [i], op->resist [i]); 1376 f.put (resist_save[i], op->resist[i]);
1256 1377
1257 CMP_OUT (path_attuned); 1378 CMP_OUT (path_attuned);
1258 CMP_OUT (path_repelled); 1379 CMP_OUT (path_repelled);
1259 CMP_OUT (path_denied); 1380 CMP_OUT (path_denied);
1260 CMP_OUT (material); 1381 CMP_OUT (material);
… …
1299 CMP_OUT (move_on); 1420 CMP_OUT (move_on);
1300 CMP_OUT (move_off); 1421 CMP_OUT (move_off);
1301 CMP_OUT (move_slow); 1422 CMP_OUT (move_slow);
1302 CMP_OUT (move_slow_penalty); 1423 CMP_OUT (move_slow_penalty);
1303 1424
1304 if (!COMPARE_FLAGS (op, tmp)) 1425 if (op->flag != tmp->flag)
1305 for (i = 0; i <= NUM_FLAGS; i++) 1426 for (i = 0; i <= NUM_FLAGS; i++)
1306 if (flag_names [i] 1427 if (flag_names [i] && op->flag [i] != tmp->flag [i])
1307 && (QUERY_FLAG (op, i) != QUERY_FLAG (tmp, i)))
1308 f.put (flag_names [i], QUERY_FLAG (op, i) ? "1" : "0"); 1428 f.put (flag_names [i], op->flag [i] ? "1" : "0");
1309 1429
1310 /* Save body locations */ 1430 /* Save body locations */
1311 for (i = 0; i < NUM_BODY_LOCATIONS; i++) 1431 for (i = 0; i < NUM_BODY_LOCATIONS; i++)
1312 if (op->body_info[i] != tmp->body_info[i]) 1432 if (op->body_info[i] != tmp->body_info[i])
1313 f.put (body_locations[i].save_name, op->body_info[i]); 1433 f.put (body_locations[i].save_name, op->body_info[i]);
… …
1315 1435
1316/* 1436/*
1317 * Dumps all variables in an object to a file. 1437 * Dumps all variables in an object to a file.
1318 * If bit 0 of flag is set, unpaid objects will be saved. As of now, 1438 * If bit 0 of flag is set, unpaid objects will be saved. As of now,
1319 * the only place this is not set is when saving the player. 1439 * the only place this is not set is when saving the player.
1320 * If bit 1 of flag is set, don't remove the object after save. As of now,
1321 * all of the callers are setting this.
1322 */ 1440 */
1323
1324void 1441void
1325save_object (object_freezer &fp, object *op, int flag) 1442save_object (object_freezer &fp, object *op, int flag)
1326{ 1443{
1327 archetype *at;
1328 object *tmp, *old;
1329
1330 /* Even if the object does have an owner, it would seem that we should 1444 /* Even if the object does have an owner, it would seem that we should
1331 * still save it. 1445 * still save it.
1332 */ 1446 */
1333 if (op->owner != NULL) 1447 if (op->owner)
1334 return; 1448 return;
1335 1449
1336 /* If it is unpaid and we don't want to save those, just return. */ 1450 /* If it is unpaid and we don't want to save those, just return. */
1337 if (!(flag & 1) && (QUERY_FLAG (op, FLAG_UNPAID))) 1451 if (!(flag & 1) && op->flag [FLAG_UNPAID])
1338 return; 1452 return;
1339 1453
1340 if ((at = op->arch) == NULL) 1454 archetype *at = op->arch ? (archetype *)op->arch : empty_archetype;
1341 at = empty_archetype;
1342 1455
1343 fp.put (KW_arch, at->name); 1456 fp.put (KW_arch, at->name);
1344
1345 put (fp, op, &at->clone); 1457 put (fp, op, &at->clone);
1346 1458
1347 /* Eneq(@csd.uu.se): Added this to allow containers being saved with contents */ 1459 /* Eneq(@csd.uu.se): Added this to allow containers being saved with contents */
1348 1460
1349 old = NULL;
1350
1351 if (flag & 2)
1352 for (tmp = op->inv; tmp != NULL; tmp = tmp->below) 1461 for (object *tmp = op->inv; tmp; tmp = tmp->below)
1353 save_object (fp, tmp, flag); 1462 save_object (fp, tmp, flag);
1354 else
1355 /* Slightly different logic because tmp/op will be removed by
1356 * the save_object we call. So we just keep looking at op->inv
1357 * until there is nothing left. In theory, the variable old
1358 * should not be needed, as recursive loops shouldn't happen.
1359 */
1360 while ((tmp = op->inv) != NULL)
1361 {
1362 if (old == tmp)
1363 {
1364 LOG (llevError, " Recursive loop in inventory\n");
1365 break;
1366 }
1367
1368 save_object (fp, tmp, flag);
1369 old = tmp;
1370 }
1371
1372 if (!(flag & 2))
1373 {
1374 remove_ob (op);
1375 free_object (op);
1376 }
1377 1463
1378 fp.put (op); 1464 fp.put (op);
1379 fprintf (fp, "end\n"); 1465 fp.put (KW_end);
1380} 1466}
1381 1467

Diff Legend

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