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

Diff Legend

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