aleajactaest/khanat-opennel-code
1
0
Fork 0
mirror of https://port.numenaute.org/aleajactaest/khanat-opennel-code.git synced 2024-11-23 07:36:16 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
khanat-opennel-code/code/ryzom/tools/leveldesign/mission_compiler_lib/mission_compiler.cpp
kervala a3262bb971 Fixed: Warnings 
--HG--
branch : develop
2016-11-22 12:22:17 +01:00

2292 lines
59 KiB
C++
Raw Blame History

// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2010 Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "mission_compiler.h"
#include "step.h"
#include "nel/misc/i18n.h"
#include "nel/misc/common.h"
#include "nel/ligo/primitive_utils.h"
using namespace std;
using namespace NLMISC;
using namespace NLLIGO;
// hack to get access to string manager item enumeration to string without including
// almost all of the Ryzom server side project
namespace STRING_MANAGER
{
NL_BEGIN_STRING_CONVERSION_TABLE (TParamType)
NL_STRING_CONVERSION_TABLE_ENTRY( item )
NL_STRING_CONVERSION_TABLE_ENTRY( place )
NL_STRING_CONVERSION_TABLE_ENTRY( creature )
NL_STRING_CONVERSION_TABLE_ENTRY( skill )
NL_STRING_CONVERSION_TABLE_ENTRY( role )
NL_STRING_CONVERSION_TABLE_ENTRY( ecosystem )
NL_STRING_CONVERSION_TABLE_ENTRY( race )
NL_STRING_CONVERSION_TABLE_ENTRY( sbrick )
NL_STRING_CONVERSION_TABLE_ENTRY( faction )
NL_STRING_CONVERSION_TABLE_ENTRY( guild )
NL_STRING_CONVERSION_TABLE_ENTRY( player )
NL_STRING_CONVERSION_TABLE_ENTRY( bot )
{ "int", integer},
// NL_STRING_CONVERSION_TABLE_ENTRY( integer )
NL_STRING_CONVERSION_TABLE_ENTRY( time )
NL_STRING_CONVERSION_TABLE_ENTRY( money )
NL_STRING_CONVERSION_TABLE_ENTRY( compass )
NL_STRING_CONVERSION_TABLE_ENTRY( string_id )
NL_STRING_CONVERSION_TABLE_ENTRY( dyn_string_id )
NL_STRING_CONVERSION_TABLE_ENTRY( self )
NL_STRING_CONVERSION_TABLE_ENTRY( creature_model )
NL_STRING_CONVERSION_TABLE_ENTRY( entity )
NL_STRING_CONVERSION_TABLE_ENTRY( body_part )
NL_STRING_CONVERSION_TABLE_ENTRY( score )
NL_STRING_CONVERSION_TABLE_ENTRY( sphrase )
NL_STRING_CONVERSION_TABLE_ENTRY( characteristic )
NL_STRING_CONVERSION_TABLE_ENTRY( damage_type )
NL_STRING_CONVERSION_TABLE_ENTRY( bot_name)
NL_STRING_CONVERSION_TABLE_ENTRY( power_type )
NL_STRING_CONVERSION_TABLE_ENTRY( literal )
NL_END_STRING_CONVERSION_TABLE(TParamType, ParamTypeConversion, NB_PARAM_TYPES)
//-----------------------------------------------
// stringToParamType
//-----------------------------------------------
TParamType stringToParamType( const std::string & str )
{
return ParamTypeConversion.fromString( str );
}
//-----------------------------------------------
// stringToParamType
//-----------------------------------------------
const std::string & paramTypeToString( TParamType type )
{
return ParamTypeConversion.toString( type );
}
}
// utility to 'tabulate' the lines in a string
void tabulateLine(std::string &text, uint nbTabs)
{
if (text.empty())
return;
string::size_type pos = 0;
string tabs;
for (uint i=0; i<nbTabs; ++i)
tabs += "\t";
// add a tab at start
text = tabs + text;
// add a tab at each new line
while ((pos = text.find('\n', pos)) != string::npos)
{
if (pos < text.size()-1 && text[pos+1] == '\r')
{
// add after the '\r' char
++pos;
}
if (pos < text.size()-1)
text = text.substr(0, pos+1) + tabs + text.substr(pos+1);
}
}
class GenderExtractor
{
public:
GenderExtractor(const std::string & literal, const std::string& identifier, unsigned int level=0);
std::string operator()(unsigned int i) const;
unsigned int size() const;
~GenderExtractor();
private:
bool extractMarkup(const std::string& literal, const std::string & markup, std::string &before, std::string &inside, std::string & after);
bool parseMarkup(const std::string& literal, const std::string & markup, std::string& newPhrase, bool include = false );
std::string getPhrase(unsigned int i) const;
std::string getExtension(unsigned int i) const;
std::string getCondition(unsigned int i) const;
std::string getEntity(unsigned int i) const;
std::string getIdentifier(unsigned int i) const;
private:
bool _Entity;
std::string _EntityName;
std::string _Text;
std::string _Identifier;
GenderExtractor* _Female;
GenderExtractor* _Male;
};
GenderExtractor::~GenderExtractor()
{
delete _Female;
delete _Male;
}
std::string GenderExtractor::getIdentifier(unsigned int i) const
{
return _Identifier + getExtension(i);
}
std::string GenderExtractor::operator()(unsigned int i) const
{
std::string ret("\t");
std::string condition = getCondition(i);
ret += condition.empty() ? "":std::string("( ") + condition + " )" + NL + "\t\t";
ret += getIdentifier(i) + "\t[" + getPhrase(i) + "]" + NL;
return ret;
}
GenderExtractor::GenderExtractor(const std::string & literal, const std::string& identifier, unsigned int level)
{
static const char * es[] ={"e", "e1", "e2", "e3"};
static const char * fs[] ={"f", "f1", "f2", "f3"};
static const char * hs[] ={"h", "h1", "h2", "h3"};
const char * e = es[level];
const char * f = fs[level];
const char * h = hs[level];
_Identifier = toLower(identifier);
std::string newPhrase;
std::string before;
std::string after;
std::string femaleText;
std::string maleText;
_Entity = extractMarkup(literal, e, before, _EntityName, after);
if (_EntityName.size() > 2)
{
if (_EntityName[0] == '$' && _EntityName[_EntityName.size() - 1] == '$')
{
_EntityName = _EntityName.substr(1, _EntityName.size() - 2);
}
}
std::string newLiteral = before + after;
bool isFemale = parseMarkup(newLiteral,f,newPhrase, true);
if ( isFemale)
{
parseMarkup(newPhrase,h,newPhrase, false);
femaleText = newPhrase;
}
bool isMale = parseMarkup(newLiteral, h, newPhrase, true);
if (isMale)
{
parseMarkup(newPhrase, f, newPhrase, false);
maleText = newPhrase;
}
if (isMale != isFemale)
{
std::string goodMarkup = isMale ? std::string("") +"<" + h + "></" + h + ">" : std::string("")+"<"+f+"></"+f+">";
std::string badMarkup = isFemale ? std::string("") +"<" + h + "></" + h + ">" : std::string("")+"<"+f+"></"+f+">";
std::string exceptionText = std::string("Expression ") + identifier + " that contains a tag " + goodMarkup + " needs also tags " + badMarkup + " even empty.";
throw EParseException(0, exceptionText.c_str());
}
if (!isMale && !isFemale)
{
_Text = literal;
_Female = 0;
_Male = 0;
}
else
{
if (!_Entity) { _EntityName = "self"; }
_Female = new GenderExtractor(femaleText, identifier, level+1);
_Male = new GenderExtractor(maleText, identifier, level+1);
}
}
bool GenderExtractor::extractMarkup(const std::string& literal, const std::string & markup, std::string &before, std::string &inside, std::string & after)
{
std::string::size_type posBegin;
std::string::size_type posEnd;
std::string::size_type posInside;
std::string beginMarkup = std::string("<") + markup + std::string(">");
std::string endMarkup = std::string("</") + markup + std::string(">");
posBegin = literal.find(beginMarkup);
if ( posBegin != std::string::npos )
{
posEnd = literal.find(endMarkup, posBegin + beginMarkup.size());
if (posEnd != std::string::npos)
{
before = literal.substr(0, posBegin);
posInside = posBegin + beginMarkup.size();
inside = literal.substr(posInside, posEnd - posInside);
after = literal.substr(posEnd+endMarkup.size());
return true;
}
}
after = literal;
return false;
}
bool GenderExtractor::parseMarkup(const std::string& literal, const std::string & markup, std::string& newPhrase, bool include )
{
bool markupExist;
bool changed = false;
std::string oldPhrase = literal;
newPhrase.clear();
do
{
std::string before;
std::string inside;
std::string after;
markupExist = extractMarkup(oldPhrase, markup, before, inside, after);
newPhrase += before;
if (include){ newPhrase += inside; }
oldPhrase = after;
if (markupExist){ changed = true; }
} while(markupExist);
newPhrase += oldPhrase;
return changed;
}
std::string GenderExtractor::getPhrase(unsigned int i) const
{
if ( i%2 == 0) { return _Male ? _Male->getPhrase(i/2) : _Text; }
if ( i%2 == 1) { nlassert(_Female); return _Female->getPhrase(i/2);}
nlassert(0);
return "";
}
std::string GenderExtractor::getExtension(unsigned int i) const
{
if ( i%2 == 0) { return _Male ? std::string("_m") + _Male->getExtension(i/2) : ""; }
if ( i%2 == 1) { nlassert(_Female); return std::string("_f") + _Female->getExtension(i/2);}
nlassert(0);
return "";
}
std::string GenderExtractor::getCondition(unsigned int i) const
{
//if ( i%2 == 0) { return _Male ? std::string("\t(") + _Male->getExtension(i/2) : "\t"; }
//if ( i%2 == 1) { nlassert(_Female); return std::string("_f") + _Female->getExtension(i/2);}
if ( i%2 == 0)
{
if (_Male)
{
std::string next = _Male->getCondition(i/2);
std::string current = _EntityName + ".gender = male";
return next.size() ? current + " & " + next : current;
}
else
{
return "";
}
}
if ( i%2 == 1)
{
std::string next = _Female->getCondition(i/2);
std::string current = _EntityName + ".gender = female";
return next.size() ? current + " & " + next : current;
}
nlassert(0);
return "";
}
unsigned int GenderExtractor::size() const
{
return _Male ? _Male->size() + _Female->size(): 1;
}
string CPhrase::genPhrase()
{
string ret;
if (!_PhraseLiterals.empty())
{
for (uint p=0; p<_PhraseLiterals.size(); ++p)
{
string identifier = _PhraseId;
if (_NumEntry != 0)
identifier += toString("_%u", p+1);
GenderExtractor gender(_PhraseLiterals[p], identifier, 0);
ret += identifier + " (";
// generate default param list
if (_DefaultParams.size() > p)
{
for (uint i=0; i<_DefaultParams[p].size(); ++i)
{
ret += STRING_MANAGER::paramTypeToString(_DefaultParams[p][i].ParamType) + " "+_DefaultParams[p][i].ParamName;
if (i != _DefaultParams[p].size()-1 || !_AdditionalParams.empty())
ret += ", ";
}
}
// generate additional param list
for (uint i=0; i<_AdditionalParams.size(); ++i)
{
ret += STRING_MANAGER::paramTypeToString(_AdditionalParams[i].ParamType) + " "+_AdditionalParams[i].ParamName;
if (i != _AdditionalParams.size()-1)
ret += ", ";
}
ret += ")" + NL;
ret += "{" + NL;
for (unsigned int i = 0; i < gender.size(); ++i)
{
ret += gender(i);
}
ret += "}" + NL + NL;
}
}
nlinfo("genphrase: %s", ret.c_str());
return ret;
}
bool CMissionCompiler::generateDotScript(NLLIGO::IPrimitive *missionPrim, std::string &dotScript, std::string &log)
{
//assume that the mission is compiled in the last compiled mission slot
try
{
if (compileMission(missionPrim, string()))
{
dotScript = _CompiledMission.back()->generateDotScript();
return true;
}
else
{
return false;
}
}
catch(const EParseException & e)
{
log = e.Why;
return false;
}
}
/*
bool CMissionCompiler::parseGlobalMissionData(IPrimitive *mission, CMissionData &md)
{
// Mission name
string *s;
if (!mission->getPropertyByName("name", s) || s->empty())
throw EParseException(mission, "missing mission name !");
md.setMissionName(*s);
// giver primitive file
if (!mission->getPropertyByName("giver_primitive", s) || s->empty())
throw EParseException(mission, "missing giver primitive !");
md.setGiverPrimitive(*s);
// giver name
if (!mission->getPropertyByName("giver_primitive", s) || s->empty())
throw EParseException(mission, "missing giver primitive !");
md.setGiverName(*s);
// If the mission is under a npc_bot node, then the giver is directly taken
// from the npc name
if (mission->getParent())
{
if (mission->getParent()->getPropertyByName("class", s) && *s == "npc_bot")
{
if (mission->getParent()->getPropertyByName("name", s))
md.setGiverName(*s);
}
}
// TODO : read all other params...
return true;
}
*/
void CMissionData::initHeaderPhrase(IPrimitive *prim)
{
CPhrase::TPredefParams params;
params.resize(1);
params[0].push_back(CPhrase::TParamInfo("giver", STRING_MANAGER::bot));
_MissionTitle.initPhrase(*this, prim, _MissionTitleRaw, 0, params);
_MissionDescription.initPhrase(*this, prim, _MissionDescriptionRaw, 0, params);
_MissionAutoMenu.initPhrase(*this, prim, _MissionAutoMenuRaw);
}
bool CMissionCompiler::compileMission(NLLIGO::IPrimitive *rootPrim, const std::string &primFileName)
{
TPrimitiveClassPredicate pred("mission_tree");
if (!pred(rootPrim))
return false;
IPrimitive *mission = rootPrim;
CMissionData *pmd = new CMissionData;
CMissionData &md = *pmd;
// Read the mission name
string missionName = md.getProperty(mission, "name", false, false);
if( missionName.find(' ') != string::npos)
{
throw EParseException(mission, toString("Mission name '%s' must not contains space", missionName.c_str()).c_str());
}
md.setMissionName(missionName);
// Create a temporary primitive node to create default variable
{
// giver default var
IPrimitive *temp = new CPrimNode();
temp->addPropertyByName("class", new CPropertyString("var_npc"));
temp->addPropertyByName("name", new CPropertyString("giver = giver"));
temp->addPropertyByName("npc_name", new CPropertyString("giver"));
temp->addPropertyByName("var_name", new CPropertyString("giver"));
IVar *var = IVar::createVar(md, temp);
md.addVariable(NULL, var);
delete temp;
}
{
// player default var
IPrimitive *temp = new CPrimNode();
temp->addPropertyByName("class", new CPropertyString("var_npc"));
temp->addPropertyByName("name", new CPropertyString("player = player"));
temp->addPropertyByName("npc_name", new CPropertyString("player"));
temp->addPropertyByName("var_name", new CPropertyString("player"));
IVar *var = IVar::createVar(md, temp);
md.addVariable(NULL, var);
delete temp;
}
{
// guild_name default var
IPrimitive *temp = new CPrimNode();
temp->addPropertyByName("class", new CPropertyString("var_text"));
temp->addPropertyByName("name", new CPropertyString("guild_name = guild_name"));
temp->addPropertyByName("npc_name", new CPropertyString("guild_name"));
temp->addPropertyByName("var_name", new CPropertyString("guild_name"));
IVar *var = IVar::createVar(md, temp);
md.addVariable(NULL, var);
delete temp;
}
// first, start by reading mission variables
IPrimitive *variables;
{
TPrimitiveClassPredicate predTmp("variables");
variables= NLLIGO::getPrimitiveChild(mission, predTmp);
}
if (!variables)
{
nlwarning("Can't find variables !");
return false;
}
parseVariables(md, variables);
// read global mission data
md.parseMissionHeader(rootPrim);
// now, we can init the mission header phrase (they need variable knwoled)
md.initHeaderPhrase(rootPrim);
IPrimitive *preReq;
{
TPrimitiveClassPredicate predTmp("pre_requisite");
preReq = getPrimitiveChild(mission, predTmp);
}
if (!preReq)
{
nlwarning("Can't find pre requisite !");
return false;
}
parsePreRequisite(md, preReq);
/* IPrimitive *steps = getPrimitiveChild(mission, TPrimitivePropertyPredicate("step_tag", "true"));
if (!steps)
{
nlwarning("Can't find steps !");
return false;
}
*/ parseSteps(md, mission);
// Store the compiled mission
_CompiledMission.push_back(pmd);
string script = md.generateMissionScript(primFileName);
nlinfo("The script :");
nlinfo("%s", script.c_str());
string phrases = md.generatePhraseFile();
nlinfo("The phrase file is :");
{
vector<string> lines;
explode(phrases, string("\n"), lines, false);
for (uint i=0; i<lines.size(); ++i)
{
if(lines[i][0] == '\r') lines[i] = lines[i].substr(1);
nlinfo("%s", lines[i].c_str());
}
}
string dot = md.generateDotScript();
nlinfo("The dot script is :");
{
vector<string> lines;
explode(dot, string("\n"), lines, false);
for (uint i=0; i<lines.size(); ++i)
{
if(lines[i][0] == '\r') lines[i] = lines[i].substr(1);
nlinfo("%s", lines[i].c_str());
}
}
return true;
}
bool CMissionCompiler::compileMissions(IPrimitive *rootPrim, const std::string &primFileName)
{
bool ret = true;
// 1st, build a set of mission_scrip nodes
NLLIGO::TPrimitiveSet missionTrees;
CPrimitiveSet<TPrimitiveClassPredicate> scriptsSet;
TPrimitiveClassPredicate pred("mission_tree");
scriptsSet.buildSet(rootPrim, pred, missionTrees);
nlinfo("Found %u mission tree in the primitive file", missionTrees.size());
for (uint i=0; i<missionTrees.size(); ++i)
{
// try
// {
compileMission(missionTrees[i], primFileName);
// }
// catch (const EParseException &e)
// {
// nlwarning("Error while parsing a mission: '%s'", e.Why.c_str());
// ret = false;
// }
}
return ret;
}
bool CMissionCompiler::installCompiledMission(NLLIGO::CLigoConfig &ligoConfig, const std::string &primFileName)
{
// generate the mission script into the npcs...
{
map<string, TLoadedPrimitive > loadedPrimitives;
// store the previous alias value
map<string, uint32> missionAlias;
// First loop to remove any mission that belong to the compiled primitive file
for (uint i=0; i<_CompiledMission.size(); ++i)
{
CMissionData &mission = *(_CompiledMission[i]);
// first, look for the primitive file to load
string fileName = mission.getGiverPrimitive();
if (fileName.empty())
{
// use mission primitive instead
fileName = primFileName;
}
if (loadedPrimitives.find(toLower(fileName)) == loadedPrimitives.end())
{
string fullFileName = CPath::lookup(fileName, false);
if (fullFileName.empty())
{
throw EParseException(NULL, toString("Can't find primitive file '%s' in path", fileName.c_str()).c_str());
}
// we need to load this primitive file.
CPrimitives *primDoc = new CPrimitives;
CPrimitiveContext::instance().CurrentPrimitive = primDoc;
if (loadXmlPrimitiveFile(*primDoc, fullFileName, ligoConfig))
{
// the primitive file is loaded correctly
loadedPrimitives.insert(make_pair(toLower(fileName), TLoadedPrimitive(primDoc, fullFileName)));
CPrimitiveContext::instance().CurrentPrimitive = NULL;
}
else
{
CPrimitiveContext::instance().CurrentPrimitive = NULL;
throw EParseException(NULL, toString("Can't read primitive file '%s'", fullFileName.c_str()).c_str());
}
}
TLoadedPrimitive &loadedPrim = loadedPrimitives[toLower(fileName)];
CPrimitives *primDoc = loadedPrim.PrimDoc;
TPrimitiveSet scripts;
CPrimitiveSet<TPrimitiveClassPredicate> filter;
TPrimitiveClassPredicate pred("mission");
filter.buildSet(primDoc->RootNode, pred, scripts);
// for each script, check if it was generated, and if so, check the name
// of the source primitive file.
for (uint i=0; i<scripts.size(); ++i)
{
vector<string> *script;
if (scripts[i]->getPropertyByName("script", script) && !script->empty())
{
string missionName;
scripts[i]->getPropertyByName("name", missionName);
// Format should be : #compiled from <source_primitive_name>
if (script->front().find("generated from") != string::npos)
{
// we have a compiled mission
if (script->front().find(CFile::getFilename(primFileName)) != string::npos)
{
// ok, this mission is compiled from the same primitive
// store it's alias
TPrimitiveClassPredicate pred("alias");
IPrimitive *p = getPrimitiveChild(scripts[i], pred);
if (p)
{
CPrimAlias *pa = dynamic_cast<CPrimAlias*>(p);
if (pa)
{
uint32 alias = pa->getAlias();
missionAlias.insert(make_pair(missionName, alias));
}
}
else
{
nlwarning("Can't find alias prim in primitive '%s'", buildPrimPath(scripts[i]).c_str());
}
// and remove it
scripts[i]->getParent()->removeChild(scripts[i]);
}
}
}
}
}
// second loop to assign compiled mission to giver npc
for (uint i=0; i<_CompiledMission.size(); ++i)
{
CMissionData &mission = *(_CompiledMission[i]);
string fileName = mission.getGiverPrimitive();
if (fileName.empty())
{
// no giver primitive file specified in the mission, use the mission primitive instead
fileName = primFileName;
}
TLoadedPrimitive &loadedPrim = loadedPrimitives[toLower(fileName)];
CPrimitives *primDoc = loadedPrim.PrimDoc;
CPrimitiveContext::instance().CurrentPrimitive = primDoc;
TPrimitiveSet bots;
CPrimitiveSet<TPrimitiveClassAndNamePredicate> filter;
TPrimitiveClassAndNamePredicate pred("npc_bot", mission.getGiverName());
filter.buildSet(primDoc->RootNode, pred, bots);
if (bots.empty())
{
string err = toString("Can't find bot '%s' in primitive '%s' !",
mission.getGiverName().c_str(),
fileName.c_str());
throw EParseException(NULL, err.c_str());
}
else if (bots.size() > 1)
{
string err = toString("Found more than one bot named '%s' in primitive '%s' !",
mission.getGiverName().c_str(),
fileName.c_str());
throw EParseException(NULL, err.c_str());
}
// ok, all is good, we can add the mission node to the giver
IPrimitive *giver = bots.front();
// create a new node for the mission
IPrimitive *script = new CPrimNode;
// set the class
script->addPropertyByName("class", new CPropertyString("mission"));
// set the name
script->addPropertyByName("name", new CPropertyString(mission.getMissionName()));
// string alias(toString("%u", makeHash32(mission.getMissionName())));
// script->addPropertyByName("alias", new CPropertyString(mission.getAlias()));
string scriptLines = mission.generateMissionScript(primFileName);
vector<string> lines;
explode(scriptLines, NL, lines, false);
script->addPropertyByName("script", new CPropertyStringArray(lines));
// insert the script into the giver
giver->insertChild(script);
// add the alias
{
CPrimAlias *pa = new CPrimAlias;
pa->addPropertyByName("class", new CPropertyString ("alias"));
pa->addPropertyByName("name", new CPropertyString ("alias"));
if (missionAlias.find(mission.getMissionName()) != missionAlias.end())
{
// restore the previous alias
primDoc->forceAlias(pa, missionAlias.find(mission.getMissionName())->second);
}
// insert in first place
script->insertChild(pa, 0);
}
CPrimitiveContext::instance().CurrentPrimitive = NULL;
}
// Save the modified primitive files
while (!loadedPrimitives.empty())
{
TLoadedPrimitive &loadedPrim = loadedPrimitives.begin()->second;
if (!saveXmlPrimitiveFile(*(loadedPrim.PrimDoc), loadedPrim.FullFileName))
return false;
_FilesToPublish.push_back(loadedPrim.FullFileName);
// Free the memory
delete loadedPrim.PrimDoc;
loadedPrimitives.erase(loadedPrimitives.begin());
}
}
// generate the phrase file (if any)
{
string phraseFileName = CFile::getFilenameWithoutExtension(primFileName) + "_wk.txt";
CSString content;
for (uint i=0; i<_CompiledMission.size(); ++i)
{
content += _CompiledMission[i]->generatePhraseFile();
}
// transform NL (\n\r) into single \n
content = content.replace(NL.c_str(), "\n");
ucstring ucs;
ucs.fromUtf8(content);
CI18N::writeTextFile(phraseFileName, ucs, true);
_FilesToPublish.push_back(phraseFileName);
}
return true;
}
bool CMissionCompiler::publishFiles(const std::string &serverPathPrim, const std::string &serverPathText, const std::string &localPathText)
{
for (uint i=0 ; i<_FilesToPublish.size() ; i++)
{
string dst, src = _FilesToPublish[i];
string::size_type n = src.find("primitives");
if (n == string::npos)
{
// text files : copy it and check include in phrase_rites_wk.txt
// server
string textFile = CPath::standardizePath(serverPathText) + "phrase_rites_wk.txt";
includeText(textFile, string("#include \"") + src + string("\"\n"));
dst = CPath::standardizePath(serverPathText) + src;
NLMISC::CFile::copyFile(dst, src);
// local
textFile = CPath::standardizePath(localPathText) + "phrase_rites_wk.txt";
includeText(textFile, string("#include \"") + src + string("\"\n"));
dst = CPath::standardizePath(localPathText) + src;
NLMISC::CFile::copyFile(dst, src);
}
else
{
// primitive file : copy to server
dst = CPath::standardizePath(serverPathPrim) + string(src, n, src.size());
NLMISC::CFile::copyFile(dst, src);
}
}
return true;
}
bool CMissionCompiler::includeText(const std::string &filename, const std::string &text)
{
FILE *f = nlfopen(filename, "r+");
if (f == NULL)
{
nlwarning("Unable to open %s", filename.c_str());
return false;
}
bool isIn = false;
char buffer[1024];
// Check for UTF8 format
if (fread(buffer, 1, 3, f) != 3)
{
fclose(f);
nlwarning("Unable to read 3 bytes from %s", filename.c_str());
return false;
}
if (buffer[0] != -17 || buffer[1] != -69 || buffer[2] != -65)
fseek(f, 0, SEEK_SET);
// Compare each line
while(fgets(buffer, 1024, f))
{
if (!strcmp(text.c_str(), buffer))
{
isIn = true;
break;
}
}
if (!isIn)
fputs(text.c_str(), f);
fclose(f);
return true;
}
bool CMissionCompiler::parsePreRequisite(CMissionData &md, IPrimitive *preReq)
{
md.parsePrerequisites(preReq);
return true;
}
bool CMissionCompiler::parseOneStep(CMissionData &md, IPrimitive *stepToParse, IStep *parent, bool bEndOfBranch)
{
IStep *step = IStep::createStep(md, stepToParse);
if (step != NULL)
{
if (!step->isAJump() && !step->getStepName().empty())
{
if (md.getStepByName(step->getStepName()) != NULL)
{
string err = toString("Step '%s' already defined !", step->getStepName().c_str());
throw EParseException(step->getPrimitive(), err.c_str());
}
if (step->getStepName().find(' ') != string::npos)
{
throw EParseException(step->getPrimitive(), toString("Step name '%s' must not contains space", step->getStepName().c_str()).c_str());
}
md.addStepName(step->getStepName(), step);
}
TPrimitiveSet subBranchs = step->getSubBranchs();
// Add the step (if no parent add to the mission data)
if (parent == NULL)
{
if (!md.addStep(step))
{
throw EParseException(stepToParse, "Error parsing mission step");
}
}
else
{
parent->addSubStep(step);
}
CStepIf *pSI = dynamic_cast<CStepIf *>(step);
// If this is a IF step : parse with 'step' as a parent
IStep *pParentStep = NULL;
if ((dynamic_cast<CStepIf*>(step) != NULL) ||
(dynamic_cast<CStepPlayerReconnect*>(step) != NULL))
pParentStep = step;
if (!subBranchs.empty())
{
// need to parse subbranch before continuing
for (uint i=0; i<subBranchs.size(); ++i)
{
if (!parseOneStep(md, subBranchs[i], pParentStep, i==(subBranchs.size()-1)))
return false;
}
}
// if this is the last step, flag it as such
step->EndOfBranch = bEndOfBranch;
}
return true;
}
bool CMissionCompiler::parseSteps(CMissionData &md, IPrimitive *steps, IStep *parent)
{
TPrimitiveSet childs;
TPrimitivePropertyPredicate pred("step_tag", "true");
filterPrimitiveChilds(steps, pred, childs);
if (childs.empty())
{
CPrimNode node;
node.addPropertyByName("class", new CPropertyString("end"));
node.addPropertyByName("name", new CPropertyString(""));
IStep *step = IStep::createStep(md, &node);
delete step;
// md.addStep(step);
}
if (!childs.empty())
{
for (uint i=0; i<childs.size(); ++i)
{
IPrimitive *child = childs[i];
parseOneStep(md, childs[i], NULL, i == (childs.size()-1));
}
}
return true;
}
string CMissionCompiler::getProp(IPrimitive *prim, const string &propName)
{
string s;
bool ret = prim->getPropertyByName(propName.c_str(), s);
if (!ret)
throw EParseException(prim, toString("Property %s does't exist", propName.c_str()).c_str());
return s;
}
string CMissionCompiler::getClass(IPrimitive *prim)
{
string className;
bool ret = prim->getPropertyByName("class", className);
nlassert(ret);
return className;
}
bool CMissionCompiler::parseVariables(CMissionData &md, IPrimitive *variables)
{
for (uint i=0; i<variables->getNumChildren(); ++i)
{
IPrimitive *child;
if (variables->getChild(child, i))
{
IVar *var = IVar::createVar(md, child);
if (var)
{
nldebug("Adding variable '%s' as type %u", var->getVarName().c_str(), var->getVarType());
md.addVariable(child, var);
}
}
}
return true;
}
template <class VectorType>
bool strtokquote(const string &src, VectorType &tokens)
{
enum TMode
{
read_blank,
read_token,
read_quoted
};
string temp;
TMode mode = read_blank;
for (uint i=0; i<src.size(); ++i)
{
switch (mode)
{
case read_blank:
if (src[i] != ' ' && src[i] != '\t' && src[i] != '\n' && src[i] != '\r')
{
// end of blank !
if (src[i] == '\"')
{
// begin of a quoted string
temp = "\"";
mode = read_quoted;
}
else
{
// begin of a token
temp.clear();
temp += src[i];
mode = read_token;
}
}
break;
case read_token:
if (src[i] == ' ' || src[i] == '\t' || src[i] == '\n' || src[i] == '\r' || src[i] == '\"')
{
// end of token
tokens.push_back(temp);
temp.clear();
--i;
mode = read_blank;
}
else
{
temp += src[i];
}
break;
case read_quoted:
if (src[i] == '\\')
{
// special treatment for escape command
if (i < src.size()-1)
{
temp += src[i];
temp += src[i+1];
// skip escaped char
i++;
}
else
{
nlwarning("Error parsing escape char in quoted string");
return false;
}
}
else if (src[i] != '\"')
{
// just add this char
temp += src[i];
}
else
{
// end of quoted string
temp += src[i];
tokens.push_back(temp);
temp.clear();
mode = read_blank;
}
break;
}
}
if (!temp.empty())
{
if (mode == read_quoted)
{
nlwarning("Missing closing quote at end of string while reading text in '%s'", src.c_str());
return false;
}
tokens.push_back(temp);
}
return true;
}
template <class VectorType>
bool strtokquote(const vector<string> &src, VectorType &tokens)
{
for (uint i=0; i<src.size(); ++i)
{
if (!strtokquote(src[i], tokens))
return false;
}
return true;
}
struct TFindParamPred : std::unary_function<CPhrase::TParamInfo, bool>
{
string Name;
TFindParamPred(const std::string &name)
: Name (name)
{}
bool operator() (const CPhrase::TParamInfo &paramInfo) const
{
return paramInfo.ParamName == Name;
}
};
bool CPhrase::isEmpty()
{
return _PhraseId.empty();
}
bool CPhrase::asAdditionnalParams()
{
return !_AdditionalParams.empty();
}
void CPhrase::initPhrase (CMissionData &md,
IPrimitive *prim,
const vector<string> &texts,
uint32 numEntry,
const TPredefParams &predefParams )
{
// nlassert(numEntry == predefParams.size());
// store the predefined/default parameters
_DefaultParams = predefParams;
// store the number of entry to generate (for literal with variant)
_NumEntry = numEntry;
numEntry = max(uint32(1), numEntry);
_PhraseLiterals.clear();
// _PhraseLiterals.resize(numEntry);
// first, concatenate the text vector
string text;
for (uint i=0; i<texts.size(); ++i)
{
text = text + texts[i];
if (i != texts.size() -1)
text += "\n";
}
nldebug("phrase text: %s", text.c_str());
CVectorSString tokens;
if (!strtokquote(text, tokens))
throw EParseException(prim, toString("failed to tokenize the string '%s'", text.c_str()).c_str());
if (tokens.empty())
// nothing to parse
return;
// storage for additional parameters
vector<string> params;
retry:
// ok, the string is parsed, now we can analyze it
// look at the first letter of the first token to determine the type of data we have
if (tokens[0][0] == '\"')
{
// we have a literal, so we must found numEntry literal, then a suffix tag for the phrase name
if (tokens.size() != numEntry +1)
throw EParseException(prim, toString("bad number of tokens in phrase : need %u (%u entries + 1 suffix), found %u\n(in : '%s')",
numEntry+1,
numEntry,
tokens.size(),
text.c_str()
).c_str());
_PhraseLiterals.resize(numEntry);
for (uint i=0; i<numEntry; ++i)
{
CSString text = tokens[i];
// remove quotation marks
text = text.leftCrop(1);
text = text.rightCrop(1);
// store the literal phrase value
_PhraseLiterals[i] = text;
// escape any ']' in the string
_PhraseLiterals[i] = CSString(_PhraseLiterals[i]).replace("]", "\\]");
// now, we can analyse the string content, looking for parameters replacement
while (text.contains('$'))
{
// 'advance' to replacement point
text = text.splitFrom('$');
if (!text.empty())
{
if (text[0] != '$')
{
if (!text.contains('$'))
throw EParseException(prim, "missing parameter closing tag '$'");
string::size_type paramStart = _PhraseLiterals[i].size() - text.size();
// ok, we found a parameter
CSString p = text.splitTo('$', true);
// remove any subpart access
p = p.splitTo('.');
if (i >= predefParams.size() || find_if(predefParams[i].begin(), predefParams[i].end(), TFindParamPred(static_cast<string&>(p))) == predefParams[i].end())
{
// this param is not in the predefined params list, add it to the optional params
params.push_back(p);
}
// remove any compiler param from the phrase literal
if (p.find("@") != string::npos)
{
string::size_type pos = _PhraseLiterals[i].find(p, paramStart);
if (pos != string::npos)
{
string::size_type pos2 = _PhraseLiterals[i].find("@", pos);
if (pos2 != string::npos)
{
while (pos2 < _PhraseLiterals[i].size()
&& _PhraseLiterals[i][pos2] != '.'
&& _PhraseLiterals[i][pos2] != '$')
{
_PhraseLiterals[i].erase(pos2, 1);
}
}
}
}
}
else
{
// this is an escaped $, skip it
text.leftCrop(1);
}
}
}
}
// last, read the suffix
_Suffixe = tokens.back();
// generate identifier
_PhraseId = toUpper(md.getMissionName()+"_"+_Suffixe);
set<string> ps;
// select only unique params
ps.insert(params.begin(), params.end());
vector<string> temp(ps.begin(), ps.end());
params.swap(temp);
}
else if (tokens[0][0] == '$')
{
// we have a variable substitution. Retrieve the var and recall init
// do the var replacement
CVectorSString tokens2;
tokens[0] = md.replaceVar(prim, tokens[0]);
if (!strtokquote(tokens[0], tokens2))
throw EParseException(prim, toString("failed to tokenize the string ('%s')", tokens[0].c_str()).c_str());
tokens2.insert(tokens2.end(), tokens.begin()+1, tokens.end());
tokens.swap(tokens2);
// and retry the decoding
goto retry;
}
else
{
// this should be a simple identifier, followed by any number of additional parameters
// do the var replacement
// tokens = md.replaceVar(prim, tokens);
// untagVar(tokens[0]);
// ok, now extract the phrase label and the additional parameters
_PhraseId = tokens[0];
for (uint i=1; i<tokens.size(); ++i)
{
untagVar(tokens[i]);
if (predefParams.empty() || find_if(predefParams[0].begin(), predefParams[0].end(), TFindParamPred(static_cast<string&>(tokens[i]))) == predefParams[0].end())
{
// this param is not in the predefined params list, add it to the optional params
params.push_back(tokens[i]);
}
}
}
// now, build the parameter list
vector<string>::iterator first(params.begin()), last(params.end());
for (; first != last; ++first)
{
string name, param;
vector<string> parts;
NLMISC::explode(*first, string("@"), parts, false);
if (parts.size() > 0)
name = parts[0];
if (parts.size() > 1)
param = parts[1];
const string &varName = name;
if (varName != "self")
{
IVar *var = md.getVariable(varName);
if (var == NULL)
{
string err = toString("Can't find variable '%s' referenced from a phrase",
name.c_str());
throw EParseException(prim, err.c_str());
}
TParamInfo pi;
pi.ParamName = name;
pi.CompilerParam = param;
pi.ParamType = var->getStringManagerType();
_AdditionalParams.push_back(pi);
}
}
}
std::string CPhrase::genScript(CMissionData &md)
{
std::string ret;
ret = _PhraseId;
for (uint i=0; i<_AdditionalParams.size(); ++i)
{
IVar *var = md.getVariable(_AdditionalParams[i].ParamName);
if (var == NULL)
{
string err = toString("Can't find variable named '%s' to generate phrase param", _AdditionalParams[i].ParamName.c_str());
throw EParseException(NULL, err.c_str());
}
ret += "; " + var->evalVar(_AdditionalParams[i].CompilerParam);
}
return ret;
}
CMissionData::CMissionData()
{
// init all datas
_MonoInstance = false;
_MissionAuto = false;
_RunOnce = false;
_Replayable = false;
_Solo = false;
_Guild = false;
_NotInJournal = false;
_AutoRemoveFromJournal = false;
_PlayerReplayTimer = 0;
_GlobalReplayTimer = 0;
_NotProposed = false;
_NonAbandonnable = false;
_NeedValidation = false;
_FailIfInventoryIsFull = false;
}
CMissionData::~CMissionData()
{
while (!_Variables.empty())
{
delete _Variables.begin()->second;
_Variables.erase(_Variables.begin());
}
while (!_Steps.empty())
{
delete _Steps.back();
_Steps.pop_back();
}
}
void CMissionData::setMissionName(const string &missionName)
{
_MissionName = missionName;
}
const string &CMissionData::getMissionName() { return _MissionName;}
bool CMissionData::addVariable(NLLIGO::IPrimitive *prim, IVar *var)
{
if (_Variables.find(var->getVarName()) != _Variables.end())
throw EParseException(prim, toString("Variable '%s' already defined !", var->getVarName().c_str()).c_str());
_Variables.insert(make_pair(var->getVarName(), var));
_VariablesOrder.push_back(var);
return true;
}
IVar *CMissionData::getVariable(const string &varName)
{
map<string, IVar*>::iterator it(_Variables.find(varName));
if (it != _Variables.end())
return it->second;
return NULL;
}
IStep *CMissionData::getNextStep(IStep *current)
{
for (uint i=0; i<_Steps.size(); ++i)
{
if (_Steps[i] == current && i < _Steps.size()-1)
return _Steps[i+1];
}
return NULL;
}
IStep *CMissionData::getStepByName(const std::string &stepName)
{
if (_StepsByNames.find(stepName) != _StepsByNames.end())
{
return _StepsByNames[stepName];
}
return NULL;
}
bool CMissionData::addStep(IStep *step)
{
_Steps.push_back(step);
return true;
}
string CMissionData::genPreRequisites()
{
string ret;
if (!_ReqSkills.empty())
{
ret += "req_skill : ";
for (uint i=0; i<_ReqSkills.size(); ++i)
{
ret += _ReqSkills[i].Skill+" "+_ReqSkills[i].MinLevel+" "+_ReqSkills[i].MaxLevel;
if (i < _ReqSkills.size()-1)
ret +="; ";
else
ret += NL;
}
}
if (!_ReqMissionDone.empty())
{
for (uint i=0; i<_ReqMissionDone.size(); ++i)
{
ret += "req_mission : "+ _ReqMissionDone[i]+NL;
}
}
if (!_ReqMissionNotDone.empty())
{
for (uint i=0; i<_ReqMissionNotDone.size(); ++i)
{
ret += "req_mission_neg : "+_ReqMissionNotDone[i]+NL;
}
}
if (!_ReqMissionRunning.empty())
{
for (uint i=0; i<_ReqMissionRunning.size(); ++i)
{
ret += "req_mission_running : "+_ReqMissionRunning[i]+NL;
}
}
if (!_ReqMissionNotRunning.empty())
{
for (uint i=0; i<_ReqMissionNotRunning.size(); ++i)
{
ret += "req_mission_running_neg : "+_ReqMissionNotRunning[i]+NL;
}
}
if (!_ReqWearItem.empty())
{
ret += "req_wear : ";
for (uint i=0; i<_ReqWearItem.size(); ++i)
{
ret += _ReqWearItem[i];
if(i < _ReqWearItem.size()-1)
ret +="; ";
ret += NL;
}
}
if (!_ReqOwnItem.empty())
{
ret += "req_item : ";
for (uint i=0; i<_ReqOwnItem.size(); ++i)
{
ret += _ReqOwnItem[i];
if(i < _ReqOwnItem.size()-1)
ret +="; ";
ret += NL;
}
}
if (!_ReqTitle.empty())
{
ret += "req_title : "+_ReqTitle+NL;
}
if (!_ReqFames.empty())
{
for (uint i=0; i<_ReqFames.size(); ++i)
{
ret += "req_fame : "+_ReqFames[i].Faction+" "+_ReqFames[i].Fame;
ret += NL;
}
}
if(_ReqGuild)
{
ret += "req_guild"+NL;
}
if (!_ReqGrade.empty())
{
ret += "req_grade : "+_ReqGrade+NL;
}
if (!_ReqTeamSize.empty())
{
ret += "req_team_size : "+_ReqTeamSize+NL;
}
if (!_ReqBrick.empty())
{
ret += "req_brick : ";
for (uint i=0; i<_ReqBrick.size(); ++i)
{
ret += _ReqBrick[i];
if(i < _ReqBrick.size()-1)
ret +="; ";
ret += NL;
}
}
if (!_ReqCharacterAge.empty())
{
ret += "req_character_age : "+_ReqCharacterAge+NL;
}
if (!_ReqMaxPlayerID.empty())
{
ret += "req_max_player_id : "+_ReqMaxPlayerID+NL;
}
if (!_ReqSeason.empty())
{
ret += "req_season : "+_ReqSeason+NL;
}
if (!_ReqEncyclo.empty())
{
ret += "req_encyclo_thema : " + _ReqEncyclo + NL;
}
if (!_ReqEncycloNeg.empty())
{
ret += "req_encyclo_thema_neg : " + _ReqEncycloNeg + NL;
}
if (!_ReqEventFaction.empty())
{
ret += "req_event_faction : " + _ReqEventFaction + NL;
}
return ret;
}
string CMissionData::generateMissionScript(const std::string &primFileName)
{
_JumpPoints.clear();
// first, gather jump point list
for (uint i=0; i<_Steps.size(); ++i)
{
set<TJumpInfo> temp;
_Steps[i]->fillStepJump(*this, temp);
// remove any jump to the next step (normal flow)
if (i < _Steps.size()-1)
{
set<TJumpInfo>::iterator first(temp.begin()), last(temp.end());
for (; first != last; )
{
const TJumpInfo &ji = *first;
if (ji.StepName == _Steps[i+1]->getStepName() && ji.Discardable)
{
temp.erase(first);
first = temp.begin();
}
else
++first;
}
}
_JumpPoints.insert(temp.begin(), temp.end());
}
// generate the script
string script;
// generate mission header
script += "# script generated from '"+CFile::getFilename(primFileName)+"'"+NL+NL;
script += "#mission tags and pre-requisites"+NL;
if (_MonoInstance)
script += "mono"+NL;
if (_RunOnce)
script += "once"+NL;
if (_Replayable)
script += "replayable"+NL;
if (_Solo)
script += "solo"+NL;
if (_Guild)
script += "guild"+NL;
if (_NotInJournal)
script += "no_list"+NL;
if (_AutoRemoveFromJournal)
script += "auto_remove"+NL;
if (!_MissionCategory.empty())
script += "mission_category : "+_MissionCategory+NL;
if (_PlayerReplayTimer != 0)
script += "player_replay_timer : "+toString("%u", _PlayerReplayTimer)+NL;
if (_GlobalReplayTimer != 0)
script += "global_replay_timer : "+toString("%u", _GlobalReplayTimer)+NL;
if (_NotProposed)
script += "not_proposed"+NL;
if (_MissionAuto)
script += string("auto : ")+_MissionAutoMenu.genScript(*this)+NL;
if (_NonAbandonnable)
script += "non_abandonnable"+NL;
if (!_MissionIcon.empty())
script += "mission_icon : "+_MissionIcon+NL;
if (_NeedValidation)
script += "need_validation"+NL;
if (_FailIfInventoryIsFull)
script += "fail_if_inventory_is_full"+NL;
if (!_ParentMissions.empty())
{
set<string>::iterator first(_ParentMissions.begin()), last(_ParentMissions.end());
for (; first != last; ++first)
{
script += "parent : "+ *first+NL;
}
}
script += NL+"#Variables declaration"+NL;
// declare all the variables
{
std::vector<IVar*>::iterator first(_VariablesOrder.begin()), last(_VariablesOrder.end());
for (; first != last; ++first)
{
script += (*first)->genDecl(*this);
}
}
script += NL+"#pre-requisites"+NL;
script += genPreRequisites();
script += NL+"#script"+NL;
// generate mission title and desc
script += "mission_title : "+_MissionTitle.genScript(*this)+NL;
script += "mission_desc : "+_MissionDescription.genScript(*this)+NL;
// generate steps scripts
for (uint i=0; i<_Steps.size(); ++i)
{
script += "# "+_Steps[i]->getStepName()+NL;
if (_JumpPoints.find(_Steps[i]->getStepName()) != _JumpPoints.end()
&& !_Steps[i]->isAJump())
{
// insert a jump point
script += "jump_point : " + _Steps[i]->getStepName() + NL;
}
script += _Steps[i]->genCode(*this);
//if (_Steps[i]->EndOfBranch && !_Steps[i]->isAJump())
// script += "end"+NL;
}
return script;
}
string CMissionData::generatePhraseFile()
{
string ret;
// generate header phrase
ret = _MissionTitle.genPhrase();
ret += _MissionDescription.genPhrase();
ret += _MissionAutoMenu.genPhrase();
// generate var phrase
for (uint i=0; i<_VariablesOrder.size(); ++i)
{
ret += _VariablesOrder[i]->genPhrase();
}
// generate step phrase
for (uint i=0; i<_Steps.size(); ++i)
{
ret += _Steps[i]->genPhrase();
}
return ret;
}
string CMissionData::generateDotScript()
{
string ret = "digraph " + _MissionName + NL;
ret += "{" + NL;
// set default shape to 'record'
ret += "node [shape=record]"+NL;
ret += "\t__start__ [shape=\"point\", peripheries=2, label=\"\"]"+NL;
// 1st pass, generate node for each step
for (uint i=0; i<_Steps.size(); ++i)
{
if (!_Steps[i]->isEnd() && !_Steps[i]->isAJump())
{
ret += "\t"+_Steps[i]->getStepName();
ret += " [URL=\""+buildPrimPath(_Steps[i]->getPrimitive())+"\"]"+NL;
}
}
ret += "\t__end__ [shape=\"point\"]"+NL;
// activate red color for shapes that are created after this points
ret += "node [color=red]"+NL;
// 2nd pass, generate link between steps
for (uint i=0; i<_Steps.size(); ++i)
{
if (_Steps[i]->isAJump())
continue;
if (i == 0)
{
ret += "\t__start__ -> " + _Steps[i]->getStepName() + NL;
}
set<TJumpInfo> jumps;
_Steps[i]->fillStepJump(*this, jumps);
// there is a link there
while (!jumps.empty())
{
const TJumpInfo &ji = *(jumps.begin());
if (_StepsByNames.find(ji.StepName) != _StepsByNames.end()
&& _StepsByNames[ji.StepName]->isAJump())
{
// this step is a jump, skip to link to the jump destination
IStep *jumpStep = _StepsByNames[ji.StepName];
set<TJumpInfo> jumpJump;
jumpStep->fillStepJump(*this, jumpJump);
if (jumpJump.size() != 1)
{
string str = toString("Step jump contains %u jumps destination instead of 1", jumpJump.size());
throw EParseException(jumpStep->getPrimitive(), str.c_str());
}
ret += "\t"+_Steps[i]->getStepName() + " -> " + jumpJump.begin()->StepName+" [label=\""+ji.JumpName+"\"]" + NL;
}
else
{
ret += "\t"+_Steps[i]->getStepName() + " -> " + ji.StepName+" [label=\""+jumps.begin()->JumpName+"\"]" + NL;
}
jumps.erase(jumps.begin());
}
}
ret += "}" + NL;
return ret;
}
void CMissionData::parseMissionHeader(NLLIGO::IPrimitive *prim)
{
// _MissionName = getProperty(prim, "name", false, false);
// if( _MissionName.find(' ') != string::npos)
// {
// throw EParseException(prim, toString("Mission name '%s' must not contains space", _MissionName.c_str()).c_str());
// }
_GiverPrimitive = getProperty(prim,"giver_primitive", true, false);
_MissionGiver = getProperty(prim, "mission_giver", true, false);
// _Alias = getProperty(prim, "alias", false, false);
// If the mission is under a npc_bot node, then the giver is directly taken
// from the npc name
if (prim->getParent())
{
if (getProperty(prim->getParent(), "class", false, false) == "npc_bot")
{
_MissionGiver = getProperty(prim->getParent(), "name", false, false);
}
}
vector<string> vs;
_MissionTitleRaw = getPropertyArray(prim, "mission_title", false, false);
// _MissionTitle.init(*this, prim, vs);
_MissionDescriptionRaw = getPropertyArray(prim, "mission_description", false, false);
// _MissionDescription.init(*this, prim, vs);
_MonoInstance = toLower(getProperty(prim, "mono_instance", true, false)) == "true";
_RunOnce = toLower(getProperty(prim, "run_only_once", true, false)) == "true";
_Replayable = toLower(getProperty(prim, "replayable", true, false)) == "true";
_NeedValidation = toLower(getProperty(prim, "need_validation", true, false)) == "true";
_MissionAutoMenuRaw = getPropertyArray(prim, "phrase_auto_menu", false, false);
// audience setting
string s = getProperty(prim, "audience", false, false);
if (s == "solo")
_Solo = true;
else if (s == "guild")
_Guild = true;
_NotInJournal = NLMISC::toLower(getProperty(prim, "not_in_journal", false, false)) == "true";
_AutoRemoveFromJournal = NLMISC::toLower(getProperty(prim, "auto_remove_from_journal", false, false)) == "true";
_MissionCategory = getProperty(prim, "mission_category", false, false);
NLMISC::fromString(getProperty(prim, "player_replay_timer", true, false), _PlayerReplayTimer);
NLMISC::fromString(getProperty(prim, "global_replay_timer", true, false), _GlobalReplayTimer);
_NotProposed = NLMISC::toLower(getProperty(prim, "not_proposed", false, false)) == "true";
_MissionAuto = NLMISC::toLower(getProperty(prim, "automatic", false, false)) == "true";
_NonAbandonnable = NLMISC::toLower(getProperty(prim, "non_abandonnable", false, false)) == "true";
_FailIfInventoryIsFull = NLMISC::toLower(getProperty(prim, "fail_if_inventory_is_full", false, false)) == "true";
_MissionIcon = getProperty(prim, "mission_icon", false, false);
if (_MissionAuto)
{
if (_MissionAutoMenuRaw.empty())
{
string error = toString("Mission is flagged automatic, but no phrase_auto_menu defined !");
throw EParseException(prim, error.c_str());
}
}
vs = getPropertyArray(prim, "parent_missions", true, false);
_ParentMissions.insert(vs.begin(), vs.end());
}
void CMissionData::parsePrerequisites(NLLIGO::IPrimitive *prim)
{
// skills
vector<string> vs;
vs = getPropertyArray(prim, "require_skill/min_level/max_level", true, false);
for (uint i=0; i<vs.size(); ++i)
{
if (!vs[i].empty())
{
vector<string> parts;
strtokquote(vs[i], parts);
if (parts.size() != 3)
{
throw EParseException(prim, toString("Invalide argument count in line %u of require_skill array. Need 3, found %u", i, parts.size()).c_str());
}
TReqSkill rs;
rs.Skill = parts[0];
rs.MinLevel = parts[1];
rs.MaxLevel = parts[2];
_ReqSkills.push_back(rs);
}
}
// Mission done
vs = getPropertyArray(prim, "require_mission_done", true, false);
for (uint i=0; i<vs.size(); ++i)
{
if (!vs[i].empty())
{
vector<string> parts;
strtokquote(vs[i], parts);
if (parts.size() != 1)
{
throw EParseException(prim, toString("Invalide argument count in line %u of require_mission_done array. Need 1, found %u", i, parts.size()).c_str());
}
_ReqMissionDone.push_back(parts[0]);
}
}
// Mission not done
vs = getPropertyArray(prim, "require_mission_not_done", true, false);
for (uint i=0; i<vs.size(); ++i)
{
if (!vs[i].empty())
{
vector<string> parts;
strtokquote(vs[i], parts);
if (parts.size() != 1)
{
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());
}
_ReqMissionNotDone.push_back(parts[0]);
}
}
// Mission running
vs = getPropertyArray(prim, "require_mission_running", true, false);
for (uint i=0; i<vs.size(); ++i)
{
if (!vs[i].empty())
{
vector<string> parts;
strtokquote(vs[i], parts);
if (parts.size() != 1)
{
throw EParseException(prim, toString("Invalide argument count in line %u of require_mission_running array. Need 1, found %u", i, parts.size()).c_str());
}
_ReqMissionRunning.push_back(parts[0]);
}
}
// Mission not running
vs = getPropertyArray(prim, "require_mission_not_running", true, false);
for (uint i=0; i<vs.size(); ++i)
{
if (!vs[i].empty())
{
vector<string> parts;
strtokquote(vs[i], parts);
if (parts.size() != 1)
{
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());
}
_ReqMissionNotRunning.push_back(parts[0]);
}
}
// wearing item
vs = getPropertyArray(prim, "require_wearing_item", true, false);
for (uint i=0; i<vs.size(); ++i)
{
if (!vs[i].empty())
{
vector<string> parts;
strtokquote(vs[i], parts);
if (parts.size() != 1)
{
throw EParseException(prim, toString("Invalide argument count in line %u of require_wearing_item array. Need 1, found %u", i, parts.size()).c_str());
}
_ReqWearItem.push_back(parts[0]);
}
}
// own item
vs = getPropertyArray(prim, "require_own_item", true, false);
for (uint i=0; i<vs.size(); ++i)
{
if (!vs[i].empty())
{
vector<string> parts;
strtokquote(vs[i], parts);
if (parts.size() != 1)
{
throw EParseException(prim, toString("Invalide argument count in line %u of require_own_item array. Need 1, found %u", i, parts.size()).c_str());
}
_ReqOwnItem.push_back(parts[0]);
}
}
// title
_ReqTitle = getProperty(prim, "require_title", true, false);
// fame
vs = getPropertyArray(prim, "require_faction/fame", true, false);
for (uint i=0; i<vs.size(); ++i)
{
if (!vs[i].empty())
{
vector<string> parts;
strtokquote(vs[i], parts);
if (parts.size() != 2)
{
throw EParseException(prim, toString("Invalide argument count in line %u of require_faction/fame array. Need 2, found %u", i, parts.size()).c_str());
}
TReqFame rf;
rf.Faction = parts[0];
rf.Fame = parts[1];
_ReqFames.push_back(rf);
}
}
// guild
if (getProperty(prim, "require_guild_membership", true, false) == "true")
_ReqGuild = true;
else
_ReqGuild = false;
// grade
_ReqGrade = getProperty(prim, "require_guild_grade", true, false);
// team size
_ReqTeamSize = getProperty(prim, "require_team_size", true, false);
// character minimum age
_ReqCharacterAge = getProperty(prim, "require_character_age", true, false);
// maximum player ID
_ReqMaxPlayerID = getProperty(prim, "require_max_player_id", true, false);
// brick
vs = getPropertyArray(prim, "require_brick_knowledge", true, false);
for (uint i=0; i<vs.size(); ++i)
{
if (!vs[i].empty())
{
vector<string> parts;
strtokquote(vs[i], parts);
if (parts.size() != 1)
{
throw EParseException(prim, toString("Invalide argument count in line %u of require_brick_knowledge array. Need 1, found %u", i, parts.size()).c_str());
}
_ReqBrick.push_back(parts[0]);
}
}
// season
_ReqSeason = getProperty(prim, "require_season", true, false);
// encyclopedia
_ReqEncyclo = getProperty(prim, "require_encyclo_thema", true, false);
_ReqEncycloNeg = getProperty(prim, "require_encyclo_thema_neg", true, false);
if ((!_ReqEncyclo.empty() && !_ReqEncycloNeg.empty())
|| (!_ReqEncycloNeg.empty() && !_ReqEncyclo.empty()))
{
string err = toString("You can't mix positive and negative encyclopedy requirement");
throw EParseException(prim, err.c_str());
}
// event faction
_ReqEventFaction = getProperty(prim, "require_event_faction", true, false);
}
std::string CMissionData::replaceVar(NLLIGO::IPrimitive *prim, const std::string &str)
{
string::size_type pos = 0;
string::size_type pos2 = 0;
string ret;
while (pos < str.size())
{
if (str[pos] != '$')
{
ret += str[pos++];
}
else if (pos+1 < str.size() && str[pos+1] == '$')
{
// check that this $ is not escaped
ret += '$';
pos+=2;
}
else
{
// ok, this is not an escaped $
CSString varName;
// skip the initial '$'
pos++;
// while (str[pos] != ' ' && str[pos] != '\t' && str[pos] != '\n' && str[pos] != '\r')
while (pos < str.size() && str[pos] != '$')
varName += str[pos++];
if (pos >= str.size())
{
string err = toString("Error while parsing variable in '%s', missing closing '$'", str.c_str());
throw EParseException (NULL, err.c_str());
}
// skip the final '$'
pos++;
// split the var name and subpart
vector<string> varParts;
explode(string(varName), string("@"), varParts, true);
if (varParts.empty() || varParts.size() > 2)
{
throw EParseException(prim, toString("Error parsing varName '%s' in string '%s'", varName.c_str(), str.c_str()).c_str());
}
if (_Variables.find(varParts.front()) == _Variables.end())
{
string err = toString("Unknown variable '%s' in string '%s'", varParts.front().c_str(), str.c_str());
throw EParseException (prim, err.c_str());
}
IVar *var = _Variables[varParts[0]];
if (varParts.size() == 1)
ret += var->evalVar("");
else
ret += var->evalVar(varParts[1]);
}
}
return ret;
}
std::vector<std::string> CMissionData::replaceVar(NLLIGO::IPrimitive *prim, const std::vector<std::string> &strs)
{
vector<string> ret;
for (uint i=0; i<strs.size(); ++i)
{
ret.push_back(replaceVar(prim, strs[i]));
}
return ret;
}
std::string CMissionData::getProperty(NLLIGO::IPrimitive *prim, const std::string &propertyName, bool replaceVar, bool canFail)
{
string ret;
string *s;
if (!prim->getPropertyByName(propertyName.c_str(), s))
{
if (!canFail)
{
string err = toString("Can't find property '%s'", propertyName.c_str());
throw EParseException (prim, err.c_str());
}
}
else
{
ret = *s;
}
if (replaceVar)
{
ret = this->replaceVar(prim, ret);
}
return ret;
}
std::vector<std::string> CMissionData::getPropertyArray(NLLIGO::IPrimitive *prim, const std::string &propertyName, bool replaceVar, bool canFail)
{
vector<string> ret;
vector<string> *vs;
if (!prim->getPropertyByName(propertyName.c_str(), vs))
{
if (!canFail)
{
string err = toString("Can't find property '%s'", propertyName.c_str());
throw EParseException (prim, err.c_str());
}
}
else
{
ret = *vs;
}
if (replaceVar)
{
ret = this->replaceVar(prim, ret);
}
return ret;
}
bool CMissionData::isThereAJumpTo(const std::string &stepName)
{
if (_JumpPoints.find(stepName) != _JumpPoints.end())
return true;
else
return false;
}
void TCompilerVarName::init(const std::string &defaultName, STRING_MANAGER::TParamType type, CMissionData &md, NLLIGO::IPrimitive *prim, const std::string propName)
{
_DefaultName = defaultName;
_ParamType = type;
_VarName = md.getProperty(prim, propName, false, false);
// remove the variable tag if any
untagVar(_VarName);
_VarValue = md.getProperty(prim, propName, true, false);
}
void TCompilerVarName::initWithText(const std::string &defaultName, STRING_MANAGER::TParamType type, CMissionData &md, NLLIGO::IPrimitive *prim, const std::string &text)
{
_DefaultName = defaultName;
_ParamType = type;
_VarName = text;
// remove the variable tag if any
untagVar(_VarName);
_VarValue = md.replaceVar(prim, text);
}
CPhrase::TParamInfo TCompilerVarName::getParamInfo() const
{
if (_VarName.empty())
return CPhrase::TParamInfo(_DefaultName, _ParamType);
else
return CPhrase::TParamInfo(_VarName, _ParamType);
}
bool TCompilerVarName::empty() const
{
return _VarValue.empty();
}
TCompilerVarName::operator const std::string () const
{
return _VarValue;
}
TCompilerVarName::operator CPhrase::TParamInfo() const
{
return getParamInfo();
}
std::string operator+(const TCompilerVarName& left, const std::string & right) { return left._VarValue + right;}
std::string operator+(const std::string & left, const TCompilerVarName& right) { return left + right._VarValue;}
std::vector<TCompilerVarName> TCompilerVarName::getPropertyArrayWithText(const std::string &defaultName, STRING_MANAGER::TParamType type, CMissionData &md, NLLIGO::IPrimitive *prim, const std::string & arrayProperyName)
{
std::vector<TCompilerVarName> compilerParams;
std::vector<std::string> values = md.getPropertyArray(prim, arrayProperyName,false, false);
uint first = 0;
uint last = (uint)values.size();
compilerParams.resize(last);
for ( ; first != last; ++first)
{
compilerParams[first].initWithText( toString("%s%d", defaultName.c_str(), first+1) , type, md, prim, values[first]);
}
return compilerParams;
}
std::vector<TCompilerVarName> TCompilerVarName::getPropertyArrayWithTextStaticDefaultName(const std::string &defaultName, STRING_MANAGER::TParamType type, CMissionData &md, NLLIGO::IPrimitive *prim, const std::string & arrayProperyName)
{
std::vector<TCompilerVarName> compilerParams;
std::vector<std::string> values = md.getPropertyArray(prim, arrayProperyName,false, false);
uint first = 0;
uint last = (uint)values.size();
compilerParams.resize(last);
for ( ; first != last; ++first)
{
compilerParams[first].initWithText( defaultName, type, md, prim, values[first]);
}
return compilerParams;
}
Reference in a new issue View git blame Copy permalink