src/game/script.h

   1 /*
   2  *
   3  *  Iter Vehemens ad Necem (IVAN)
   4  *  Copyright (C) Timo Kiviluoto
   5  *  Released under the GNU General
   6  *  Public License
   7  *
   8  *  See LICENSING which should be included
   9  *  along with this file for more details
  10  *
  11  */
  12 #ifndef __SCRIPT_H__
  13 #define __SCRIPT_H__
  14
  15 #include <list>
  16 #include <map>
  17
  18 #include "rect.h"
  19 #include "femath.h"
  20 #include "festring.h"
  21
  22
  23 #define SCRIPT_MEMBER(type, name)\
  24 public:\
  25   const type* Get##name() const { return name##Holder.Member; }\
  26 protected:\
  27   scriptmember< type > name##Holder
  28
  29 #define SCRIPT_MEMBER_WITH_BASE(type, name)\
  30 public:\
  31   const type* Get##name() const { return GetMemberOf(name##Holder, Base, &scripttype::Get##name); }\
  32 protected:\
  33   scriptmember< type > name##Holder
  34
  35 #define FAST_SCRIPT_MEMBER(type, name)\
  36 public:\
  37   type Get##name() const { return name##Holder.Member; }\
  38 protected:\
  39   fastscriptmember< type > name##Holder
  40
  41 #define SCRIPT_TRUTH(name)\
  42 public:\
  43   ctruth* name() const { return name##Holder.Member; }\
  44 protected:\
  45   scriptmember<truth> name##Holder
  46
  47 #define SCRIPT_TRUTH_WITH_BASE(name)\
  48 public:\
  49   ctruth* name() const { return GetMemberOf(name##Holder, Base, &scripttype::name); }\
  50 protected:\
  51   scriptmember<truth> name##Holder
  52
  53 #define FAST_SCRIPT_TRUTH(name)\
  54 public:\
  55   truth name() const { return name##Holder.Member; }\
  56 protected:\
  57   fastscriptmember<truth> name##Holder
  58
  59
  60 class glterrain;
  61 class olterrain;
  62 class character;
  63 class item;
  64 class material;
  65 class scriptwithbase;
  66 class outputfile;
  67 class inputfile;
  68
  69
  70 struct scriptmemberbase {
  71   virtual ~scriptmemberbase () {}
  72   virtual void ReadFrom (inputfile &) = 0;
  73   virtual void Save (outputfile &) const = 0;
  74   virtual void Load (inputfile &) = 0;
  75   virtual void Replace (scriptmemberbase &) = 0;
  76 };
  77
  78
  79 template <class type> struct scriptmember : public scriptmemberbase {
  80   virtual ~scriptmember () { delete Member; }
  81   scriptmember () : Member (0) {}
  82   scriptmember (const scriptmember& Data) : scriptmemberbase (Data), Member (Data.Member ? new type (*Data.Member) : 0) {}
  83   scriptmember& operator= (const scriptmember &);
  84   virtual void ReadFrom (inputfile &);
  85   virtual void Replace (scriptmemberbase &);
  86   virtual void Save (outputfile &) const;
  87   virtual void Load (inputfile &);
  88   type *Member;
  89 };
  90
  91
  92 template <class type, class scripttype> inline const type *GetMemberOf (const scriptmember<type> &Data,
  93   const scriptwithbase *Base, const type *(scripttype::*MemberRetriever)() const)
  94 {
  95   return Data.Member ? Data.Member : Base ?  (static_cast<const scripttype*> (Base)->*MemberRetriever) () : 0;
  96 }
  97
  98
  99 template <class type> inline scriptmember<type>& scriptmember<type>::operator = (const scriptmember<type> &Data) {
 100   if (Member) {
 101     if (Data.Member) {
 102       *Member = *Data.Member;
 103     } else {
 104       delete Member;
 105       Member = 0;
 106     }
 107   } else if (Data.Member) {
 108     Member = new type (*Data.Member);
 109   }
 110   return *this;
 111 }
 112
 113
 114 template <class type> struct fastscriptmember : public scriptmemberbase {
 115   fastscriptmember () {}
 116   fastscriptmember (type Member) : Member (Member) {}
 117   virtual void ReadFrom (inputfile &);
 118   virtual void Replace (scriptmemberbase &);
 119   virtual void Save (outputfile &) const;
 120   virtual void Load (inputfile &);
 121   type Member;
 122 };
 123
 124
 125 class script {
 126 public:
 127   typedef std::map<cchar *, scriptmemberbase script::*, charcomparer> datamap;
 128   virtual ~script () {}
 129   virtual void ReadFrom (inputfile &) = 0;
 130   virtual void Save (outputfile& SaveFile) const { SaveDataMap (GetDataMap (), SaveFile); }
 131   virtual void Load (inputfile& SaveFile) { LoadDataMap (GetDataMap (), SaveFile); }
 132
 133 protected:
 134   truth ReadMember (inputfile&, cfestring &);
 135   virtual scriptmemberbase *GetDataFromMap (const datamap&, cchar *);
 136   virtual scriptmemberbase *GetData (cchar *String) { return GetDataFromMap (GetDataMap (), String); }
 137   virtual const datamap& GetDataMap () const = 0;
 138   virtual void SaveDataMap (const datamap &, outputfile &) const;
 139   virtual void LoadDataMap (const datamap &, inputfile &);
 140 };
 141
 142
 143 inline void ReadData (script &Type, inputfile &SaveFile) { Type.ReadFrom (SaveFile); }
 144 inline outputfile &operator << (outputfile &SaveFile, const script &Script) { Script.Save (SaveFile); return SaveFile; }
 145 inline inputfile &operator >> (inputfile &SaveFile, script &Script) { Script.Load (SaveFile); return SaveFile; }
 146
 147
 148 class scriptwithbase : public script {
 149 public:
 150   scriptwithbase () : Base (0) {}
 151   const scriptwithbase *GetBase () const { return Base; }
 152   virtual void SetBase (const scriptwithbase *What) { Base = What; }
 153
 154 protected:
 155   const scriptwithbase *Base;
 156 };
 157
 158
 159 class posscript : public script {
 160 public:
 161   typedef posscript scripttype;
 162   virtual void ReadFrom (inputfile &);
 163   truth GetRandom () const { return Random; }
 164   static void InitDataMap ();
 165   virtual void Save (outputfile &) const;
 166   virtual void Load (inputfile &);
 167
 168 protected:
 169   virtual const datamap &GetDataMap () const { return DataMap; }
 170
 171 protected:
 172   static datamap DataMap;
 173   SCRIPT_MEMBER(rect, Borders);
 174   FAST_SCRIPT_MEMBER(packv2, Vector);
 175   FAST_SCRIPT_MEMBER(uChar, Flags);
 176   truth Random;
 177 };
 178
 179
 180 class materialscript : public script {
 181 public:
 182   typedef materialscript scripttype;
 183   virtual void ReadFrom (inputfile &);
 184   int GetConfig () const { return Config; }
 185   void SetConfig (int What) { Config = What; }
 186   material *Instantiate () const;
 187   virtual void Save (outputfile &) const;
 188   virtual void Load (inputfile &);
 189   static void InitDataMap ();
 190
 191 protected:
 192   virtual const datamap& GetDataMap () const { return DataMap; }
 193
 194 protected:
 195   static datamap DataMap;
 196   SCRIPT_MEMBER(interval, Volume);
 197   int Config;
 198 };
 199
 200
 201 class basecontentscript : public script {
 202 public:
 203   typedef basecontentscript scripttype;
 204   basecontentscript ();
 205   virtual void ReadFrom (inputfile &);
 206   int GetContentType () const { return ContentType; }
 207   truth IsValid () const { return ContentType || Random; }
 208   virtual void Save (outputfile &) const;
 209   virtual void Load (inputfile &);
 210   static void InitDataMap ();
 211
 212 protected:
 213   virtual const datamap &GetDataMap () const { return DataMap; }
 214   virtual scriptmemberbase *GetData (cchar *);
 215   virtual int SearchCodeName (cfestring &) const = 0;
 216   virtual cchar *GetClassID () const = 0;
 217
 218 protected:
 219   static datamap DataMap;
 220   SCRIPT_MEMBER(materialscript, MainMaterial);
 221   SCRIPT_MEMBER(materialscript, SecondaryMaterial);
 222   uShort ContentType : 15;
 223   truth Random : 1;
 224   uShort Config;
 225   FAST_SCRIPT_MEMBER(uChar, Parameters);
 226   festring mCode;
 227 };
 228
 229
 230 inline truth IsValidScript (const basecontentscript *S) { return S->IsValid (); }
 231
 232
 233 template <class type> class contentscripttemplate : public basecontentscript {
 234 protected:
 235   type *BasicInstantiate (int) const;
 236   virtual int SearchCodeName (cfestring &) const;
 237 };
 238
 239
 240 template <class type> class contentscript;
 241
 242 template <> class contentscript<item> : public contentscripttemplate<item> {
 243 public:
 244   typedef contentscript<item> scripttype;
 245   contentscript<item> ();
 246   item *InstantiateBasedOnMaterial (int, int = 0) const;
 247   item *Instantiate (int = 0) const;
 248   static void InitDataMap ();
 249
 250 protected:
 251   virtual const datamap& GetDataMap () const { return DataMap; }
 252   virtual cchar *GetClassID () const;
 253   static datamap DataMap;
 254   SCRIPT_MEMBER(fearray<contentscript<item> >, ItemsInside);
 255   SCRIPT_MEMBER(interval, Times);
 256   SCRIPT_MEMBER(interval, LifeExpectancy);
 257   FAST_SCRIPT_MEMBER(uLong, Category);
 258   FAST_SCRIPT_MEMBER(sLong, MinPrice);
 259   FAST_SCRIPT_MEMBER(sLong, MaxPrice);
 260   FAST_SCRIPT_MEMBER(uChar, Team);
 261   FAST_SCRIPT_MEMBER(uChar, SquarePosition);
 262   FAST_SCRIPT_MEMBER(uChar, Chance);
 263   FAST_SCRIPT_MEMBER(uChar, ConfigFlags);
 264   FAST_SCRIPT_MEMBER(uChar, SpoilPercentage);
 265   FAST_SCRIPT_MEMBER(char, Enchantment);
 266   FAST_SCRIPT_TRUTH(IsActive);
 267 };
 268
 269
 270 truth IsValidScript (const fearray<contentscript<item> > *);
 271
 272
 273 template <> class contentscript<character> : public contentscripttemplate<character> {
 274 public:
 275   typedef contentscript<character> scripttype;
 276   contentscript<character> ();
 277   character *Instantiate (int = 0) const;
 278   static void InitDataMap ();
 279
 280 protected:
 281   virtual const datamap& GetDataMap () const { return DataMap; }
 282   virtual cchar *GetClassID () const;
 283   static datamap DataMap;
 284   SCRIPT_MEMBER(fearray<contentscript<item> >, Inventory);
 285   SCRIPT_MEMBER(fearray<packv2>, WayPoint);
 286   FAST_SCRIPT_MEMBER(uChar, Team);
 287   FAST_SCRIPT_MEMBER(uChar, Flags);
 288 };
 289
 290
 291 template <> class contentscript<glterrain> : public contentscripttemplate<glterrain> {
 292 public:
 293   typedef contentscript<glterrain> scripttype;
 294   glterrain *Instantiate (int SpecialFlags = 0) const { return contentscripttemplate<glterrain>::BasicInstantiate (SpecialFlags); }
 295   static void InitDataMap ();
 296
 297 protected:
 298   virtual const datamap& GetDataMap () const { return DataMap; }
 299   static datamap DataMap;
 300   virtual cchar *GetClassID () const;
 301   SCRIPT_TRUTH(IsInside);
 302 };
 303
 304
 305 template <> class contentscript<olterrain> : public contentscripttemplate<olterrain> {
 306 public:
 307   typedef contentscript<olterrain> scripttype;
 308   contentscript<olterrain> ();
 309   olterrain *Instantiate (int = 0) const;
 310   static void InitDataMap ();
 311
 312 protected:
 313   virtual const datamap& GetDataMap () const { return DataMap; }
 314   static datamap DataMap;
 315   virtual cchar *GetClassID () const;
 316   SCRIPT_MEMBER(fearray<contentscript<item> >, ItemsInside);
 317   SCRIPT_MEMBER(festring, Text);
 318   FAST_SCRIPT_MEMBER(uChar, VisualEffects);
 319   FAST_SCRIPT_MEMBER(uChar, AttachedArea);
 320   FAST_SCRIPT_MEMBER(uChar, AttachedEntry);
 321 };
 322
 323
 324 class squarescript : public script {
 325 public:
 326   typedef squarescript scripttype;
 327   squarescript ();
 328   virtual void ReadFrom (inputfile &);
 329   static void InitDataMap ();
 330
 331 protected:
 332   virtual const datamap& GetDataMap () const { return DataMap; }
 333   static datamap DataMap;
 334   SCRIPT_MEMBER(posscript, Position);
 335   SCRIPT_MEMBER(contentscript<character>, Character);
 336   SCRIPT_MEMBER(fearray<contentscript<item> >, Items);
 337   SCRIPT_MEMBER(contentscript<glterrain>, GTerrain);
 338   SCRIPT_MEMBER(contentscript<olterrain>, OTerrain);
 339   SCRIPT_MEMBER(interval, Times);
 340   FAST_SCRIPT_MEMBER(uChar, EntryIndex);
 341   FAST_SCRIPT_TRUTH(AttachRequired);
 342 };
 343
 344
 345 template <class type, class contenttype = contentscript<type> > class contentmap : public script {
 346 public:
 347   typedef contentmap scripttype;
 348   contentmap ();
 349   virtual ~contentmap ();
 350   virtual void ReadFrom (inputfile &);
 351   const contenttype *GetContentScript (int X, int Y) const { return ContentMap[X][Y].second; }
 352   virtual void Save (outputfile &) const;
 353   virtual void Load (inputfile &);
 354   static void InitDataMap ();
 355
 356 protected:
 357   virtual const datamap& GetDataMap () const { return DataMap; }
 358   static datamap DataMap;
 359   std::pair<int, contenttype*> **ContentMap;
 360   std::map<int, contenttype> SymbolMap;
 361   SCRIPT_MEMBER(v2, Size);
 362   SCRIPT_MEMBER(v2, Pos);
 363 };
 364
 365
 366 typedef contentmap<item, fearray<contentscript<item> > > itemcontentmap;
 367 typedef contentmap<character> charactercontentmap;
 368 typedef contentmap<glterrain> glterraincontentmap;
 369 typedef contentmap<olterrain> olterraincontentmap;
 370
 371
 372 class roomscript : public scriptwithbase {
 373 public:
 374   typedef roomscript scripttype;
 375   void ReadFrom (inputfile &);
 376   const std::list<squarescript>& GetSquare () const;
 377   virtual void Save (outputfile &) const;
 378   virtual void Load (inputfile &);
 379   static void InitDataMap ();
 380
 381 protected:
 382   virtual const datamap& GetDataMap () const { return DataMap; }
 383   static datamap DataMap;
 384   std::list<squarescript> Square;
 385   SCRIPT_MEMBER_WITH_BASE(charactercontentmap, CharacterMap);
 386   SCRIPT_MEMBER_WITH_BASE(itemcontentmap, ItemMap);
 387   SCRIPT_MEMBER_WITH_BASE(glterraincontentmap, GTerrainMap);
 388   SCRIPT_MEMBER_WITH_BASE(olterraincontentmap, OTerrainMap);
 389   SCRIPT_MEMBER_WITH_BASE(squarescript, WallSquare);
 390   SCRIPT_MEMBER_WITH_BASE(squarescript, FloorSquare);
 391   SCRIPT_MEMBER_WITH_BASE(squarescript, DoorSquare);
 392   SCRIPT_MEMBER_WITH_BASE(region, Size);
 393   SCRIPT_MEMBER_WITH_BASE(region, Pos);
 394   SCRIPT_TRUTH_WITH_BASE(AltarPossible);
 395   SCRIPT_TRUTH_WITH_BASE(GenerateDoor);
 396   SCRIPT_TRUTH_WITH_BASE(GenerateTunnel);
 397   SCRIPT_MEMBER_WITH_BASE(int, DivineMaster);
 398   SCRIPT_TRUTH_WITH_BASE(GenerateLanterns);
 399   SCRIPT_MEMBER_WITH_BASE(int, Type);
 400   SCRIPT_TRUTH_WITH_BASE(GenerateFountains);
 401   SCRIPT_TRUTH_WITH_BASE(AllowLockedDoors);
 402   SCRIPT_TRUTH_WITH_BASE(AllowBoobyTrappedDoors);
 403   SCRIPT_MEMBER_WITH_BASE(int, Shape);
 404   SCRIPT_TRUTH_WITH_BASE(IsInside);
 405   SCRIPT_TRUTH_WITH_BASE(GenerateWindows);
 406   SCRIPT_TRUTH_WITH_BASE(UseFillSquareWalls);
 407   SCRIPT_MEMBER_WITH_BASE(uLong, Flags);
 408   SCRIPT_TRUTH_WITH_BASE(GenerateWards);
 409 };
 410
 411
 412 class levelscript : public scriptwithbase {
 413 public:
 414   typedef levelscript scripttype;
 415   void ReadFrom (inputfile &);
 416   const std::list<squarescript>& GetSquare () const;
 417   const std::list<roomscript>& GetRoom () const;
 418   void Combine (levelscript &);
 419   virtual void Save (outputfile &) const;
 420   virtual void Load (inputfile &);
 421   virtual void SetBase (const scriptwithbase *);
 422   static void InitDataMap ();
 423
 424 protected:
 425   virtual const datamap& GetDataMap () const { return DataMap; }
 426   static datamap DataMap;
 427   std::list<squarescript> Square;
 428   std::list<roomscript> Room;
 429   SCRIPT_MEMBER_WITH_BASE(roomscript, RoomDefault);
 430   SCRIPT_MEMBER_WITH_BASE(squarescript, FillSquare);
 431   SCRIPT_MEMBER_WITH_BASE(squarescript, TunnelSquare);
 432   SCRIPT_MEMBER_WITH_BASE(festring, LevelMessage);
 433   SCRIPT_MEMBER_WITH_BASE(v2, Size);
 434   SCRIPT_MEMBER_WITH_BASE(interval, Items);
 435   SCRIPT_MEMBER_WITH_BASE(interval, Rooms);
 436   SCRIPT_TRUTH_WITH_BASE(GenerateMonsters);
 437   SCRIPT_TRUTH_WITH_BASE(IsOnGround);
 438   SCRIPT_MEMBER_WITH_BASE(int, TeamDefault);
 439   SCRIPT_MEMBER_WITH_BASE(festring, Description);
 440   SCRIPT_MEMBER_WITH_BASE(int, LOSModifier);
 441   SCRIPT_TRUTH_WITH_BASE(IgnoreDefaultSpecialSquares);
 442   SCRIPT_MEMBER_WITH_BASE(int, DifficultyBase);
 443   SCRIPT_MEMBER_WITH_BASE(int, DifficultyDelta);
 444   SCRIPT_MEMBER_WITH_BASE(int, MonsterAmountBase);
 445   SCRIPT_MEMBER_WITH_BASE(int, MonsterAmountDelta);
 446   SCRIPT_MEMBER_WITH_BASE(int, MonsterGenerationIntervalBase);
 447   SCRIPT_MEMBER_WITH_BASE(int, MonsterGenerationIntervalDelta);
 448   SCRIPT_TRUTH_WITH_BASE(AutoReveal);
 449   SCRIPT_MEMBER_WITH_BASE(festring, ShortDescription);
 450   SCRIPT_TRUTH_WITH_BASE(CanGenerateBone);
 451   SCRIPT_MEMBER_WITH_BASE(int, ItemMinPriceBase);
 452   SCRIPT_MEMBER_WITH_BASE(int, ItemMinPriceDelta);
 453   SCRIPT_MEMBER_WITH_BASE(int, Type);
 454   SCRIPT_MEMBER_WITH_BASE(int, EnchantmentMinusChanceBase);
 455   SCRIPT_MEMBER_WITH_BASE(int, EnchantmentMinusChanceDelta);
 456   SCRIPT_MEMBER_WITH_BASE(int, EnchantmentPlusChanceBase);
 457   SCRIPT_MEMBER_WITH_BASE(int, EnchantmentPlusChanceDelta);
 458   SCRIPT_MEMBER_WITH_BASE(int, BackGroundType);
 459   SCRIPT_TRUTH_WITH_BASE(IsCatacomb);
 460   SCRIPT_MEMBER_WITH_BASE(festring, EnterImage);
 461   SCRIPT_MEMBER_WITH_BASE(v2, EnterTextDisplacement);
 462 };
 463
 464
 465 class dungeonscript : public script {
 466 public:
 467   typedef dungeonscript scripttype;
 468   dungeonscript ();
 469   virtual ~dungeonscript ();
 470   virtual void ReadFrom (inputfile &);
 471   const std::map<int, levelscript>& GetLevel () const;
 472   void RandomizeLevels ();
 473   virtual void Save (outputfile &) const;
 474   virtual void Load (inputfile &);
 475   virtual const datamap& GetDataMap () const { return DataMap; }
 476   static void InitDataMap ();
 477
 478 protected:
 479   static datamap DataMap;
 480   std::map<int, levelscript> Level;
 481   std::list<std::pair<interval, levelscript> > RandomLevel;
 482   SCRIPT_MEMBER(levelscript, LevelDefault);
 483   SCRIPT_MEMBER(int, Levels);
 484   SCRIPT_MEMBER(festring, Description);
 485   SCRIPT_MEMBER(festring, ShortDescription);
 486 };
 487
 488
 489 class teamscript : public script {
 490 public:
 491   typedef teamscript scripttype;
 492   virtual void ReadFrom (inputfile &);
 493   const std::vector<std::pair<int, int> >& GetRelation () const;
 494   virtual void Save (outputfile &) const;
 495   virtual void Load (inputfile &);
 496   static void InitDataMap ();
 497
 498 protected:
 499   virtual const datamap& GetDataMap () const { return DataMap; }
 500   static datamap DataMap;
 501   std::vector<std::pair<int, int> > Relation;
 502   SCRIPT_MEMBER(int, KillEvilness);
 503 };
 504
 505
 506 class gamescript : public script {
 507 public:
 508   typedef gamescript scripttype;
 509   virtual void ReadFrom (inputfile &);
 510   const std::list<std::pair<int, teamscript> > &GetTeam () const;
 511   const std::map<int, dungeonscript> &GetDungeon () const;
 512   void RandomizeLevels ();
 513   virtual void Save (outputfile &) const;
 514   virtual void Load (inputfile &);
 515   static void InitDataMap ();
 516
 517 protected:
 518   virtual const datamap &GetDataMap () const { return DataMap; }
 519   static datamap DataMap;
 520   std::list<std::pair<int, teamscript> > Team;
 521   std::map<int, dungeonscript> Dungeon;
 522   SCRIPT_MEMBER(int, Dungeons);
 523   SCRIPT_MEMBER(int, Teams);
 524 };
 525
 526
 527 outputfile &operator << (outputfile &, const gamescript *);
 528 inputfile &operator >> (inputfile &, gamescript *&);
 529
 530
 531 class scriptsystem {
 532 public:
 533   static void Initialize ();
 534 };
 535
 536
 537 #endif