mirror of
https://port.numenaute.org/aleajactaest/khanat-code-old.git
synced 2024-12-14 13:14:48 +00:00
240 lines
7.1 KiB
C++
240 lines
7.1 KiB
C++
// 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 "stdpch.h"
|
|
#include "primitive_cfg.h"
|
|
#include "nel/misc/config_file.h"
|
|
#include "nel/misc/path.h"
|
|
|
|
using namespace NLMISC;
|
|
using namespace std;
|
|
|
|
// std::vector<std::string> CPrimitiveCfg::_AllPrimitives;
|
|
std::vector<std::string> CPrimitiveCfg::_MapNames;
|
|
std::map<std::string, std::vector<std::string> > CPrimitiveCfg::_Maps;
|
|
std::map<std::string, std::vector<std::string> > CPrimitiveCfg::_ContinentFiles;
|
|
|
|
void CPrimitiveCfg::addPrimitive(std::vector<std::string> &vectorlist, const std::string &str)
|
|
{
|
|
for (uint32 i=0;i<vectorlist.size();i++)
|
|
if (vectorlist[i]==str)
|
|
return;
|
|
|
|
vectorlist.push_back(str);
|
|
}
|
|
|
|
|
|
std::string CPrimitiveCfg::getContinentNameOf(const std::string &fileName)
|
|
{
|
|
CPrimitiveCfg::readPrimitiveCfg();
|
|
string name = CFile::getFilename(fileName);
|
|
|
|
std::map<std::string, std::vector<std::string> >::iterator first(_ContinentFiles.begin()), last(_ContinentFiles.end());
|
|
for (; first != last; ++first)
|
|
if (find(first->second.begin(),first->second.end(), name) != first->second.end())
|
|
return first->first;
|
|
|
|
return std::string();
|
|
}
|
|
|
|
// dumb routine to simplify repetitive text parsing code
|
|
inline bool isWhiteSpace(char c)
|
|
{
|
|
return (c==' ' || c=='\t');
|
|
}
|
|
|
|
// -- stringToWordAndTail() --
|
|
// The following routine splits a text string into a keyword and a tail.
|
|
// A white space is used as separator between keyword and tail
|
|
// All leading and trailing ' ' and '\t' round keyword and tail characters are stripped
|
|
// If no keyword is found routine retuns false (keyword and tail retain previous content)
|
|
inline bool stringToWordAndTail(const std::string &input,std::string &word, std::string &tail)
|
|
{
|
|
uint i=0, j;
|
|
|
|
// skip white space
|
|
while (i<input.size() && isWhiteSpace(input[i])) ++i; // i points to start of word
|
|
|
|
// look for the end of the word
|
|
for (j=i;j<input.size() && !isWhiteSpace(input[j]);) ++j; // j points to next character after word
|
|
|
|
// if no word found then give up
|
|
if (j==i) return false;
|
|
|
|
// copy out the word
|
|
word=input.substr(i,j-i);
|
|
|
|
// find the end of the tail text
|
|
for (i=(uint)input.size();i>j && isWhiteSpace(input[i-1]);) --i; // i points to character after end of tail text
|
|
|
|
// find start of tail text
|
|
do { ++j; } while(j<i && isWhiteSpace(input[j])); // j points to start of tail text
|
|
|
|
// copy out the tail (or clear if no tail found in input)
|
|
if (j<i)
|
|
tail=input.substr(j,i-j);
|
|
else
|
|
tail.clear();
|
|
|
|
return true;
|
|
}
|
|
|
|
void CPrimitiveCfg::readPrimitiveCfg(bool forceReload)
|
|
{
|
|
if ( !forceReload
|
|
&& !_MapNames.empty())
|
|
return;
|
|
|
|
// _AllPrimitives.clear();
|
|
_MapNames.clear();
|
|
_Maps.clear();
|
|
|
|
std::string filename = CPath::lookup("primitives.cfg");
|
|
if (filename.empty())
|
|
{
|
|
nlwarning("Can't find the primitive configuration file 'primitives.cfg'");
|
|
return;
|
|
}
|
|
|
|
try
|
|
{
|
|
CConfigFile cfg;
|
|
cfg.load(filename.c_str());
|
|
|
|
CConfigFile::CVar var = cfg.getVar("PrimitiveFiles");
|
|
|
|
std::vector<std::string> CurrentMapNames;
|
|
set<string> mapNames;
|
|
|
|
std::vector<std::string> *_CurrentContinentFiles=NULL;
|
|
|
|
for (uint32 i=0;i<var.size();++i)
|
|
{
|
|
// uint32 j,k;
|
|
|
|
// get the next string from the config file entry and make sure its not empty
|
|
const std::string s=var.asString(i);
|
|
|
|
std::string keyword;
|
|
std::string tail;
|
|
{
|
|
if (s.empty())
|
|
continue;
|
|
stringToWordAndTail(s, keyword, tail);
|
|
}
|
|
|
|
|
|
// // skip opening white space and make sure there's not just white space
|
|
// for (j=0;j<s.size() && (s[j]==' ' || s[j]=='\t');++j);
|
|
// if (j>=s.size())
|
|
// continue;
|
|
// // separate the first word (we need it to know what to do next)
|
|
// for (k=j;k<s.size() && s[k]!=' ' && s[k]!='\t';++k);
|
|
// std::string keyword=s.substr(j,k-j);
|
|
//
|
|
// // separate out the tail, pruning trailing blanks
|
|
// // ignore leading blanks
|
|
// for (j=k;j<s.size() && (s[j]==' ' || s[j]=='\t');++j);
|
|
// // ignore trailing spaces
|
|
// for (k=s.size()-1;s[k]==' '||s[k]=='\t';--k);
|
|
// // if we found some non-blank text take a copy in a 'tail' variable
|
|
// std::string tail;
|
|
// if (k>=j) tail=s.substr(j,k-j+1);
|
|
|
|
|
|
// do something depending on the keyword found earlier
|
|
if (nlstricmp(keyword,"MAPEND")==0)
|
|
{
|
|
// remove the last map entry
|
|
CurrentMapNames.pop_back();
|
|
}
|
|
else if (nlstricmp(keyword,"CONTINENT")==0)
|
|
{
|
|
_CurrentContinentFiles=&_ContinentFiles[tail];
|
|
}
|
|
else if (nlstricmp(keyword,"MAP")==0)
|
|
{
|
|
// store the map name for use later
|
|
CurrentMapNames.push_back(tail);
|
|
mapNames.insert(tail);
|
|
_Maps.insert(make_pair(tail, vector<string>()));
|
|
if (_CurrentContinentFiles)
|
|
addPrimitive(*_CurrentContinentFiles, tail); // bad but not too ..
|
|
}
|
|
else if (nlstricmp(keyword,"FILE")==0)
|
|
{
|
|
// if our file name is > 0 characters long then add it to the vector
|
|
// if (j<=k)
|
|
{
|
|
string filename = tail; //s.substr(j,k-j+1);
|
|
if (CFile::getExtension(filename).empty())
|
|
filename+=".primitive";
|
|
|
|
for (uint32 mapInd=0;mapInd<CurrentMapNames.size();mapInd++)
|
|
addPrimitive(_Maps[CurrentMapNames[mapInd]], filename);
|
|
|
|
if (_CurrentContinentFiles)
|
|
addPrimitive(*_CurrentContinentFiles, filename);
|
|
// else
|
|
// nlwarning("Not Continents specified for %s",filename.c_str());
|
|
}
|
|
|
|
}
|
|
else if (nlstricmp(keyword,"INCLUDE")==0)
|
|
{
|
|
// if our file name is > 0 characters long then add it to the vector
|
|
// if (j<=k)
|
|
{
|
|
string includeName = tail; //s.substr(j,k-j+1);
|
|
|
|
if (_Maps.find(includeName)==_Maps.end())
|
|
{
|
|
nlwarning("PrimitiveCfg: Include %s failed, not defined.",includeName.c_str());
|
|
}
|
|
else
|
|
{
|
|
std::vector<std::string> &vectorlist=_Maps[includeName];
|
|
for (uint32 primInd=0;primInd<vectorlist.size();primInd++)
|
|
{
|
|
const string &primitiveFileName=vectorlist[primInd];
|
|
|
|
for (uint32 mapInd=0;mapInd<CurrentMapNames.size();mapInd++)
|
|
addPrimitive(_Maps[CurrentMapNames[mapInd]], primitiveFileName);
|
|
if (_CurrentContinentFiles)
|
|
addPrimitive(*_CurrentContinentFiles, primitiveFileName);
|
|
else
|
|
nlwarning("Not Continents specified for %s",includeName.c_str());
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
else
|
|
nlwarning("Unknown keyword in PrimitiveFiles at line: '%s'",s.c_str());
|
|
}
|
|
// fill the maps names vector
|
|
_MapNames.insert(_MapNames.begin(), mapNames.begin(), mapNames.end());
|
|
}
|
|
catch(...)
|
|
{
|
|
nlwarning("Error reading or parsing the primitive configuration file '%s'", filename.c_str());
|
|
}
|
|
}
|
|
|