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

Diff Legend

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