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

Diff Legend

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