]> git.localhorst.tv Git - l2e.git/blob - src/loader/Interpreter.cpp
added type description of Sprite
[l2e.git] / src / loader / Interpreter.cpp
1 /*
2  * Interpreter.cpp
3  *
4  *  Created on: Aug 26, 2012
5  *      Author: holy
6  */
7
8 #include "Interpreter.h"
9
10 #include "ParsedSource.h"
11 #include "../battle/Hero.h"
12 #include "../battle/Monster.h"
13 #include "../battle/PartyLayout.h"
14 #include "../battle/Resources.h"
15 #include "../common/Ikari.h"
16 #include "../common/Item.h"
17 #include "../common/Spell.h"
18 #include "../common/TargetingMode.h"
19 #include "../graphics/ComplexAnimation.h"
20 #include "../graphics/Font.h"
21 #include "../graphics/Frame.h"
22 #include "../graphics/Gauge.h"
23 #include "../graphics/Menu.h"
24 #include "../graphics/SimpleAnimation.h"
25 #include "../graphics/Sprite.h"
26
27 #include <algorithm>
28 #include <cstring>
29 #include <SDL_image.h>
30
31 using battle::Hero;
32 using battle::Monster;
33 using battle::PartyLayout;
34 using battle::Stats;
35 using common::Ikari;
36 using common::Item;
37 using common::Spell;
38 using common::TargetingMode;
39 using graphics::Animation;
40 using graphics::Color;
41 using graphics::Font;
42 using graphics::Frame;
43 using graphics::Gauge;
44 using graphics::ComplexAnimation;
45 using graphics::SimpleAnimation;
46 using graphics::Sprite;
47 using geometry::Vector;
48 using std::make_pair;
49 using std::map;
50 using std::set;
51 using std::string;
52 using std::vector;
53
54 namespace loader {
55
56 Interpreter::~Interpreter() {
57         for (vector<battle::Resources *>::const_iterator i(battleResources.begin()), end(battleResources.end()); i != end; ++i) {
58                 delete *i;
59         }
60         for (vector<ComplexAnimation *>::const_iterator i(complexAnimations.begin()), end(complexAnimations.end()); i != end; ++i) {
61                 delete *i;
62         }
63         for (vector<Font *>::const_iterator i(fonts.begin()), end(fonts.end()); i != end; ++i) {
64                 delete *i;
65         }
66         for (vector<Frame *>::const_iterator i(frames.begin()), end(frames.end()); i != end; ++i) {
67                 delete *i;
68         }
69         for (vector<Gauge *>::const_iterator i(gauges.begin()), end(gauges.end()); i != end; ++i) {
70                 delete *i;
71         }
72         for (vector<Hero *>::const_iterator i(heroes.begin()), end(heroes.end()); i != end; ++i) {
73                 delete *i;
74         }
75         for (vector<Ikari *>::const_iterator i(ikaris.begin()), end(ikaris.end()); i != end; ++i) {
76                 delete *i;
77         }
78         for (vector<SDL_Surface *>::const_iterator i(images.begin()), end(images.end()); i != end; ++i) {
79                 SDL_FreeSurface(*i);
80         }
81         for (vector<Item *>::const_iterator i(items.begin()), end(items.end()); i != end; ++i) {
82                 delete *i;
83         }
84         for (vector<graphics::MenuProperties *>::const_iterator i(menuProperties.begin()), end(menuProperties.end()); i != end; ++i) {
85                 delete *i;
86         }
87         for (vector<Monster *>::const_iterator i(monsters.begin()), end(monsters.end()); i != end; ++i) {
88                 delete *i;
89         }
90         for (vector<PartyLayout *>::const_iterator i(partyLayouts.begin()), end(partyLayouts.end()); i != end; ++i) {
91                 delete *i;
92         }
93         for (vector<SimpleAnimation *>::const_iterator i(simpleAnimations.begin()), end(simpleAnimations.end()); i != end; ++i) {
94                 delete *i;
95         }
96         for (vector<Spell *>::const_iterator i(spells.begin()), end(spells.end()); i != end; ++i) {
97                 delete *i;
98         }
99         for (vector<Sprite *>::const_iterator i(sprites.begin()), end(sprites.end()); i != end; ++i) {
100                 delete *i;
101         }
102         for (vector<const char *>::const_iterator i(strings.begin()), end(strings.end()); i != end; ++i) {
103                 delete *i;
104         }
105         for (vector<TargetingMode *>::const_iterator i(targetingModes.begin()), end(targetingModes.end()); i != end; ++i) {
106                 delete *i;
107         }
108 }
109
110
111 Animation *Interpreter::GetAnimation(const std::string &name) {
112         map<string, ParsedDefinition>::const_iterator i(parsedDefinitions.find(name));
113         if (i != parsedDefinitions.end()) {
114                 if (i->second.type == COMPLEX_ANIMATION) {
115                         return complexAnimations[i->second.index];
116                 } else if (i->second.type == SIMPLE_ANIMATION) {
117                         return simpleAnimations[i->second.index];
118                 } else {
119                         throw Error("cannot cast " + i->second.dfn->TypeName() + " to Animation");
120                 }
121         } else {
122                 throw Error("access to undefined Animation " + name);
123         }
124 }
125
126 battle::Resources *Interpreter::GetBattleResources(const std::string &name) {
127         map<string, ParsedDefinition>::const_iterator i(parsedDefinitions.find(name));
128         if (i != parsedDefinitions.end()) {
129                 if (i->second.type == BATTLE_RESOURCES) {
130                         return battleResources[i->second.index];
131                 } else {
132                         throw Error("cannot cast " + i->second.dfn->TypeName() + " to BattleResources");
133                 }
134         } else {
135                 throw Error("access to undefined BattleResources " + name);
136         }
137 }
138
139 bool Interpreter::GetBoolean(const std::string &name) const {
140         map<string, ParsedDefinition>::const_iterator i(parsedDefinitions.find(name));
141         if (i != parsedDefinitions.end()) {
142                 if (i->second.type == BOOLEAN) {
143                         return booleans[i->second.index];
144                 } else {
145                         throw Error("cannot cast " + i->second.dfn->TypeName() + " to Boolean");
146                 }
147         } else {
148                 throw Error("access to undefined Boolean " + name);
149         }
150 }
151
152 const Color &Interpreter::GetColor(const std::string &name) const {
153         map<string, ParsedDefinition>::const_iterator i(parsedDefinitions.find(name));
154         if (i != parsedDefinitions.end()) {
155                 if (i->second.type == COLOR) {
156                         return colors[i->second.index];
157                 } else {
158                         throw Error("cannot cast " + i->second.dfn->TypeName() + " to Color");
159                 }
160         } else {
161                 throw Error("access to undefined Color " + name);
162         }
163 }
164
165 Font *Interpreter::GetFont(const std::string &name) {
166         map<string, ParsedDefinition>::const_iterator i(parsedDefinitions.find(name));
167         if (i != parsedDefinitions.end()) {
168                 if (i->second.type == FONT) {
169                         return fonts[i->second.index];
170                 } else {
171                         throw Error("cannot cast " + i->second.dfn->TypeName() + " to Font");
172                 }
173         } else {
174                 throw Error("access to undefined Font " + name);
175         }
176 }
177
178 Frame *Interpreter::GetFrame(const std::string &name) {
179         map<string, ParsedDefinition>::const_iterator i(parsedDefinitions.find(name));
180         if (i != parsedDefinitions.end()) {
181                 if (i->second.type == FRAME) {
182                         return frames[i->second.index];
183                 } else {
184                         throw Error("cannot cast " + i->second.dfn->TypeName() + " to Frame");
185                 }
186         } else {
187                 throw Error("access to undefined Frame " + name);
188         }
189 }
190
191 Gauge *Interpreter::GetGauge(const std::string &name) {
192         map<string, ParsedDefinition>::const_iterator i(parsedDefinitions.find(name));
193         if (i != parsedDefinitions.end()) {
194                 if (i->second.type == GAUGE) {
195                         return gauges[i->second.index];
196                 } else {
197                         throw Error("cannot cast " + i->second.dfn->TypeName() + " to Gauge");
198                 }
199         } else {
200                 throw Error("access to undefined Gauge " + name);
201         }
202 }
203
204 Hero *Interpreter::GetHero(const std::string &name) {
205         map<string, ParsedDefinition>::const_iterator i(parsedDefinitions.find(name));
206         if (i != parsedDefinitions.end()) {
207                 if (i->second.type == HERO) {
208                         return heroes[i->second.index];
209                 } else {
210                         throw Error("cannot cast " + i->second.dfn->TypeName() + " to Hero");
211                 }
212         } else {
213                 throw Error("access to undefined Hero " + name);
214         }
215 }
216
217 Ikari *Interpreter::GetIkari(const std::string &name) {
218         map<string, ParsedDefinition>::const_iterator i(parsedDefinitions.find(name));
219         if (i != parsedDefinitions.end()) {
220                 if (i->second.type == IKARI) {
221                         return ikaris[i->second.index];
222                 } else {
223                         throw Error("cannot cast " + i->second.dfn->TypeName() + " to Ikari");
224                 }
225         } else {
226                 throw Error("access to undefined Ikari " + name);
227         }
228 }
229
230 Item *Interpreter::GetItem(const std::string &name) {
231         map<string, ParsedDefinition>::const_iterator i(parsedDefinitions.find(name));
232         if (i != parsedDefinitions.end()) {
233                 if (i->second.type == ITEM) {
234                         return items[i->second.index];
235                 } else {
236                         throw Error("cannot cast " + i->second.dfn->TypeName() + " to Item");
237                 }
238         } else {
239                 throw Error("access to undefined Item " + name);
240         }
241 }
242
243 graphics::MenuProperties *Interpreter::GetMenuProperties(const std::string &name) {
244         map<string, ParsedDefinition>::const_iterator i(parsedDefinitions.find(name));
245         if (i != parsedDefinitions.end()) {
246                 if (i->second.type == MENU_PROPERTIES) {
247                         return menuProperties[i->second.index];
248                 } else {
249                         throw Error("cannot cast " + i->second.dfn->TypeName() + " to MenuProperties");
250                 }
251         } else {
252                 throw Error("access to undefined MenuProperties " + name);
253         }
254 }
255
256 Monster *Interpreter::GetMonster(const std::string &name) {
257         map<string, ParsedDefinition>::const_iterator i(parsedDefinitions.find(name));
258         if (i != parsedDefinitions.end()) {
259                 if (i->second.type == MONSTER) {
260                         return monsters[i->second.index];
261                 } else {
262                         throw Error("cannot cast " + i->second.dfn->TypeName() + " to Monster");
263                 }
264         } else {
265                 throw Error("access to undefined Monster " + name);
266         }
267 }
268
269 int Interpreter::GetNumber(const std::string &name) const {
270         map<string, ParsedDefinition>::const_iterator i(parsedDefinitions.find(name));
271         if (i != parsedDefinitions.end()) {
272                 if (i->second.type == NUMBER) {
273                         return numbers[i->second.index];
274                 } else {
275                         throw Error("cannot cast " + i->second.dfn->TypeName() + " to Number");
276                 }
277         } else {
278                 throw Error("access to undefined Number " + name);
279         }
280 }
281
282 PartyLayout *Interpreter::GetPartyLayout(const std::string &name) {
283         map<string, ParsedDefinition>::const_iterator i(parsedDefinitions.find(name));
284         if (i != parsedDefinitions.end()) {
285                 if (i->second.type == PARTY_LAYOUT) {
286                         return partyLayouts[i->second.index];
287                 } else {
288                         throw Error("cannot cast " + i->second.dfn->TypeName() + " to PartyLayout");
289                 }
290         } else {
291                 throw Error("access to undefined PartyLayout " + name);
292         }
293 }
294
295 const char *Interpreter::GetPath(const std::string &name) const {
296         map<string, ParsedDefinition>::const_iterator i(parsedDefinitions.find(name));
297         if (i != parsedDefinitions.end()) {
298                 if (i->second.type == PATH) {
299                         return strings[i->second.index];
300                 } else {
301                         throw Error("cannot cast " + i->second.dfn->TypeName() + " to Path");
302                 }
303         } else {
304                 throw Error("access to undefined Path " + name);
305         }
306 }
307
308 Spell *Interpreter::GetSpell(const std::string &name) {
309         map<string, ParsedDefinition>::const_iterator i(parsedDefinitions.find(name));
310         if (i != parsedDefinitions.end()) {
311                 if (i->second.type == SPELL) {
312                         return spells[i->second.index];
313                 } else {
314                         throw Error("cannot cast " + i->second.dfn->TypeName() + " to Spell");
315                 }
316         } else {
317                 throw Error("access to undefined Spell " + name);
318         }
319 }
320
321 Sprite *Interpreter::GetSprite(const std::string &name) {
322         map<string, ParsedDefinition>::const_iterator i(parsedDefinitions.find(name));
323         if (i != parsedDefinitions.end()) {
324                 if (i->second.type == SPRITE) {
325                         return sprites[i->second.index];
326                 } else {
327                         throw Error("cannot cast " + i->second.dfn->TypeName() + " to Sprite");
328                 }
329         } else {
330                 throw Error("access to undefined Sprite " + name);
331         }
332 }
333
334 const char *Interpreter::GetString(const std::string &name) const {
335         map<string, ParsedDefinition>::const_iterator i(parsedDefinitions.find(name));
336         if (i != parsedDefinitions.end()) {
337                 // TODO: enable path to string casting some time
338                 if (i->second.type == STRING /* || i->second.type == PATH */) {
339                         return strings[i->second.index];
340                 } else {
341                         throw Error("cannot cast " + i->second.dfn->TypeName() + " to String");
342                 }
343         } else {
344                 throw Error("access to undefined String " + name);
345         }
346 }
347
348 TargetingMode *Interpreter::GetTargetingMode(const std::string &name) {
349         map<string, ParsedDefinition>::const_iterator i(parsedDefinitions.find(name));
350         if (i != parsedDefinitions.end()) {
351                 if (i->second.type == TARGETING_MODE) {
352                         return targetingModes[i->second.index];
353                 } else {
354                         throw Error("cannot cast " + i->second.dfn->TypeName() + " to TargetingMode");
355                 }
356         } else {
357                 throw Error("access to undefined TargetingMode " + name);
358         }
359 }
360
361 Vector<int> Interpreter::GetVector(const std::string &name) const {
362         map<string, ParsedDefinition>::const_iterator i(parsedDefinitions.find(name));
363         if (i != parsedDefinitions.end()) {
364                 if (i->second.type == VECTOR) {
365                         return vectors[i->second.index];
366                 } else {
367                         throw Error("cannot cast " + i->second.dfn->TypeName() + " to Vector");
368                 }
369         } else {
370                 throw Error("access to undefined Vector " + name);
371         }
372 }
373
374
375 void Interpreter::ReadSource() {
376         for (set<string>::const_iterator i(source.Exports().begin()), end(source.Exports().end()); i != end; ++i) {
377                 ReadDefinition(source.GetDefinition(*i));
378         }
379 }
380
381 void Interpreter::ReadDefinition(const Definition &dfn) {
382         if (parsedDefinitions.find(dfn.Identifier()) != parsedDefinitions.end()) {
383                 return;
384         }
385         if (dfn.HasLiteralValue()) {
386                 ReadLiteral(dfn);
387         } else {
388                 ReadObject(dfn);
389         }
390 }
391
392 void Interpreter::ReadLiteral(const Definition &dfn) {
393         switch (dfn.GetLiteral()->GetType()) {
394                 case Literal::ARRAY_VALUES:
395                         valueArrays.push_back(dfn.GetLiteral()->GetValues());
396                         parsedDefinitions.insert(make_pair(dfn.Identifier(), ParsedDefinition(&dfn, VALUE_ARRAY, valueArrays.size() - 1)));
397                         break;
398                 case Literal::ARRAY_PROPS:
399                         propertyListArrays.push_back(dfn.GetLiteral()->GetPropertyLists());
400                         parsedDefinitions.insert(make_pair(dfn.Identifier(), ParsedDefinition(&dfn, PROPERTY_LIST_ARRAY, propertyListArrays.size() - 1)));
401                         break;
402                 case Literal::BOOLEAN:
403                         booleans.push_back(dfn.GetLiteral()->GetBoolean());
404                         parsedDefinitions.insert(make_pair(dfn.Identifier(), ParsedDefinition(&dfn, BOOLEAN, booleans.size() - 1)));
405                         break;
406                 case Literal::COLOR:
407                         colors.push_back(Color(dfn.GetLiteral()->GetRed(), dfn.GetLiteral()->GetGreen(), dfn.GetLiteral()->GetBlue(), dfn.GetLiteral()->GetAlpha()));
408                         parsedDefinitions.insert(make_pair(dfn.Identifier(), ParsedDefinition(&dfn, COLOR, colors.size() - 1)));
409                         break;
410                 case Literal::NUMBER:
411                         numbers.push_back(dfn.GetLiteral()->GetNumber());
412                         parsedDefinitions.insert(make_pair(dfn.Identifier(), ParsedDefinition(&dfn, NUMBER, numbers.size() - 1)));
413                         break;
414                 case Literal::PATH:
415                         {
416                                 char *str(new char[dfn.GetLiteral()->GetString().size() + 1]);
417                                 std::memcpy(str, dfn.GetLiteral()->GetString().c_str(), dfn.GetLiteral()->GetString().size());
418                                 str[dfn.GetLiteral()->GetString().size()] = '\0';
419                                 strings.push_back(str);
420                         }
421                         parsedDefinitions.insert(make_pair(dfn.Identifier(), ParsedDefinition(&dfn, PATH, strings.size() - 1)));
422                         break;
423                 case Literal::STRING:
424                         {
425                                 char *str(new char[dfn.GetLiteral()->GetString().size() + 1]);
426                                 std::memcpy(str, dfn.GetLiteral()->GetString().c_str(), dfn.GetLiteral()->GetString().size());
427                                 str[dfn.GetLiteral()->GetString().size()] = '\0';
428                                 strings.push_back(str);
429                         }
430                         parsedDefinitions.insert(make_pair(dfn.Identifier(), ParsedDefinition(&dfn, STRING, strings.size() - 1)));
431                         break;
432                 case Literal::VECTOR:
433                         vectors.push_back(Vector<int>(dfn.GetLiteral()->GetX(), dfn.GetLiteral()->GetY()));
434                         parsedDefinitions.insert(make_pair(dfn.Identifier(), ParsedDefinition(&dfn, VECTOR, vectors.size() - 1)));
435                         break;
436                 case Literal::OBJECT:
437                         ReadObject(dfn);
438                         break;
439         }
440 }
441
442 Animation *Interpreter::GetAnimation(const Value &v) {
443         if (v.IsLiteral()) {
444                 if (v.GetLiteral().GetTypeName() == "ComplexAnimation") {
445                         ComplexAnimation *a(new ComplexAnimation);
446                         ReadComplexAnimation(*a, *v.GetLiteral().GetProperties());
447                         complexAnimations.push_back(a);
448                         return a;
449                 } else {
450                         SimpleAnimation *a(new SimpleAnimation);
451                         ReadSimpleAnimation(*a, *v.GetLiteral().GetProperties());
452                         simpleAnimations.push_back(a);
453                         return a;
454                 }
455         } else {
456                 ReadDefinition(source.GetDefinition(v.GetIdentifier()));
457                 return GetAnimation(v.GetIdentifier());
458         }
459 }
460
461 battle::Resources *Interpreter::GetBattleResources(const Value &v) {
462         if (v.IsLiteral()) {
463                 battle::Resources *r(new battle::Resources);
464                 ReadBattleResources(*r, *v.GetLiteral().GetProperties());
465                 return r;
466         } else {
467                 ReadDefinition(source.GetDefinition(v.GetIdentifier()));
468                 return GetBattleResources(v.GetIdentifier());
469         }
470 }
471
472 bool Interpreter::GetBoolean(const Value &v) {
473         if (v.IsLiteral()) {
474                 return v.GetLiteral().GetBoolean();
475         } else {
476                 ReadDefinition(source.GetDefinition(v.GetIdentifier()));
477                 return GetBoolean(v.GetIdentifier());
478         }
479 }
480
481 Color Interpreter::GetColor(const Value &v) {
482         if (v.IsLiteral()) {
483                 return Color(v.GetLiteral().GetRed(), v.GetLiteral().GetGreen(), v.GetLiteral().GetBlue(), v.GetLiteral().GetAlpha());
484         } else {
485                 ReadDefinition(source.GetDefinition(v.GetIdentifier()));
486                 return GetColor(v.GetIdentifier());
487         }
488 }
489
490 Font *Interpreter::GetFont(const Value &v) {
491         if (v.IsLiteral()) {
492                 Font *f(new Font);
493                 ReadFont(*f, *v.GetLiteral().GetProperties());
494                 return f;
495         } else {
496                 ReadDefinition(source.GetDefinition(v.GetIdentifier()));
497                 return GetFont(v.GetIdentifier());
498         }
499 }
500
501 Frame *Interpreter::GetFrame(const Value &v) {
502         if (v.IsLiteral()) {
503                 Frame *f(new Frame);
504                 ReadFrame(*f, *v.GetLiteral().GetProperties());
505                 return f;
506         } else {
507                 ReadDefinition(source.GetDefinition(v.GetIdentifier()));
508                 return GetFrame(v.GetIdentifier());
509         }
510 }
511
512 Gauge *Interpreter::GetGauge(const Value &v) {
513         if (v.IsLiteral()) {
514                 Gauge *g(new Gauge);
515                 ReadGauge(*g, *v.GetLiteral().GetProperties());
516                 return g;
517         } else {
518                 ReadDefinition(source.GetDefinition(v.GetIdentifier()));
519                 return GetGauge(v.GetIdentifier());
520         }
521 }
522
523 Hero *Interpreter::GetHero(const Value &v) {
524         if (v.IsLiteral()) {
525                 Hero *h(new Hero);
526                 ReadHero(*h, *v.GetLiteral().GetProperties());
527                 return h;
528         } else {
529                 ReadDefinition(source.GetDefinition(v.GetIdentifier()));
530                 return GetHero(v.GetIdentifier());
531         }
532 }
533
534 Ikari *Interpreter::GetIkari(const Value &v) {
535         if (v.IsLiteral()) {
536                 Ikari *i(new Ikari);
537                 ReadIkari(*i, *v.GetLiteral().GetProperties());
538                 return i;
539         } else {
540                 ReadDefinition(source.GetDefinition(v.GetIdentifier()));
541                 return GetIkari(v.GetIdentifier());
542         }
543 }
544
545 SDL_Surface *Interpreter::GetImage(const Value &v) {
546         string path(GetPath(v));
547         map<string, SDL_Surface *>::const_iterator i(imageCache.find(path));
548         if (i == imageCache.end()) {
549                 SDL_Surface *image(IMG_Load(path.c_str()));
550                 images.push_back(image);
551                 imageCache.insert(make_pair(path, image));
552                 return image;
553         } else {
554                 return i->second;
555         }
556 }
557
558 Item *Interpreter::GetItem(const Value &v) {
559         if (v.IsLiteral()) {
560                 Item *i(new Item);
561                 ReadItem(*i, *v.GetLiteral().GetProperties());
562                 return i;
563         } else {
564                 ReadDefinition(source.GetDefinition(v.GetIdentifier()));
565                 return GetItem(v.GetIdentifier());
566         }
567 }
568
569 graphics::MenuProperties *Interpreter::GetMenuProperties(const Value &v) {
570         if (v.IsLiteral()) {
571                 graphics::MenuProperties *m(new graphics::MenuProperties);
572                 ReadMenuProperties(*m, *v.GetLiteral().GetProperties());
573                 return m;
574         } else {
575                 ReadDefinition(source.GetDefinition(v.GetIdentifier()));
576                 return GetMenuProperties(v.GetIdentifier());
577         }
578 }
579
580 Monster *Interpreter::GetMonster(const Value &v) {
581         if (v.IsLiteral()) {
582                 Monster *m(new Monster);
583                 ReadMonster(*m, *v.GetLiteral().GetProperties());
584                 return m;
585         } else {
586                 ReadDefinition(source.GetDefinition(v.GetIdentifier()));
587                 return GetMonster(v.GetIdentifier());
588         }
589 }
590
591 int Interpreter::GetNumber(const Value &v) {
592         if (v.IsLiteral()) {
593                 return v.GetLiteral().GetNumber();
594         } else {
595                 ReadDefinition(source.GetDefinition(v.GetIdentifier()));
596                 return GetNumber(v.GetIdentifier());
597         }
598 }
599
600 PartyLayout *Interpreter::GetPartyLayout(const Value &v) {
601         if (v.IsLiteral()) {
602                 PartyLayout *l(new PartyLayout);
603                 ReadPartyLayout(*l, *v.GetLiteral().GetProperties());
604                 return l;
605         } else {
606                 ReadDefinition(source.GetDefinition(v.GetIdentifier()));
607                 return GetPartyLayout(v.GetIdentifier());
608         }
609 }
610
611 const char *Interpreter::GetPath(const Value &v) {
612         if (v.IsLiteral()) {
613                 return v.GetLiteral().GetString().c_str();
614         } else {
615                 ReadDefinition(source.GetDefinition(v.GetIdentifier()));
616                 return GetPath(v.GetIdentifier());
617         }
618 }
619
620 const PropertyList *Interpreter::GetPropertyList(const Value &v) {
621         if (v.IsLiteral()) {
622                 return v.GetLiteral().GetProperties();
623         } else {
624                 throw Error("cannot reference property lists");
625         }
626 }
627
628 const vector<PropertyList *> &Interpreter::GetPropertyListArray(const Value &v) {
629         if (v.IsLiteral()) {
630                 return v.GetLiteral().GetPropertyLists();
631         } else {
632                 throw Error("cannot reference property list arrays");
633         }
634 }
635
636 Spell *Interpreter::GetSpell(const Value &v) {
637         if (v.IsLiteral()) {
638                 Spell *s(new Spell);
639                 ReadSpell(*s, *v.GetLiteral().GetProperties());
640                 return s;
641         } else {
642                 ReadDefinition(source.GetDefinition(v.GetIdentifier()));
643                 return GetSpell(v.GetIdentifier());
644         }
645 }
646
647 Sprite *Interpreter::GetSprite(const Value &v) {
648         if (v.IsLiteral()) {
649                 Sprite *s(new Sprite);
650                 ReadSprite(*s, *v.GetLiteral().GetProperties());
651                 return s;
652         } else {
653                 ReadDefinition(source.GetDefinition(v.GetIdentifier()));
654                 return GetSprite(v.GetIdentifier());
655         }
656 }
657
658 const char *Interpreter::GetString(const Value &v) {
659         if (v.IsLiteral()) {
660                 return v.GetLiteral().GetString().c_str();
661         } else {
662                 ReadDefinition(source.GetDefinition(v.GetIdentifier()));
663                 return GetString(v.GetIdentifier());
664         }
665 }
666
667 TargetingMode *Interpreter::GetTargetingMode(const Value &v) {
668         if (v.IsLiteral()) {
669                 TargetingMode *t(new TargetingMode);
670                 ReadTargetingMode(*t, *v.GetLiteral().GetProperties());
671                 return t;
672         } else {
673                 ReadDefinition(source.GetDefinition(v.GetIdentifier()));
674                 return GetTargetingMode(v.GetIdentifier());
675         }
676 }
677
678 Vector<int> Interpreter::GetVector(const Value &v) {
679         if (v.IsLiteral()) {
680                 return Vector<int>(v.GetLiteral().GetX(), v.GetLiteral().GetY());
681         } else {
682                 ReadDefinition(source.GetDefinition(v.GetIdentifier()));
683                 return GetVector(v.GetIdentifier());
684         }
685 }
686
687 const vector<Value *> &Interpreter::GetValueArray(const Value &v) {
688         if (v.IsLiteral()) {
689                 return v.GetLiteral().GetValues();
690         } else {
691                 throw Error("cannot reference value arrays");
692         }
693 }
694
695
696 void Interpreter::ReadObject(const Definition &dfn) {
697         if (dfn.TypeName() == "BattleResources") {
698                 battle::Resources *res(new battle::Resources);
699                 int index(battleResources.size());
700                 battleResources.push_back(res);
701                 ReadBattleResources(*res, *dfn.GetProperties());
702                 parsedDefinitions.insert(make_pair(dfn.Identifier(), ParsedDefinition(&dfn, BATTLE_RESOURCES, index)));
703         } else if (dfn.TypeName() == "ComplexAnimation") {
704                 ComplexAnimation *animation(new ComplexAnimation);
705                 int index(complexAnimations.size());
706                 complexAnimations.push_back(animation);
707                 ReadComplexAnimation(*animation, *dfn.GetProperties());
708                 parsedDefinitions.insert(make_pair(dfn.Identifier(), ParsedDefinition(&dfn, COMPLEX_ANIMATION, index)));
709         } else if (dfn.TypeName() == "Font") {
710                 Font *font(new Font);
711                 int index(fonts.size());
712                 fonts.push_back(font);
713                 ReadFont(*font, *dfn.GetProperties());
714                 parsedDefinitions.insert(make_pair(dfn.Identifier(), ParsedDefinition(&dfn, FONT, index)));
715         } else if (dfn.TypeName() == "Frame") {
716                 Frame *frame(new Frame);
717                 int index(frames.size());
718                 frames.push_back(frame);
719                 ReadFrame(*frame, *dfn.GetProperties());
720                 parsedDefinitions.insert(make_pair(dfn.Identifier(), ParsedDefinition(&dfn, FRAME, index)));
721         } else if (dfn.TypeName() == "Gauge") {
722                 Gauge *gauge(new Gauge);
723                 int index(gauges.size());
724                 gauges.push_back(gauge);
725                 ReadGauge(*gauge, *dfn.GetProperties());
726                 parsedDefinitions.insert(make_pair(dfn.Identifier(), ParsedDefinition(&dfn, GAUGE, index)));
727         } else if (dfn.TypeName() == "Hero") {
728                 Hero *hero(new Hero);
729                 int index(heroes.size());
730                 heroes.push_back(hero);
731                 ReadHero(*hero, *dfn.GetProperties());
732                 parsedDefinitions.insert(make_pair(dfn.Identifier(), ParsedDefinition(&dfn, HERO, index)));
733         } else if (dfn.TypeName() == "Ikari") {
734                 Ikari *ikari(new Ikari);
735                 int index(ikaris.size());
736                 ikaris.push_back(ikari);
737                 ReadIkari(*ikari, *dfn.GetProperties());
738                 parsedDefinitions.insert(make_pair(dfn.Identifier(), ParsedDefinition(&dfn, IKARI, index)));
739         } else if (dfn.TypeName() == "Item") {
740                 Item *item(new Item);
741                 int index(items.size());
742                 items.push_back(item);
743                 ReadItem(*item, *dfn.GetProperties());
744                 parsedDefinitions.insert(make_pair(dfn.Identifier(), ParsedDefinition(&dfn, ITEM, index)));
745         } else if (dfn.TypeName() == "MenuProperties") {
746                 graphics::MenuProperties *mprops(new graphics::MenuProperties);
747                 int index(menuProperties.size());
748                 menuProperties.push_back(mprops);
749                 ReadMenuProperties(*mprops, *dfn.GetProperties());
750                 parsedDefinitions.insert(make_pair(dfn.Identifier(), ParsedDefinition(&dfn, MENU_PROPERTIES, index)));
751         } else if (dfn.TypeName() == "Monster") {
752                 Monster *monster(new Monster);
753                 int index(monsters.size());
754                 monsters.push_back(monster);
755                 ReadMonster(*monster, *dfn.GetProperties());
756                 parsedDefinitions.insert(make_pair(dfn.Identifier(), ParsedDefinition(&dfn, MONSTER, index)));
757         } else if (dfn.TypeName() == "PartyLayout") {
758                 PartyLayout *layout(new PartyLayout);
759                 int index(partyLayouts.size());
760                 partyLayouts.push_back(layout);
761                 ReadPartyLayout(*layout, *dfn.GetProperties());
762                 parsedDefinitions.insert(make_pair(dfn.Identifier(), ParsedDefinition(&dfn, PARTY_LAYOUT, index)));
763         } else if (dfn.TypeName() == "SimpleAnimation") {
764                 SimpleAnimation *animation(new SimpleAnimation);
765                 int index(simpleAnimations.size());
766                 simpleAnimations.push_back(animation);
767                 ReadSimpleAnimation(*animation, *dfn.GetProperties());
768                 parsedDefinitions.insert(make_pair(dfn.Identifier(), ParsedDefinition(&dfn, SIMPLE_ANIMATION, index)));
769         } else if (dfn.TypeName() == "Spell") {
770                 Spell *spell(new Spell);
771                 int index(spells.size());
772                 spells.push_back(spell);
773                 ReadSpell(*spell, *dfn.GetProperties());
774                 parsedDefinitions.insert(make_pair(dfn.Identifier(), ParsedDefinition(&dfn, SPELL, index)));
775         } else if (dfn.TypeName() == "Sprite") {
776                 Sprite *sprite(new Sprite);
777                 int index(sprites.size());
778                 sprites.push_back(sprite);
779                 ReadSprite(*sprite, *dfn.GetProperties());
780                 parsedDefinitions.insert(make_pair(dfn.Identifier(), ParsedDefinition(&dfn, SPRITE, index)));
781         } else if (dfn.TypeName() == "TargetingMode") {
782                 TargetingMode *mode(new TargetingMode);
783                 int index(targetingModes.size());
784                 targetingModes.push_back(mode);
785                 ReadTargetingMode(*mode, *dfn.GetProperties());
786                 parsedDefinitions.insert(make_pair(dfn.Identifier(), ParsedDefinition(&dfn, TARGETING_MODE, index)));
787         } else {
788                 throw Error("unhandled object type: " + dfn.TypeName());
789         }
790 }
791
792
793 void Interpreter::ReadBattleResources(battle::Resources &res, const PropertyList &props) {
794         for (PropertyList::ConstIterator i(props.Begin()), end(props.End()); i != end; ++i) {
795                 if (i->first == "swapCursor") {
796                         res.swapCursor = GetSprite(*i->second);
797                 } else if (i->first == "moveIcons") {
798                         res.moveIcons = GetSprite(*i->second);
799                 } else if (i->first == "attackIcons") {
800                         res.attackIcons = GetSprite(*i->second);
801                 } else if (i->first == "attackChoiceIcons") {
802                         res.attackChoiceIcons = GetSprite(*i->second);
803                 } else if (i->first == "titleFrame") {
804                         res.titleFrame = GetFrame(*i->second);
805                 } else if (i->first == "titleFont") {
806                         res.titleFont = GetFont(*i->second);
807                 } else if (i->first == "heroTagFrame") {
808                         res.heroTagFrame = GetFrame(*i->second);
809                 } else if (i->first == "activeHeroTagFrame") {
810                         res.activeHeroTagFrame = GetFrame(*i->second);
811                 } else if (i->first == "smallHeroTagFrame") {
812                         res.smallHeroTagFrame = GetFrame(*i->second);
813                 } else if (i->first == "lastSmallHeroTagFrame") {
814                         res.lastSmallHeroTagFrame = GetFrame(*i->second);
815                 } else if (i->first == "heroTagFont") {
816                         res.heroTagFont = GetFont(*i->second);
817                 } else if (i->first == "heroTagLabels") {
818                         res.heroTagLabels = GetSprite(*i->second);
819                 } else if (i->first == "healthGauge") {
820                         res.healthGauge = GetGauge(*i->second);
821                 } else if (i->first == "manaGauge") {
822                         res.manaGauge = GetGauge(*i->second);
823                 } else if (i->first == "ikariGauge") {
824                         res.ikariGauge = GetGauge(*i->second);
825                 } else if (i->first == "selectFrame") {
826                         res.selectFrame = GetFrame(*i->second);
827                 } else if (i->first == "normalFont") {
828                         res.normalFont = GetFont(*i->second);
829                 } else if (i->first == "disabledFont") {
830                         res.disabledFont = GetFont(*i->second);
831                 } else if (i->first == "menuCursor") {
832                         res.menuCursor = GetSprite(*i->second);
833                 } else if (i->first == "weaponTargetCursor") {
834                         res.weaponTargetCursor = GetSprite(*i->second);
835                 } else if (i->first == "magicTargetCursor") {
836                         res.magicTargetCursor = GetSprite(*i->second);
837                 } else if (i->first == "itemTargetCursor") {
838                         res.itemTargetCursor = GetSprite(*i->second);
839                 } else if (i->first == "spellMenuHeadline") {
840                         res.spellMenuHeadline = GetString(*i->second);
841                 } else if (i->first == "spellMenuProperties") {
842                         res.spellMenuProperties = GetMenuProperties(*i->second);
843                 } else if (i->first == "itemMenuHeadline") {
844                         res.itemMenuHeadline = GetString(*i->second);
845                 } else if (i->first == "itemMenuProperties") {
846                         res.itemMenuProperties = GetMenuProperties(*i->second);
847                 } else if (i->first == "ikariMenuHeadline") {
848                         res.ikariMenuHeadline = GetString(*i->second);
849                 } else if (i->first == "ikariMenuProperties") {
850                         res.ikariMenuProperties = GetMenuProperties(*i->second);
851                 } else if (i->first == "noEquipmentText") {
852                         res.noEquipmentText = GetString(*i->second);
853                 } else if (i->first == "escapeText") {
854                         res.escapeText = GetString(*i->second);
855                 } else if (i->first == "numberAnimationPrototype") {
856                         res.numberAnimationPrototype = GetAnimation(*i->second);
857                 } else if (i->first == "bigNumberSprite") {
858                         res.bigNumberSprite = GetSprite(*i->second);
859                 } else if (i->first == "greenNumberSprite") {
860                         res.greenNumberSprite = GetSprite(*i->second);
861                 } else if (i->first == "weaponMenuIcon") {
862                         res.weaponMenuIcon = GetSprite(*i->second);
863                 } else if (i->first == "armorMenuIcon") {
864                         res.armorMenuIcon = GetSprite(*i->second);
865                 } else if (i->first == "shieldMenuIcon") {
866                         res.shieldMenuIcon = GetSprite(*i->second);
867                 } else if (i->first == "helmetMenuIcon") {
868                         res.helmetMenuIcon = GetSprite(*i->second);
869                 } else if (i->first == "ringMenuIcon") {
870                         res.ringMenuIcon = GetSprite(*i->second);
871                 } else if (i->first == "jewelMenuIcon") {
872                         res.jewelMenuIcon = GetSprite(*i->second);
873                 } else if (i->first == "levelLabelCol") {
874                         res.levelLabelCol = GetNumber(*i->second);
875                 } else if (i->first == "levelLabelRow") {
876                         res.levelLabelRow = GetNumber(*i->second);
877                 } else if (i->first == "healthLabelCol") {
878                         res.healthLabelCol = GetNumber(*i->second);
879                 } else if (i->first == "healthLabelRow") {
880                         res.healthLabelRow = GetNumber(*i->second);
881                 } else if (i->first == "manaLabelCol") {
882                         res.manaLabelCol = GetNumber(*i->second);
883                 } else if (i->first == "manaLabelRow") {
884                         res.manaLabelRow = GetNumber(*i->second);
885                 } else if (i->first == "moveLabelCol") {
886                         res.moveLabelCol = GetNumber(*i->second);
887                 } else if (i->first == "moveLabelRow") {
888                         res.moveLabelRow = GetNumber(*i->second);
889                 } else if (i->first == "ikariLabelCol") {
890                         res.ikariLabelCol = GetNumber(*i->second);
891                 } else if (i->first == "ikariLabelRow") {
892                         res.ikariLabelRow = GetNumber(*i->second);
893                 } else if (i->first == "heroesBgColor") {
894                         res.heroesBgColor = GetColor(*i->second);
895                 } else {
896                         throw Error("unknown BattleResources property: " + i->first);
897                 }
898         }
899 }
900
901 void Interpreter::ReadComplexAnimation(ComplexAnimation &a, const PropertyList &props) {
902         for (PropertyList::ConstIterator i(props.Begin()), end(props.End()); i != end; ++i) {
903                 if (i->first == "sprite") {
904                         a.SetSprite(GetSprite(*i->second));
905                 } else if (i->first == "frametime") {
906                         a.SetFrameTime(GetNumber(*i->second));
907                 } else if (i->first == "repeat") {
908                         a.SetRepeat(GetBoolean(*i->second));
909                 } else if (i->first == "frames") {
910                         const vector<PropertyList *> &values(GetPropertyListArray(*i->second));
911                         for (vector<PropertyList *>::const_iterator i(values.begin()), end(values.end()); i != end; ++i) {
912                                 ComplexAnimation::FrameProp frame;
913                                 ReadComplexAnimationFrame(frame, **i);
914                                 a.AddFrame(frame);
915                         }
916                 } else {
917                         throw Error("unknown ComplexAnimation property: " + i->first);
918                 }
919         }
920 }
921
922 void Interpreter::ReadComplexAnimationFrame(ComplexAnimation::FrameProp &f, const PropertyList &props) {
923         for (PropertyList::ConstIterator i(props.Begin()), end(props.End()); i != end; ++i) {
924                 if (i->first == "column") {
925                         f.col = GetNumber(*i->second);
926                 } else if (i->first == "row") {
927                         f.row = GetNumber(*i->second);
928                 } else if (i->first == "disposition") {
929                         f.disposition = GetVector(*i->second);
930                 } else {
931                         throw Error("unknown ComplexAnimationFrame property: " + i->first);
932                 }
933         }
934 }
935
936 void Interpreter::ReadFont(Font &f, const PropertyList &props) {
937         for (PropertyList::ConstIterator i(props.Begin()), end(props.End()); i != end; ++i) {
938                 if (i->first == "sprite") {
939                         f.SetSprite(GetSprite(*i->second));
940                 } else if (i->first == "columnoffset") {
941                         f.SetColOffset(GetNumber(*i->second));
942                 } else if (i->first == "rowoffset") {
943                         f.SetRowOffset(GetNumber(*i->second));
944                 } else {
945                         throw Error("unknown Font property: " + i->first);
946                 }
947         }
948 }
949
950 void Interpreter::ReadFrame(Frame &f, const PropertyList &props) {
951         for (PropertyList::ConstIterator i(props.Begin()), end(props.End()); i != end; ++i) {
952                 if (i->first == "image") {
953                         f.SetSurface(GetImage(*i->second));
954                 } else if (i->first == "border") {
955                         f.SetBorderSize(GetVector(*i->second));
956                 } else if (i->first == "repeat") {
957                         f.SetRepeatSize(GetVector(*i->second));
958                 } else if (i->first == "offset") {
959                         f.SetOffset(GetVector(*i->second));
960                 } else {
961                         throw Error("unknown Frame property: " + i->first);
962                 }
963         }
964 }
965
966 void Interpreter::ReadGauge(Gauge &g, const PropertyList &props) {
967         for (PropertyList::ConstIterator i(props.Begin()), end(props.End()); i != end; ++i) {
968                 if (i->first == "image") {
969                         g.SetSurface(GetImage(*i->second));
970                 } else if (i->first == "full") {
971                         g.SetFullOffset(GetVector(*i->second));
972                 } else if (i->first == "empty") {
973                         g.SetEmptyOffset(GetVector(*i->second));
974                 } else if (i->first == "height") {
975                         g.SetHeight(GetNumber(*i->second));
976                 } else if (i->first == "start") {
977                         g.SetStartWidth(GetNumber(*i->second));
978                 } else if (i->first == "repeat") {
979                         g.SetRepeatWidth(GetNumber(*i->second));
980                 } else if (i->first == "end") {
981                         g.SetEndWidth(GetNumber(*i->second));
982                 } else {
983                         throw Error("unknown Gauge property: " + i->first);
984                 }
985         }
986 }
987
988 void Interpreter::ReadIkari(Ikari &ikari, const PropertyList &props) {
989         for (PropertyList::ConstIterator i(props.Begin()), end(props.End()); i != end; ++i) {
990                 if (i->first == "name") {
991                         ikari.SetName(GetString(*i->second));
992                 } else if (i->first == "cost") {
993                         ikari.SetCost(GetNumber(*i->second));
994                 } else if (i->first == "targets") {
995                         ikari.GetTargetingMode() = *GetTargetingMode(*i->second);
996                 } else if (i->first == "magical") {
997                         if (GetBoolean(*i->second)) {
998                                 ikari.SetMagical();
999                         }
1000                 } else if (i->first == "physical") {
1001                         if (GetBoolean(*i->second)) {
1002                                 ikari.SetPhysical();
1003                         }
1004                 } else {
1005                         throw Error("unknown Ikari property: " + i->first);
1006                 }
1007         }
1008 }
1009
1010 void Interpreter::ReadItem(Item &item, const PropertyList &props) {
1011         for (PropertyList::ConstIterator i(props.Begin()), end(props.End()); i != end; ++i) {
1012                 if (i->first == "name") {
1013                         item.SetName(GetString(*i->second));
1014                 } else if (i->first == "menuicon") {
1015                         item.SetMenuIcon(GetSprite(*i->second));
1016                 } else if (i->first == "battle") {
1017                         if (GetBoolean(*i->second)) {
1018                                 item.SetUsableInBattle();
1019                         }
1020                 } else if (i->first == "targets") {
1021                         item.GetTargetingMode() = *GetTargetingMode(*i->second);
1022                 } else if (i->first == "ikari") {
1023                         item.SetIkari(GetIkari(*i->second));
1024                 } else if (i->first == "attackanimation") {
1025                         item.SetAttackAnimation(GetAnimation(*i->second));
1026                 } else {
1027                         throw Error("unknown Item property: " + i->first);
1028                 }
1029         }
1030 }
1031
1032 void Interpreter::ReadHero(Hero &h, const PropertyList &props) {
1033         for (PropertyList::ConstIterator i(props.Begin()), end(props.End()); i != end; ++i) {
1034                 if (i->first == "name") {
1035                         h.SetName(GetString(*i->second));
1036                 } else if (i->first == "sprite") {
1037                         h.SetSprite(GetSprite(*i->second));
1038                 } else if (i->first == "level") {
1039                         h.SetLevel(GetNumber(*i->second));
1040                 } else if (i->first == "maxHealth") {
1041                         h.SetMaxHealth(GetNumber(*i->second));
1042                 } else if (i->first == "health") {
1043                         h.SetHealth(GetNumber(*i->second));
1044                 } else if (i->first == "maxMana") {
1045                         h.SetMaxMana(GetNumber(*i->second));
1046                 } else if (i->first == "mana") {
1047                         h.SetMana(GetNumber(*i->second));
1048                 } else if (i->first == "ip") {
1049                         h.SetIP(GetNumber(*i->second));
1050                 } else if (i->first == "stats") {
1051                         battle::Stats stats;
1052                         ReadStats(stats, *GetPropertyList(*i->second));
1053                         h.SetStats(stats);
1054                 } else if (i->first == "attackAnimation") {
1055                         h.SetAttackAnimation(GetAnimation(*i->second));
1056                 } else if (i->first == "spellAnimation") {
1057                         h.SetSpellAnimation(GetAnimation(*i->second));
1058                 } else if (i->first == "meleeAnimation") {
1059                         h.SetMeleeAnimation(GetAnimation(*i->second));
1060                 } else {
1061                         throw Error("unknown Hero property: " + i->first);
1062                 }
1063         }
1064 }
1065
1066 void Interpreter::ReadMenuProperties(graphics::MenuProperties &mprops, const PropertyList &props) {
1067         for (PropertyList::ConstIterator i(props.Begin()), end(props.End()); i != end; ++i) {
1068                 if (i->first == "font") {
1069                         mprops.font = GetFont(*i->second);
1070                 } else if (i->first == "disabledFont") {
1071                         mprops.disabledFont = GetFont(*i->second);
1072                 } else if (i->first == "cursor") {
1073                         mprops.cursor = GetSprite(*i->second);
1074                 } else if (i->first == "charsPerEntry") {
1075                         mprops.charsPerEntry = GetNumber(*i->second);
1076                 } else if (i->first == "rows") {
1077                         mprops.rows = GetNumber(*i->second);
1078                 } else if (i->first == "rowGap") {
1079                         mprops.rowGap = GetNumber(*i->second);
1080                 } else if (i->first == "iconSpace") {
1081                         mprops.iconSpace = GetNumber(*i->second);
1082                 } else if (i->first == "cols") {
1083                         mprops.cols = GetNumber(*i->second);
1084                 } else if (i->first == "colGap") {
1085                         mprops.colGap = GetNumber(*i->second);
1086                 } else if (i->first == "delimiter") {
1087                         mprops.delimiter = *GetString(*i->second);
1088                 } else if (i->first == "charsPerNumber") {
1089                         mprops.charsPerNumber = GetNumber(*i->second);
1090                 } else if (i->first == "charsPerAdditionalText") {
1091                         mprops.charsPerAdditionalText = GetNumber(*i->second);
1092                 } else if (i->first == "additionalTextGap") {
1093                         mprops.additionalTextGap = GetNumber(*i->second);
1094                 } else {
1095                         throw Error("unknown MenuProperties property: " + i->first);
1096                 }
1097         }
1098 }
1099
1100 void Interpreter::ReadMonster(Monster &m, const PropertyList &props) {
1101         for (PropertyList::ConstIterator i(props.Begin()), end(props.End()); i != end; ++i) {
1102                 if (i->first == "name") {
1103                         m.SetName(GetString(*i->second));
1104                 } else if (i->first == "sprite") {
1105                         m.SetSprite(GetSprite(*i->second));
1106                 } else if (i->first == "level") {
1107                         m.SetLevel(GetNumber(*i->second));
1108                 } else if (i->first == "maxHealth") {
1109                         m.SetMaxHealth(GetNumber(*i->second));
1110                 } else if (i->first == "health") {
1111                         m.SetHealth(GetNumber(*i->second));
1112                 } else if (i->first == "maxMana") {
1113                         m.SetMaxMana(GetNumber(*i->second));
1114                 } else if (i->first == "mana") {
1115                         m.SetMana(GetNumber(*i->second));
1116                 } else if (i->first == "stats") {
1117                         battle::Stats stats;
1118                         ReadStats(stats, *GetPropertyList(*i->second));
1119                         m.SetStats(stats);
1120                 } else if (i->first == "attackAnimation") {
1121                         m.SetAttackAnimation(GetAnimation(*i->second));
1122                 } else if (i->first == "meleeAnimation") {
1123                         m.SetMeleeAnimation(GetAnimation(*i->second));
1124                 } else {
1125                         throw Error("unknown Monster property: " + i->first);
1126                 }
1127         }
1128 }
1129
1130 void Interpreter::ReadPartyLayout(PartyLayout &p, const PropertyList &props) {
1131         for (PropertyList::ConstIterator i(props.Begin()), end(props.End()); i != end; ++i) {
1132                 if (i->first == "positions") {
1133                         const vector<Value *> &positions(GetValueArray(*i->second));
1134                         for (vector<Value *>::const_iterator j(positions.begin()), end(positions.end()); j != end; ++j) {
1135                                 p.AddPosition(GetVector(**j));
1136                         }
1137                 } else {
1138                         throw Error("unknown PartyLayout property: " + i->first);
1139                 }
1140         }
1141 }
1142
1143 void Interpreter::ReadSimpleAnimation(SimpleAnimation &a, const PropertyList &props) {
1144         for (PropertyList::ConstIterator i(props.Begin()), end(props.End()); i != end; ++i) {
1145                 if (i->first == "sprite") {
1146                         a.SetSprite(GetSprite(*i->second));
1147                 } else if (i->first == "frametime") {
1148                         a.SetFrameTime(GetNumber(*i->second));
1149                 } else if (i->first == "repeat") {
1150                         a.SetRepeat(GetBoolean(*i->second));
1151                 } else if (i->first == "framecount") {
1152                         a.SetNumFrames(GetNumber(*i->second));
1153                 } else if (i->first == "col") {
1154                         a.SetCol(GetNumber(*i->second));
1155                 } else if (i->first == "row") {
1156                         a.SetRow(GetNumber(*i->second));
1157                 } else {
1158                         throw Error("unknown SimpleAnimation property: " + i->first);
1159                 }
1160         }
1161 }
1162
1163 void Interpreter::ReadSpell(Spell &s, const PropertyList &props) {
1164         for (PropertyList::ConstIterator i(props.Begin()), end(props.End()); i != end; ++i) {
1165                 if (i->first == "name") {
1166                         s.SetName(GetString(*i->second));
1167                 } else if (i->first == "cost") {
1168                         s.SetCost(GetNumber(*i->second));
1169                 } else if (i->first == "battle") {
1170                         if (GetBoolean(*i->second)) {
1171                                 s.SetUsableInBattle();
1172                         }
1173                 } else if (i->first == "targets") {
1174                         s.GetTargetingMode() = *GetTargetingMode(*i->second);
1175                 } else {
1176                         throw Error("unknown Spell property: " + i->first);
1177                 }
1178         }
1179 }
1180
1181 void Interpreter::ReadSprite(Sprite &s, const PropertyList &props) {
1182         for (PropertyList::ConstIterator i(props.Begin()), end(props.End()); i != end; ++i) {
1183                 if (i->first == "image") {
1184                         s.SetSurface(GetImage(*i->second));
1185                 } else if (i->first == "size") {
1186                         s.SetSize(GetVector(*i->second));
1187                 } else if (i->first == "offset") {
1188                         s.SetOffset(GetVector(*i->second));
1189                 } else {
1190                         throw Error("unknown Sprite property: " + i->first);
1191                 }
1192         }
1193 }
1194
1195 void Interpreter::ReadStats(Stats &s, const PropertyList &props) {
1196         for (PropertyList::ConstIterator i(props.Begin()), end(props.End()); i != end; ++i) {
1197                 if (i->first == "atp") {
1198                         s.SetAttack(GetNumber(*i->second));
1199                 } else if (i->first == "dfp") {
1200                         s.SetDefense(GetNumber(*i->second));
1201                 } else if (i->first == "str") {
1202                         s.SetStrength(GetNumber(*i->second));
1203                 } else if (i->first == "agl") {
1204                         s.SetAgility(GetNumber(*i->second));
1205                 } else if (i->first == "int") {
1206                         s.SetIntelligence(GetNumber(*i->second));
1207                 } else if (i->first == "gut") {
1208                         s.SetGut(GetNumber(*i->second));
1209                 } else if (i->first == "mgr") {
1210                         s.SetMagicResistance(GetNumber(*i->second));
1211                 } else {
1212                         throw Error("unknown Stats property: " + i->first);
1213                 }
1214         }
1215 }
1216
1217 void Interpreter::ReadTargetingMode(TargetingMode &t, const PropertyList &props) {
1218         for (PropertyList::ConstIterator i(props.Begin()), end(props.End()); i != end; ++i) {
1219                 if (i->first == "ally") {
1220                         if (GetBoolean(*i->second)) {
1221                                 t.TargetAlly();
1222                         } else {
1223                                 t.TargetEnemy();
1224                         }
1225                 } else if (i->first == "enemy") {
1226                         if (GetBoolean(*i->second)) {
1227                                 t.TargetEnemy();
1228                         } else {
1229                                 t.TargetAlly();
1230                         }
1231                 } else if (i->first == "all") {
1232                         if (GetBoolean(*i->second)) {
1233                                 t.TargetAll();
1234                         }
1235                 } else if (i->first == "multiple") {
1236                         if (GetBoolean(*i->second)) {
1237                                 t.TargetMultiple();
1238                         }
1239                 } else if (i->first == "single") {
1240                         if (GetBoolean(*i->second)) {
1241                                 t.TargetSingle();
1242                         }
1243                 } else {
1244                         throw Error("unknown TargetingMode property: " + i->first);
1245                 }
1246         }
1247 }
1248
1249 }