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.8 by pippijn, Thu Sep 7 09:37:12 2006 UTC vs.
Revision 1.30 by root, Tue Dec 26 08:54:59 2006 UTC

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

Diff Legend

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