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.9 by root, Thu Sep 7 14:21:04 2006 UTC vs.
Revision 1.33 by root, Sun Dec 31 17:17:22 2006 UTC

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

Diff Legend

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