ryzom/tools/leveldesign/mission_compiler_lib/mission_compiler.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) 2011  Matt RAYKOWSKI (sfb) <matt.raykowski@gmail.com>
   6 // Copyright (C) 2013-2020  Jan BOON (Kaetemi) <jan.boon@kaetemi.be>
   7 //
   8 // This program is free software: you can redistribute it and/or modify
   9 // it under the terms of the GNU Affero General Public License as
  10 // published by the Free Software Foundation, either version 3 of the
  11 // License, or (at your option) any later version.
  12 //
  13 // This program is distributed in the hope that it will be useful,
  14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 // GNU Affero General Public License for more details.
  17 //
  18 // You should have received a copy of the GNU Affero General Public License
  19 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20
  21 #include "mission_compiler.h"
  22 #include "step.h"
  23 #include "nel/misc/i18n.h"
  24 #include "nel/misc/common.h"
  25 #include "nel/ligo/primitive_utils.h"
  26
  27 using namespace std;
  28 using namespace NLMISC;
  29 using namespace NLLIGO;
  30
  31
  32 // hack to get access to string manager item enumeration to string without including
  33 // almost all of the Ryzom server side project
  34 namespace STRING_MANAGER
  35 {
  36         NL_BEGIN_STRING_CONVERSION_TABLE (TParamType)
  37                 NL_STRING_CONVERSION_TABLE_ENTRY( item )
  38                 NL_STRING_CONVERSION_TABLE_ENTRY( place )
  39                 NL_STRING_CONVERSION_TABLE_ENTRY( creature )
  40                 NL_STRING_CONVERSION_TABLE_ENTRY( skill )
  41                 NL_STRING_CONVERSION_TABLE_ENTRY( role )
  42                 NL_STRING_CONVERSION_TABLE_ENTRY( ecosystem )
  43                 NL_STRING_CONVERSION_TABLE_ENTRY( race )
  44                 NL_STRING_CONVERSION_TABLE_ENTRY( sbrick )
  45                 NL_STRING_CONVERSION_TABLE_ENTRY( faction )
  46                 NL_STRING_CONVERSION_TABLE_ENTRY( guild )
  47                 NL_STRING_CONVERSION_TABLE_ENTRY( player )
  48                 NL_STRING_CONVERSION_TABLE_ENTRY( bot )
  49                 { "int", integer},
  50 //              NL_STRING_CONVERSION_TABLE_ENTRY( integer )
  51                 NL_STRING_CONVERSION_TABLE_ENTRY( time )
  52                 NL_STRING_CONVERSION_TABLE_ENTRY( money )
  53                 NL_STRING_CONVERSION_TABLE_ENTRY( compass )
  54                 NL_STRING_CONVERSION_TABLE_ENTRY( string_id )
  55                 NL_STRING_CONVERSION_TABLE_ENTRY( dyn_string_id )
  56                 NL_STRING_CONVERSION_TABLE_ENTRY( self )
  57                 NL_STRING_CONVERSION_TABLE_ENTRY( creature_model )
  58                 NL_STRING_CONVERSION_TABLE_ENTRY( entity )
  59                 NL_STRING_CONVERSION_TABLE_ENTRY( body_part )
  60                 NL_STRING_CONVERSION_TABLE_ENTRY( score )
  61                 NL_STRING_CONVERSION_TABLE_ENTRY( sphrase )
  62                 NL_STRING_CONVERSION_TABLE_ENTRY( characteristic )
  63                 NL_STRING_CONVERSION_TABLE_ENTRY( damage_type )
  64                 NL_STRING_CONVERSION_TABLE_ENTRY( bot_name)
  65                 NL_STRING_CONVERSION_TABLE_ENTRY( power_type )
  66                 NL_STRING_CONVERSION_TABLE_ENTRY( literal )
  67         NL_END_STRING_CONVERSION_TABLE(TParamType, ParamTypeConversion, NB_PARAM_TYPES)
  68
  69         //-----------------------------------------------
  70         // stringToParamType
  71         //-----------------------------------------------
  72         TParamType stringToParamType( const std::string & str )
  73         {
  74                 return ParamTypeConversion.fromString( str );
  75         }
  76
  77         //-----------------------------------------------
  78         // stringToParamType
  79         //-----------------------------------------------
  80         const std::string & paramTypeToString( TParamType type )
  81         {
  82                 return ParamTypeConversion.toString( type );
  83         }
  84 }
  85
  86 // utility to 'tabulate' the lines in a string
  87 void tabulateLine(std::string &text, uint nbTabs)
  88 {
  89         if (text.empty())
  90                 return;
  91         string::size_type pos = 0;
  92         string  tabs;
  93
  94         for (uint i=0; i<nbTabs; ++i)
  95                 tabs += "\t";
  96
  97         // add a tab at start
  98         text = tabs + text;
  99
 100         // add a tab at each new line
 101         while ((pos = text.find('\n', pos)) != string::npos)
 102         {
 103                 if (pos < text.size()-1 && text[pos+1] == '\r')
 104                 {
 105                         // add after the '\r' char
 106                         ++pos;
 107                 }
 108                 if (pos < text.size()-1)
 109                         text = text.substr(0, pos+1) + tabs + text.substr(pos+1);
 110         }
 111 }
 112
 113
 114
 115 class GenderExtractor
 116 {
 117 public:
 118
 119
 120         GenderExtractor(const std::string & literal, const std::string& identifier, unsigned int level=0);
 121
 122         std::string operator()(unsigned int i) const;
 123
 124         unsigned int size() const;
 125
 126
 127         ~GenderExtractor();
 128 private:
 129         bool extractMarkup(const std::string& literal, const std::string & markup,  std::string &before,  std::string &inside,  std::string & after);
 130
 131         bool parseMarkup(const std::string& literal, const std::string & markup, std::string& newPhrase, bool include = false );
 132
 133         std::string getPhrase(unsigned int i) const;
 134
 135         std::string getExtension(unsigned int i) const;
 136
 137         std::string getCondition(unsigned int i) const;
 138
 139         std::string getEntity(unsigned int i) const;
 140
 141         std::string getIdentifier(unsigned int i) const;
 142
 143
 144 private:
 145
 146
 147         bool _Entity;
 148         std::string _EntityName;
 149
 150         std::string _Text;
 151         std::string _Identifier;
 152
 153         GenderExtractor* _Female;
 154         GenderExtractor* _Male;
 155
 156
 157
 158 };
 159 GenderExtractor::~GenderExtractor()
 160 {
 161         delete _Female;
 162         delete _Male;
 163 }
 164 std::string GenderExtractor::getIdentifier(unsigned int i) const
 165 {
 166         return _Identifier + getExtension(i);
 167 }
 168
 169 std::string GenderExtractor::operator()(unsigned int i) const
 170 {
 171         std::string ret("\t");
 172         std::string condition = getCondition(i);
 173
 174         ret += condition.empty() ? "":std::string("( ") + condition + " )" + NL + "\t\t";
 175         ret +=  getIdentifier(i) + "\t[" + getPhrase(i) + "]" + NL;
 176         return ret;
 177 }
 178
 179
 180 GenderExtractor::GenderExtractor(const std::string & literal, const std::string& identifier, unsigned int level)
 181 {
 182
 183
 184         static const char * es[] ={"e", "e1", "e2", "e3"};
 185         static const char * fs[] ={"f", "f1", "f2", "f3"};
 186         static const char * hs[] ={"h", "h1", "h2", "h3"};
 187
 188         const char * e = es[level];
 189         const char * f = fs[level];
 190         const char * h = hs[level];
 191
 192         _Identifier = toLowerAscii(identifier);
 193
 194         std::string newPhrase;
 195
 196         std::string before;
 197         std::string after;
 198         std::string femaleText;
 199         std::string maleText;
 200
 201         _Entity =  extractMarkup(literal, e, before, _EntityName, after);
 202         if (_EntityName.size() > 2)
 203         {
 204                 if (_EntityName[0] == '$'  && _EntityName[_EntityName.size() - 1] == '$')
 205                 {
 206                         _EntityName = _EntityName.substr(1, _EntityName.size() - 2);
 207                 }
 208         }
 209
 210         std::string newLiteral = before + after;
 211
 212         bool isFemale = parseMarkup(newLiteral,f,newPhrase, true);
 213         if ( isFemale)
 214         {
 215                 parseMarkup(newPhrase,h,newPhrase, false);
 216                 femaleText = newPhrase;
 217         }
 218
 219         bool isMale = parseMarkup(newLiteral, h, newPhrase, true);
 220         if (isMale)
 221         {
 222
 223                 parseMarkup(newPhrase, f, newPhrase, false);
 224                 maleText = newPhrase;
 225         }
 226
 227         if (isMale != isFemale)
 228         {
 229                 std::string goodMarkup = isMale ? std::string("") +"<" + h + "></" + h + ">" : std::string("")+"<"+f+"></"+f+">";
 230                 std::string badMarkup  = isFemale ? std::string("") +"<" + h + "></" + h + ">" : std::string("")+"<"+f+"></"+f+">";
 231                 std::string exceptionText = std::string("Expression ") + identifier + " that contains a tag " + goodMarkup + " needs also tags " + badMarkup + " even empty.";
 232                 throw EParseException(0, exceptionText.c_str());
 233         }
 234
 235         if (!isMale && !isFemale)
 236         {
 237                 _Text = literal;
 238                 _Female = 0;
 239                 _Male = 0;
 240
 241         }
 242         else
 243         {
 244                 if (!_Entity) { _EntityName = "self"; }
 245                 _Female = new GenderExtractor(femaleText, identifier, level+1);
 246                 _Male =  new GenderExtractor(maleText, identifier, level+1);
 247         }
 248
 249
 250
 251 }
 252
 253 bool GenderExtractor::extractMarkup(const std::string& literal, const std::string & markup,  std::string &before,  std::string &inside,  std::string & after)
 254 {
 255         std::string::size_type posBegin;
 256         std::string::size_type posEnd;
 257         std::string::size_type posInside;
 258
 259         std::string beginMarkup = std::string("<") + markup + std::string(">");
 260         std::string endMarkup = std::string("</") + markup + std::string(">");
 261         posBegin = literal.find(beginMarkup);
 262         if ( posBegin != std::string::npos )
 263         {
 264                 posEnd = literal.find(endMarkup, posBegin + beginMarkup.size());
 265                 if (posEnd != std::string::npos)
 266                 {
 267                         before = literal.substr(0, posBegin);
 268                         posInside = posBegin + beginMarkup.size();
 269                         inside = literal.substr(posInside, posEnd - posInside);
 270                         after = literal.substr(posEnd+endMarkup.size());
 271                         return true;
 272                 }
 273         }
 274         after = literal;
 275         return false;
 276 }
 277
 278 bool GenderExtractor::parseMarkup(const std::string& literal, const std::string & markup, std::string& newPhrase, bool include )
 279 {
 280
 281         bool markupExist;
 282         bool changed = false;
 283         std::string oldPhrase = literal;
 284
 285         newPhrase.clear();
 286         do
 287         {
 288                 std::string before;
 289                 std::string inside;
 290                 std::string after;
 291                 markupExist = extractMarkup(oldPhrase, markup, before, inside, after);
 292                 newPhrase += before;
 293                 if (include){ newPhrase += inside; }
 294                 oldPhrase = after;
 295                 if (markupExist){ changed = true; }
 296
 297         } while(markupExist);
 298
 299         newPhrase += oldPhrase;
 300         return changed;
 301 }
 302
 303 std::string GenderExtractor::getPhrase(unsigned int i) const
 304 {
 305         if ( i%2 == 0) { return _Male ?  _Male->getPhrase(i/2) :  _Text; }
 306         if ( i%2 == 1) { nlassert(_Female); return  _Female->getPhrase(i/2);}
 307         nlassert(0);
 308         return "";
 309 }
 310
 311 std::string GenderExtractor::getExtension(unsigned int i) const
 312 {
 313         if ( i%2 == 0) { return _Male ?  std::string("_m") + _Male->getExtension(i/2) :  ""; }
 314         if ( i%2 == 1) { nlassert(_Female); return  std::string("_f") + _Female->getExtension(i/2);}
 315         nlassert(0);
 316         return "";
 317 }
 318
 319 std::string GenderExtractor::getCondition(unsigned int i) const
 320 {
 321
 322         //if ( i%2 == 0) { return _Male ?  std::string("\t(") + _Male->getExtension(i/2) :  "\t"; }
 323         //if ( i%2 == 1) { nlassert(_Female); return  std::string("_f") + _Female->getExtension(i/2);}
 324
 325         if ( i%2 == 0)
 326         {
 327                 if (_Male)
 328                 {
 329                         std::string next = _Male->getCondition(i/2);
 330                         std::string current = _EntityName + ".gender = male";
 331                         return next.size() ? current + " & " + next : current;
 332
 333                 }
 334                 else
 335                 {
 336                         return "";
 337                 }
 338         }
 339
 340         if ( i%2 == 1)
 341         {
 342                 std::string next = _Female->getCondition(i/2);
 343                 std::string current = _EntityName + ".gender = female";
 344                 return next.size() ? current + " & " + next : current;
 345         }
 346
 347         nlassert(0);
 348
 349         return "";
 350 }
 351
 352 unsigned int GenderExtractor::size() const
 353 {
 354         return _Male ? _Male->size() +  _Female->size(): 1;
 355 }
 356
 357
 358 string CPhrase::genPhrase()
 359 {
 360         string ret;
 361         if (!_PhraseLiterals.empty())
 362         {
 363                 for (uint p=0; p<_PhraseLiterals.size(); ++p)
 364                 {
 365                         string identifier = _PhraseId;
 366                         if (_NumEntry != 0)
 367                                 identifier += toString("_%u", p+1);
 368
 369                         GenderExtractor gender(_PhraseLiterals[p], identifier, 0);
 370
 371                         ret += identifier + " (";
 372                         // generate default param list
 373                         if (_DefaultParams.size() > p)
 374                         {
 375                                 for (uint i=0; i<_DefaultParams[p].size(); ++i)
 376                                 {
 377                                         ret += STRING_MANAGER::paramTypeToString(_DefaultParams[p][i].ParamType) + " "+_DefaultParams[p][i].ParamName;
 378                                         if (i != _DefaultParams[p].size()-1 || !_AdditionalParams.empty())
 379                                                 ret += ", ";
 380                                 }
 381                         }
 382                         // generate additional param list
 383                         for (uint i=0; i<_AdditionalParams.size(); ++i)
 384                         {
 385                                 ret += STRING_MANAGER::paramTypeToString(_AdditionalParams[i].ParamType) + " "+_AdditionalParams[i].ParamName;
 386                                 if (i != _AdditionalParams.size()-1)
 387                                         ret += ", ";
 388                         }
 389                         ret += ")" + NL;
 390                         ret += "{" + NL;
 391
 392                         for (unsigned int i = 0; i < gender.size(); ++i)
 393                         {
 394                                 ret += gender(i);
 395                         }
 396
 397                         ret += "}" + NL + NL;
 398                 }
 399         }
 400 nlinfo("genphrase: %s", ret.c_str());
 401         return ret;
 402 }
 403
 404
 405
 406
 407 bool CMissionCompiler::generateDotScript(NLLIGO::IPrimitive *missionPrim, std::string &dotScript, std::string &log)
 408 {
 409         //assume that the mission is compiled in the last compiled mission slot
 410         try
 411         {
 412                 if (compileMission(missionPrim, string()))
 413                 {
 414                         dotScript = _CompiledMission.back()->generateDotScript();
 415                         return true;
 416                 }
 417                 else
 418                 {
 419                         return false;
 420                 }
 421         }
 422         catch(const EParseException & e)
 423         {
 424                 log = e.Why;
 425                 return false;
 426         }
 427 }
 428
 429 /*
 430 bool CMissionCompiler::parseGlobalMissionData(IPrimitive *mission, CMissionData &md)
 431 {
 432         // Mission name
 433         string *s;
 434         if (!mission->getPropertyByName("name", s) || s->empty())
 435                 throw EParseException(mission, "missing mission name !");
 436         md.setMissionName(*s);
 437
 438         // giver primitive file
 439         if (!mission->getPropertyByName("giver_primitive", s) || s->empty())
 440                 throw EParseException(mission, "missing giver primitive !");
 441         md.setGiverPrimitive(*s);
 442
 443         // giver name
 444         if (!mission->getPropertyByName("giver_primitive", s) || s->empty())
 445                 throw EParseException(mission, "missing giver primitive !");
 446         md.setGiverName(*s);
 447         // If the mission is under a npc_bot node, then the giver is directly taken
 448         // from the npc name
 449         if (mission->getParent())
 450         {
 451                 if (mission->getParent()->getPropertyByName("class", s) && *s == "npc_bot")
 452                 {
 453                         if (mission->getParent()->getPropertyByName("name", s))
 454                                 md.setGiverName(*s);
 455                 }
 456         }
 457
 458         // TODO : read all other params...
 459
 460         return true;
 461 }
 462 */
 463
 464 void CMissionData::initHeaderPhrase(IPrimitive *prim)
 465 {
 466         CPhrase::TPredefParams params;
 467         params.resize(1);
 468         params[0].push_back(CPhrase::TParamInfo("giver", STRING_MANAGER::bot));
 469         _MissionTitle.initPhrase(*this, prim, _MissionTitleRaw, 0, params);
 470         _MissionDescription.initPhrase(*this, prim, _MissionDescriptionRaw, 0, params);
 471         _MissionAutoMenu.initPhrase(*this, prim, _MissionAutoMenuRaw);
 472 }
 473
 474 bool CMissionCompiler::compileMission(NLLIGO::IPrimitive *rootPrim, const std::string &primFileName)
 475 {
 476         TPrimitiveClassPredicate pred("mission_tree");
 477         if (!pred(rootPrim))
 478                 return false;
 479
 480         IPrimitive      *mission = rootPrim;
 481         CMissionData    *pmd = new CMissionData;
 482         CMissionData    &md = *pmd;
 483
 484         // Read the mission name
 485         string missionName = md.getProperty(mission, "name", false, false);
 486         if( missionName.find(' ') != string::npos)
 487         {
 488                 throw EParseException(mission, toString("Mission name '%s' must not contains space", missionName.c_str()).c_str());
 489         }
 490         md.setMissionName(missionName);
 491         // Create a temporary primitive node to create default variable
 492         {
 493                 // giver default var
 494                 IPrimitive *temp = new CPrimNode();
 495                 temp->addPropertyByName("class", new CPropertyString("var_npc"));
 496                 temp->addPropertyByName("name", new CPropertyString("giver = giver"));
 497                 temp->addPropertyByName("npc_name", new CPropertyString("giver"));
 498                 temp->addPropertyByName("var_name", new CPropertyString("giver"));
 499
 500                 IVar *var = IVar::createVar(md, temp);
 501                 md.addVariable(NULL, var);
 502
 503                 delete temp;
 504         }
 505
 506         {
 507                 // player default var
 508                 IPrimitive *temp = new CPrimNode();
 509                 temp->addPropertyByName("class", new CPropertyString("var_npc"));
 510                 temp->addPropertyByName("name", new CPropertyString("player = player"));
 511                 temp->addPropertyByName("npc_name", new CPropertyString("player"));
 512                 temp->addPropertyByName("var_name", new CPropertyString("player"));
 513
 514                 IVar *var = IVar::createVar(md, temp);
 515                 md.addVariable(NULL, var);
 516
 517                 delete temp;
 518         }
 519
 520         {
 521                 // guild_name default var
 522                 IPrimitive *temp = new CPrimNode();
 523                 temp->addPropertyByName("class", new CPropertyString("var_text"));
 524                 temp->addPropertyByName("name", new CPropertyString("guild_name = guild_name"));
 525                 temp->addPropertyByName("npc_name", new CPropertyString("guild_name"));
 526                 temp->addPropertyByName("var_name", new CPropertyString("guild_name"));
 527
 528                 IVar *var = IVar::createVar(md, temp);
 529                 md.addVariable(NULL, var);
 530
 531                 delete temp;
 532         }
 533
 534         // first, start by reading mission variables
 535         IPrimitive      *variables;
 536         {
 537                 TPrimitiveClassPredicate predTmp("variables");
 538                 variables= NLLIGO::getPrimitiveChild(mission, predTmp);
 539         }
 540
 541         if (!variables)
 542         {
 543                 nlwarning("Can't find variables !");
 544                 return false;
 545         }
 546         parseVariables(md, variables);
 547
 548         // read global mission data
 549         md.parseMissionHeader(rootPrim);
 550
 551         // now, we can init the mission header phrase (they need variable knwoled)
 552         md.initHeaderPhrase(rootPrim);
 553
 554         IPrimitive      *preReq;
 555         {
 556                 TPrimitiveClassPredicate predTmp("pre_requisite");
 557                 preReq = getPrimitiveChild(mission, predTmp);
 558         }
 559
 560         if (!preReq)
 561         {
 562                 nlwarning("Can't find pre requisite !");
 563                 return false;
 564         }
 565         parsePreRequisite(md, preReq);
 566
 567 /*      IPrimitive      *steps = getPrimitiveChild(mission, TPrimitivePropertyPredicate("step_tag", "true"));
 568         if (!steps)
 569         {
 570                 nlwarning("Can't find steps !");
 571                 return false;
 572         }
 573 */      parseSteps(md, mission);
 574
 575         // Store the compiled mission
 576         _CompiledMission.push_back(pmd);
 577
 578         string script = md.generateMissionScript(primFileName);
 579
 580         nlinfo("The script :");
 581         nlinfo("%s", script.c_str());
 582
 583         string phrases = md.generatePhraseFile();
 584         nlinfo("The phrase file is :");
 585         {
 586                 vector<string> lines;
 587                 explode(phrases, string("\n"), lines, false);
 588                 for (uint i=0; i<lines.size(); ++i)
 589                 {
 590                         if(lines[i][0] == '\r') lines[i] = lines[i].substr(1);
 591                         nlinfo("%s", lines[i].c_str());
 592                 }
 593         }
 594
 595         string dot = md.generateDotScript();
 596         nlinfo("The dot script is :");
 597         {
 598                 vector<string> lines;
 599                 explode(dot, string("\n"), lines, false);
 600                 for (uint i=0; i<lines.size(); ++i)
 601                 {
 602                         if(lines[i][0] == '\r') lines[i] = lines[i].substr(1);
 603                         nlinfo("%s", lines[i].c_str());
 604                 }
 605         }
 606         return true;
 607 }
 608
 609 bool    CMissionCompiler::compileMissions(IPrimitive *rootPrim, const std::string &primFileName)
 610 {
 611         bool ret = true;
 612         // 1st, build a set of mission_scrip nodes
 613         NLLIGO::TPrimitiveSet   missionTrees;
 614
 615         CPrimitiveSet<TPrimitiveClassPredicate> scriptsSet;
 616
 617         TPrimitiveClassPredicate pred("mission_tree");
 618         scriptsSet.buildSet(rootPrim, pred, missionTrees);
 619
 620         nlinfo("Found %u mission tree in the primitive file", missionTrees.size());
 621
 622         for (uint i=0; i<missionTrees.size(); ++i)
 623         {
 624 //              try
 625 //              {
 626                         compileMission(missionTrees[i], primFileName);
 627 //              }
 628 //              catch (const EParseException &e)
 629 //              {
 630 //                      nlwarning("Error while parsing a mission: '%s'", e.Why.c_str());
 631 //                      ret = false;
 632 //              }
 633
 634         }
 635
 636         return ret;
 637
 638 }
 639
 640 bool CMissionCompiler::installCompiledMission(NLLIGO::CLigoConfig &ligoConfig, const std::string &primFileName)
 641 {
 642         // generate the mission script into the npcs...
 643         {
 644                 map<string, TLoadedPrimitive >  loadedPrimitives;
 645
 646                 // store the previous alias value
 647                 map<string, uint32>                     missionAlias;
 648
 649                 // First loop to remove any mission that belong to the compiled primitive file
 650                 for (uint i=0; i<_CompiledMission.size(); ++i)
 651                 {
 652                         CMissionData &mission = *(_CompiledMission[i]);
 653                         // first, look for the primitive file to load
 654                         string fileName = mission.getGiverPrimitive();
 655                         if (fileName.empty())
 656                         {
 657                                 // use mission primitive instead
 658                                 fileName = primFileName;
 659                         }
 660                         if (loadedPrimitives.find(toLowerAscii(fileName)) == loadedPrimitives.end())
 661                         {
 662                                 string fullFileName = CPath::lookup(fileName, false);
 663                                 if (fullFileName.empty())
 664                                 {
 665                                         throw EParseException(NULL, toString("Can't find primitive file '%s' in path", fileName.c_str()).c_str());
 666                                 }
 667                                 // we need to load this primitive file.
 668                                 CPrimitives *primDoc = new CPrimitives;
 669                                 CPrimitiveContext::instance().CurrentPrimitive = primDoc;
 670                                 if (loadXmlPrimitiveFile(*primDoc, fullFileName, ligoConfig))
 671                                 {
 672                                         // the primitive file is loaded correctly
 673                                         loadedPrimitives.insert(make_pair(toLowerAscii(fileName), TLoadedPrimitive(primDoc, fullFileName)));
 674                                         CPrimitiveContext::instance().CurrentPrimitive = NULL;
 675                                 }
 676                                 else
 677                                 {
 678                                         CPrimitiveContext::instance().CurrentPrimitive = NULL;
 679                                         throw EParseException(NULL, toString("Can't read primitive file '%s'", fullFileName.c_str()).c_str());
 680                                 }
 681                         }
 682                         TLoadedPrimitive &loadedPrim = loadedPrimitives[toLowerAscii(fileName)];
 683                         CPrimitives *primDoc = loadedPrim.PrimDoc;
 684
 685                         TPrimitiveSet scripts;
 686                         CPrimitiveSet<TPrimitiveClassPredicate> filter;
 687                         TPrimitiveClassPredicate pred("mission");
 688                         filter.buildSet(primDoc->RootNode, pred, scripts);
 689
 690                         // for each script, check if it was generated, and if so, check the name
 691                         // of the source primitive file.
 692                         for (uint i=0; i<scripts.size(); ++i)
 693                         {
 694                                 vector<string> *script;
 695                                 if (scripts[i]->getPropertyByName("script", script) && !script->empty())
 696                                 {
 697                                         string missionName;
 698
 699                                         scripts[i]->getPropertyByName("name", missionName);
 700
 701                                         // Format should be : #compiled from <source_primitive_name>
 702                                         if (script->front().find("generated from") != string::npos)
 703                                         {
 704                                                 // we have a compiled mission
 705                                                 if (script->front().find(CFile::getFilename(primFileName)) != string::npos)
 706                                                 {
 707                                                         // ok, this mission is compiled from the same primitive
 708
 709                                                         // store it's alias
 710                                                         TPrimitiveClassPredicate pred("alias");
 711
 712                                                         IPrimitive *p = getPrimitiveChild(scripts[i], pred);
 713
 714                                                         if (p)
 715                                                         {
 716                                                                 CPrimAlias *pa = dynamic_cast<CPrimAlias*>(p);
 717                                                                 if (pa)
 718                                                                 {
 719                                                                         uint32 alias = pa->getAlias();
 720                                                                         missionAlias.insert(make_pair(missionName, alias));
 721                                                                 }
 722                                                         }
 723                                                         else
 724                                                         {
 725                                                                 nlwarning("Can't find alias prim in primitive '%s'", buildPrimPath(scripts[i]).c_str());
 726                                                         }
 727
 728                                                         // and remove it
 729                                                         scripts[i]->getParent()->removeChild(scripts[i]);
 730                                                 }
 731                                         }
 732                                 }
 733                         }
 734                 }
 735
 736                 // second loop to assign compiled mission to giver npc
 737                 for (uint i=0; i<_CompiledMission.size(); ++i)
 738                 {
 739                         CMissionData &mission = *(_CompiledMission[i]);
 740                         string fileName = mission.getGiverPrimitive();
 741                         if (fileName.empty())
 742                         {
 743                                 // no giver primitive file specified in the mission, use the mission primitive instead
 744                                 fileName = primFileName;
 745                         }
 746
 747                         TLoadedPrimitive &loadedPrim = loadedPrimitives[toLowerAscii(fileName)];
 748                         CPrimitives *primDoc = loadedPrim.PrimDoc;
 749                         CPrimitiveContext::instance().CurrentPrimitive = primDoc;
 750
 751                         TPrimitiveSet bots;
 752                         CPrimitiveSet<TPrimitiveClassAndNamePredicate> filter;
 753                         TPrimitiveClassAndNamePredicate pred("npc_bot", mission.getGiverName());
 754                         filter.buildSet(primDoc->RootNode, pred, bots);
 755
 756                         if (bots.empty())
 757                         {
 758                                 string err = toString("Can't find bot '%s' in primitive '%s' !",
 759                                         mission.getGiverName().c_str(),
 760                                         fileName.c_str());
 761                                 throw EParseException(NULL, err.c_str());
 762                         }
 763                         else if (bots.size() > 1)
 764                         {
 765                                 string err = toString("Found more than one bot named '%s' in primitive '%s' !",
 766                                         mission.getGiverName().c_str(),
 767                                         fileName.c_str());
 768                                 throw EParseException(NULL, err.c_str());
 769                         }
 770
 771                         // ok, all is good, we can add the mission node to the giver
 772                         IPrimitive *giver = bots.front();
 773                         // create a new node for the mission
 774                         IPrimitive *script = new CPrimNode;
 775                         // set the class
 776                         script->addPropertyByName("class", new CPropertyString("mission"));
 777                         // set the name
 778                         script->addPropertyByName("name", new CPropertyString(mission.getMissionName()));
 779 //                              string alias(toString("%u", makeHash32(mission.getMissionName())));
 780 //                      script->addPropertyByName("alias", new CPropertyString(mission.getAlias()));
 781                         string scriptLines = mission.generateMissionScript(primFileName);
 782                         vector<string> lines;
 783                         explode(scriptLines, NL, lines, false);
 784
 785                         script->addPropertyByName("script", new CPropertyStringArray(lines));
 786
 787                         // insert the script into the giver
 788                         giver->insertChild(script);
 789
 790                         // add the alias
 791                         {
 792                                 CPrimAlias *pa = new CPrimAlias;
 793                                 pa->addPropertyByName("class", new CPropertyString ("alias"));
 794                                 pa->addPropertyByName("name", new CPropertyString ("alias"));
 795
 796                                 if (missionAlias.find(mission.getMissionName()) != missionAlias.end())
 797                                 {
 798                                         // restore the previous alias
 799                                         primDoc->forceAlias(pa, missionAlias.find(mission.getMissionName())->second);
 800                                 }
 801
 802                                 // insert in first place
 803                                 script->insertChild(pa, 0);
 804                         }
 805
 806                         CPrimitiveContext::instance().CurrentPrimitive = NULL;
 807                 }
 808
 809                 // Save the modified primitive files
 810                 while (!loadedPrimitives.empty())
 811                 {
 812                         TLoadedPrimitive &loadedPrim = loadedPrimitives.begin()->second;
 813                         if (!saveXmlPrimitiveFile(*(loadedPrim.PrimDoc), loadedPrim.FullFileName))
 814                                 return false;
 815
 816                         _FilesToPublish.push_back(loadedPrim.FullFileName);
 817
 818                         // Free the memory
 819                         delete loadedPrim.PrimDoc;
 820
 821                         loadedPrimitives.erase(loadedPrimitives.begin());
 822                 }
 823         }
 824
 825         // generate the phrase file (if any)
 826         {
 827                 string phraseFileName = CFile::getFilenameWithoutExtension(primFileName) + "_wk.txt";
 828
 829                 CSString content;
 830
 831                 for (uint i=0; i<_CompiledMission.size(); ++i)
 832                 {
 833                         content += _CompiledMission[i]->generatePhraseFile();
 834                 }
 835                 // transform NL (\n\r) into single \n
 836                 content = content.replace(NL.c_str(), "\n");
 837                 ucstring ucs;
 838                 ucs.fromUtf8(content);
 839
 840                 CI18N::writeTextFile(phraseFileName, ucs, true);
 841
 842                 _FilesToPublish.push_back(phraseFileName);
 843         }
 844
 845         return true;
 846 }
 847
 848
 849 bool CMissionCompiler::publishFiles(const std::string &serverPathPrim, const std::string &serverPathText, const std::string &localPathText)
 850 {
 851         for (uint i=0 ; i<_FilesToPublish.size() ; i++)
 852         {
 853                 string dst, src = _FilesToPublish[i];
 854
 855                 string::size_type n = src.find("primitives");
 856                 if (n == string::npos)
 857                 {
 858                         // text files : copy it and check include in phrase_rites_wk.txt
 859
 860                         // server
 861                         string textFile = CPath::standardizePath(serverPathText) + "phrase_rites_wk.txt";
 862                         includeText(textFile, string("#include \"") + src + string("\"\n"));
 863                         dst = CPath::standardizePath(serverPathText) + src;
 864                         NLMISC::CFile::copyFile(dst, src);
 865
 866                         // local
 867                         textFile = CPath::standardizePath(localPathText) + "phrase_rites_wk.txt";
 868                         includeText(textFile, string("#include \"") + src + string("\"\n"));
 869                         dst = CPath::standardizePath(localPathText) + src;
 870                         NLMISC::CFile::copyFile(dst, src);
 871                 }
 872                 else
 873                 {
 874                         // primitive file : copy to server
 875                         dst = CPath::standardizePath(serverPathPrim) + string(src, n, src.size());
 876                         NLMISC::CFile::copyFile(dst, src);
 877                 }
 878         }
 879         return true;
 880 }
 881
 882 bool CMissionCompiler::includeText(const std::string &filename, const std::string &text)
 883 {
 884         FILE *f = nlfopen(filename, "r+");
 885         if (f == NULL)
 886         {
 887                 nlwarning("Unable to open %s", filename.c_str());
 888                 return false;
 889         }
 890
 891         bool isIn = false;
 892         char buffer[1024];
 893
 894         // Check for UTF8 format
 895         if (fread(buffer, 1, 3, f) != 3)
 896         {
 897                 fclose(f);
 898                 nlwarning("Unable to read 3 bytes from %s", filename.c_str());
 899                 return false;
 900         }
 901
 902         if (buffer[0] != -17 || buffer[1] != -69 || buffer[2] != -65)
 903                 fseek(f, 0, SEEK_SET);
 904
 905         // Compare each line
 906         while(fgets(buffer, 1024, f))
 907         {
 908                 if (!strcmp(text.c_str(), buffer))
 909                 {
 910                         isIn = true;
 911                         break;
 912                 }
 913         }
 914
 915         if (!isIn)
 916                 fputs(text.c_str(), f);
 917
 918         fclose(f);
 919         return true;
 920 }
 921
 922 bool CMissionCompiler::parsePreRequisite(CMissionData &md, IPrimitive *preReq)
 923 {
 924         md.parsePrerequisites(preReq);
 925         return true;
 926 }
 927
 928 bool CMissionCompiler::parseOneStep(CMissionData &md, IPrimitive *stepToParse, IStep *parent, bool bEndOfBranch)
 929 {
 930         IStep *step = IStep::createStep(md, stepToParse);
 931         if (step != NULL)
 932         {
 933
 934                 if (!step->isAJump() && !step->getStepName().empty())
 935                 {
 936                         if (md.getStepByName(step->getStepName()) != NULL)
 937                         {
 938                                 string err = toString("Step '%s' already defined !", step->getStepName().c_str());
 939                                 throw EParseException(step->getPrimitive(), err.c_str());
 940                         }
 941
 942                         if (step->getStepName().find(' ') != string::npos)
 943                         {
 944                                 throw EParseException(step->getPrimitive(), toString("Step name '%s' must not contains space", step->getStepName().c_str()).c_str());
 945                         }
 946                         md.addStepName(step->getStepName(), step);
 947                 }
 948
 949                 TPrimitiveSet subBranchs = step->getSubBranchs();
 950
 951                 // Add the step (if no parent add to the mission data)
 952                 if (parent == NULL)
 953                 {
 954                         if (!md.addStep(step))
 955                         {
 956                                 throw EParseException(stepToParse, "Error parsing mission step");
 957                         }
 958                 }
 959                 else
 960                 {
 961                         parent->addSubStep(step);
 962                 }
 963
 964                 CStepIf *pSI = dynamic_cast<CStepIf *>(step);
 965                 // If this is a IF step : parse with 'step' as a parent
 966
 967                 IStep *pParentStep = NULL;
 968
 969                 if ((dynamic_cast<CStepIf*>(step) != NULL) ||
 970                         (dynamic_cast<CStepPlayerReconnect*>(step) != NULL))
 971                         pParentStep = step;
 972
 973                 if (!subBranchs.empty())
 974                 {
 975                         // need to parse subbranch before continuing
 976                         for (uint i=0; i<subBranchs.size(); ++i)
 977                         {
 978                                 if (!parseOneStep(md, subBranchs[i], pParentStep, i==(subBranchs.size()-1)))
 979                                         return false;
 980                         }
 981                 }
 982
 983                 // if this is the last step, flag it as such
 984                 step->EndOfBranch = bEndOfBranch;
 985         }
 986         return true;
 987 }
 988
 989 bool CMissionCompiler::parseSteps(CMissionData &md, IPrimitive *steps, IStep *parent)
 990 {
 991         TPrimitiveSet childs;
 992         TPrimitivePropertyPredicate pred("step_tag", "true");
 993         filterPrimitiveChilds(steps, pred, childs);
 994
 995         if (childs.empty())
 996         {
 997                 CPrimNode node;
 998                 node.addPropertyByName("class", new CPropertyString("end"));
 999                 node.addPropertyByName("name", new CPropertyString(""));
1000                 IStep *step = IStep::createStep(md, &node);
1001                 delete step;
1002 //              md.addStep(step);
1003         }
1004         if (!childs.empty())
1005         {
1006                 for (uint i=0; i<childs.size(); ++i)
1007                 {
1008                         IPrimitive *child = childs[i];
1009
1010                         parseOneStep(md, childs[i], NULL, i == (childs.size()-1));
1011
1012                 }
1013         }
1014         return true;
1015 }
1016
1017 string CMissionCompiler::getProp(IPrimitive *prim, const string &propName)
1018 {
1019         string s;
1020         bool ret = prim->getPropertyByName(propName.c_str(), s);
1021         if (!ret)
1022                 throw EParseException(prim, toString("Property %s does't exist", propName.c_str()).c_str());
1023
1024         return s;
1025 }
1026
1027 string CMissionCompiler::getClass(IPrimitive *prim)
1028 {
1029         string className;
1030         bool ret = prim->getPropertyByName("class", className);
1031         nlassert(ret);
1032         return className;
1033 }
1034
1035 bool CMissionCompiler::parseVariables(CMissionData &md, IPrimitive *variables)
1036 {
1037         for (uint i=0; i<variables->getNumChildren(); ++i)
1038         {
1039                 IPrimitive *child;
1040                 if (variables->getChild(child, i))
1041                 {
1042                         IVar *var = IVar::createVar(md, child);
1043                         if (var)
1044                         {
1045                                 nldebug("Adding variable '%s' as type %u", var->getVarName().c_str(), var->getVarType());
1046                                 md.addVariable(child, var);
1047                         }
1048                 }
1049         }
1050         return true;
1051 }
1052
1053 template <class VectorType>
1054 bool strtokquote(const string &src, VectorType &tokens)
1055 {
1056         enum TMode
1057         {
1058                 read_blank,
1059                 read_token,
1060                 read_quoted
1061         };
1062
1063         string  temp;
1064         TMode   mode = read_blank;
1065
1066         for (uint i=0; i<src.size(); ++i)
1067         {
1068                 switch (mode)
1069                 {
1070                 case read_blank:
1071                         if (src[i] != ' ' && src[i] != '\t' && src[i] != '\n' && src[i] != '\r')
1072                         {
1073                                 // end of blank !
1074                                 if (src[i] == '\"')
1075                                 {
1076                                         // begin of a quoted string
1077                                         temp = "\"";
1078                                         mode = read_quoted;
1079                                 }
1080                                 else
1081                                 {
1082                                         // begin of a token
1083                                         temp.clear();
1084                                         temp += src[i];
1085                                         mode = read_token;
1086                                 }
1087                         }
1088                         break;
1089                 case read_token:
1090                         if (src[i] == ' ' || src[i] == '\t' || src[i] == '\n' || src[i] == '\r' || src[i] == '\"')
1091                         {
1092                                 // end of token
1093                                 tokens.push_back(temp);
1094                                 temp.clear();
1095                                 --i;
1096                                 mode = read_blank;
1097                         }
1098                         else
1099                         {
1100                                 temp += src[i];
1101                         }
1102                         break;
1103                 case read_quoted:
1104                         if (src[i] == '\\')
1105                         {
1106                                 // special treatment for escape command
1107                                 if (i < src.size()-1)
1108                                 {
1109                                         temp += src[i];
1110                                         temp += src[i+1];
1111                                         // skip escaped char
1112                                         i++;
1113                                 }
1114                                 else
1115                                 {
1116                                         nlwarning("Error parsing escape char in quoted string");
1117                                         return false;
1118                                 }
1119                         }
1120                         else if (src[i] != '\"')
1121                         {
1122                                 // just add this char
1123                                 temp += src[i];
1124                         }
1125                         else
1126                         {
1127                                 // end of quoted string
1128                                 temp += src[i];
1129                                 tokens.push_back(temp);
1130                                 temp.clear();
1131                                 mode = read_blank;
1132                         }
1133                         break;
1134                 }
1135         }
1136         if (!temp.empty())
1137         {
1138                 if (mode == read_quoted)
1139                 {
1140                         nlwarning("Missing closing quote at end of string while reading text in '%s'", src.c_str());
1141                         return false;
1142                 }
1143                 tokens.push_back(temp);
1144         }
1145         return true;
1146 }
1147
1148 template <class VectorType>
1149 bool strtokquote(const vector<string> &src, VectorType &tokens)
1150 {
1151         for (uint i=0; i<src.size(); ++i)
1152         {
1153                 if (!strtokquote(src[i], tokens))
1154                         return false;
1155         }
1156         return true;
1157 }
1158
1159 struct TFindParamPred : std::unary_function<CPhrase::TParamInfo, bool>
1160 {
1161         string  Name;
1162         TFindParamPred(const std::string &name)
1163                 : Name (name)
1164         {}
1165
1166         bool operator() (const CPhrase::TParamInfo &paramInfo) const
1167         {
1168                 return paramInfo.ParamName == Name;
1169         }
1170 };
1171
1172
1173 bool CPhrase::isEmpty()
1174 {
1175         return _PhraseId.empty();
1176 }
1177
1178 bool CPhrase::asAdditionnalParams()
1179 {
1180         return !_AdditionalParams.empty();
1181 }
1182
1183
1184 void CPhrase::initPhrase (CMissionData &md,
1185                                         IPrimitive *prim,
1186                                         const vector<string> &texts,
1187                                         uint32 numEntry,
1188                                         const TPredefParams &predefParams )
1189 {
1190 //      nlassert(numEntry == predefParams.size());
1191
1192         // store the predefined/default parameters
1193         _DefaultParams = predefParams;
1194         // store the number of entry to generate (for literal with variant)
1195         _NumEntry = numEntry;
1196
1197         numEntry = max(uint32(1), numEntry);
1198
1199         _PhraseLiterals.clear();
1200 //      _PhraseLiterals.resize(numEntry);
1201
1202         // first, concatenate the text vector
1203         string text;
1204         for (uint i=0; i<texts.size(); ++i)
1205         {
1206                 text = text + texts[i];
1207                 if (i != texts.size() -1)
1208                         text += "\n";
1209         }
1210
1211         nldebug("phrase text: %s", text.c_str());
1212
1213         CVectorSString  tokens;
1214
1215         if (!strtokquote(text, tokens))
1216                 throw EParseException(prim, toString("failed to tokenize the string '%s'", text.c_str()).c_str());
1217
1218         if (tokens.empty())
1219                 // nothing to parse
1220                 return;
1221
1222         // storage for additional parameters
1223         vector<string>  params;
1224
1225 retry:
1226         // ok, the string is parsed, now we can analyze it
1227         // look at the first letter of the first token to determine the type of data we have
1228         if (tokens[0][0] == '\"')
1229         {
1230                 // we have a literal, so we must found numEntry literal, then a suffix tag for the phrase name
1231                 if (tokens.size() != numEntry +1)
1232                         throw EParseException(prim, toString("bad number of tokens in phrase : need %u (%u entries + 1 suffix), found %u\n(in : '%s')",
1233                                                                         numEntry+1,
1234                                                                         numEntry,
1235                                                                         tokens.size(),
1236                                                                         text.c_str()
1237                                                                         ).c_str());
1238
1239                 _PhraseLiterals.resize(numEntry);
1240                 for (uint i=0; i<numEntry; ++i)
1241                 {
1242                         CSString text = tokens[i];
1243                         // remove quotation marks
1244                         text = text.leftCrop(1);
1245                         text = text.rightCrop(1);
1246
1247                         // store the literal phrase value
1248                         _PhraseLiterals[i] = text;
1249                         // escape any ']' in the string
1250                         _PhraseLiterals[i] = CSString(_PhraseLiterals[i]).replace("]", "\\]");
1251
1252                         // now, we can analyse the string content, looking for parameters replacement
1253                         while (text.contains('$'))
1254                         {
1255                                 // 'advance' to replacement point
1256                                 text = text.splitFrom('$');
1257                                 if (!text.empty())
1258                                 {
1259                                         if (text[0] != '$')
1260                                         {
1261                                                 if (!text.contains('$'))
1262                                                         throw EParseException(prim, "missing parameter closing tag '$'");
1263
1264                                                 string::size_type paramStart = _PhraseLiterals[i].size() - text.size();
1265                                                 // ok, we found a parameter
1266                                                 CSString p = text.splitTo('$', true);
1267                                                 // remove any subpart access
1268                                                 p = p.splitTo('.');
1269                                                 if (i >= predefParams.size() || find_if(predefParams[i].begin(), predefParams[i].end(), TFindParamPred(static_cast<string&>(p))) == predefParams[i].end())
1270                                                 {
1271                                                         // this param is not in the predefined params list, add it to the optional params
1272                                                         params.push_back(p);
1273                                                 }
1274
1275                                                 // remove any compiler param from the phrase literal
1276                                                 if (p.find("@") != string::npos)
1277                                                 {
1278                                                         string::size_type pos = _PhraseLiterals[i].find(p, paramStart);
1279                                                         if (pos != string::npos)
1280                                                         {
1281                                                                 string::size_type pos2 = _PhraseLiterals[i].find("@", pos);
1282                                                                 if (pos2 != string::npos)
1283                                                                 {
1284                                                                         while (pos2 < _PhraseLiterals[i].size()
1285                                                                                 && _PhraseLiterals[i][pos2] != '.'
1286                                                                                 && _PhraseLiterals[i][pos2] != '$')
1287                                                                         {
1288                                                                                 _PhraseLiterals[i].erase(pos2, 1);
1289                                                                         }
1290                                                                 }
1291
1292                                                         }
1293                                                 }
1294                                         }
1295                                         else
1296                                         {
1297                                                 // this is an escaped $, skip it
1298                                                 text.leftCrop(1);
1299                                         }
1300                                 }
1301                         }
1302                 }
1303                 // last, read the suffix
1304                 _Suffixe = tokens.back();
1305
1306                 // generate identifier
1307                 _PhraseId = toUpperAscii(md.getMissionName()+"_"+_Suffixe);
1308
1309                 set<string>     ps;
1310                 // select only unique params
1311                 ps.insert(params.begin(), params.end());
1312
1313                 vector<string> temp(ps.begin(), ps.end());
1314                 params.swap(temp);
1315
1316         }
1317         else if (tokens[0][0] == '$')
1318         {
1319                 // we have a variable substitution. Retrieve the var and recall init
1320
1321                 // do the var replacement
1322                 CVectorSString  tokens2;
1323
1324                 tokens[0] = md.replaceVar(prim, tokens[0]);
1325
1326                 if (!strtokquote(tokens[0], tokens2))
1327                         throw EParseException(prim, toString("failed to tokenize the string ('%s')", tokens[0].c_str()).c_str());
1328
1329                 tokens2.insert(tokens2.end(), tokens.begin()+1, tokens.end());
1330                 tokens.swap(tokens2);
1331
1332                 // and retry the decoding
1333                 goto retry;
1334         }
1335         else
1336         {
1337                 // this should be a simple identifier, followed by any number of additional parameters
1338
1339                 // do the var replacement
1340 //              tokens = md.replaceVar(prim, tokens);
1341 //              untagVar(tokens[0]);
1342
1343                 // ok, now extract the phrase label and the additional parameters
1344                 _PhraseId = tokens[0];
1345                 for (uint i=1; i<tokens.size(); ++i)
1346                 {
1347                         untagVar(tokens[i]);
1348                         if (predefParams.empty() || find_if(predefParams[0].begin(), predefParams[0].end(), TFindParamPred(static_cast<string&>(tokens[i]))) == predefParams[0].end())
1349                         {
1350                                 // this param is not in the predefined params list, add it to the optional params
1351                                 params.push_back(tokens[i]);
1352                         }
1353                 }
1354         }
1355
1356         // now, build the parameter list
1357
1358         vector<string>::iterator first(params.begin()), last(params.end());
1359         for (; first != last; ++first)
1360         {
1361                 string name, param;
1362                 vector<string> parts;
1363                 NLMISC::explode(*first, string("@"), parts, false);
1364
1365                 if (!parts.empty())
1366                         name = parts[0];
1367                 if (parts.size() > 1)
1368                         param = parts[1];
1369
1370                 const string &varName = name;
1371
1372                 if (varName != "self")
1373                 {
1374                         IVar *var = md.getVariable(varName);
1375                         if (var == NULL)
1376                         {
1377                                 string err = toString("Can't find variable '%s' referenced from a phrase",
1378                                         name.c_str());
1379                                 throw EParseException(prim, err.c_str());
1380                         }
1381
1382                         TParamInfo pi;
1383                         pi.ParamName = name;
1384                         pi.CompilerParam = param;
1385                         pi.ParamType = var->getStringManagerType();
1386                         _AdditionalParams.push_back(pi);
1387                 }
1388         }
1389 }
1390
1391 std::string CPhrase::genScript(CMissionData &md)
1392 {
1393         std::string ret;
1394
1395         ret = _PhraseId;
1396         for (uint i=0; i<_AdditionalParams.size(); ++i)
1397         {
1398                 IVar *var = md.getVariable(_AdditionalParams[i].ParamName);
1399                 if (var == NULL)
1400                 {
1401                         string err = toString("Can't find variable named '%s' to generate phrase param", _AdditionalParams[i].ParamName.c_str());
1402                         throw EParseException(NULL, err.c_str());
1403                 }
1404                 ret += "; " + var->evalVar(_AdditionalParams[i].CompilerParam);
1405         }
1406
1407         return ret;
1408 }
1409
1410 CMissionData::CMissionData()
1411 {
1412         // init all datas
1413         _MonoInstance = false;
1414         _MissionAuto = false;
1415         _RunOnce = false;
1416         _Replayable = false;
1417         _Solo = false;
1418         _Guild = false;
1419         _NotInJournal = false;
1420         _AutoRemoveFromJournal = false;
1421         _PlayerReplayTimer = 0;
1422         _GlobalReplayTimer = 0;
1423         _NotProposed = false;
1424         _NonAbandonnable = false;
1425         _NeedValidation = false;
1426         _FailIfInventoryIsFull = false;
1427 }
1428
1429 CMissionData::~CMissionData()
1430 {
1431         while (!_Variables.empty())
1432         {
1433                 delete _Variables.begin()->second;
1434                 _Variables.erase(_Variables.begin());
1435         }
1436
1437         while (!_Steps.empty())
1438         {
1439                 delete _Steps.back();
1440                 _Steps.pop_back();
1441         }
1442 }
1443
1444 void CMissionData::setMissionName(const string &missionName)
1445 {
1446         _MissionName = missionName;
1447 }
1448
1449 const string &CMissionData::getMissionName()    { return _MissionName;}
1450
1451 bool CMissionData::addVariable(NLLIGO::IPrimitive *prim, IVar *var)
1452 {
1453         if (_Variables.find(var->getVarName()) != _Variables.end())
1454                 throw EParseException(prim, toString("Variable '%s' already defined !", var->getVarName().c_str()).c_str());
1455
1456         _Variables.insert(make_pair(var->getVarName(), var));
1457         _VariablesOrder.push_back(var);
1458         return true;
1459 }
1460
1461 IVar *CMissionData::getVariable(const string &varName)
1462 {
1463         map<string, IVar*>::iterator it(_Variables.find(varName));
1464         if (it != _Variables.end())
1465                 return it->second;
1466         return NULL;
1467 }
1468
1469 IStep *CMissionData::getNextStep(IStep *current)
1470 {
1471         for (uint i=0; i<_Steps.size(); ++i)
1472         {
1473                 if (_Steps[i] == current && i < _Steps.size()-1)
1474                         return _Steps[i+1];
1475         }
1476         return NULL;
1477 }
1478
1479 IStep *CMissionData::getStepByName(const std::string &stepName)
1480 {
1481         if (_StepsByNames.find(stepName) != _StepsByNames.end())
1482         {
1483                 return _StepsByNames[stepName];
1484         }
1485
1486         return NULL;
1487 }
1488
1489
1490 bool CMissionData::addStep(IStep *step)
1491 {
1492         _Steps.push_back(step);
1493         return true;
1494 }
1495
1496 string CMissionData::genPreRequisites()
1497 {
1498         string ret;
1499         if (!_ReqSkills.empty())
1500         {
1501                 ret += "req_skill : ";
1502                 for (uint i=0; i<_ReqSkills.size(); ++i)
1503                 {
1504                         ret += _ReqSkills[i].Skill+" "+_ReqSkills[i].MinLevel+" "+_ReqSkills[i].MaxLevel;
1505                         if (i < _ReqSkills.size()-1)
1506                                 ret +="; ";
1507                         else
1508                                 ret += NL;
1509                 }
1510         }
1511         if (!_ReqMissionDone.empty())
1512         {
1513                 for (uint i=0; i<_ReqMissionDone.size(); ++i)
1514                 {
1515                         ret += "req_mission : "+ _ReqMissionDone[i]+NL;
1516                 }
1517         }
1518         if (!_ReqMissionNotDone.empty())
1519         {
1520                 for (uint i=0; i<_ReqMissionNotDone.size(); ++i)
1521                 {
1522                         ret += "req_mission_neg : "+_ReqMissionNotDone[i]+NL;
1523                 }
1524         }
1525         if (!_ReqMissionRunning.empty())
1526         {
1527                 for (uint i=0; i<_ReqMissionRunning.size(); ++i)
1528                 {
1529                         ret += "req_mission_running : "+_ReqMissionRunning[i]+NL;
1530                 }
1531         }
1532         if (!_ReqMissionNotRunning.empty())
1533         {
1534
1535                 for (uint i=0; i<_ReqMissionNotRunning.size(); ++i)
1536                 {
1537                         ret += "req_mission_running_neg : "+_ReqMissionNotRunning[i]+NL;
1538                 }
1539         }
1540         if (!_ReqWearItem.empty())
1541         {
1542                 ret += "req_wear : ";
1543                 for (uint i=0; i<_ReqWearItem.size(); ++i)
1544                 {
1545                         ret += _ReqWearItem[i];
1546                         if(i < _ReqWearItem.size()-1)
1547                                 ret +="; ";
1548                         ret += NL;
1549                 }
1550         }
1551         if (!_ReqOwnItem.empty())
1552         {
1553                 ret += "req_item : ";
1554                 for (uint i=0; i<_ReqOwnItem.size(); ++i)
1555                 {
1556                         ret += _ReqOwnItem[i];
1557                         if(i < _ReqOwnItem.size()-1)
1558                                 ret +="; ";
1559                         ret += NL;
1560                 }
1561         }
1562         if (!_ReqTitle.empty())
1563         {
1564                 ret += "req_title : "+_ReqTitle+NL;
1565         }
1566         if (!_ReqFames.empty())
1567         {
1568                 for (uint i=0; i<_ReqFames.size(); ++i)
1569                 {
1570                         ret += "req_fame : "+_ReqFames[i].Faction+" "+_ReqFames[i].Fame;
1571                         ret += NL;
1572                 }
1573         }
1574         if(_ReqGuild)
1575         {
1576                 ret += "req_guild"+NL;
1577         }
1578         if (!_ReqGrade.empty())
1579         {
1580                 ret += "req_grade : "+_ReqGrade+NL;
1581         }
1582         if (!_ReqTeamSize.empty())
1583         {
1584                 ret += "req_team_size : "+_ReqTeamSize+NL;
1585         }
1586         if (!_ReqBrick.empty())
1587         {
1588                 ret += "req_brick : ";
1589                 for (uint i=0; i<_ReqBrick.size(); ++i)
1590                 {
1591                         ret += _ReqBrick[i];
1592                         if(i < _ReqBrick.size()-1)
1593                                 ret +="; ";
1594                         ret += NL;
1595                 }
1596         }
1597         if (!_ReqCharacterAge.empty())
1598         {
1599                 ret += "req_character_age : "+_ReqCharacterAge+NL;
1600         }
1601         if (!_ReqMaxPlayerID.empty())
1602         {
1603                 ret += "req_max_player_id : "+_ReqMaxPlayerID+NL;
1604         }
1605         if (!_ReqSeason.empty())
1606         {
1607                 ret += "req_season : "+_ReqSeason+NL;
1608         }
1609         if (!_ReqEncyclo.empty())
1610         {
1611                 ret += "req_encyclo_thema : " + _ReqEncyclo + NL;
1612         }
1613         if (!_ReqEncycloNeg.empty())
1614         {
1615                 ret += "req_encyclo_thema_neg : " + _ReqEncycloNeg + NL;
1616         }
1617         if (!_ReqEventFaction.empty())
1618         {
1619                 ret += "req_event_faction : " + _ReqEventFaction + NL;
1620         }
1621
1622         return ret;
1623 }
1624
1625
1626 string CMissionData::generateMissionScript(const std::string &primFileName)
1627 {
1628         _JumpPoints.clear();
1629         // first, gather jump point list
1630         for (uint i=0; i<_Steps.size(); ++i)
1631         {
1632                 set<TJumpInfo>  temp;
1633                 _Steps[i]->fillStepJump(*this, temp);
1634
1635                 // remove any jump to the next step (normal flow)
1636                 if (i < _Steps.size()-1)
1637                 {
1638                         set<TJumpInfo>::iterator first(temp.begin()), last(temp.end());
1639                         for (; first != last; )
1640                         {
1641                                 const TJumpInfo &ji = *first;
1642
1643                                 if (ji.StepName == _Steps[i+1]->getStepName() && ji.Discardable)
1644                                 {
1645                                         temp.erase(first);
1646                                         first = temp.begin();
1647                                 }
1648                                 else
1649                                         ++first;
1650                         }
1651                 }
1652
1653                 _JumpPoints.insert(temp.begin(), temp.end());
1654         }
1655         // generate the script
1656         string script;
1657         // generate mission header
1658         script += "# script generated from '"+CFile::getFilename(primFileName)+"'"+NL+NL;
1659         script += "#mission tags and pre-requisites"+NL;
1660         if (_MonoInstance)
1661                 script += "mono"+NL;
1662         if (_RunOnce)
1663                 script += "once"+NL;
1664         if (_Replayable)
1665                 script += "replayable"+NL;
1666         if (_Solo)
1667                 script += "solo"+NL;
1668         if (_Guild)
1669                 script += "guild"+NL;
1670         if (_NotInJournal)
1671                 script += "no_list"+NL;
1672         if (_AutoRemoveFromJournal)
1673                 script += "auto_remove"+NL;
1674         if (!_MissionCategory.empty())
1675                 script += "mission_category : "+_MissionCategory+NL;
1676         if (_PlayerReplayTimer != 0)
1677                 script += "player_replay_timer : "+toString("%u", _PlayerReplayTimer)+NL;
1678         if (_GlobalReplayTimer != 0)
1679                 script += "global_replay_timer : "+toString("%u", _GlobalReplayTimer)+NL;
1680         if (_NotProposed)
1681                 script += "not_proposed"+NL;
1682         if (_MissionAuto)
1683                 script += string("auto : ")+_MissionAutoMenu.genScript(*this)+NL;
1684         if (_NonAbandonnable)
1685                 script += "non_abandonnable"+NL;
1686         if (!_MissionIcon.empty())
1687                 script += "mission_icon : "+_MissionIcon+NL;
1688         if (_NeedValidation)
1689                 script += "need_validation"+NL;
1690         if (_FailIfInventoryIsFull)
1691                 script += "fail_if_inventory_is_full"+NL;
1692
1693         if (!_ParentMissions.empty())
1694         {
1695                 set<string>::iterator first(_ParentMissions.begin()), last(_ParentMissions.end());
1696                 for (; first != last; ++first)
1697                 {
1698                         script += "parent : "+ *first+NL;
1699                 }
1700         }
1701
1702         script += NL+"#Variables declaration"+NL;
1703
1704         // declare all the variables
1705         {
1706                 std::vector<IVar*>::iterator first(_VariablesOrder.begin()), last(_VariablesOrder.end());
1707                 for (; first != last; ++first)
1708                 {
1709                         script += (*first)->genDecl(*this);
1710                 }
1711         }
1712
1713         script += NL+"#pre-requisites"+NL;
1714         script += genPreRequisites();
1715
1716         script += NL+"#script"+NL;
1717         // generate mission title and desc
1718         script += "mission_title : "+_MissionTitle.genScript(*this)+NL;
1719         script += "mission_desc : "+_MissionDescription.genScript(*this)+NL;
1720
1721         // generate steps scripts
1722         for (uint i=0; i<_Steps.size(); ++i)
1723         {
1724                 script += "# "+_Steps[i]->getStepName()+NL;
1725                 if (_JumpPoints.find(_Steps[i]->getStepName()) != _JumpPoints.end()
1726                         && !_Steps[i]->isAJump())
1727                 {
1728                         // insert a jump point
1729                         script += "jump_point : " + _Steps[i]->getStepName() + NL;
1730                 }
1731
1732                 script += _Steps[i]->genCode(*this);
1733                 //if (_Steps[i]->EndOfBranch && !_Steps[i]->isAJump())
1734                 //      script += "end"+NL;
1735         }
1736
1737         return script;
1738 }
1739
1740 string CMissionData::generatePhraseFile()
1741 {
1742         string ret;
1743         // generate header phrase
1744         ret = _MissionTitle.genPhrase();
1745         ret += _MissionDescription.genPhrase();
1746         ret += _MissionAutoMenu.genPhrase();
1747
1748         // generate var phrase
1749         for (uint i=0; i<_VariablesOrder.size(); ++i)
1750         {
1751                 ret += _VariablesOrder[i]->genPhrase();
1752         }
1753
1754         // generate step phrase
1755         for (uint i=0; i<_Steps.size(); ++i)
1756         {
1757                 ret += _Steps[i]->genPhrase();
1758         }
1759         return ret;
1760 }
1761
1762 string CMissionData::generateDotScript()
1763 {
1764         string ret = "digraph " + _MissionName + NL;
1765         ret += "{" + NL;
1766
1767         // set default shape to 'record'
1768         ret += "node [shape=record]"+NL;
1769
1770         ret += "\t__start__ [shape=\"point\", peripheries=2, label=\"\"]"+NL;
1771
1772         // 1st pass, generate node for each step
1773         for (uint i=0; i<_Steps.size(); ++i)
1774         {
1775                 if (!_Steps[i]->isEnd() && !_Steps[i]->isAJump())
1776                 {
1777                         ret += "\t"+_Steps[i]->getStepName();
1778                         ret += " [URL=\""+buildPrimPath(_Steps[i]->getPrimitive())+"\"]"+NL;
1779                 }
1780         }
1781
1782         ret += "\t__end__ [shape=\"point\"]"+NL;
1783
1784         // activate red color for shapes that are created after this points
1785         ret += "node [color=red]"+NL;
1786
1787         // 2nd pass, generate link between steps
1788         for (uint i=0; i<_Steps.size(); ++i)
1789         {
1790                 if (_Steps[i]->isAJump())
1791                         continue;
1792
1793                 if (i == 0)
1794                 {
1795                         ret += "\t__start__ -> " + _Steps[i]->getStepName() + NL;
1796                 }
1797                 set<TJumpInfo> jumps;
1798                 _Steps[i]->fillStepJump(*this, jumps);
1799                 // there is a link there
1800                 while (!jumps.empty())
1801                 {
1802                         const TJumpInfo &ji = *(jumps.begin());
1803                         if (_StepsByNames.find(ji.StepName) != _StepsByNames.end()
1804                                 && _StepsByNames[ji.StepName]->isAJump())
1805                         {
1806                                 // this step is a jump, skip to link to the jump destination
1807                                 IStep *jumpStep = _StepsByNames[ji.StepName];
1808                                 set<TJumpInfo> jumpJump;
1809                                 jumpStep->fillStepJump(*this, jumpJump);
1810                                 if (jumpJump.size() != 1)
1811                                 {
1812                                         string str = toString("Step jump contains %u jumps destination instead of 1", jumpJump.size());
1813                                         throw EParseException(jumpStep->getPrimitive(), str.c_str());
1814                                 }
1815
1816                                 ret += "\t"+_Steps[i]->getStepName() + " -> " + jumpJump.begin()->StepName+" [label=\""+ji.JumpName+"\"]" + NL;
1817                         }
1818                         else
1819                         {
1820                                 ret += "\t"+_Steps[i]->getStepName() + " -> " + ji.StepName+" [label=\""+jumps.begin()->JumpName+"\"]" + NL;
1821                         }
1822                         jumps.erase(jumps.begin());
1823                 }
1824
1825         }
1826
1827         ret += "}" + NL;
1828
1829         return ret;
1830 }
1831
1832
1833 void CMissionData::parseMissionHeader(NLLIGO::IPrimitive *prim)
1834 {
1835 //      _MissionName = getProperty(prim, "name", false, false);
1836 //      if( _MissionName.find(' ') != string::npos)
1837 //      {
1838 //              throw EParseException(prim, toString("Mission name '%s' must not contains space", _MissionName.c_str()).c_str());
1839 //      }
1840         _GiverPrimitive = getProperty(prim,"giver_primitive", true, false);
1841         _MissionGiver = getProperty(prim, "mission_giver", true, false);
1842
1843 //      _Alias = getProperty(prim, "alias", false, false);
1844
1845         // If the mission is under a npc_bot node, then the giver is directly taken
1846         // from the npc name
1847         if (prim->getParent())
1848         {
1849                 if (getProperty(prim->getParent(), "class", false, false) == "npc_bot")
1850                 {
1851                         _MissionGiver = getProperty(prim->getParent(), "name", false, false);
1852                 }
1853         }
1854
1855         vector<string> vs;
1856         _MissionTitleRaw = getPropertyArray(prim, "mission_title", false, false);
1857 //      _MissionTitle.init(*this, prim, vs);
1858         _MissionDescriptionRaw = getPropertyArray(prim, "mission_description", false, false);
1859 //      _MissionDescription.init(*this, prim, vs);
1860         _MonoInstance = toBool(getProperty(prim, "mono_instance", true, false));
1861         _RunOnce = toBool(getProperty(prim, "run_only_once", true, false));
1862         _Replayable = toBool(getProperty(prim, "replayable", true, false));
1863
1864         _NeedValidation = toBool(getProperty(prim, "need_validation", true, false));
1865
1866         _MissionAutoMenuRaw = getPropertyArray(prim, "phrase_auto_menu", false, false);
1867
1868         // audience setting
1869         string s = getProperty(prim, "audience", false, false);
1870         if (s == "solo")
1871                 _Solo = true;
1872         else if (s == "guild")
1873                 _Guild = true;
1874
1875         _NotInJournal = NLMISC::toBool(getProperty(prim, "not_in_journal", false, false));
1876         _AutoRemoveFromJournal = NLMISC::toBool(getProperty(prim, "auto_remove_from_journal", false, false));
1877         _MissionCategory = getProperty(prim, "mission_category", false, false);
1878         NLMISC::fromString(getProperty(prim, "player_replay_timer", true, false), _PlayerReplayTimer);
1879         NLMISC::fromString(getProperty(prim, "global_replay_timer", true, false), _GlobalReplayTimer);
1880         _NotProposed = NLMISC::toBool(getProperty(prim, "not_proposed", false, false));
1881         _MissionAuto = NLMISC::toBool(getProperty(prim, "automatic", false, false));
1882         _NonAbandonnable = NLMISC::toBool(getProperty(prim, "non_abandonnable", false, false));
1883         _FailIfInventoryIsFull = NLMISC::toBool(getProperty(prim, "fail_if_inventory_is_full", false, false));
1884         _MissionIcon = getProperty(prim, "mission_icon", false, false);
1885
1886         if (_MissionAuto)
1887         {
1888                 if (_MissionAutoMenuRaw.empty())
1889                 {
1890                         string error = toString("Mission is flagged automatic, but no phrase_auto_menu defined !");
1891                         throw EParseException(prim, error.c_str());
1892                 }
1893         }
1894
1895         vs = getPropertyArray(prim, "parent_missions", true, false);
1896         _ParentMissions.insert(vs.begin(), vs.end());
1897
1898 }
1899
1900 void CMissionData::parsePrerequisites(NLLIGO::IPrimitive *prim)
1901 {
1902         // skills
1903         vector<string>  vs;
1904         vs = getPropertyArray(prim, "require_skill/min_level/max_level", true, false);
1905         for (uint i=0; i<vs.size(); ++i)
1906         {
1907                 if (!vs[i].empty())
1908                 {
1909                         vector<string> parts;
1910                         strtokquote(vs[i], parts);
1911                         if (parts.size() != 3)
1912                         {
1913                                 throw EParseException(prim, toString("Invalide argument count in line %u of require_skill array. Need 3, found %u", i, parts.size()).c_str());
1914                         }
1915                         TReqSkill rs;
1916                         rs.Skill = parts[0];
1917                         rs.MinLevel = parts[1];
1918                         rs.MaxLevel = parts[2];
1919
1920                         _ReqSkills.push_back(rs);
1921
1922                 }
1923         }
1924         // Mission done
1925         vs = getPropertyArray(prim, "require_mission_done", true, false);
1926         for (uint i=0; i<vs.size(); ++i)
1927         {
1928                 if (!vs[i].empty())
1929                 {
1930                         vector<string> parts;
1931                         strtokquote(vs[i], parts);
1932                         if (parts.size() != 1)
1933                         {
1934                                 throw EParseException(prim, toString("Invalide argument count in line %u of require_mission_done array. Need 1, found %u", i, parts.size()).c_str());
1935                         }
1936                         _ReqMissionDone.push_back(parts[0]);
1937                 }
1938         }
1939         // Mission not done
1940         vs = getPropertyArray(prim, "require_mission_not_done", true, false);
1941         for (uint i=0; i<vs.size(); ++i)
1942         {
1943                 if (!vs[i].empty())
1944                 {
1945                         vector<string> parts;
1946                         strtokquote(vs[i], parts);
1947                         if (parts.size() != 1)
1948                         {
1949                                 throw EParseException(prim, toString("Invalide argument count in line %u of require_mission_not_done array. Need 1, found %u", i, parts.size()).c_str());
1950                         }
1951                         _ReqMissionNotDone.push_back(parts[0]);
1952                 }
1953         }
1954         // Mission running
1955         vs = getPropertyArray(prim, "require_mission_running", true, false);
1956         for (uint i=0; i<vs.size(); ++i)
1957         {
1958                 if (!vs[i].empty())
1959                 {
1960                         vector<string> parts;
1961                         strtokquote(vs[i], parts);
1962                         if (parts.size() != 1)
1963                         {
1964                                 throw EParseException(prim, toString("Invalide argument count in line %u of require_mission_running array. Need 1, found %u", i, parts.size()).c_str());
1965                         }
1966                         _ReqMissionRunning.push_back(parts[0]);
1967                 }
1968         }
1969         // Mission not running
1970         vs = getPropertyArray(prim, "require_mission_not_running", true, false);
1971         for (uint i=0; i<vs.size(); ++i)
1972         {
1973                 if (!vs[i].empty())
1974                 {
1975                         vector<string> parts;
1976                         strtokquote(vs[i], parts);
1977                         if (parts.size() != 1)
1978                         {
1979                                 throw EParseException(prim, toString("Invalide argument count in line %u of require_mission_not_running array. Need 1, found %u", i, parts.size()).c_str());
1980                         }
1981                         _ReqMissionNotRunning.push_back(parts[0]);
1982                 }
1983         }
1984         // wearing item
1985         vs = getPropertyArray(prim, "require_wearing_item", true, false);
1986         for (uint i=0; i<vs.size(); ++i)
1987         {
1988                 if (!vs[i].empty())
1989                 {
1990                         vector<string> parts;
1991                         strtokquote(vs[i], parts);
1992                         if (parts.size() != 1)
1993                         {
1994                                 throw EParseException(prim, toString("Invalide argument count in line %u of require_wearing_item array. Need 1, found %u", i, parts.size()).c_str());
1995                         }
1996                         _ReqWearItem.push_back(parts[0]);
1997                 }
1998         }
1999         // own item
2000         vs = getPropertyArray(prim, "require_own_item", true, false);
2001         for (uint i=0; i<vs.size(); ++i)
2002         {
2003                 if (!vs[i].empty())
2004                 {
2005                         vector<string> parts;
2006                         strtokquote(vs[i], parts);
2007                         if (parts.size() != 1)
2008                         {
2009                                 throw EParseException(prim, toString("Invalide argument count in line %u of require_own_item array. Need 1, found %u", i, parts.size()).c_str());
2010                         }
2011                         _ReqOwnItem.push_back(parts[0]);
2012                 }
2013         }
2014         // title
2015         _ReqTitle = getProperty(prim, "require_title", true, false);
2016         // fame
2017         vs = getPropertyArray(prim, "require_faction/fame", true, false);
2018         for (uint i=0; i<vs.size(); ++i)
2019         {
2020                 if (!vs[i].empty())
2021                 {
2022                         vector<string> parts;
2023                         strtokquote(vs[i], parts);
2024                         if (parts.size() != 2)
2025                         {
2026                                 throw EParseException(prim, toString("Invalide argument count in line %u of require_faction/fame array. Need 2, found %u", i, parts.size()).c_str());
2027                         }
2028                         TReqFame rf;
2029                         rf.Faction = parts[0];
2030                         rf.Fame = parts[1];
2031
2032                         _ReqFames.push_back(rf);
2033                 }
2034         }
2035         // guild
2036         if (getProperty(prim, "require_guild_membership", true, false) == "true")
2037                 _ReqGuild = true;
2038         else
2039                 _ReqGuild = false;
2040         // grade
2041         _ReqGrade = getProperty(prim, "require_guild_grade", true, false);
2042         // team size
2043         _ReqTeamSize = getProperty(prim, "require_team_size", true, false);
2044         // character minimum age
2045         _ReqCharacterAge = getProperty(prim, "require_character_age", true, false);
2046         // maximum player ID
2047         _ReqMaxPlayerID = getProperty(prim, "require_max_player_id", true, false);
2048         // brick
2049         vs = getPropertyArray(prim, "require_brick_knowledge", true, false);
2050         for (uint i=0; i<vs.size(); ++i)
2051         {
2052                 if (!vs[i].empty())
2053                 {
2054                         vector<string> parts;
2055                         strtokquote(vs[i], parts);
2056                         if (parts.size() != 1)
2057                         {
2058                                 throw EParseException(prim, toString("Invalide argument count in line %u of require_brick_knowledge array. Need 1, found %u", i, parts.size()).c_str());
2059                         }
2060                         _ReqBrick.push_back(parts[0]);
2061                 }
2062         }
2063         // season
2064         _ReqSeason = getProperty(prim, "require_season", true, false);
2065         // encyclopedia
2066         _ReqEncyclo = getProperty(prim, "require_encyclo_thema", true, false);
2067         _ReqEncycloNeg = getProperty(prim, "require_encyclo_thema_neg", true, false);
2068
2069         if ((!_ReqEncyclo.empty() && !_ReqEncycloNeg.empty())
2070                 || (!_ReqEncycloNeg.empty() && !_ReqEncyclo.empty()))
2071         {
2072                 string err = toString("You can't mix positive and negative encyclopedy requirement");
2073                 throw EParseException(prim, err.c_str());
2074         }
2075         // event faction
2076         _ReqEventFaction = getProperty(prim, "require_event_faction", true, false);
2077 }
2078
2079 std::string CMissionData::replaceVar(NLLIGO::IPrimitive *prim, const std::string &str)
2080 {
2081         string::size_type pos = 0;
2082         string::size_type pos2 = 0;
2083         string ret;
2084
2085         while (pos < str.size())
2086         {
2087                 if (str[pos] != '$')
2088                 {
2089                         ret += str[pos++];
2090                 }
2091                 else if (pos+1 < str.size() && str[pos+1] == '$')
2092                 {
2093                         // check that this $ is not escaped
2094                         ret += '$';
2095                         pos+=2;
2096                 }
2097                 else
2098                 {
2099                         // ok, this is not an escaped $
2100                         CSString varName;
2101                         // skip the initial '$'
2102                         pos++;
2103 //                      while (str[pos] != ' ' && str[pos] != '\t' && str[pos] != '\n' && str[pos] != '\r')
2104                         while (pos < str.size() && str[pos] != '$')
2105                                 varName += str[pos++];
2106
2107                         if (pos >= str.size())
2108                         {
2109                                 string err = toString("Error while parsing variable in '%s', missing closing '$'", str.c_str());
2110                                 throw EParseException (NULL, err.c_str());
2111                         }
2112
2113                         // skip the final '$'
2114                         pos++;
2115
2116                         // split the var name and subpart
2117                         vector<string> varParts;
2118                         explode(string(varName), string("@"), varParts, true);
2119
2120                         if (varParts.empty() || varParts.size() > 2)
2121                         {
2122                                 throw EParseException(prim, toString("Error parsing varName '%s' in string '%s'", varName.c_str(), str.c_str()).c_str());
2123                         }
2124
2125                         if (_Variables.find(varParts.front()) == _Variables.end())
2126                         {
2127                                 string err = toString("Unknown variable '%s' in string '%s'", varParts.front().c_str(), str.c_str());
2128                                 throw EParseException (prim, err.c_str());
2129                         }
2130
2131                         IVar *var = _Variables[varParts[0]];
2132
2133                         if (varParts.size() == 1)
2134                                 ret += var->evalVar("");
2135                         else
2136                                 ret += var->evalVar(varParts[1]);
2137
2138                 }
2139         }
2140
2141         return ret;
2142 }
2143
2144 std::vector<std::string> CMissionData::replaceVar(NLLIGO::IPrimitive *prim, const std::vector<std::string> &strs)
2145 {
2146         vector<string> ret;
2147
2148         for (uint i=0; i<strs.size(); ++i)
2149         {
2150                 ret.push_back(replaceVar(prim, strs[i]));
2151         }
2152
2153         return ret;
2154 }
2155
2156 std::string CMissionData::getProperty(NLLIGO::IPrimitive *prim, const std::string &propertyName, bool replaceVar, bool canFail)
2157 {
2158         string ret;
2159         string *s;
2160         if (!prim->getPropertyByName(propertyName.c_str(), s))
2161         {
2162                 if (!canFail)
2163                 {
2164                         string err = toString("Can't find property '%s'", propertyName.c_str());
2165                         throw EParseException (prim, err.c_str());
2166                 }
2167         }
2168         else
2169         {
2170                 ret = *s;
2171         }
2172
2173         if (replaceVar)
2174         {
2175                 ret = this->replaceVar(prim, ret);
2176         }
2177
2178         return ret;
2179 }
2180
2181 std::vector<std::string> CMissionData::getPropertyArray(NLLIGO::IPrimitive *prim, const std::string &propertyName, bool replaceVar, bool canFail)
2182 {
2183         vector<string> ret;
2184         vector<string> *vs;
2185         if (!prim->getPropertyByName(propertyName.c_str(), vs))
2186         {
2187                 if (!canFail)
2188                 {
2189                         string err = toString("Can't find property '%s'", propertyName.c_str());
2190                         throw EParseException (prim, err.c_str());
2191                 }
2192         }
2193         else
2194         {
2195                 ret = *vs;
2196         }
2197
2198         if (replaceVar)
2199         {
2200                 ret = this->replaceVar(prim, ret);
2201         }
2202         return ret;
2203 }
2204
2205 bool CMissionData::isThereAJumpTo(const std::string &stepName)
2206 {
2207         if (_JumpPoints.find(stepName) != _JumpPoints.end())
2208                 return true;
2209         else
2210                 return false;
2211 }
2212
2213 void TCompilerVarName::init(const std::string &defaultName, STRING_MANAGER::TParamType type, CMissionData &md, NLLIGO::IPrimitive *prim, const std::string propName)
2214 {
2215         _DefaultName = defaultName;
2216         _ParamType = type;
2217
2218         _VarName = md.getProperty(prim, propName, false, false);
2219         // remove the variable tag if any
2220         untagVar(_VarName);
2221
2222         _VarValue = md.getProperty(prim, propName, true, false);
2223 }
2224
2225 void TCompilerVarName::initWithText(const std::string &defaultName, STRING_MANAGER::TParamType type, CMissionData &md, NLLIGO::IPrimitive *prim, const std::string &text)
2226 {
2227         _DefaultName = defaultName;
2228         _ParamType = type;
2229
2230         _VarName = text;
2231         // remove the variable tag if any
2232         untagVar(_VarName);
2233
2234         _VarValue = md.replaceVar(prim, text);
2235 }
2236
2237
2238 CPhrase::TParamInfo TCompilerVarName::getParamInfo() const
2239 {
2240         if (_VarName.empty())
2241                 return CPhrase::TParamInfo(_DefaultName, _ParamType);
2242         else
2243                 return CPhrase::TParamInfo(_VarName, _ParamType);
2244 }
2245
2246
2247 bool TCompilerVarName::empty() const
2248 {
2249         return _VarValue.empty();
2250 }
2251
2252 TCompilerVarName::operator const std::string  () const
2253 {
2254         return _VarValue;
2255 }
2256
2257 TCompilerVarName::operator CPhrase::TParamInfo() const
2258 {
2259         return getParamInfo();
2260 }
2261
2262
2263 std::string operator+(const TCompilerVarName& left, const std::string & right) { return left._VarValue + right;}
2264
2265 std::string operator+(const std::string & left, const TCompilerVarName& right) { return left + right._VarValue;}
2266
2267 std::vector<TCompilerVarName> TCompilerVarName::getPropertyArrayWithText(const std::string &defaultName, STRING_MANAGER::TParamType type, CMissionData &md, NLLIGO::IPrimitive *prim, const std::string & arrayProperyName)
2268 {
2269         std::vector<TCompilerVarName> compilerParams;
2270
2271         std::vector<std::string> values = md.getPropertyArray(prim, arrayProperyName,false, false);
2272         uint first = 0;
2273         uint last = (uint)values.size();
2274         compilerParams.resize(last);
2275         for ( ; first != last; ++first)
2276         {
2277                 compilerParams[first].initWithText( toString("%s%d", defaultName.c_str(), first+1) , type, md, prim,  values[first]);
2278         }
2279
2280         return compilerParams;
2281 }
2282
2283 std::vector<TCompilerVarName> TCompilerVarName::getPropertyArrayWithTextStaticDefaultName(const std::string &defaultName, STRING_MANAGER::TParamType type, CMissionData &md, NLLIGO::IPrimitive *prim, const std::string & arrayProperyName)
2284 {
2285         std::vector<TCompilerVarName> compilerParams;
2286         std::vector<std::string> values = md.getPropertyArray(prim, arrayProperyName,false, false);
2287         uint first = 0;
2288         uint last = (uint)values.size();
2289         compilerParams.resize(last);
2290         for ( ; first != last; ++first)
2291         {
2292                 compilerParams[first].initWithText( defaultName, type, md, prim,  values[first]);
2293         }
2294         return compilerParams;
2295 }
2296