1 /**
2 * \file mon-init.c
3 * \brief Monster initialization routines.
4 *
5 * Copyright (c) 1997 Ben Harrison
6 *
7 * This work is free software; you can redistribute it and/or modify it
8 * under the terms of either:
9 *
10 * a) the GNU General Public License as published by the Free Software
11 * Foundation, version 2, or
12 *
13 * b) the "Angband licence":
14 * This software may be copied and distributed for educational, research,
15 * and not for profit purposes provided that this copyright and statement
16 * are included in all such copies. Other copyrights may also apply.
17 */
18
19 #include "angband.h"
20 #include "datafile.h"
21 #include "effects.h"
22 #include "generate.h"
23 #include "init.h"
24 #include "mon-init.h"
25 #include "mon-lore.h"
26 #include "mon-msg.h"
27 #include "mon-spell.h"
28 #include "mon-util.h"
29 #include "mon-blows.h"
30 #include "monster.h"
31 #include "obj-tval.h"
32 #include "obj-util.h"
33 #include "object.h"
34 #include "player-spell.h"
35 #include "project.h"
36 #include "ui-visuals.h"
37
38 struct blow_method *blow_methods;
39 struct blow_effect *blow_effects;
40 struct monster_pain *pain_messages;
41 struct monster_spell *monster_spells;
42 struct monster_base *rb_info;
43 struct monster_race *r_info;
44 const struct monster_race *ref_race = NULL;
45 struct monster_lore *l_list;
46
47 const char *r_info_flags[] =
48 {
49 #define RF(a, b, c) #a,
50 #include "list-mon-race-flags.h"
51 #undef RF
52 NULL
53 };
54
55 const char *r_info_spell_flags[] =
56 {
57 #define RSF(a, b) #a,
58 #include "list-mon-spells.h"
59 #undef RSF
60 NULL
61 };
62
63 static const char *obj_flags[] =
64 {
65 "NONE",
66 #define OF(a) #a,
67 #include "list-object-flags.h"
68 #undef OF
69 ""
70 };
71
72 /**
73 * Return the index of a flag from its name.
74 */
flag_index_by_name(const char * name)75 int flag_index_by_name(const char *name)
76 {
77 size_t i;
78 for (i = 0; i < N_ELEMENTS(obj_flags); i++) {
79 if (streq(name, obj_flags[i])) {
80 return i;
81 }
82 }
83
84 return -1;
85 }
86
87 /**
88 * ------------------------------------------------------------------------
89 * Initialize monster blow methods
90 * ------------------------------------------------------------------------ */
91
findmeth(const char * meth_name)92 static struct blow_method *findmeth(const char *meth_name) {
93 struct blow_method *meth = &blow_methods[1];
94 while (meth) {
95 if (streq(meth->name, meth_name))
96 break;
97 meth = meth->next;
98 }
99 return meth;
100 }
101
parse_meth_name(struct parser * p)102 static enum parser_error parse_meth_name(struct parser *p) {
103 const char *name = parser_getstr(p, "name");
104 struct blow_method *h = parser_priv(p);
105
106 struct blow_method *meth = mem_zalloc(sizeof *meth);
107 meth->next = h;
108 parser_setpriv(p, meth);
109 meth->name = string_make(name);
110
111 return PARSE_ERROR_NONE;
112 }
113
parse_meth_cut(struct parser * p)114 static enum parser_error parse_meth_cut(struct parser *p) {
115 struct blow_method *meth = parser_priv(p);
116 int val;
117 assert(meth);
118
119 val = parser_getuint(p, "cut");
120 meth->cut = val ? true : false;
121 return PARSE_ERROR_NONE;
122 }
123
parse_meth_stun(struct parser * p)124 static enum parser_error parse_meth_stun(struct parser *p) {
125 struct blow_method *meth = parser_priv(p);
126 int val;
127 assert(meth);
128
129 val = parser_getuint(p, "stun");
130 meth->stun = val ? true : false;
131 return PARSE_ERROR_NONE;
132 }
133
parse_meth_miss(struct parser * p)134 static enum parser_error parse_meth_miss(struct parser *p) {
135 struct blow_method *meth = parser_priv(p);
136 int val;
137 assert(meth);
138
139 val = parser_getuint(p, "miss");
140 meth->miss = val ? true : false;
141 return PARSE_ERROR_NONE;
142 }
143
parse_meth_phys(struct parser * p)144 static enum parser_error parse_meth_phys(struct parser *p) {
145 struct blow_method *meth = parser_priv(p);
146 int val;
147 assert(meth);
148
149 val = parser_getuint(p, "phys");
150 meth->phys = val ? true : false;
151 return PARSE_ERROR_NONE;
152 }
153
parse_meth_message_type(struct parser * p)154 static enum parser_error parse_meth_message_type(struct parser *p)
155 {
156 int msg_index;
157 const char *type;
158 struct blow_method *meth = parser_priv(p);
159 assert(meth);
160
161 if (parser_hasval(p, "msg")) {
162 type = parser_getstr(p, "msg");
163
164 msg_index = message_lookup_by_name(type);
165
166 if (msg_index < 0)
167 return PARSE_ERROR_INVALID_MESSAGE;
168
169 meth->msgt = msg_index;
170 }
171 return PARSE_ERROR_NONE;
172 }
173
parse_meth_act_msg(struct parser * p)174 static enum parser_error parse_meth_act_msg(struct parser *p) {
175 const char *message = parser_getstr(p, "act");
176 struct blow_method *meth = parser_priv(p);
177 struct blow_message *msg = mem_zalloc(sizeof(*msg));
178 if (!meth)
179 return PARSE_ERROR_MISSING_RECORD_HEADER;
180
181 msg->act_msg = string_make(message);
182 msg->next = meth->messages;
183 meth->messages = msg;
184 meth->num_messages++;
185 return PARSE_ERROR_NONE;
186 }
187
parse_meth_desc(struct parser * p)188 static enum parser_error parse_meth_desc(struct parser *p) {
189 struct blow_method *meth = parser_priv(p);
190 assert(meth);
191
192 meth->desc = string_append(meth->desc, parser_getstr(p, "desc"));
193 return PARSE_ERROR_NONE;
194 }
195
init_parse_meth(void)196 struct parser *init_parse_meth(void) {
197 struct parser *p = parser_new();
198 parser_setpriv(p, NULL);
199 parser_reg(p, "name str name", parse_meth_name);
200 parser_reg(p, "cut uint cut", parse_meth_cut);
201 parser_reg(p, "stun uint stun", parse_meth_stun);
202 parser_reg(p, "miss uint miss", parse_meth_miss);
203 parser_reg(p, "phys uint phys", parse_meth_phys);
204 parser_reg(p, "msg ?str msg", parse_meth_message_type);
205 parser_reg(p, "act str act", parse_meth_act_msg);
206 parser_reg(p, "desc str desc", parse_meth_desc);
207 return p;
208 }
209
run_parse_meth(struct parser * p)210 static errr run_parse_meth(struct parser *p) {
211 return parse_file_quit_not_found(p, "blow_methods");
212 }
213
finish_parse_meth(struct parser * p)214 static errr finish_parse_meth(struct parser *p) {
215 struct blow_method *meth, *next = NULL;
216 int count = 1;
217
218 /* Count the entries */
219 z_info->blow_methods_max = 0;
220 meth = parser_priv(p);
221 while (meth) {
222 z_info->blow_methods_max++;
223 meth = meth->next;
224 }
225
226 /* Allocate the direct access list and copy the data to it */
227 blow_methods = mem_zalloc((z_info->blow_methods_max + 1) * sizeof(*meth));
228 for (meth = parser_priv(p); meth; meth = next, count++) {
229 memcpy(&blow_methods[count], meth, sizeof(*meth));
230 next = meth->next;
231 if (next)
232 blow_methods[count].next = &blow_methods[count + 1];
233 else
234 blow_methods[count].next = NULL;
235
236 mem_free(meth);
237 }
238 z_info->blow_methods_max += 1;
239
240 parser_destroy(p);
241 return 0;
242 }
243
cleanup_meth(void)244 static void cleanup_meth(void)
245 {
246 struct blow_method *meth = &blow_methods[1];
247
248 while (meth) {
249 struct blow_message *msg = meth->messages;
250 string_free(meth->desc);
251 while (msg) {
252 struct blow_message *next = msg->next;
253 string_free(msg->act_msg);
254 mem_free(msg);
255 msg = next;
256 }
257 string_free(meth->name);
258 meth = meth->next;
259 }
260 mem_free(blow_methods);
261 }
262
263 struct file_parser meth_parser = {
264 "blow_methods",
265 init_parse_meth,
266 run_parse_meth,
267 finish_parse_meth,
268 cleanup_meth
269 };
270
271
272 /**
273 * ------------------------------------------------------------------------
274 * Initialize monster blow effects
275 * ------------------------------------------------------------------------ */
276
findeff(const char * eff_name)277 static struct blow_effect *findeff(const char *eff_name) {
278 struct blow_effect *eff = &blow_effects[0];
279 while (eff) {
280 if (streq(eff->name, eff_name))
281 break;
282 eff = eff->next;
283 }
284 return eff;
285 }
286
parse_eff_name(struct parser * p)287 static enum parser_error parse_eff_name(struct parser *p) {
288 const char *name = parser_getstr(p, "name");
289 struct blow_effect *h = parser_priv(p);
290
291 struct blow_effect *eff = mem_zalloc(sizeof *eff);
292 eff->next = h;
293 parser_setpriv(p, eff);
294 eff->name = string_make(name);
295
296 return PARSE_ERROR_NONE;
297 }
298
parse_eff_power(struct parser * p)299 static enum parser_error parse_eff_power(struct parser *p) {
300 struct blow_effect *eff = parser_priv(p);
301 assert(eff);
302 eff->power = parser_getint(p, "power");
303 return PARSE_ERROR_NONE;
304 }
305
parse_eff_eval(struct parser * p)306 static enum parser_error parse_eff_eval(struct parser *p) {
307 struct blow_effect *eff = parser_priv(p);
308 assert(eff);
309 eff->eval = parser_getint(p, "eval");
310 return PARSE_ERROR_NONE;
311 }
312
parse_eff_desc(struct parser * p)313 static enum parser_error parse_eff_desc(struct parser *p) {
314 struct blow_effect *eff = parser_priv(p);
315 assert(eff);
316
317 eff->desc = string_append(eff->desc, parser_getstr(p, "desc"));
318 return PARSE_ERROR_NONE;
319 }
320
parse_eff_lore_color(struct parser * p)321 static enum parser_error parse_eff_lore_color(struct parser *p) {
322 struct blow_effect *eff = parser_priv(p);
323 const char *color;
324 int attr;
325
326 if (!eff)
327 return PARSE_ERROR_MISSING_RECORD_HEADER;
328
329 color = parser_getsym(p, "color");
330 if (strlen(color) > 1)
331 attr = color_text_to_attr(color);
332 else
333 attr = color_char_to_attr(color[0]);
334 if (attr < 0)
335 return PARSE_ERROR_INVALID_COLOR;
336 eff->lore_attr = attr;
337 return PARSE_ERROR_NONE;
338 }
339
parse_eff_lore_color_resist(struct parser * p)340 static enum parser_error parse_eff_lore_color_resist(struct parser *p) {
341 struct blow_effect *eff = parser_priv(p);
342 const char *color;
343 int attr;
344
345 if (!eff)
346 return PARSE_ERROR_MISSING_RECORD_HEADER;
347
348 color = parser_getsym(p, "color");
349 if (strlen(color) > 1)
350 attr = color_text_to_attr(color);
351 else
352 attr = color_char_to_attr(color[0]);
353 if (attr < 0)
354 return PARSE_ERROR_INVALID_COLOR;
355 eff->lore_attr_resist = attr;
356 return PARSE_ERROR_NONE;
357 }
358
parse_eff_lore_color_immune(struct parser * p)359 static enum parser_error parse_eff_lore_color_immune(struct parser *p) {
360 struct blow_effect *eff = parser_priv(p);
361 const char *color;
362 int attr;
363
364 if (!eff)
365 return PARSE_ERROR_MISSING_RECORD_HEADER;
366
367 color = parser_getsym(p, "color");
368 if (strlen(color) > 1)
369 attr = color_text_to_attr(color);
370 else
371 attr = color_char_to_attr(color[0]);
372 if (attr < 0)
373 return PARSE_ERROR_INVALID_COLOR;
374 eff->lore_attr_immune = attr;
375 return PARSE_ERROR_NONE;
376 }
377
parse_eff_effect_type(struct parser * p)378 static enum parser_error parse_eff_effect_type(struct parser *p) {
379 struct blow_effect *eff = parser_priv(p);
380 assert(eff);
381
382 eff->effect_type = string_make(parser_getstr(p, "type"));
383 return PARSE_ERROR_NONE;
384 }
385
parse_eff_resist(struct parser * p)386 static enum parser_error parse_eff_resist(struct parser *p) {
387 struct blow_effect *eff = parser_priv(p);
388 const char *resist = parser_getstr(p, "resist");
389 assert(eff);
390
391 if (streq(eff->effect_type, "element")) {
392 eff->resist = proj_name_to_idx(resist);
393 } else if (streq(eff->effect_type, "flag")) {
394 eff->resist = flag_index_by_name(resist);
395 } else {
396 return PARSE_ERROR_MISSING_BLOW_EFF_TYPE;
397 }
398 return PARSE_ERROR_NONE;
399 }
400
parse_eff_lash_type(struct parser * p)401 static enum parser_error parse_eff_lash_type(struct parser *p) {
402 struct blow_effect *eff = parser_priv(p);
403 int type;
404 assert(eff);
405
406 type = proj_name_to_idx(parser_getstr(p, "type"));
407 eff->lash_type = type >= 0 ? type : PROJ_MISSILE;
408 return PARSE_ERROR_NONE;
409 }
410
init_parse_eff(void)411 struct parser *init_parse_eff(void) {
412 struct parser *p = parser_new();
413 parser_setpriv(p, NULL);
414 parser_reg(p, "name str name", parse_eff_name);
415 parser_reg(p, "power int power", parse_eff_power);
416 parser_reg(p, "eval int eval", parse_eff_eval);
417 parser_reg(p, "desc str desc", parse_eff_desc);
418 parser_reg(p, "lore-color-base sym color", parse_eff_lore_color);
419 parser_reg(p, "lore-color-resist sym color", parse_eff_lore_color_resist);
420 parser_reg(p, "lore-color-immune sym color", parse_eff_lore_color_immune);
421 parser_reg(p, "effect-type str type", parse_eff_effect_type);
422 parser_reg(p, "resist str resist", parse_eff_resist);
423 parser_reg(p, "lash-type str type", parse_eff_lash_type);
424 return p;
425 }
426
run_parse_eff(struct parser * p)427 static errr run_parse_eff(struct parser *p) {
428 return parse_file_quit_not_found(p, "blow_effects");
429 }
430
finish_parse_eff(struct parser * p)431 static errr finish_parse_eff(struct parser *p) {
432 struct blow_effect *eff, *next = NULL;
433 int count;
434
435 /* Count the entries */
436 z_info->blow_effects_max = 0;
437 eff = parser_priv(p);
438 while (eff) {
439 z_info->blow_effects_max++;
440 eff = eff->next;
441 }
442
443 /* Allocate the direct access list and copy the data to it */
444 count = z_info->blow_effects_max - 1;
445 blow_effects = mem_zalloc((z_info->blow_effects_max + 1) * sizeof(*eff));
446 for (eff = parser_priv(p); eff; eff = next, count--) {
447 memcpy(&blow_effects[count], eff, sizeof(*eff));
448 next = eff->next;
449 if (count < z_info->blow_effects_max - 1)
450 blow_effects[count].next = &blow_effects[count + 1];
451 else
452 blow_effects[count].next = NULL;
453
454 mem_free(eff);
455 }
456 z_info->blow_effects_max++;
457
458 parser_destroy(p);
459 return 0;
460 }
461
cleanup_eff(void)462 static void cleanup_eff(void)
463 {
464 struct blow_effect *eff = blow_effects;
465 struct blow_effect *next;
466
467 while (eff) {
468 next = eff->next;
469 string_free(eff->effect_type);
470 string_free(eff->desc);
471 string_free(eff->name);
472 eff = next;
473 }
474 mem_free(blow_effects);
475 }
476
477 struct file_parser eff_parser = {
478 "blow_effects",
479 init_parse_eff,
480 run_parse_eff,
481 finish_parse_eff,
482 cleanup_eff
483 };
484
485 /**
486 * ------------------------------------------------------------------------
487 * Initialize monster pain messages
488 * ------------------------------------------------------------------------ */
489
parse_pain_type(struct parser * p)490 static enum parser_error parse_pain_type(struct parser *p) {
491 struct monster_pain *h = parser_priv(p);
492 struct monster_pain *mp = mem_zalloc(sizeof *mp);
493 mp->next = h;
494 mp->pain_idx = parser_getuint(p, "index");
495 parser_setpriv(p, mp);
496 return PARSE_ERROR_NONE;
497 }
498
parse_pain_message(struct parser * p)499 static enum parser_error parse_pain_message(struct parser *p) {
500 struct monster_pain *mp = parser_priv(p);
501 int i;
502
503 if (!mp)
504 return PARSE_ERROR_MISSING_RECORD_HEADER;
505 for (i = 0; i < 7; i++)
506 if (!mp->messages[i])
507 break;
508 if (i == 7)
509 return PARSE_ERROR_TOO_MANY_ENTRIES;
510 mp->messages[i] = string_make(parser_getstr(p, "message"));
511 return PARSE_ERROR_NONE;
512 }
513
init_parse_pain(void)514 struct parser *init_parse_pain(void) {
515 struct parser *p = parser_new();
516 parser_setpriv(p, NULL);
517
518 parser_reg(p, "type uint index", parse_pain_type);
519 parser_reg(p, "message str message", parse_pain_message);
520 return p;
521 }
522
run_parse_pain(struct parser * p)523 static errr run_parse_pain(struct parser *p) {
524 return parse_file_quit_not_found(p, "pain");
525 }
526
finish_parse_pain(struct parser * p)527 static errr finish_parse_pain(struct parser *p) {
528 struct monster_pain *mp, *n;
529
530 /* scan the list for the max id */
531 z_info->mp_max = 0;
532 mp = parser_priv(p);
533 while (mp) {
534 if (mp->pain_idx > z_info->mp_max)
535 z_info->mp_max = mp->pain_idx;
536 mp = mp->next;
537 }
538
539 /* allocate the direct access list and copy the data to it */
540 pain_messages = mem_zalloc((z_info->mp_max + 1) * sizeof(*mp));
541 for (mp = parser_priv(p); mp; mp = n) {
542 memcpy(&pain_messages[mp->pain_idx], mp, sizeof(*mp));
543 n = mp->next;
544 if (n)
545 pain_messages[mp->pain_idx].next = &pain_messages[n->pain_idx];
546 else
547 pain_messages[mp->pain_idx].next = NULL;
548 mem_free(mp);
549 }
550 z_info->mp_max += 1;
551
552 parser_destroy(p);
553 return 0;
554 }
555
cleanup_pain(void)556 static void cleanup_pain(void)
557 {
558 int idx, i;
559 for (idx = 0; idx < z_info->mp_max; idx++) {
560 for (i = 0; i < 7; i++) {
561 string_free((char *)pain_messages[idx].messages[i]);
562 }
563 }
564 mem_free(pain_messages);
565 }
566
567 struct file_parser pain_parser = {
568 "pain messages",
569 init_parse_pain,
570 run_parse_pain,
571 finish_parse_pain,
572 cleanup_pain
573 };
574
575
576 /**
577 * ------------------------------------------------------------------------
578 * Initialize monster spells
579 * ------------------------------------------------------------------------ */
580
parse_mon_spell_name(struct parser * p)581 static enum parser_error parse_mon_spell_name(struct parser *p) {
582 struct monster_spell *h = parser_priv(p);
583 struct monster_spell *s = mem_zalloc(sizeof *s);
584 const char *name = parser_getstr(p, "name");
585 int index;
586 s->next = h;
587 if (grab_name("monster spell", name, r_info_spell_flags, N_ELEMENTS(r_info_spell_flags), &index))
588 return PARSE_ERROR_INVALID_SPELL_NAME;
589 s->index = index;
590 s->level = mem_zalloc(sizeof(*(s->level)));
591 parser_setpriv(p, s);
592 return PARSE_ERROR_NONE;
593 }
594
595
parse_mon_spell_message_type(struct parser * p)596 static enum parser_error parse_mon_spell_message_type(struct parser *p)
597 {
598 int msg_index;
599 const char *type;
600 struct monster_spell *s = parser_priv(p);
601 assert(s);
602
603 type = parser_getsym(p, "type");
604
605 msg_index = message_lookup_by_name(type);
606
607 if (msg_index < 0)
608 return PARSE_ERROR_INVALID_MESSAGE;
609
610 s->msgt = msg_index;
611 return PARSE_ERROR_NONE;
612 }
613
parse_mon_spell_hit(struct parser * p)614 static enum parser_error parse_mon_spell_hit(struct parser *p) {
615 struct monster_spell *s = parser_priv(p);
616 assert(s);
617 s->hit = parser_getuint(p, "hit");
618 return PARSE_ERROR_NONE;
619 }
620
parse_mon_spell_effect(struct parser * p)621 static enum parser_error parse_mon_spell_effect(struct parser *p) {
622 struct monster_spell *s = parser_priv(p);
623 struct effect *effect;
624 struct effect *new_effect = mem_zalloc(sizeof(*new_effect));
625
626 if (!s)
627 return PARSE_ERROR_MISSING_RECORD_HEADER;
628
629 /* Go to the next vacant effect and set it to the new one */
630 if (s->effect) {
631 effect = s->effect;
632 while (effect->next)
633 effect = effect->next;
634 effect->next = new_effect;
635 } else
636 s->effect = new_effect;
637
638 /* Fill in the detail */
639 return grab_effect_data(p, new_effect);
640 }
641
parse_mon_spell_effect_yx(struct parser * p)642 static enum parser_error parse_mon_spell_effect_yx(struct parser *p) {
643 struct monster_spell *s = parser_priv(p);
644 struct effect *effect = s->effect;
645
646 if (!s)
647 return PARSE_ERROR_MISSING_RECORD_HEADER;
648
649 /* If there is no effect, assume that this is human and not parser error. */
650 if (effect == NULL)
651 return PARSE_ERROR_NONE;
652
653 while (effect->next) effect = effect->next;
654 effect->y = parser_getint(p, "y");
655 effect->x = parser_getint(p, "x");
656
657 return PARSE_ERROR_NONE;
658 }
659
parse_mon_spell_dice(struct parser * p)660 static enum parser_error parse_mon_spell_dice(struct parser *p) {
661 struct monster_spell *s = parser_priv(p);
662 dice_t *dice = NULL;
663 struct effect *effect = s->effect;
664 const char *string = NULL;
665
666 if (!s)
667 return PARSE_ERROR_MISSING_RECORD_HEADER;
668
669 /* If there is no effect, assume that this is human and not parser error. */
670 if (effect == NULL)
671 return PARSE_ERROR_NONE;
672
673 while (effect->next) effect = effect->next;
674
675 dice = dice_new();
676
677 if (dice == NULL)
678 return PARSE_ERROR_INVALID_DICE;
679
680 string = parser_getstr(p, "dice");
681
682 if (dice_parse_string(dice, string)) {
683 effect->dice = dice;
684 }
685 else {
686 dice_free(dice);
687 return PARSE_ERROR_INVALID_DICE;
688 }
689
690 return PARSE_ERROR_NONE;
691 }
692
parse_mon_spell_expr(struct parser * p)693 static enum parser_error parse_mon_spell_expr(struct parser *p) {
694 struct monster_spell *s = parser_priv(p);
695 struct effect *effect = s->effect;
696 expression_t *expression = NULL;
697 expression_base_value_f function = NULL;
698 const char *name;
699 const char *base;
700 const char *expr;
701
702 if (!s)
703 return PARSE_ERROR_MISSING_RECORD_HEADER;
704
705 /* If there is no effect, assume that this is human and not parser error. */
706 if (effect == NULL)
707 return PARSE_ERROR_NONE;
708
709 while (effect->next) effect = effect->next;
710
711 /* If there are no dice, assume that this is human and not parser error. */
712 if (effect->dice == NULL)
713 return PARSE_ERROR_NONE;
714
715 name = parser_getsym(p, "name");
716 base = parser_getsym(p, "base");
717 expr = parser_getstr(p, "expr");
718 expression = expression_new();
719
720 if (expression == NULL)
721 return PARSE_ERROR_INVALID_EXPRESSION;
722
723 function = spell_value_base_by_name(base);
724 expression_set_base_value(expression, function);
725
726 if (expression_add_operations_string(expression, expr) < 0)
727 return PARSE_ERROR_BAD_EXPRESSION_STRING;
728
729 if (dice_bind_expression(effect->dice, name, expression) < 0)
730 return PARSE_ERROR_UNBOUND_EXPRESSION;
731
732 /* The dice object makes a deep copy of the expression, so we can free it */
733 expression_free(expression);
734
735 return PARSE_ERROR_NONE;
736 }
737
parse_mon_spell_power_cutoff(struct parser * p)738 static enum parser_error parse_mon_spell_power_cutoff(struct parser *p) {
739 struct monster_spell *s = parser_priv(p);
740 struct monster_spell_level *l, *new;
741 assert(s);
742 new = mem_zalloc(sizeof(*new));
743 new->power = parser_getint(p, "power");
744 l = s->level;
745 while (l->next) {
746 l = l->next;
747 }
748 l->next = new;
749 return PARSE_ERROR_NONE;
750 }
751
parse_mon_spell_lore_desc(struct parser * p)752 static enum parser_error parse_mon_spell_lore_desc(struct parser *p) {
753 struct monster_spell *s = parser_priv(p);
754 struct monster_spell_level *l;
755 assert(s);
756 l = s->level;
757 while (l->next) {
758 l = l->next;
759 }
760
761 l->lore_desc = string_append(l->lore_desc,
762 parser_getstr(p, "text"));
763 return PARSE_ERROR_NONE;
764 }
765
parse_mon_spell_lore_color(struct parser * p)766 static enum parser_error parse_mon_spell_lore_color(struct parser *p) {
767 struct monster_spell *s = parser_priv(p);
768 struct monster_spell_level *l;
769 const char *color;
770 int attr;
771
772 if (!s)
773 return PARSE_ERROR_MISSING_RECORD_HEADER;
774
775 color = parser_getsym(p, "color");
776 if (strlen(color) > 1)
777 attr = color_text_to_attr(color);
778 else
779 attr = color_char_to_attr(color[0]);
780 if (attr < 0)
781 return PARSE_ERROR_INVALID_COLOR;
782 l = s->level;
783 while (l->next) {
784 l = l->next;
785 }
786 l->lore_attr = attr;
787 return PARSE_ERROR_NONE;
788 }
789
parse_mon_spell_lore_color_resist(struct parser * p)790 static enum parser_error parse_mon_spell_lore_color_resist(struct parser *p) {
791 struct monster_spell *s = parser_priv(p);
792 struct monster_spell_level *l;
793 const char *color;
794 int attr;
795
796 if (!s)
797 return PARSE_ERROR_MISSING_RECORD_HEADER;
798
799 color = parser_getsym(p, "color");
800 if (strlen(color) > 1)
801 attr = color_text_to_attr(color);
802 else
803 attr = color_char_to_attr(color[0]);
804 if (attr < 0)
805 return PARSE_ERROR_INVALID_COLOR;
806 l = s->level;
807 while (l->next) {
808 l = l->next;
809 }
810 l->lore_attr_resist = attr;
811 return PARSE_ERROR_NONE;
812 }
813
parse_mon_spell_lore_color_immune(struct parser * p)814 static enum parser_error parse_mon_spell_lore_color_immune(struct parser *p) {
815 struct monster_spell *s = parser_priv(p);
816 struct monster_spell_level *l;
817 const char *color;
818 int attr;
819
820 if (!s)
821 return PARSE_ERROR_MISSING_RECORD_HEADER;
822
823 color = parser_getsym(p, "color");
824 if (strlen(color) > 1)
825 attr = color_text_to_attr(color);
826 else
827 attr = color_char_to_attr(color[0]);
828 if (attr < 0)
829 return PARSE_ERROR_INVALID_COLOR;
830 l = s->level;
831 while (l->next) {
832 l = l->next;
833 }
834 l->lore_attr_immune = attr;
835 return PARSE_ERROR_NONE;
836 }
837
parse_mon_spell_message(struct parser * p)838 static enum parser_error parse_mon_spell_message(struct parser *p) {
839 struct monster_spell *s = parser_priv(p);
840 struct monster_spell_level *l;
841 assert(s);
842
843 l = s->level;
844 while (l->next) {
845 l = l->next;
846 }
847 l->message = string_append(l->message, parser_getstr(p, "text"));
848 return PARSE_ERROR_NONE;
849 }
850
parse_mon_spell_blind_message(struct parser * p)851 static enum parser_error parse_mon_spell_blind_message(struct parser *p) {
852 struct monster_spell *s = parser_priv(p);
853 struct monster_spell_level *l;
854 assert(s);
855
856 l = s->level;
857 while (l->next) {
858 l = l->next;
859 }
860 l->blind_message = string_append(l->blind_message,parser_getstr(p, "text"));
861 return PARSE_ERROR_NONE;
862 }
863
parse_mon_spell_miss_message(struct parser * p)864 static enum parser_error parse_mon_spell_miss_message(struct parser *p) {
865 struct monster_spell *s = parser_priv(p);
866 struct monster_spell_level *l;
867 assert(s);
868
869 l = s->level;
870 while (l->next) {
871 l = l->next;
872 }
873 l->miss_message = string_append(l->miss_message, parser_getstr(p, "text"));
874 return PARSE_ERROR_NONE;
875 }
876
parse_mon_spell_save_message(struct parser * p)877 static enum parser_error parse_mon_spell_save_message(struct parser *p) {
878 struct monster_spell *s = parser_priv(p);
879 struct monster_spell_level *l;
880 assert(s);
881
882 l = s->level;
883 while (l->next) {
884 l = l->next;
885 }
886 l->save_message = string_append(l->save_message, parser_getstr(p, "text"));
887 return PARSE_ERROR_NONE;
888 }
889
init_parse_mon_spell(void)890 struct parser *init_parse_mon_spell(void) {
891 struct parser *p = parser_new();
892 parser_setpriv(p, NULL);
893 parser_reg(p, "name str name", parse_mon_spell_name);
894 parser_reg(p, "msgt sym type", parse_mon_spell_message_type);
895 parser_reg(p, "hit uint hit", parse_mon_spell_hit);
896 parser_reg(p, "effect sym eff ?sym type ?int radius ?int other", parse_mon_spell_effect);
897 parser_reg(p, "effect-yx int y int x", parse_mon_spell_effect_yx);
898 parser_reg(p, "dice str dice", parse_mon_spell_dice);
899 parser_reg(p, "expr sym name sym base str expr", parse_mon_spell_expr);
900 parser_reg(p, "power-cutoff int power", parse_mon_spell_power_cutoff);
901 parser_reg(p, "lore str text", parse_mon_spell_lore_desc);
902 parser_reg(p, "lore-color-base sym color", parse_mon_spell_lore_color);
903 parser_reg(p, "lore-color-resist sym color", parse_mon_spell_lore_color_resist);
904 parser_reg(p, "lore-color-immune sym color", parse_mon_spell_lore_color_immune);
905 parser_reg(p, "message-vis str text", parse_mon_spell_message);
906 parser_reg(p, "message-invis str text", parse_mon_spell_blind_message);
907 parser_reg(p, "message-miss str text", parse_mon_spell_miss_message);
908 parser_reg(p, "message-save str text", parse_mon_spell_save_message);
909 return p;
910 }
911
run_parse_mon_spell(struct parser * p)912 static errr run_parse_mon_spell(struct parser *p) {
913 return parse_file_quit_not_found(p, "monster_spell");
914 }
915
finish_parse_mon_spell(struct parser * p)916 static errr finish_parse_mon_spell(struct parser *p) {
917 monster_spells = parser_priv(p);
918 parser_destroy(p);
919 return 0;
920 }
921
cleanup_mon_spell(void)922 static void cleanup_mon_spell(void)
923 {
924 struct monster_spell *rs = monster_spells;
925 struct monster_spell *next;
926 struct monster_spell_level *level;
927
928 while (rs) {
929 next = rs->next;
930 level = rs->level;
931 free_effect(rs->effect);
932 while (level) {
933 struct monster_spell_level *next_level = level->next;
934 string_free(level->lore_desc);
935 string_free(level->message);
936 string_free(level->blind_message);
937 string_free(level->miss_message);
938 string_free(level->save_message);
939 mem_free(level);
940 level = next_level;
941 }
942 mem_free(rs);
943 rs = next;
944 }
945 }
946
947 struct file_parser mon_spell_parser = {
948 "monster_spell",
949 init_parse_mon_spell,
950 run_parse_mon_spell,
951 finish_parse_mon_spell,
952 cleanup_mon_spell
953 };
954
955 /**
956 * ------------------------------------------------------------------------
957 * Initialize monster bases
958 * ------------------------------------------------------------------------ */
959
parse_mon_base_name(struct parser * p)960 static enum parser_error parse_mon_base_name(struct parser *p) {
961 struct monster_base *h = parser_priv(p);
962 struct monster_base *rb = mem_zalloc(sizeof *rb);
963 rb->next = h;
964 rb->name = string_make(parser_getstr(p, "name"));
965 parser_setpriv(p, rb);
966 return PARSE_ERROR_NONE;
967 }
968
parse_mon_base_glyph(struct parser * p)969 static enum parser_error parse_mon_base_glyph(struct parser *p) {
970 struct monster_base *rb = parser_priv(p);
971
972 if (!rb)
973 return PARSE_ERROR_MISSING_RECORD_HEADER;
974
975 rb->d_char = parser_getchar(p, "glyph");
976 return PARSE_ERROR_NONE;
977 }
978
parse_mon_base_pain(struct parser * p)979 static enum parser_error parse_mon_base_pain(struct parser *p) {
980 struct monster_base *rb = parser_priv(p);
981 int pain_idx;
982
983 if (!rb)
984 return PARSE_ERROR_MISSING_RECORD_HEADER;
985
986 pain_idx = parser_getuint(p, "pain");
987 if (pain_idx >= z_info->mp_max)
988 return PARSE_ERROR_OUT_OF_BOUNDS;
989
990 rb->pain = &pain_messages[pain_idx];
991
992 return PARSE_ERROR_NONE;
993 }
994
parse_mon_base_flags(struct parser * p)995 static enum parser_error parse_mon_base_flags(struct parser *p) {
996 struct monster_base *rb = parser_priv(p);
997 char *flags;
998 char *s;
999
1000 if (!rb)
1001 return PARSE_ERROR_MISSING_RECORD_HEADER;
1002 if (!parser_hasval(p, "flags"))
1003 return PARSE_ERROR_NONE;
1004 flags = string_make(parser_getstr(p, "flags"));
1005 s = strtok(flags, " |");
1006 while (s) {
1007 if (grab_flag(rb->flags, RF_SIZE, r_info_flags, s)) {
1008 mem_free(flags);
1009 quit_fmt("bad f-flag: %s", s);
1010 return PARSE_ERROR_INVALID_FLAG;
1011 }
1012 s = strtok(NULL, " |");
1013 }
1014
1015 mem_free(flags);
1016 return PARSE_ERROR_NONE;
1017 }
1018
parse_mon_base_desc(struct parser * p)1019 static enum parser_error parse_mon_base_desc(struct parser *p) {
1020 struct monster_base *rb = parser_priv(p);
1021
1022 if (!rb)
1023 return PARSE_ERROR_MISSING_RECORD_HEADER;
1024 rb->text = string_append(rb->text, parser_getstr(p, "desc"));
1025 return PARSE_ERROR_NONE;
1026 }
1027
1028
init_parse_mon_base(void)1029 static struct parser *init_parse_mon_base(void) {
1030 struct parser *p = parser_new();
1031 parser_setpriv(p, NULL);
1032
1033 parser_reg(p, "name str name", parse_mon_base_name);
1034 parser_reg(p, "glyph char glyph", parse_mon_base_glyph);
1035 parser_reg(p, "pain uint pain", parse_mon_base_pain);
1036 parser_reg(p, "flags ?str flags", parse_mon_base_flags);
1037 parser_reg(p, "desc str desc", parse_mon_base_desc);
1038 return p;
1039 }
1040
run_parse_mon_base(struct parser * p)1041 static errr run_parse_mon_base(struct parser *p) {
1042 return parse_file_quit_not_found(p, "monster_base");
1043 }
1044
finish_parse_mon_base(struct parser * p)1045 static errr finish_parse_mon_base(struct parser *p) {
1046 rb_info = parser_priv(p);
1047 parser_destroy(p);
1048 return 0;
1049 }
1050
cleanup_mon_base(void)1051 static void cleanup_mon_base(void)
1052 {
1053 struct monster_base *rb, *next;
1054
1055 rb = rb_info;
1056 while (rb) {
1057 next = rb->next;
1058 string_free(rb->text);
1059 string_free(rb->name);
1060 mem_free(rb);
1061 rb = next;
1062 }
1063 }
1064
1065 struct file_parser mon_base_parser = {
1066 "monster_base",
1067 init_parse_mon_base,
1068 run_parse_mon_base,
1069 finish_parse_mon_base,
1070 cleanup_mon_base
1071 };
1072
1073
1074 /**
1075 * ------------------------------------------------------------------------
1076 * Initialize monsters
1077 * ------------------------------------------------------------------------ */
1078
parse_monster_name(struct parser * p)1079 static enum parser_error parse_monster_name(struct parser *p) {
1080 struct monster_race *h = parser_priv(p);
1081 struct monster_race *r = mem_zalloc(sizeof *r);
1082 r->next = h;
1083 r->name = string_make(parser_getstr(p, "name"));
1084 parser_setpriv(p, r);
1085 return PARSE_ERROR_NONE;
1086 }
1087
parse_monster_base(struct parser * p)1088 static enum parser_error parse_monster_base(struct parser *p) {
1089 struct monster_race *r = parser_priv(p);
1090
1091 r->base = lookup_monster_base(parser_getsym(p, "base"));
1092 if (r->base == NULL)
1093 return PARSE_ERROR_INVALID_MONSTER_BASE;
1094
1095 /* The template sets the default display character */
1096 r->d_char = r->base->d_char;
1097
1098 /* Give the monster its default flags */
1099 rf_union(r->flags, r->base->flags);
1100
1101 return PARSE_ERROR_NONE;
1102 }
1103
parse_monster_glyph(struct parser * p)1104 static enum parser_error parse_monster_glyph(struct parser *p) {
1105 struct monster_race *r = parser_priv(p);
1106
1107 /* If the display character is specified, it overrides any template */
1108 r->d_char = parser_getchar(p, "glyph");
1109
1110 return PARSE_ERROR_NONE;
1111 }
1112
parse_monster_color(struct parser * p)1113 static enum parser_error parse_monster_color(struct parser *p) {
1114 struct monster_race *r = parser_priv(p);
1115 const char *color;
1116 int attr;
1117
1118 if (!r)
1119 return PARSE_ERROR_MISSING_RECORD_HEADER;
1120
1121 color = parser_getsym(p, "color");
1122 if (strlen(color) > 1)
1123 attr = color_text_to_attr(color);
1124 else
1125 attr = color_char_to_attr(color[0]);
1126 if (attr < 0)
1127 return PARSE_ERROR_INVALID_COLOR;
1128 r->d_attr = attr;
1129 return PARSE_ERROR_NONE;
1130 }
1131
parse_monster_speed(struct parser * p)1132 static enum parser_error parse_monster_speed(struct parser *p) {
1133 struct monster_race *r = parser_priv(p);
1134
1135 if (!r)
1136 return PARSE_ERROR_MISSING_RECORD_HEADER;
1137 r->speed = parser_getint(p, "speed");
1138 return PARSE_ERROR_NONE;
1139 }
1140
parse_monster_hit_points(struct parser * p)1141 static enum parser_error parse_monster_hit_points(struct parser *p) {
1142 struct monster_race *r = parser_priv(p);
1143
1144 if (!r)
1145 return PARSE_ERROR_MISSING_RECORD_HEADER;
1146 r->avg_hp = parser_getint(p, "hp");
1147 return PARSE_ERROR_NONE;
1148 }
1149
parse_monster_light(struct parser * p)1150 static enum parser_error parse_monster_light(struct parser *p) {
1151 struct monster_race *r = parser_priv(p);
1152
1153 if (!r)
1154 return PARSE_ERROR_MISSING_RECORD_HEADER;
1155 r->light = parser_getint(p, "light");
1156 return PARSE_ERROR_NONE;
1157 }
1158
parse_monster_hearing(struct parser * p)1159 static enum parser_error parse_monster_hearing(struct parser *p) {
1160 struct monster_race *r = parser_priv(p);
1161
1162 if (!r)
1163 return PARSE_ERROR_MISSING_RECORD_HEADER;
1164 /* Assumes max_sight is 20, so we adjust in case it isn't */
1165 r->hearing = parser_getint(p, "hearing") * 20 / z_info->max_sight;
1166 return PARSE_ERROR_NONE;
1167 }
1168
parse_monster_smell(struct parser * p)1169 static enum parser_error parse_monster_smell(struct parser *p) {
1170 struct monster_race *r = parser_priv(p);
1171
1172 if (!r)
1173 return PARSE_ERROR_MISSING_RECORD_HEADER;
1174 /* Assumes max_sight is 20, so we adjust in case it isn't */
1175 r->smell = parser_getint(p, "smell") * 20 / z_info->max_sight;
1176 return PARSE_ERROR_NONE;
1177 }
1178
parse_monster_armor_class(struct parser * p)1179 static enum parser_error parse_monster_armor_class(struct parser *p) {
1180 struct monster_race *r = parser_priv(p);
1181
1182 if (!r)
1183 return PARSE_ERROR_MISSING_RECORD_HEADER;
1184 r->ac = parser_getint(p, "ac");
1185 return PARSE_ERROR_NONE;
1186 }
1187
parse_monster_sleepiness(struct parser * p)1188 static enum parser_error parse_monster_sleepiness(struct parser *p) {
1189 struct monster_race *r = parser_priv(p);
1190
1191 if (!r)
1192 return PARSE_ERROR_MISSING_RECORD_HEADER;
1193 r->sleep = parser_getint(p, "sleep");
1194 return PARSE_ERROR_NONE;
1195 }
1196
parse_monster_depth(struct parser * p)1197 static enum parser_error parse_monster_depth(struct parser *p) {
1198 struct monster_race *r = parser_priv(p);
1199
1200 if (!r)
1201 return PARSE_ERROR_MISSING_RECORD_HEADER;
1202 r->level = parser_getint(p, "level");
1203
1204 /* Level is default spell power */
1205 r->spell_power = r->level;
1206 return PARSE_ERROR_NONE;
1207 }
1208
parse_monster_rarity(struct parser * p)1209 static enum parser_error parse_monster_rarity(struct parser *p) {
1210 struct monster_race *r = parser_priv(p);
1211
1212 if (!r)
1213 return PARSE_ERROR_MISSING_RECORD_HEADER;
1214 r->rarity = parser_getint(p, "rarity");
1215 return PARSE_ERROR_NONE;
1216 }
1217
parse_monster_experience(struct parser * p)1218 static enum parser_error parse_monster_experience(struct parser *p) {
1219 struct monster_race *r = parser_priv(p);
1220
1221 if (!r)
1222 return PARSE_ERROR_MISSING_RECORD_HEADER;
1223 r->mexp = parser_getint(p, "mexp");
1224 return PARSE_ERROR_NONE;
1225 }
1226
parse_monster_blow(struct parser * p)1227 static enum parser_error parse_monster_blow(struct parser *p) {
1228 struct monster_race *r = parser_priv(p);
1229 struct monster_blow *b = r->blow;
1230
1231 if (!r)
1232 return PARSE_ERROR_MISSING_RECORD_HEADER;
1233
1234 /* Go to the last valid blow, then allocate a new one */
1235 if (!b) {
1236 r->blow = mem_zalloc(sizeof(struct monster_blow));
1237 b = r->blow;
1238 } else {
1239 while (b->next)
1240 b = b->next;
1241 b->next = mem_zalloc(sizeof(struct monster_blow));
1242 b = b->next;
1243 }
1244
1245 /* Now read the data */
1246 b->method = findmeth(parser_getsym(p, "method"));
1247 if (!b->method)
1248 return PARSE_ERROR_UNRECOGNISED_BLOW;
1249 if (parser_hasval(p, "effect")) {
1250 b->effect = findeff(parser_getsym(p, "effect"));
1251 if (!b->effect)
1252 return PARSE_ERROR_INVALID_EFFECT;
1253 } else {
1254 b->effect = findeff("NONE");
1255 }
1256 if (parser_hasval(p, "damage"))
1257 b->dice = parser_getrand(p, "damage");
1258
1259 return PARSE_ERROR_NONE;
1260 }
1261
parse_monster_flags(struct parser * p)1262 static enum parser_error parse_monster_flags(struct parser *p) {
1263 struct monster_race *r = parser_priv(p);
1264 char *flags;
1265 char *s;
1266
1267 if (!r)
1268 return PARSE_ERROR_MISSING_RECORD_HEADER;
1269 if (!parser_hasval(p, "flags"))
1270 return PARSE_ERROR_NONE;
1271 flags = string_make(parser_getstr(p, "flags"));
1272 s = strtok(flags, " |");
1273 while (s) {
1274 if (grab_flag(r->flags, RF_SIZE, r_info_flags, s)) {
1275 mem_free(flags);
1276 quit_fmt("bad f2-flag: %s", s);
1277 return PARSE_ERROR_INVALID_FLAG;
1278 }
1279 s = strtok(NULL, " |");
1280 }
1281
1282 mem_free(flags);
1283 return PARSE_ERROR_NONE;
1284 }
1285
parse_monster_flags_off(struct parser * p)1286 static enum parser_error parse_monster_flags_off(struct parser *p) {
1287 struct monster_race *r = parser_priv(p);
1288 char *flags;
1289 char *s;
1290
1291 if (!r)
1292 return PARSE_ERROR_MISSING_RECORD_HEADER;
1293 if (!parser_hasval(p, "flags"))
1294 return PARSE_ERROR_NONE;
1295 flags = string_make(parser_getstr(p, "flags"));
1296 s = strtok(flags, " |");
1297 while (s) {
1298 if (remove_flag(r->flags, RF_SIZE, r_info_flags, s)) {
1299 mem_free(flags);
1300 quit_fmt("bad mf-flag: %s", s);
1301 return PARSE_ERROR_INVALID_FLAG;
1302 }
1303 s = strtok(NULL, " |");
1304 }
1305
1306 mem_free(flags);
1307 return PARSE_ERROR_NONE;
1308 }
1309
parse_monster_desc(struct parser * p)1310 static enum parser_error parse_monster_desc(struct parser *p) {
1311 struct monster_race *r = parser_priv(p);
1312
1313 if (!r)
1314 return PARSE_ERROR_MISSING_RECORD_HEADER;
1315 r->text = string_append(r->text, parser_getstr(p, "desc"));
1316 return PARSE_ERROR_NONE;
1317 }
1318
parse_monster_innate_freq(struct parser * p)1319 static enum parser_error parse_monster_innate_freq(struct parser *p) {
1320 struct monster_race *r = parser_priv(p);
1321 int pct;
1322
1323 if (!r)
1324 return PARSE_ERROR_MISSING_RECORD_HEADER;
1325 pct = parser_getint(p, "freq");
1326 if (pct < 1 || pct > 100)
1327 return PARSE_ERROR_INVALID_SPELL_FREQ;
1328 r->freq_innate = 100 / pct;
1329 return PARSE_ERROR_NONE;
1330 }
1331
parse_monster_spell_freq(struct parser * p)1332 static enum parser_error parse_monster_spell_freq(struct parser *p) {
1333 struct monster_race *r = parser_priv(p);
1334 int pct;
1335
1336 if (!r)
1337 return PARSE_ERROR_MISSING_RECORD_HEADER;
1338 pct = parser_getint(p, "freq");
1339 if (pct < 1 || pct > 100)
1340 return PARSE_ERROR_INVALID_SPELL_FREQ;
1341 r->freq_spell = 100 / pct;
1342 return PARSE_ERROR_NONE;
1343 }
1344
parse_monster_spell_power(struct parser * p)1345 static enum parser_error parse_monster_spell_power(struct parser *p) {
1346 struct monster_race *r = parser_priv(p);
1347
1348 if (!r)
1349 return PARSE_ERROR_MISSING_RECORD_HEADER;
1350 r->spell_power = parser_getuint(p, "power");
1351 return PARSE_ERROR_NONE;
1352 }
1353
parse_monster_spells(struct parser * p)1354 static enum parser_error parse_monster_spells(struct parser *p) {
1355 struct monster_race *r = parser_priv(p);
1356 char *flags;
1357 char *s;
1358 int ret = PARSE_ERROR_NONE;
1359 bitflag current_flags[RSF_SIZE], test_flags[RSF_SIZE];
1360
1361 if (!r)
1362 return PARSE_ERROR_MISSING_RECORD_HEADER;
1363 flags = string_make(parser_getstr(p, "spells"));
1364 s = strtok(flags, " |");
1365 while (s) {
1366 if (grab_flag(r->spell_flags, RSF_SIZE, r_info_spell_flags, s)) {
1367 quit_fmt("bad spell flag: %s", s);
1368 ret = PARSE_ERROR_INVALID_FLAG;
1369 break;
1370 }
1371 s = strtok(NULL, " |");
1372 }
1373
1374 /* Add the "base monster" flags to the monster */
1375 if (r->base)
1376 rsf_union(r->spell_flags, r->base->spell_flags);
1377
1378 /* Make sure innate frequency is set if necessary */
1379 create_mon_spell_mask(current_flags, RST_INNATE, RST_NONE);
1380 rsf_inter(current_flags, r->spell_flags);
1381 if (!rsf_is_empty(current_flags) && !r->freq_innate) {
1382 /* Set frequency to the lowest found value */
1383 r->freq_innate = 4;
1384 }
1385
1386 /* Make sure innate frequency is set if necessary */
1387 rsf_copy(current_flags, r->spell_flags);
1388 create_mon_spell_mask(test_flags, RST_BREATH, RST_INNATE, RST_NONE);
1389 rsf_diff(current_flags, test_flags);
1390 if (!rsf_is_empty(current_flags) && !r->freq_spell) {
1391 /* Set frequency to the lowest found value */
1392 r->freq_spell = 4;
1393 }
1394
1395 mem_free(flags);
1396 return ret;
1397 }
1398
parse_monster_drop(struct parser * p)1399 static enum parser_error parse_monster_drop(struct parser *p) {
1400 struct monster_race *r = parser_priv(p);
1401 struct monster_drop *d;
1402 struct object_kind *k;
1403 int tval, sval;
1404
1405 if (!r)
1406 return PARSE_ERROR_MISSING_RECORD_HEADER;
1407 tval = tval_find_idx(parser_getsym(p, "tval"));
1408 if (tval < 0)
1409 return PARSE_ERROR_UNRECOGNISED_TVAL;
1410 sval = lookup_sval(tval, parser_getsym(p, "sval"));
1411 if (sval < 0)
1412 return PARSE_ERROR_UNRECOGNISED_SVAL;
1413
1414 if (parser_getuint(p, "min") > 99 || parser_getuint(p, "max") > 99)
1415 return PARSE_ERROR_INVALID_ITEM_NUMBER;
1416
1417 k = lookup_kind(tval, sval);
1418 if (!k)
1419 return PARSE_ERROR_UNRECOGNISED_SVAL;
1420
1421 d = mem_zalloc(sizeof *d);
1422 d->kind = k;
1423 d->percent_chance = parser_getuint(p, "chance");
1424 d->min = parser_getuint(p, "min");
1425 d->max = parser_getuint(p, "max");
1426 d->next = r->drops;
1427 r->drops = d;
1428 return PARSE_ERROR_NONE;
1429 }
1430
parse_monster_drop_base(struct parser * p)1431 static enum parser_error parse_monster_drop_base(struct parser *p) {
1432 struct monster_race *r = parser_priv(p);
1433 struct monster_drop *d;
1434 int tval;
1435
1436 if (!r)
1437 return PARSE_ERROR_MISSING_RECORD_HEADER;
1438 tval = tval_find_idx(parser_getsym(p, "tval"));
1439 if (tval < 0)
1440 return PARSE_ERROR_UNRECOGNISED_TVAL;
1441
1442 if (parser_getuint(p, "min") > 99 || parser_getuint(p, "max") > 99)
1443 return PARSE_ERROR_INVALID_ITEM_NUMBER;
1444
1445 d = mem_zalloc(sizeof *d);
1446 d->tval = tval;
1447 d->percent_chance = parser_getuint(p, "chance");
1448 d->min = parser_getuint(p, "min");
1449 d->max = parser_getuint(p, "max");
1450 d->next = r->drops;
1451 r->drops = d;
1452 return PARSE_ERROR_NONE;
1453 }
1454
parse_monster_friends(struct parser * p)1455 static enum parser_error parse_monster_friends(struct parser *p) {
1456 struct monster_race *r = parser_priv(p);
1457 struct monster_friends *f;
1458 struct random number;
1459
1460 if (!r)
1461 return PARSE_ERROR_MISSING_RECORD_HEADER;
1462 f = mem_zalloc(sizeof *f);
1463 number = parser_getrand(p, "number");
1464 f->number_dice = number.dice;
1465 f->number_side = number.sides;
1466 f->percent_chance = parser_getuint(p, "chance");
1467 f->name = string_make(parser_getsym(p, "name"));
1468 if (parser_hasval(p, "role")) {
1469 const char *role_name = parser_getsym(p, "role");
1470 if (streq(role_name, "servant")) {
1471 f->role = MON_GROUP_SERVANT;
1472 } else if (streq(role_name, "bodyguard")) {
1473 f->role = MON_GROUP_BODYGUARD;
1474 } else {
1475 return PARSE_ERROR_INVALID_MONSTER_ROLE;
1476 }
1477 } else {
1478 f->role = MON_GROUP_MEMBER;
1479 }
1480 f->next = r->friends;
1481 r->friends = f;
1482
1483 return PARSE_ERROR_NONE;
1484 }
1485
parse_monster_friends_base(struct parser * p)1486 static enum parser_error parse_monster_friends_base(struct parser *p) {
1487 struct monster_race *r = parser_priv(p);
1488 struct monster_friends_base *f;
1489 struct random number;
1490
1491 if (!r)
1492 return PARSE_ERROR_MISSING_RECORD_HEADER;
1493 f = mem_zalloc(sizeof *f);
1494 number = parser_getrand(p, "number");
1495 f->number_dice = number.dice;
1496 f->number_side = number.sides;
1497 f->percent_chance = parser_getuint(p, "chance");
1498 f->base = lookup_monster_base(parser_getsym(p, "name"));
1499 if (!f->base) return PARSE_ERROR_UNRECOGNISED_TVAL;
1500 if (parser_hasval(p, "role")) {
1501 const char *role_name = parser_getsym(p, "role");
1502 if (streq(role_name, "servant")) {
1503 f->role = MON_GROUP_SERVANT;
1504 } else if (streq(role_name, "bodyguard")) {
1505 f->role = MON_GROUP_BODYGUARD;
1506 } else {
1507 return PARSE_ERROR_INVALID_MONSTER_ROLE;
1508 }
1509 } else {
1510 f->role = MON_GROUP_MEMBER;
1511 }
1512
1513 f->next = r->friends_base;
1514 r->friends_base = f;
1515
1516 return PARSE_ERROR_NONE;
1517 }
1518
parse_monster_mimic(struct parser * p)1519 static enum parser_error parse_monster_mimic(struct parser *p) {
1520 struct monster_race *r = parser_priv(p);
1521 struct monster_mimic *m;
1522 int tval, sval;
1523 struct object_kind *kind;
1524
1525 if (!r)
1526 return PARSE_ERROR_MISSING_RECORD_HEADER;
1527 tval = tval_find_idx(parser_getsym(p, "tval"));
1528 if (tval < 0)
1529 return PARSE_ERROR_UNRECOGNISED_TVAL;
1530 sval = lookup_sval(tval, parser_getsym(p, "sval"));
1531 if (sval < 0)
1532 return PARSE_ERROR_UNRECOGNISED_SVAL;
1533
1534 kind = lookup_kind(tval, sval);
1535 if (!kind)
1536 return PARSE_ERROR_NO_KIND_FOUND;
1537 m = mem_zalloc(sizeof *m);
1538 m->kind = kind;
1539 m->next = r->mimic_kinds;
1540 r->mimic_kinds = m;
1541 return PARSE_ERROR_NONE;
1542 }
1543
parse_monster_shape(struct parser * p)1544 static enum parser_error parse_monster_shape(struct parser *p) {
1545 struct monster_race *r = parser_priv(p);
1546 struct monster_shape *s;
1547
1548 if (!r)
1549 return PARSE_ERROR_MISSING_RECORD_HEADER;
1550 s = mem_zalloc(sizeof *s);
1551 s->name = string_make(parser_getstr(p, "name"));
1552 s->base = lookup_monster_base(s->name);
1553 s->next = r->shapes;
1554 r->shapes = s;
1555 r->num_shapes++;
1556
1557 return PARSE_ERROR_NONE;
1558 }
1559
parse_monster_plural(struct parser * p)1560 static enum parser_error parse_monster_plural(struct parser *p)
1561 {
1562 struct monster_race *r = parser_priv(p);
1563
1564 if (r == NULL)
1565 return PARSE_ERROR_MISSING_RECORD_HEADER;
1566
1567 if (parser_hasval(p, "plural")) {
1568 const char *plural = parser_getstr(p, "plural");
1569
1570 if (strlen(plural) > 0)
1571 r->plural = string_make(plural);
1572 else
1573 r->plural = NULL;
1574 }
1575
1576 return PARSE_ERROR_NONE;
1577 }
1578
parse_monster_color_cycle(struct parser * p)1579 static enum parser_error parse_monster_color_cycle(struct parser *p)
1580 {
1581 struct monster_race *r = parser_priv(p);
1582 const char *group = parser_getsym(p, "group");
1583 const char *cycle = parser_getsym(p, "cycle");
1584
1585 if (r == NULL)
1586 return PARSE_ERROR_MISSING_RECORD_HEADER;
1587
1588 if (group == NULL || strlen(group) == 0)
1589 return PARSE_ERROR_INVALID_VALUE;
1590
1591 if (cycle == NULL || strlen(cycle) == 0)
1592 return PARSE_ERROR_INVALID_VALUE;
1593
1594 visuals_cycler_set_cycle_for_race(r, group, cycle);
1595
1596 return PARSE_ERROR_NONE;
1597 }
1598
init_parse_monster(void)1599 struct parser *init_parse_monster(void) {
1600 struct parser *p = parser_new();
1601 parser_setpriv(p, NULL);
1602
1603 parser_reg(p, "name str name", parse_monster_name);
1604 parser_reg(p, "plural ?str plural", parse_monster_plural);
1605 parser_reg(p, "base sym base", parse_monster_base);
1606 parser_reg(p, "glyph char glyph", parse_monster_glyph);
1607 parser_reg(p, "color sym color", parse_monster_color);
1608 parser_reg(p, "speed int speed", parse_monster_speed);
1609 parser_reg(p, "hit-points int hp", parse_monster_hit_points);
1610 parser_reg(p, "light int light", parse_monster_light);
1611 parser_reg(p, "hearing int hearing", parse_monster_hearing);
1612 parser_reg(p, "smell int smell", parse_monster_smell);
1613 parser_reg(p, "armor-class int ac", parse_monster_armor_class);
1614 parser_reg(p, "sleepiness int sleep", parse_monster_sleepiness);
1615 parser_reg(p, "depth int level", parse_monster_depth);
1616 parser_reg(p, "rarity int rarity", parse_monster_rarity);
1617 parser_reg(p, "experience int mexp", parse_monster_experience);
1618 parser_reg(p, "blow sym method ?sym effect ?rand damage", parse_monster_blow);
1619 parser_reg(p, "flags ?str flags", parse_monster_flags);
1620 parser_reg(p, "flags-off ?str flags", parse_monster_flags_off);
1621 parser_reg(p, "desc str desc", parse_monster_desc);
1622 parser_reg(p, "innate-freq int freq", parse_monster_innate_freq);
1623 parser_reg(p, "spell-freq int freq", parse_monster_spell_freq);
1624 parser_reg(p, "spell-power uint power", parse_monster_spell_power);
1625 parser_reg(p, "spells str spells", parse_monster_spells);
1626 parser_reg(p, "drop sym tval sym sval uint chance uint min uint max", parse_monster_drop);
1627 parser_reg(p, "drop-base sym tval uint chance uint min uint max", parse_monster_drop_base);
1628 parser_reg(p, "friends uint chance rand number sym name ?sym role", parse_monster_friends);
1629 parser_reg(p, "friends-base uint chance rand number sym name ?sym role", parse_monster_friends_base);
1630 parser_reg(p, "mimic sym tval sym sval", parse_monster_mimic);
1631 parser_reg(p, "shape str name", parse_monster_shape);
1632 parser_reg(p, "color-cycle sym group sym cycle", parse_monster_color_cycle);
1633 return p;
1634 }
1635
run_parse_monster(struct parser * p)1636 static errr run_parse_monster(struct parser *p) {
1637 return parse_file_quit_not_found(p, "monster");
1638 }
1639
finish_parse_monster(struct parser * p)1640 static errr finish_parse_monster(struct parser *p) {
1641 struct monster_race *r, *n;
1642 size_t i;
1643 int ridx;
1644
1645 /* Scan the list for the max id and max blows */
1646 z_info->r_max = 0;
1647 z_info->mon_blows_max = 0;
1648 r = parser_priv(p);
1649 while (r) {
1650 int max_blows = 0;
1651 struct monster_blow *b = r->blow;
1652 z_info->r_max++;
1653 while (b) {
1654 b = b->next;
1655 max_blows++;
1656 }
1657 if (max_blows > z_info->mon_blows_max)
1658 z_info->mon_blows_max = max_blows;
1659 r = r->next;
1660 }
1661
1662 /* Allocate the direct access list and copy the race records to it */
1663 r_info = mem_zalloc((z_info->r_max + 1) * sizeof(*r));
1664 ridx = z_info->r_max - 1;
1665 for (r = parser_priv(p); r; r = n, ridx--) {
1666 struct monster_blow *b_new;
1667
1668 assert(ridx >= 0);
1669
1670 /* Main record */
1671 memcpy(&r_info[ridx], r, sizeof(*r));
1672 r_info[ridx].ridx = ridx;
1673 n = r->next;
1674 if (ridx < z_info->r_max - 1)
1675 r_info[ridx].next = &r_info[ridx + 1];
1676 else
1677 r_info[ridx].next = NULL;
1678
1679 /* Blows */
1680 b_new = mem_zalloc(z_info->mon_blows_max * sizeof(*b_new));
1681 if (r->blow) {
1682 struct monster_blow *b_temp, *b_old = r->blow;
1683
1684 /* Allocate space and copy */
1685 for (i = 0; i < z_info->mon_blows_max; i++) {
1686 memcpy(&b_new[i], b_old, sizeof(*b_old));
1687 b_old = b_old->next;
1688 if (!b_old) break;
1689 }
1690
1691 /* Make next point correctly */
1692 for (i = 0; i < z_info->mon_blows_max; i++)
1693 if (b_new[i].next)
1694 b_new[i].next = &b_new[i + 1];
1695
1696 /* Tidy up */
1697 b_old = r->blow;
1698 b_temp = b_old;
1699 while (b_temp) {
1700 b_temp = b_old->next;
1701 mem_free(b_old);
1702 b_old = b_temp;
1703 }
1704 }
1705 r_info[ridx].blow = b_new;
1706
1707 mem_free(r);
1708 }
1709 z_info->r_max += 1;
1710
1711 /* Convert friend and shape names into race pointers */
1712 for (i = 0; i < z_info->r_max; i++) {
1713 struct monster_race *race = &r_info[i];
1714 struct monster_friends *f;
1715 struct monster_shape *s;
1716 for (f = race->friends; f; f = f->next) {
1717 if (!my_stricmp(f->name, "same")) {
1718 f->race = race;
1719 } else {
1720 f->race = lookup_monster(f->name);
1721 }
1722 if (!f->race) {
1723 quit_fmt("Couldn't find friend named '%s' for monster '%s'",
1724 f->name, race->name);
1725 }
1726 string_free(f->name);
1727 }
1728 for (s = race->shapes; s; s = s->next) {
1729 if (!s->base) {
1730 s->race = lookup_monster(s->name);
1731 if (!s->race) {
1732 quit_fmt("Couldn't find shape named '%s' for monster '%s'",
1733 s->name, race->name);
1734 }
1735 }
1736 string_free(s->name);
1737 }
1738 }
1739
1740 /* Allocate space for the monster lore */
1741 l_list = mem_zalloc(z_info->r_max * sizeof(struct monster_lore));
1742 for (i = 0; i < z_info->r_max; i++) {
1743 struct monster_lore *l = &l_list[i];
1744 l->blows = mem_zalloc(z_info->mon_blows_max * sizeof(struct monster_blow));
1745 l->blow_known = mem_zalloc(z_info->mon_blows_max * sizeof(bool));
1746 }
1747
1748 parser_destroy(p);
1749 return 0;
1750 }
1751
cleanup_monster(void)1752 static void cleanup_monster(void)
1753 {
1754 int ridx;
1755
1756 for (ridx = 0; ridx < z_info->r_max; ridx++) {
1757 struct monster_race *r = &r_info[ridx];
1758 struct monster_drop *d;
1759 struct monster_friends *f;
1760 struct monster_friends_base *fb;
1761 struct monster_mimic *m;
1762 struct monster_shape *s;
1763
1764 d = r->drops;
1765 while (d) {
1766 struct monster_drop *dn = d->next;
1767 mem_free(d);
1768 d = dn;
1769 }
1770 f = r->friends;
1771 while (f) {
1772 struct monster_friends *fn = f->next;
1773 mem_free(f);
1774 f = fn;
1775 }
1776 fb = r->friends_base;
1777 while (fb) {
1778 struct monster_friends_base *fbn = fb->next;
1779 mem_free(fb);
1780 fb = fbn;
1781 }
1782 m = r->mimic_kinds;
1783 while (m) {
1784 struct monster_mimic *mn = m->next;
1785 mem_free(m);
1786 m = mn;
1787 }
1788 s = r->shapes;
1789 while (s) {
1790 struct monster_shape *sn = s->next;
1791 mem_free(s);
1792 s = sn;
1793 }
1794 string_free(r->plural);
1795 string_free(r->text);
1796 string_free(r->name);
1797 mem_free(r->blow);
1798 }
1799
1800 mem_free(r_info);
1801 }
1802
1803 struct file_parser monster_parser = {
1804 "monster",
1805 init_parse_monster,
1806 run_parse_monster,
1807 finish_parse_monster,
1808 cleanup_monster
1809 };
1810
1811 /**
1812 * ------------------------------------------------------------------------
1813 * Initialize monster pits
1814 * ------------------------------------------------------------------------ */
1815
parse_pit_name(struct parser * p)1816 static enum parser_error parse_pit_name(struct parser *p) {
1817 struct pit_profile *h = parser_priv(p);
1818 struct pit_profile *pit = mem_zalloc(sizeof *pit);
1819 pit->next = h;
1820 pit->name = string_make(parser_getstr(p, "name"));
1821 pit->colors = NULL;
1822 pit->forbidden_monsters = NULL;
1823 parser_setpriv(p, pit);
1824 return PARSE_ERROR_NONE;
1825 }
1826
parse_pit_room(struct parser * p)1827 static enum parser_error parse_pit_room(struct parser *p) {
1828 struct pit_profile *pit = parser_priv(p);
1829
1830 if (!pit)
1831 return PARSE_ERROR_MISSING_RECORD_HEADER;
1832
1833 pit->room_type = parser_getuint(p, "type");
1834 return PARSE_ERROR_NONE;
1835 }
parse_pit_alloc(struct parser * p)1836 static enum parser_error parse_pit_alloc(struct parser *p) {
1837 struct pit_profile *pit = parser_priv(p);
1838
1839 if (!pit)
1840 return PARSE_ERROR_MISSING_RECORD_HEADER;
1841
1842 pit->rarity = parser_getuint(p, "rarity");
1843 pit->ave = parser_getuint(p, "level");
1844 return PARSE_ERROR_NONE;
1845 }
1846
parse_pit_obj_rarity(struct parser * p)1847 static enum parser_error parse_pit_obj_rarity(struct parser *p) {
1848 struct pit_profile *pit = parser_priv(p);
1849
1850 if (!pit)
1851 return PARSE_ERROR_MISSING_RECORD_HEADER;
1852
1853 pit->obj_rarity = parser_getuint(p, "obj_rarity");
1854 return PARSE_ERROR_NONE;
1855 }
1856
parse_pit_mon_base(struct parser * p)1857 static enum parser_error parse_pit_mon_base(struct parser *p) {
1858 struct pit_profile *pit = parser_priv(p);
1859 struct pit_monster_profile *bases;
1860 struct monster_base *base = lookup_monster_base(parser_getsym(p, "base"));
1861
1862 if (!pit)
1863 return PARSE_ERROR_MISSING_RECORD_HEADER;
1864 else if (!base)
1865 return PARSE_ERROR_UNRECOGNISED_TVAL;
1866
1867 bases = mem_zalloc(sizeof *bases);
1868 bases->base = base;
1869 bases->next = pit->bases;
1870 pit->bases = bases;
1871 return PARSE_ERROR_NONE;
1872 }
1873
parse_pit_mon_ban(struct parser * p)1874 static enum parser_error parse_pit_mon_ban(struct parser *p) {
1875 struct pit_profile *pit = parser_priv(p);
1876 struct pit_forbidden_monster *monsters;
1877 struct monster_race *r = lookup_monster(parser_getsym(p, "race"));
1878
1879 if (!pit)
1880 return PARSE_ERROR_MISSING_RECORD_HEADER;
1881
1882 monsters = mem_zalloc(sizeof *monsters);
1883 monsters->race = r;
1884 monsters->next = pit->forbidden_monsters;
1885 pit->forbidden_monsters = monsters;
1886 return PARSE_ERROR_NONE;
1887 }
1888
parse_pit_color(struct parser * p)1889 static enum parser_error parse_pit_color(struct parser *p) {
1890 struct pit_profile *pit = parser_priv(p);
1891 struct pit_color_profile *colors;
1892 const char *color;
1893 int attr;
1894
1895 if (!pit)
1896 return PARSE_ERROR_MISSING_RECORD_HEADER;
1897 color = parser_getsym(p, "color");
1898 if (strlen(color) > 1)
1899 attr = color_text_to_attr(color);
1900 else
1901 attr = color_char_to_attr(color[0]);
1902 if (attr < 0)
1903 return PARSE_ERROR_INVALID_COLOR;
1904
1905 colors = mem_zalloc(sizeof *colors);
1906 colors->color = attr;
1907 colors->next = pit->colors;
1908 pit->colors = colors;
1909 return PARSE_ERROR_NONE;
1910 }
1911
parse_pit_flags_req(struct parser * p)1912 static enum parser_error parse_pit_flags_req(struct parser *p) {
1913 struct pit_profile *pit = parser_priv(p);
1914 char *flags;
1915 char *s;
1916
1917 if (!pit)
1918 return PARSE_ERROR_MISSING_RECORD_HEADER;
1919 if (!parser_hasval(p, "flags"))
1920 return PARSE_ERROR_NONE;
1921 flags = string_make(parser_getstr(p, "flags"));
1922 s = strtok(flags, " |");
1923 while (s) {
1924 if (grab_flag(pit->flags, RF_SIZE, r_info_flags, s)) {
1925 mem_free(flags);
1926 return PARSE_ERROR_INVALID_FLAG;
1927 }
1928 s = strtok(NULL, " |");
1929 }
1930
1931 mem_free(flags);
1932 return PARSE_ERROR_NONE;
1933 }
1934
parse_pit_flags_ban(struct parser * p)1935 static enum parser_error parse_pit_flags_ban(struct parser *p) {
1936 struct pit_profile *pit = parser_priv(p);
1937 char *flags;
1938 char *s;
1939
1940 if (!pit)
1941 return PARSE_ERROR_MISSING_RECORD_HEADER;
1942 if (!parser_hasval(p, "flags"))
1943 return PARSE_ERROR_NONE;
1944 flags = string_make(parser_getstr(p, "flags"));
1945 s = strtok(flags, " |");
1946 while (s) {
1947 if (grab_flag(pit->forbidden_flags, RF_SIZE, r_info_flags, s)) {
1948 mem_free(flags);
1949 return PARSE_ERROR_INVALID_FLAG;
1950 }
1951 s = strtok(NULL, " |");
1952 }
1953
1954 mem_free(flags);
1955 return PARSE_ERROR_NONE;
1956 }
1957
parse_pit_innate_freq(struct parser * p)1958 static enum parser_error parse_pit_innate_freq(struct parser *p) {
1959 struct pit_profile *pit = parser_priv(p);
1960 int pct;
1961
1962 if (!pit)
1963 return PARSE_ERROR_MISSING_RECORD_HEADER;
1964 pct = parser_getint(p, "freq");
1965 if (pct < 1 || pct > 100)
1966 return PARSE_ERROR_INVALID_SPELL_FREQ;
1967 pit->freq_innate = 100 / pct;
1968 return PARSE_ERROR_NONE;
1969 }
parse_pit_spell_req(struct parser * p)1970 static enum parser_error parse_pit_spell_req(struct parser *p) {
1971 struct pit_profile *pit = parser_priv(p);
1972 char *flags;
1973 char *s;
1974
1975 if (!pit)
1976 return PARSE_ERROR_MISSING_RECORD_HEADER;
1977 if (!parser_hasval(p, "spells"))
1978 return PARSE_ERROR_NONE;
1979 flags = string_make(parser_getstr(p, "spells"));
1980 s = strtok(flags, " |");
1981 while (s) {
1982 if (grab_flag(pit->spell_flags, RSF_SIZE, r_info_spell_flags, s)) {
1983 mem_free(flags);
1984 return PARSE_ERROR_INVALID_FLAG;
1985 }
1986 s = strtok(NULL, " |");
1987 }
1988
1989 mem_free(flags);
1990 return PARSE_ERROR_NONE;
1991 }
1992
parse_pit_spell_ban(struct parser * p)1993 static enum parser_error parse_pit_spell_ban(struct parser *p) {
1994 struct pit_profile *pit = parser_priv(p);
1995 char *flags;
1996 char *s;
1997
1998 if (!pit)
1999 return PARSE_ERROR_MISSING_RECORD_HEADER;
2000 if (!parser_hasval(p, "spells"))
2001 return PARSE_ERROR_NONE;
2002 flags = string_make(parser_getstr(p, "spells"));
2003 s = strtok(flags, " |");
2004 while (s) {
2005 if (grab_flag(pit->forbidden_spell_flags, RSF_SIZE, r_info_spell_flags, s)) {
2006 mem_free(flags);
2007 return PARSE_ERROR_INVALID_FLAG;
2008 }
2009 s = strtok(NULL, " |");
2010 }
2011
2012 mem_free(flags);
2013 return PARSE_ERROR_NONE;
2014 }
2015
init_parse_pit(void)2016 struct parser *init_parse_pit(void) {
2017 struct parser *p = parser_new();
2018 parser_setpriv(p, NULL);
2019
2020 parser_reg(p, "name str name", parse_pit_name);
2021 parser_reg(p, "room uint type", parse_pit_room);
2022 parser_reg(p, "alloc uint rarity uint level", parse_pit_alloc);
2023 parser_reg(p, "obj-rarity uint obj_rarity", parse_pit_obj_rarity);
2024 parser_reg(p, "mon-base sym base", parse_pit_mon_base);
2025 parser_reg(p, "mon-ban sym race", parse_pit_mon_ban);
2026 parser_reg(p, "color sym color", parse_pit_color);
2027 parser_reg(p, "flags-req ?str flags", parse_pit_flags_req);
2028 parser_reg(p, "flags-ban ?str flags", parse_pit_flags_ban);
2029 parser_reg(p, "innate-freq int freq", parse_pit_innate_freq);
2030 parser_reg(p, "spell-req ?str spells", parse_pit_spell_req);
2031 parser_reg(p, "spell-ban ?str spells", parse_pit_spell_ban);
2032 return p;
2033 }
2034
run_parse_pit(struct parser * p)2035 static errr run_parse_pit(struct parser *p) {
2036 return parse_file_quit_not_found(p, "pit");
2037 }
2038
finish_parse_pit(struct parser * p)2039 static errr finish_parse_pit(struct parser *p) {
2040 struct pit_profile *pit, *n;
2041 int pit_idx;
2042
2043 /* Scan the list for the max id */
2044 z_info->pit_max = 0;
2045 pit = parser_priv(p);
2046 while (pit) {
2047 z_info->pit_max++;
2048 pit = pit->next;
2049 }
2050
2051 /* Allocate the direct access list and copy the data to it */
2052 pit_info = mem_zalloc((z_info->pit_max + 1) * sizeof(*pit));
2053 pit_idx = z_info->pit_max - 1;
2054 for (pit = parser_priv(p); pit; pit = n, pit_idx--) {
2055 assert(pit_idx >= 0);
2056
2057 memcpy(&pit_info[pit_idx], pit, sizeof(*pit));
2058 pit_info[pit_idx].pit_idx = pit_idx;
2059 n = pit->next;
2060 if (pit_idx < z_info->pit_max - 1)
2061 pit_info[pit_idx].next = &pit_info[pit_idx + 1];
2062 else
2063 pit_info[pit_idx].next = NULL;
2064
2065 mem_free(pit);
2066 }
2067 z_info->pit_max += 1;
2068
2069 parser_destroy(p);
2070 return 0;
2071 }
2072
cleanup_pits(void)2073 static void cleanup_pits(void)
2074 {
2075 int idx;
2076
2077 for (idx = 0; idx < z_info->pit_max; idx++) {
2078 struct pit_profile *pit = &pit_info[idx];
2079 struct pit_color_profile *c, *cn;
2080 struct pit_forbidden_monster *m, *mn;
2081 struct pit_monster_profile *b, *bn;
2082
2083 c = pit->colors;
2084 while (c) {
2085 cn = c->next;
2086 mem_free(c);
2087 c = cn;
2088 }
2089 m = pit->forbidden_monsters;
2090 while (m) {
2091 mn = m->next;
2092 mem_free(m);
2093 m = mn;
2094 }
2095 b = pit->bases;
2096 while (b) {
2097 bn = b->next;
2098 mem_free(b);
2099 b = bn;
2100 }
2101 string_free((char *)pit_info[idx].name);
2102
2103 }
2104 mem_free(pit_info);
2105 }
2106
2107 struct file_parser pit_parser = {
2108 "pits",
2109 init_parse_pit,
2110 run_parse_pit,
2111 finish_parse_pit,
2112 cleanup_pits
2113 };
2114
2115
2116 /**
2117 * ------------------------------------------------------------------------
2118 * Initialize monster lore
2119 * ------------------------------------------------------------------------ */
2120
parse_lore_name(struct parser * p)2121 static enum parser_error parse_lore_name(struct parser *p) {
2122 struct monster_race *race = lookup_monster(parser_getstr(p, "name"));
2123 struct monster_lore *l = NULL;
2124
2125 /* Only set lore if we have a race, to allow for non-existent monsters */
2126 if (race) {
2127 l = &l_list[race->ridx];
2128 l->ridx = race->ridx;
2129 }
2130 parser_setpriv(p, l);
2131 return PARSE_ERROR_NONE;
2132 }
2133
parse_lore_base(struct parser * p)2134 static enum parser_error parse_lore_base(struct parser *p) {
2135 struct monster_lore *l = parser_priv(p);
2136 struct monster_base *base = lookup_monster_base(parser_getsym(p, "base"));
2137
2138 if (!l)
2139 return PARSE_ERROR_NONE;
2140 if (base == NULL)
2141 return PARSE_ERROR_INVALID_MONSTER_BASE;
2142
2143 /* Know everything */
2144 l->all_known = true;
2145 rf_setall(l->flags);
2146
2147 return PARSE_ERROR_NONE;
2148 }
2149
parse_lore_counts(struct parser * p)2150 static enum parser_error parse_lore_counts(struct parser *p) {
2151 struct monster_lore *l = parser_priv(p);
2152
2153 if (!l)
2154 return PARSE_ERROR_NONE;
2155 l->sights = parser_getint(p, "sights");
2156 l->deaths = parser_getint(p, "deaths");
2157 l->tkills = parser_getint(p, "tkills");
2158 l->wake = parser_getint(p, "wake");
2159 l->ignore = parser_getint(p, "ignore");
2160 l->cast_innate = parser_getint(p, "innate");
2161 l->cast_spell = parser_getint(p, "spell");
2162
2163 return PARSE_ERROR_NONE;
2164 }
2165
parse_lore_blow(struct parser * p)2166 static enum parser_error parse_lore_blow(struct parser *p) {
2167 struct monster_lore *l = parser_priv(p);
2168 struct blow_method *method = NULL;
2169 struct blow_effect *effect = NULL;
2170 int seen = 0, index = 0;
2171 struct random dam = { 0, 0, 0, 0 };
2172
2173 if (!l)
2174 return PARSE_ERROR_NONE;
2175
2176 /* Read in all the data */
2177 method = findmeth(parser_getsym(p, "method"));
2178 if (!method)
2179 return PARSE_ERROR_UNRECOGNISED_BLOW;
2180 if (parser_hasval(p, "effect")) {
2181 effect = findeff(parser_getsym(p, "effect"));
2182 if (!effect)
2183 return PARSE_ERROR_INVALID_EFFECT;
2184 }
2185 if (parser_hasval(p, "damage"))
2186 dam = parser_getrand(p, "damage");
2187 if (parser_hasval(p, "seen"))
2188 seen = parser_getint(p, "seen");
2189 if (parser_hasval(p, "index"))
2190 index = parser_getint(p, "index");
2191 if (index >= z_info->mon_blows_max)
2192 return PARSE_ERROR_TOO_MANY_ENTRIES;
2193
2194 /* Interpret */
2195 if (seen) {
2196 struct monster_blow *b = &l->blows[index];
2197 b->method = method;
2198 b->effect = effect;
2199 b->dice = dam;
2200 b->times_seen = seen;
2201 }
2202
2203 return PARSE_ERROR_NONE;
2204 }
2205
parse_lore_flags(struct parser * p)2206 static enum parser_error parse_lore_flags(struct parser *p) {
2207 struct monster_lore *l = parser_priv(p);
2208 char *flags;
2209 char *s;
2210
2211 if (!l)
2212 return PARSE_ERROR_NONE;
2213 if (!parser_hasval(p, "flags"))
2214 return PARSE_ERROR_NONE;
2215 flags = string_make(parser_getstr(p, "flags"));
2216 s = strtok(flags, " |");
2217 while (s) {
2218 (void) grab_flag(l->flags, RF_SIZE, r_info_flags, s);
2219 s = strtok(NULL, " |");
2220 }
2221
2222 mem_free(flags);
2223 return PARSE_ERROR_NONE;
2224 }
2225
parse_lore_spells(struct parser * p)2226 static enum parser_error parse_lore_spells(struct parser *p) {
2227 struct monster_lore *l = parser_priv(p);
2228 char *flags;
2229 char *s;
2230 int ret = PARSE_ERROR_NONE;
2231
2232 if (!l)
2233 return PARSE_ERROR_NONE;
2234 flags = string_make(parser_getstr(p, "spells"));
2235 s = strtok(flags, " |");
2236 while (s) {
2237 (void) grab_flag(l->spell_flags, RSF_SIZE, r_info_spell_flags, s);
2238 s = strtok(NULL, " |");
2239 }
2240
2241 mem_free(flags);
2242 return ret;
2243 }
2244
parse_lore_drop(struct parser * p)2245 static enum parser_error parse_lore_drop(struct parser *p) {
2246 struct monster_lore *l = parser_priv(p);
2247 struct monster_drop *d;
2248 struct object_kind *k;
2249 int tval, sval;
2250
2251 if (!l)
2252 return PARSE_ERROR_NONE;
2253 tval = tval_find_idx(parser_getsym(p, "tval"));
2254 if (tval < 0)
2255 return PARSE_ERROR_UNRECOGNISED_TVAL;
2256 sval = lookup_sval(tval, parser_getsym(p, "sval"));
2257 if (sval < 0)
2258 return PARSE_ERROR_UNRECOGNISED_SVAL;
2259
2260 if (parser_getuint(p, "min") > 99 || parser_getuint(p, "max") > 99)
2261 return PARSE_ERROR_INVALID_ITEM_NUMBER;
2262
2263 k = lookup_kind(tval, sval);
2264 if (!k)
2265 return PARSE_ERROR_UNRECOGNISED_SVAL;
2266
2267 d = mem_zalloc(sizeof *d);
2268 d->kind = k;
2269 d->percent_chance = parser_getuint(p, "chance");
2270 d->min = parser_getuint(p, "min");
2271 d->max = parser_getuint(p, "max");
2272 d->next = l->drops;
2273 l->drops = d;
2274 return PARSE_ERROR_NONE;
2275 }
2276
parse_lore_drop_base(struct parser * p)2277 static enum parser_error parse_lore_drop_base(struct parser *p) {
2278 struct monster_lore *l = parser_priv(p);
2279 struct monster_drop *d;
2280 int tval;
2281
2282 if (!l)
2283 return PARSE_ERROR_NONE;
2284 tval = tval_find_idx(parser_getsym(p, "tval"));
2285 if (tval < 0)
2286 return PARSE_ERROR_UNRECOGNISED_TVAL;
2287
2288 if (parser_getuint(p, "min") > 99 || parser_getuint(p, "max") > 99)
2289 return PARSE_ERROR_INVALID_ITEM_NUMBER;
2290
2291 d = mem_zalloc(sizeof *d);
2292 d->tval = tval;
2293 d->percent_chance = parser_getuint(p, "chance");
2294 d->min = parser_getuint(p, "min");
2295 d->max = parser_getuint(p, "max");
2296 d->next = l->drops;
2297 l->drops = d;
2298 return PARSE_ERROR_NONE;
2299 }
parse_lore_friends(struct parser * p)2300 static enum parser_error parse_lore_friends(struct parser *p) {
2301 struct monster_lore *l = parser_priv(p);
2302 struct monster_friends *f;
2303 struct random number;
2304
2305 if (!l)
2306 return PARSE_ERROR_NONE;
2307 f = mem_zalloc(sizeof *f);
2308 number = parser_getrand(p, "number");
2309 f->number_dice = number.dice;
2310 f->number_side = number.sides;
2311 f->percent_chance = parser_getuint(p, "chance");
2312 f->name = string_make(parser_getsym(p, "name"));
2313 if (parser_hasval(p, "role")) {
2314 const char *role_name = parser_getsym(p, "role");
2315 if (streq(role_name, "servant")) {
2316 f->role = MON_GROUP_SERVANT;
2317 } else if (streq(role_name, "bodyguard")) {
2318 f->role = MON_GROUP_BODYGUARD;
2319 } else {
2320 return PARSE_ERROR_INVALID_MONSTER_ROLE;
2321 }
2322 } else {
2323 f->role = MON_GROUP_MEMBER;
2324 }
2325 f->next = l->friends;
2326 l->friends = f;
2327
2328 return PARSE_ERROR_NONE;
2329 }
2330
parse_lore_friends_base(struct parser * p)2331 static enum parser_error parse_lore_friends_base(struct parser *p) {
2332 struct monster_lore *l = parser_priv(p);
2333 struct monster_friends_base *f;
2334 struct random number;
2335
2336 if (!l)
2337 return PARSE_ERROR_NONE;
2338 f = mem_zalloc(sizeof *f);
2339 number = parser_getrand(p, "number");
2340 f->number_dice = number.dice;
2341 f->number_side = number.sides;
2342 f->percent_chance = parser_getuint(p, "chance");
2343 f->base = lookup_monster_base(parser_getsym(p, "name"));
2344 if (!f->base) return PARSE_ERROR_UNRECOGNISED_TVAL;
2345 if (parser_hasval(p, "role")) {
2346 const char *role_name = parser_getsym(p, "role");
2347 if (streq(role_name, "servant")) {
2348 f->role = MON_GROUP_SERVANT;
2349 } else if (streq(role_name, "bodyguard")) {
2350 f->role = MON_GROUP_BODYGUARD;
2351 } else {
2352 return PARSE_ERROR_INVALID_MONSTER_ROLE;
2353 }
2354 } else {
2355 f->role = MON_GROUP_MEMBER;
2356 }
2357
2358 f->next = l->friends_base;
2359 l->friends_base = f;
2360
2361 return PARSE_ERROR_NONE;
2362 }
2363
parse_lore_mimic(struct parser * p)2364 static enum parser_error parse_lore_mimic(struct parser *p) {
2365 struct monster_lore *l = parser_priv(p);
2366 struct monster_mimic *m;
2367 int tval, sval;
2368 struct object_kind *kind;
2369
2370 if (!l)
2371 return PARSE_ERROR_NONE;
2372 tval = tval_find_idx(parser_getsym(p, "tval"));
2373 if (tval < 0)
2374 return PARSE_ERROR_UNRECOGNISED_TVAL;
2375 sval = lookup_sval(tval, parser_getsym(p, "sval"));
2376 if (sval < 0)
2377 return PARSE_ERROR_UNRECOGNISED_SVAL;
2378
2379 kind = lookup_kind(tval, sval);
2380 if (!kind)
2381 return PARSE_ERROR_NO_KIND_FOUND;
2382 m = mem_zalloc(sizeof *m);
2383 m->kind = kind;
2384 m->next = l->mimic_kinds;
2385 l->mimic_kinds = m;
2386 return PARSE_ERROR_NONE;
2387 }
2388
init_parse_lore(void)2389 struct parser *init_parse_lore(void) {
2390 struct parser *p = parser_new();
2391 parser_setpriv(p, NULL);
2392
2393 parser_reg(p, "name str name", parse_lore_name);
2394 parser_reg(p, "plural ?str plural", ignored);
2395 parser_reg(p, "base sym base", parse_lore_base);
2396 parser_reg(p, "glyph char glyph", ignored);
2397 parser_reg(p, "color sym color", ignored);
2398 parser_reg(p, "speed int speed", ignored);
2399 parser_reg(p, "hit-points int hp", ignored);
2400 parser_reg(p, "light int light", ignored);
2401 parser_reg(p, "hearing int hearing", ignored);
2402 parser_reg(p, "smell int smell", ignored);
2403 parser_reg(p, "armor-class int ac", ignored);
2404 parser_reg(p, "sleepiness int sleep", ignored);
2405 parser_reg(p, "depth int level", ignored);
2406 parser_reg(p, "rarity int rarity", ignored);
2407 parser_reg(p, "experience int mexp", ignored);
2408 parser_reg(p, "counts int sights int deaths int tkills int wake int ignore int innate int spell", parse_lore_counts);
2409 parser_reg(p, "blow sym method ?sym effect ?rand damage ?int seen ?int index", parse_lore_blow);
2410 parser_reg(p, "flags ?str flags", parse_lore_flags);
2411 parser_reg(p, "flags-off ?str flags", ignored);
2412 parser_reg(p, "desc str desc", ignored);
2413 parser_reg(p, "innate-freq int freq", ignored);
2414 parser_reg(p, "spell-freq int freq", ignored);
2415 parser_reg(p, "spell-power uint power", ignored);
2416 parser_reg(p, "spells str spells", parse_lore_spells);
2417 parser_reg(p, "drop sym tval sym sval uint chance uint min uint max", parse_lore_drop);
2418 parser_reg(p, "drop-base sym tval uint chance uint min uint max", parse_lore_drop_base);
2419 parser_reg(p, "drop-artifact str name", ignored);
2420 parser_reg(p, "friends uint chance rand number sym name ?sym role", parse_lore_friends);
2421 parser_reg(p, "friends-base uint chance rand number sym name ?sym role", parse_lore_friends_base);
2422 parser_reg(p, "mimic sym tval sym sval", parse_lore_mimic);
2423 parser_reg(p, "shape str name", ignored);
2424 parser_reg(p, "color-cycle sym group sym cycle", ignored);
2425 return p;
2426 }
2427
run_parse_lore(struct parser * p)2428 static errr run_parse_lore(struct parser *p) {
2429 /* Failure is always an option */
2430 if (parse_file(p, "lore")) {
2431 event_signal_message(EVENT_INITSTATUS, 0, "No monster lore file found");
2432 }
2433 return PARSE_ERROR_NONE;
2434 }
2435
finish_parse_lore(struct parser * p)2436 static errr finish_parse_lore(struct parser *p) {
2437 size_t i;
2438
2439 /* Processing */
2440 for (i = 0; i < z_info->r_max; i++) {
2441 struct monster_lore *l = &l_list[i];
2442 struct monster_race *r = &r_info[i];
2443 struct monster_friends *f;
2444 int j;
2445
2446 /* Base flag knowledge */
2447 if (r->base) {
2448 rf_union(l->flags, r->base->flags);
2449 rsf_union(l->spell_flags, r->base->spell_flags);
2450 }
2451
2452 /* Remove blows data for non-blows */
2453 for (j = 0; j < z_info->mon_blows_max; j++) {
2454 if (!r->blow) break;
2455 if (!(r->blow[j].effect || r->blow[j].method))
2456 l->blows[j].times_seen = 0;
2457 }
2458
2459 /* Convert friend names into race pointers - failure leaves NULL race */
2460 for (f = l->friends; f; f = f->next) {
2461 if (!my_stricmp(f->name, "same"))
2462 f->race = r;
2463 else
2464 f->race = lookup_monster(f->name);
2465
2466 string_free(f->name);
2467 }
2468
2469 /* update any derived values */
2470 lore_update(r, l);
2471 }
2472
2473 parser_destroy(p);
2474 return 0;
2475 }
2476
cleanup_lore(void)2477 static void cleanup_lore(void)
2478 {
2479 int ridx;
2480
2481 for (ridx = 0; ridx < z_info->r_max; ridx++) {
2482 struct monster_lore *l = &l_list[ridx];
2483 struct monster_drop *d;
2484 struct monster_friends *f;
2485 struct monster_friends_base *fb;
2486 struct monster_mimic *m;
2487
2488 d = l->drops;
2489 while (d) {
2490 struct monster_drop *dn = d->next;
2491 mem_free(d);
2492 d = dn;
2493 }
2494 f = l->friends;
2495 while (f) {
2496 struct monster_friends *fn = f->next;
2497 mem_free(f);
2498 f = fn;
2499 }
2500 fb = l->friends_base;
2501 while (fb) {
2502 struct monster_friends_base *fbn = fb->next;
2503 mem_free(fb);
2504 fb = fbn;
2505 }
2506 m = l->mimic_kinds;
2507 while (m) {
2508 struct monster_mimic *mn = m->next;
2509 mem_free(m);
2510 m = mn;
2511 }
2512 mem_free(l->blows);
2513 mem_free(l->blow_known);
2514 }
2515
2516 mem_free(l_list);
2517 }
2518
2519 struct file_parser lore_parser = {
2520 "lore",
2521 init_parse_lore,
2522 run_parse_lore,
2523 finish_parse_lore,
2524 cleanup_lore
2525 };
2526
2527