ryzom/tools/leveldesign/mission_compiler_lib/variables.cpp

   1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This source file has been modified by the following contributors:
   5 // Copyright (C) 2013  Jan BOON (Kaetemi) <jan.boon@kaetemi.be>
   6 //
   7 // This program is free software: you can redistribute it and/or modify
   8 // it under the terms of the GNU Affero General Public License as
   9 // published by the Free Software Foundation, either version 3 of the
  10 // License, or (at your option) any later version.
  11 //
  12 // This program is distributed in the hope that it will be useful,
  13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 // GNU Affero General Public License for more details.
  16 //
  17 // You should have received a copy of the GNU Affero General Public License
  18 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19
  20 #include "mission_compiler.h"
  21
  22 using namespace std;
  23 using namespace NLMISC;
  24 using namespace NLLIGO;
  25
  26
  27 class IVarFactory
  28 {
  29 public:
  30         virtual IVar *createVar(CMissionData &md, IPrimitive *prim) = 0;
  31
  32 };
  33
  34 template <class VarClass>
  35 class CVarFactory : public IVarFactory
  36 {
  37         IVar *createVar(CMissionData &md, IPrimitive *prim)
  38         {
  39                 return new VarClass(md, prim);
  40         }
  41 };
  42
  43 #define REGISTER_VAR_INDIRECT(varClass, key)    typedef CVarFactory<varClass> TVarFactory##varClass; \
  44                                                                                                 NLMISC_REGISTER_OBJECT_INDIRECT(IVarFactory, TVarFactory##varClass, string, string(key));
  45
  46
  47 //#define REGISTER_VARIABLE(className, varName) NLMISC_REGISTER_OBJECT(IVar, className, std::string, string(varName));
  48
  49 /* Class for npc variable */
  50 class CVarNpc : public IVar
  51 {
  52 public:
  53         CVarNpc(CMissionData &md, IPrimitive *prim)
  54                 : IVar(vt_npc, prim)
  55         {
  56                 _NpcLabel = getPrimProperty(prim, "npc_name");
  57                 _NpcFunction = getPrimProperty(prim, "npc_function");
  58                 if (!_NpcFunction.empty())
  59                 {
  60                         _NpcFunction = "$"+_NpcFunction+"$";
  61                 }
  62
  63                 IVar *nameVar = CFactoryIndirect<IVarFactory, string>::instance().getFactory("var_npc_name")->createVar(md, prim);
  64                 md.addVariable(prim, nameVar);
  65         }
  66
  67         const std::string getNpcLabel()
  68         {
  69                 return _NpcLabel;
  70         }
  71         const std::string getNpcFunction()
  72         {
  73                 return _NpcFunction;
  74         }
  75         const std::string getNpcFullName()
  76         {
  77                 return _NpcLabel+_NpcFunction;
  78         }
  79
  80         string evalVar(const string &subPart)
  81         {
  82                 if (subPart == "fullname")
  83                         return getNpcFullName();
  84                 else if (subPart == "function")
  85                         return _NpcFunction;
  86                 else if (subPart.empty())
  87                         return _NpcLabel;
  88
  89                 throw EParseException(NULL, toString("var_npc don't have a subpart '%s'", subPart.c_str()).c_str());
  90         }
  91
  92         STRING_MANAGER::TParamType getStringManagerType()
  93         {
  94                 return STRING_MANAGER::bot;
  95         }
  96
  97         string genDecl(CMissionData &md)
  98         {
  99                 return "decl : bot : "+evalVar("")+NL;
 100         }
 101 private:
 102         string          _NpcLabel;
 103         string          _NpcFunction;
 104 };
 105
 106 REGISTER_VAR_INDIRECT(CVarNpc, "var_npc");
 107
 108 /** Var for npc name (aka bot_name)
 109  *      This class is implicitly instancied by
 110  *      CVarNpc.
 111  */
 112 class CVarNpcName : public IVar
 113 {
 114 public:
 115         CVarNpcName(CMissionData &md, IPrimitive *prim)
 116                 : IVar(vt_npc, prim)
 117         {
 118                 // Change the var name
 119                 _VarName += "_name";
 120                 _NpcLabel = getPrimProperty(prim, "npc_name");
 121                 _NpcFunction = getPrimProperty(prim, "npc_function");
 122                 if (!_NpcFunction.empty())
 123                 {
 124                         _NpcFunction = "$"+_NpcFunction+"$";
 125                 }
 126         }
 127
 128         const std::string getNpcLabel()
 129         {
 130                 return _NpcLabel;
 131         }
 132         const std::string getNpcFunction()
 133         {
 134                 return _NpcFunction;
 135         }
 136         const std::string getNpcFullName()
 137         {
 138                 return _NpcLabel+_NpcFunction;
 139         }
 140
 141         string evalVar(const string &subPart)
 142         {
 143                 if (subPart.empty())
 144                         return string("\"")+_NpcLabel+"\"";
 145
 146                 throw EParseException(NULL, toString("var_npc_name don't have a subpart '%s'", subPart.c_str()).c_str());
 147         }
 148
 149         STRING_MANAGER::TParamType getStringManagerType()
 150         {
 151                 return STRING_MANAGER::bot_name;
 152         }
 153
 154         string genDecl(CMissionData &md)
 155         {
 156                 return string();
 157         }
 158
 159 private:
 160         string          _NpcLabel;
 161         string          _NpcFunction;
 162 };
 163 REGISTER_VAR_INDIRECT(CVarNpcName, "var_npc_name");
 164
 165 /* Class for npc variable */
 166 class CVarGroup : public IVar
 167 {
 168 public:
 169         CVarGroup(CMissionData &md, IPrimitive *prim)
 170                 : IVar(vt_npc, prim)
 171         {
 172                 _GroupName = getPrimProperty(prim, "group_name");
 173         }
 174
 175         string evalVar(const string &subPart)
 176         {
 177                 if (subPart.empty())
 178                         return _GroupName;
 179                 else if (subPart == "quoted")
 180                         return string("\"")+_GroupName+"\"";
 181                 else
 182                         nlassert(false);
 183                 return "";
 184         }
 185
 186         STRING_MANAGER::TParamType getStringManagerType()
 187         {
 188                 return STRING_MANAGER::bot_name;
 189         }
 190
 191         string genDecl(CMissionData &md)
 192         {
 193 //              return "decl : bot : "+evalVar("no_quote")+NL;
 194                 return "decl : bot : "+evalVar("")+NL;
 195         }
 196 private:
 197         string          _GroupName;
 198 };
 199
 200 REGISTER_VAR_INDIRECT(CVarGroup, "var_group");
 201 //NLMISC_REGISTER_OBJECT(IVar, CVarGroup, std::string, string("var_group"));
 202
 203
 204 /* Class for item */
 205 class CVarItem : public IVar
 206 {
 207 public:
 208         CVarItem(CMissionData &md, IPrimitive *prim)
 209                 : IVar(vt_item, prim)
 210         {
 211                 _ItemSheet = getPrimProperty(prim, "item_sheet");
 212         }
 213
 214         const std::string getItemSheet()
 215         {
 216                 return _ItemSheet;
 217         }
 218
 219         string evalVar(const string &subPart)
 220         {
 221                 nlassert(subPart.empty());
 222                 return _ItemSheet;
 223         }
 224
 225         STRING_MANAGER::TParamType getStringManagerType()
 226         {
 227                 return STRING_MANAGER::item;
 228         }
 229
 230         string genDecl(CMissionData &md)
 231         {
 232                 return "decl : item : "+evalVar("")+NL;
 233         }
 234 private:
 235         string          _ItemSheet;
 236 };
 237
 238 REGISTER_VAR_INDIRECT(CVarItem, "var_item");
 239 //NLMISC_REGISTER_OBJECT(IVar, CVarItem, std::string, string("var_item"));
 240
 241
 242 /* Class for race */
 243 class CVarRace : public IVar
 244 {
 245 public:
 246         CVarRace(CMissionData &md, IPrimitive *prim)
 247                 : IVar(vt_item, prim)
 248         {
 249                 _Race = getPrimProperty(prim, "race");
 250         }
 251
 252         string evalVar(const string &subPart)
 253         {
 254                 nlassert(subPart.empty());
 255                 return _Race;
 256         }
 257
 258         STRING_MANAGER::TParamType getStringManagerType()
 259         {
 260                 return STRING_MANAGER::race;
 261         }
 262
 263         string genDecl(CMissionData &md)
 264         {
 265                 return "decl : race : "+evalVar("")+NL;
 266         }
 267 private:
 268         string          _Race;
 269 };
 270
 271 REGISTER_VAR_INDIRECT(CVarRace, "var_race");
 272
 273 /* Class for sphrase */
 274 class CVarSPhrase : public IVar
 275 {
 276 public:
 277         CVarSPhrase(CMissionData &md, IPrimitive *prim)
 278                 : IVar(vt_item, prim)
 279         {
 280                 _SPhrase = getPrimProperty(prim, "sphrase_sheet");
 281         }
 282
 283         string evalVar(const string &subPart)
 284         {
 285                 nlassert(subPart.empty());
 286                 return _SPhrase;
 287         }
 288
 289         STRING_MANAGER::TParamType getStringManagerType()
 290         {
 291                 return STRING_MANAGER::sphrase;
 292         }
 293
 294         string genDecl(CMissionData &md)
 295         {
 296                 return "decl : sphrase : "+evalVar("")+NL;
 297         }
 298 private:
 299         string          _SPhrase;
 300 };
 301
 302 REGISTER_VAR_INDIRECT(CVarSPhrase, "var_sphrase");
 303
 304 /* Class for sbrick */
 305 class CVarSBrick : public IVar
 306 {
 307 public:
 308         CVarSBrick(CMissionData &md, IPrimitive *prim)
 309                 : IVar(vt_item, prim)
 310         {
 311                 _SBrick = getPrimProperty(prim, "sbrick_sheet");
 312         }
 313
 314         string evalVar(const string &subPart)
 315         {
 316                 nlassert(subPart.empty());
 317                 return _SBrick;
 318         }
 319
 320         STRING_MANAGER::TParamType getStringManagerType()
 321         {
 322                 return STRING_MANAGER::sbrick;
 323         }
 324
 325         string genDecl(CMissionData &md)
 326         {
 327                 return "decl : sbrick : "+evalVar("")+NL;
 328         }
 329 private:
 330         string          _SBrick;
 331 };
 332
 333 REGISTER_VAR_INDIRECT(CVarSBrick, "var_sbrick");
 334
 335
 336 /* for special item */
 337 const char      *SpecialItemProp[] =
 338 {
 339         "Durability",
 340         "Weight",
 341         "SapLoad",
 342         "Dmg",
 343         "Speed",
 344         "Range",
 345         "DodgeModifier",
 346         "ParryModifier",
 347         "AdversaryDodgeModifier",
 348         "AdversaryParryModifier",
 349         "ProtectionFactor",
 350         "MaxSlashingProtection",
 351         "MaxBluntProtection",
 352         "MaxPiercingProtection",
 353         "HpBuff",
 354         "SapBuff",
 355         "StaBuff",
 356         "FocusBuff"
 357 };
 358
 359 struct TItemProperty
 360 {
 361         string  PropName;
 362         string  PropValue;
 363 };
 364
 365 /* Class for special item */
 366 class CVarSpecialItem : public IVar
 367 {
 368 public:
 369         CVarSpecialItem(CMissionData &md, IPrimitive *prim)
 370                 : IVar(vt_item, prim)
 371         {
 372                 static bool init = false;
 373                 static set<string> propertyNames;
 374
 375                 if (!init)
 376                 {
 377                         for (uint i=0; i<sizeof(SpecialItemProp)/sizeof(char*); ++i)
 378                                 propertyNames.insert(SpecialItemProp[i]);
 379
 380                         init = true;
 381                 }
 382
 383                 _ItemSheet = getPrimProperty(prim, "item_sheet");
 384                 _ReqSkill = getPrimProperty(prim, "req_skill_level");
 385                 vector<string>  vs;
 386                 vs = getPrimPropertyArray(prim, "properties/values");
 387                 // parse the strings vector
 388                 for (uint i=0; i<vs.size(); ++i)
 389                 {
 390                         vector<string> parts;
 391                         explode(vs[i], string(" "), parts, true);
 392                         if (!parts.empty() && parts.size() != 2)
 393                         {
 394                                 string s = toString("Invalid special item property at line %u", i+1);
 395                                 throw EParseException(prim, s.c_str());
 396                         }
 397
 398                         if (parts.size() == 2)
 399                         {
 400                                 TItemProperty ip;
 401                                 ip.PropName = parts[0];
 402                                 ip.PropValue = parts[1];
 403
 404                                 if (propertyNames.find(ip.PropName) == propertyNames.end())
 405                                 {
 406                                         string s = toString("Invalid property name '%s'", ip.PropName.c_str());
 407                                         throw EParseException(prim, s.c_str());
 408                                 }
 409
 410                                 _Properties.push_back(ip);
 411                         }
 412                 }
 413                 _Action = getPrimProperty(prim, "item_action");
 414                 vs.clear();
 415                 vs = getPrimPropertyArray(prim, "phrase_item_name");
 416                 _ItemPhrase.initPhrase(md, prim, vs);
 417
 418                 string s;
 419                 s = getPrimProperty(prim, "no_drop");
 420                 _NoDrop = (s == "true");
 421         }
 422
 423 //      const std::string getItemSheet()
 424 //      {
 425 //              return _ItemSheet;
 426 //      }
 427
 428         string evalVar(const string &subPart)
 429         {
 430                 nlassert(subPart.empty());
 431                 return _VarName;
 432         }
 433
 434         STRING_MANAGER::TParamType getStringManagerType()
 435         {
 436                 return STRING_MANAGER::item;
 437         }
 438
 439         string genDecl(CMissionData &md)
 440         {
 441                 string ret = string("decl_item : ")+_VarName+" : "+_ItemSheet+" : "+_ReqSkill;
 442                 if (!_Properties.empty() ||!_Action.empty())
 443                         ret += " : ";
 444                 for (uint i=0; i<_Properties.size(); ++i)
 445                 {
 446                         TItemProperty &ip = _Properties[i];
 447                         ret += ip.PropName+" "+ip.PropValue;
 448                         if (i < _Properties.size()-1 || !_Action.empty())
 449                                 ret += "; ";
 450                 }
 451
 452                 if (!_Action.empty())
 453                         ret += _Action;
 454
 455                 ret += " : "+_ItemPhrase.genScript(md);
 456
 457                 if (_NoDrop)
 458                         ret += " : no_drop";
 459
 460                 ret += NL;
 461
 462                 return ret;
 463         }
 464
 465         std::string genPhrase()
 466         {
 467                 return _ItemPhrase.genPhrase();
 468         }
 469
 470
 471 private:
 472         /// the item sheet used as base for this special item
 473         string                                  _ItemSheet;
 474         /// The skill required to use the item
 475         string                                  _ReqSkill;
 476         /// The list of properties
 477         vector<TItemProperty>   _Properties;
 478         // Optional action (enchantement)
 479         string                                  _Action;
 480         // Name of the item
 481         CPhrase                                 _ItemPhrase;
 482         // No drop flag
 483         bool                                    _NoDrop;
 484
 485         string          _Color;
 486
 487 };
 488
 489 REGISTER_VAR_INDIRECT(CVarSpecialItem, "var_special_item");
 490 //NLMISC_REGISTER_OBJECT(IVar, CVarSpecialItem, std::string, string("var_special_item"));
 491
 492 /* Class for place variable */
 493 class CVarPlace : public IVar
 494 {
 495 public:
 496         CVarPlace(CMissionData &md, IPrimitive *prim)
 497                 : IVar(vt_npc, prim)
 498         {
 499                 _PlaceLabel = getPrimProperty(prim, "place_name");
 500         }
 501
 502 /*      const std::string getPlaceLabel()
 503         {
 504                 return _PlaceLabel;
 505         }
 506 */
 507         string evalVar(const string &subPart)
 508         {
 509                 nlassert(subPart.empty());
 510                 return _PlaceLabel;
 511         }
 512
 513         STRING_MANAGER::TParamType getStringManagerType()
 514         {
 515                 return STRING_MANAGER::place;
 516         }
 517
 518         string genDecl(CMissionData &md)
 519         {
 520                 return "decl : place : "+evalVar("")+NL;
 521         }
 522
 523 private:
 524         string          _PlaceLabel;
 525 };
 526 REGISTER_VAR_INDIRECT(CVarPlace, "var_place");
 527 //NLMISC_REGISTER_OBJECT(IVar, CVarPlace, std::string, string("var_place"));
 528
 529 /* Class for integer variable */
 530 class CVarInteger : public IVar
 531 {
 532 public:
 533         CVarInteger(CMissionData &md, IPrimitive *prim)
 534                 : IVar(vt_integer, prim)
 535         {
 536                 if (prim->checkProperty("value"))
 537                         _Value = getPrimProperty(prim, "value");
 538                 else if (prim->checkProperty("quantity"))
 539                         _Value = getPrimProperty(prim, "quantity");
 540                 else if (prim->checkProperty("quality"))
 541                         _Value = getPrimProperty(prim, "quality");
 542                 else
 543                 {
 544                         string err = toString("Can't find a valid property for integer variable");
 545                         throw EParseException(prim, err.c_str());
 546                 }
 547         }
 548
 549         const std::string getIntegerValue()
 550         {
 551                 return _Value;
 552         }
 553
 554         string evalVar(const string &subPart)
 555         {
 556                 nlassert(subPart.empty());
 557                 return _Value;;
 558         }
 559
 560         STRING_MANAGER::TParamType getStringManagerType()
 561         {
 562                 return STRING_MANAGER::integer;
 563         }
 564
 565         string genDecl(CMissionData &md)
 566         {
 567                 // nothing to declare for this pseudo var
 568                 return string();
 569         }
 570 private:
 571         string          _Value;
 572 };
 573 REGISTER_VAR_INDIRECT(CVarInteger, "var_integer");
 574 //NLMISC_REGISTER_OBJECT(IVar, CVarInteger, std::string, string("var_integer"));
 575 typedef CVarInteger CVarQuantity;
 576 REGISTER_VAR_INDIRECT(CVarQuantity, "var_quantity");
 577 //NLMISC_REGISTER_OBJECT(IVar, CVarQuantity, std::string, string("var_quantity"));
 578 typedef CVarInteger CVarQuality;
 579 REGISTER_VAR_INDIRECT(CVarQuality, "var_quality");
 580 //NLMISC_REGISTER_OBJECT(IVar, CVarQuality, std::string, string("var_quality"));
 581
 582
 583 /* Class for text var */
 584 class CVarText : public IVar
 585 {
 586 public:
 587         CVarText(CMissionData &md, IPrimitive *prim)
 588                 : IVar(vt_item, prim)
 589         {
 590                 _TextValue = getPrimPropertyArray(prim, "text");
 591         }
 592
 593         const vector<std::string> &getText()
 594         {
 595                 return _TextValue;;
 596         }
 597
 598         string evalVar(const string &subPart)
 599         {
 600                 nlassert(subPart.empty());
 601                 string t;
 602                 return std::accumulate(_TextValue.begin(), _TextValue.end(), string(""));
 603                 return t;
 604         }
 605
 606         STRING_MANAGER::TParamType getStringManagerType()
 607         {
 608                 nlassert(false);
 609                 return STRING_MANAGER::NB_PARAM_TYPES;
 610         }
 611
 612         string genDecl(CMissionData &md)
 613         {
 614                 // nothing to declare for this one
 615                 return string();
 616         }
 617 private:
 618         vector<string>          _TextValue;
 619 };
 620 REGISTER_VAR_INDIRECT(CVarText, "var_text");
 621 //NLMISC_REGISTER_OBJECT(IVar, CVarText, std::string, string("var_text"));
 622
 623 /* Class for creature var */
 624 class CVarCreature : public IVar
 625 {
 626 public:
 627         CVarCreature(CMissionData &md, IPrimitive *prim)
 628                 : IVar(vt_item, prim)
 629         {
 630                 _CreatureSheet = getPrimProperty(prim, "creature_sheet");
 631         }
 632
 633         string evalVar(const string &subPart)
 634         {
 635                 nlassert(subPart.empty());
 636                 return _CreatureSheet;
 637         }
 638
 639         STRING_MANAGER::TParamType getStringManagerType()
 640         {
 641 //              return STRING_MANAGER::creature;
 642                 return STRING_MANAGER::creature_model;
 643         }
 644
 645         string genDecl(CMissionData &md)
 646         {
 647                 // declare a creature sheet
 648 //              return "decl : creature : "+_CreatureSheet+NL;
 649                 return "decl : creature_model : "+_CreatureSheet+NL;
 650         }
 651 private:
 652         string                          _CreatureSheet;
 653 };
 654 REGISTER_VAR_INDIRECT(CVarCreature, "var_creature");
 655 //NLMISC_REGISTER_OBJECT(IVar, CVarCreature, std::string, string("var_creature"));
 656
 657 /* Class for faction var */
 658 class CVarFaction : public IVar
 659 {
 660 public:
 661         CVarFaction(CMissionData &md, IPrimitive *prim)
 662                 : IVar(vt_item, prim)
 663         {
 664                 _FactionName = getPrimProperty(prim, "faction_name");
 665         }
 666
 667         string evalVar(const string &subPart)
 668         {
 669                 nlassert(subPart.empty());
 670                 return _FactionName;
 671         }
 672
 673         STRING_MANAGER::TParamType getStringManagerType()
 674         {
 675                 return STRING_MANAGER::faction;
 676         }
 677
 678         string genDecl(CMissionData &md)
 679         {
 680                 // declare a creature sheet
 681                 return "decl : faction : "+_FactionName+NL;
 682         }
 683 private:
 684         string                          _FactionName;
 685 };
 686 REGISTER_VAR_INDIRECT(CVarFaction, "var_faction");
 687 //NLMISC_REGISTER_OBJECT(IVar, CVarFaction, std::string, string("var_faction"));
 688
 689 // Variable factory.
 690 IVar *IVar::createVar(CMissionData &md, IPrimitive *prim)
 691 {
 692         string *c;
 693         if (!prim->getPropertyByName("class", c))
 694                 throw EParseException(prim, "Can't find property 'class' on primitive");
 695
 696         return CFactoryIndirect<IVarFactory, string>::instance().getFactory(*c)->createVar(md, prim);
 697
 698         return NULL;
 699 };
 700 //IVar *IVar::createVar(CMissionData &md, IPrimitive *prim)
 701 //{
 702 //      string *className;
 703 //      if (!prim->getPropertyByName("class", className))
 704 //              throw EParseException(prim, "Can't find property 'class' in primitive");
 705 //
 706 //      IVar *ret = NLMISC_GET_FACTORY_INDIRECT(IVar, std::string).createObject(md, *className, prim);
 707 //
 708 //      return ret;
 709 //}
 710 //