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

Diff Legend

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