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

Diff Legend

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