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.2 by root, Mon Sep 4 11:07:59 2006 UTC vs.
Revision 1.26 by elmex, Mon Dec 18 17:10:07 2006 UTC

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

Diff Legend

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