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.7 by root, Mon Sep 4 17:34:50 2006 UTC vs.
Revision 1.17 by root, Thu Sep 14 22:33:59 2006 UTC

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

Diff Legend

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