khanat-opennel-code/code/ryzom/tools/leveldesign/mission_compiler_lib/mission_compiler.cpp.REMOTE.3111.cpp

// 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.empty())
			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;
}