aleajactaest/khanat-code-old
1
0
Fork 0
mirror of https://port.numenaute.org/aleajactaest/khanat-code-old.git synced 2024-11-09 00:39:02 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
khanat-code-old/code/ryzom/tools/sheet_random_generator/srg_utilities.h
acemtp 1792297c93 initial version
2010-05-06 02:08:41 +02:00

2964 lines
79 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/>.
#ifndef NL_SRG_UTILITIES_H
#define NL_SRG_UTILITIES_H
// Misc
#include <nel/misc/types_nl.h>
#include <nel/misc/sstring.h>
#include "nel/misc/path.h"
#include "nel/misc/file.h"
#include "nel/misc/smart_ptr.h"
#include "nel/misc/command.h"
#include "nel/misc/path.h"
#include <nel/misc/diff_tool.h>
#include <nel/misc/random.h>
// Georges
#include "nel/georges/u_form.h"
#include "nel/georges/u_form_elm.h"
#include "nel/georges/u_form_dfn.h"
#include "nel/georges/u_form_loader.h"
#include "nel/georges/u_type.h"
// Georges, bypassing interface
#include "georges/stdgeorges.h"
#include "georges/form.h"
// C
#include <time.h>
#include <conio.h>
// stl
#include <set>
#include <map>
#include <hash_map>
using namespace NLMISC;
using namespace NLGEORGES;
using namespace std;
typedef sint TFaberInterestLevel;
const TFaberInterestLevel NAInterestLevel = -1;
const uint32 NbNomenclaturedFaberLevel = 5; // excluding N/A
const char *sNomenclaturedInterestLevels [NbNomenclaturedFaberLevel+1] = { "N/A", "Worst", "Bad", "Average", "Good", "Best" }; // from -1 to 5
CRandom RandomGenerator;
typedef CVectorSString vs;
typedef map <uint32, vector<uint32> > CRulesFilter;
typedef map <CSString, vector<uint32>, CUnsensitiveSStringLessPred > CRulesStrFilter;
typedef map <CSString, vs, CUnsensitiveSStringLessPred > CRulesStr2Filter;
typedef map< CSString, CSString, CUnsensitiveSStringLessPred > mss;
typedef vector<uint32> vu;
typedef hash_map< string, string, hash<string> > CTitles; // code -> utf8 title
// Write sheet files, or display to screen only
bool WriteSheetsToDisk = true;
// Overriden by command-line argument after -n
string ExtractNamesCsv;
const uint32 NbFaberElements = 26;
const uint32 RM_INDEX_FAMILY_CODE = 1;
const uint32 NB_FAMILY_CODE_CHARS = 4;
const uint32 RM_INDEX_CREATURE_CODE = 5;
const uint32 NB_CREATURE_CODE_CHARS = 5;
const uint32 RM_INDEX_ECOSYSTEM_CODE = 8;
const uint32 NB_ECOSYSTEM_CODE_CHARS = 1;
const uint32 RM_INDEX_LEVELZONE_CODE = 9;
const uint32 SIZE_RAW_MATERIAL_SHEET_FILENAME = 18;
/*const uint32 RM_INDEX_INTEREST_LEVEL = 6;
const uint32 NB_INTEREST_LEVEL_CHARS = 2;
const uint32 RM_INDEX_FABERELEMS_CODE = 8;
const uint32 NB_FABERELEMS_CODE_CHARS = 6;*/
const uint32 CR_INDEX_ECOSYSTEM_CODE = 3; // in creature code
const uint32 CR_INDEX_LEVELZONE_CODE = 4;
const uint32 CR_INDEX_LOCAL_LEVEL_CODE = 5;
//const uint32 NB_UNIQUE_LEVELS_PER_ZONE = 4; // not counting the bosses, the fifth equals the first one of next
const uint32 NB_UNIQUE_LEVELZONES_PER_CONTINENT = 5;
const uint32 MAX_NB_LOCAL_LEVELS = 8;
//const uint32 NB_ZONE_LEVELS = 5; // TEMP for forest ecosystem
//const uint32 NbFaberInterestLevels = (NB_ZONE_LEVELS * NB_UNIQUE_LEVELS_PER_ZONE) + 1; // excluding N/A
string inputSheetPath;
bool inputSheetPathLoaded = false;
map<string, string> inputSheetPathContent; // short filename without ext, full filename with path
string TranslationPath;
string SystemMPPath;
// These vectors have the same indices : by family
vs families;
vs familyCodes, ecosystemCodes, propertyCodes, creatureCodes;
sint MaxFamilyNum = -1;
enum TColor { Red, Beige, Green, Turquoise, Blue, Violet, White, Black, NbColors, InvalidColor=NbColors };
// By ecosystem, color, property, rm group, creature, season
vs ecosystems, colors, properties, groups, creatures, seasons;
mss adjectives;
// DtName must be the 1st one
enum TDataCol { DtName, DtTitle, DtRMFamily, DtGroup, DtEcosystem, DtLevelZone, DtStatQuality, DtProp, DtCreature, DtCreaTitle, DtCraftSlotName, DtCraftCivSpec, DtColor, DtAverageEnergy, DtMaxLevel, DtJewelProtectionType, DtCustomizedProperties, DtNbCols };
const char *DataColStr [DtNbCols] = { "Code", "Name", "Family", "Group", "Ecosystem", "LevelZone", "Stat Quality", "Properties", "Creature sheets", "Creatures", "Item parts", "Craft civ spec", "Color", "Average energy", "Max level", "Jewel protection type", "Customized" };
const uint32 NbPropertyDepths = 5;
const char *PropertyDepths [NbPropertyDepths] = { "Unknown", "Slightly", "Moderately", "Quite", "Extremely" };
typedef uint32 TGroup; // index in groups, and value in groups .typ
//enum TLocation { Under, Over, Flora, Creatures, NB_LOCATIONS, NB_DEPOSITS=Flora+1 };
enum TLocation { InDeposits, InCreatures, NB_LOCATIONS };
vu DepositFamilyIndices;
enum TCiv { Fyros, Matis, Tryker, Zorai, AllCiv, NbCiv };
const char *CivNames [NbCiv] = { "Fyros", "Matis", "Tryker", "Zorai", "All" };
const char *CivEcosystemCodes [NbCiv] = { "D", "F", "L", "J", "X" };
enum TEcosystem { CommonEcosystem, Desert, Forest, Lacustre, Jungle, PrimeRoots, NbEcosystems, Goo=NbEcosystems, Invasion, Raid, Event, N, S, T, U, V, W, X, Y, Z, NbEcosystemsPlusExtensions };
TCiv EcosystemToCiv[NbEcosystems] = { AllCiv, Fyros, Matis, Tryker, Zorai, AllCiv };
enum TStatQuality { Basic, Fine, Choice, Excellent, Supreme, NbStatQualities, InvalidStatQuality=NbStatQualities };
char *StatQualityStr [NbStatQualities+1] = { "Basic", "Fine", "Choice", "Excellent", "Supreme", "N/A" };
TStatQuality CreatureLocalLevelToStatQuality [MAX_NB_LOCAL_LEVELS] =
{
Basic, // 1 (index 0)
Fine, // 2
Basic, // 3
Fine, // 4
Excellent, // 5 (named creatures)
InvalidStatQuality, // 6 (mission creatures, their RMs have no craft stats)
Supreme, // 7 (bosses)
Choice // 8 (mini-bosses)
};
enum TIndexOfRemarkableStatIndex { RBestA, RBest=RBestA, RWorstA1, RWorst1=RWorstA1, RWorstA2, RWorst2=RWorstA2, RBestB, RWorstB1, RWorstB2, NB_REMARKABLE_STAT_INDICES };
struct TSkeletonInfo
{
TSkeletonInfo() : IsUsed(false) {}
//vs CreaturesOfSke;
CSString Name;
CSString AbbrevName;
//CSString SkGroup;
bool IsUsed; // true if has RM
};
typedef map<CSString, TSkeletonInfo, CUnsensitiveSStringLessPred> CSkeletonMap;
// By skeleton group, by skeleton, bu creature model
CRulesStr2Filter SkgroupToModels;
CSkeletonMap CreatureModels;
mss CreatureToModel;
//vs skeletonGroupColumns;
set<CSString, CUnsensitiveSStringLessPred> CreatureMainModelsWithoutRM;
// By creature model
CRulesStrFilter RMFamilyIndicesByCreatureModel;
vu GooCreatureFamilyIndices;
typedef map<char, vu> CCreatureTypeToFamilyIndices; // the key is the 2nd char of the creature code (h for herbivore, k for kitin...)
CCreatureTypeToFamilyIndices InvasionRaidCreatureFamilyIndices;
struct TBool
{
TBool() : Done(false) {}
bool Done;
};
typedef map< uint, TBool > CDoneMap; // indexed by levelzone
map< string, TBool > IsRMSheetGenerated; // indexed by sheetname
string rawMaterialPath, creaturePath, creatureAssignmentPath, depositPath;
string dirbase;
const string oldRmSheetType = "item";
const string rmSheetType = "sitem";
const string crSheetType = "creature";
const string dpSheetType = "deposit";
//const uint32 NbPropertySlots = 10; // obsolete
uint32 UndefinedProperty = ~0;
/*
*
*/
struct CIconInfo
{
CSString IconBackground, Icon, IconOver, IconOver2;
};
map< CSString, CIconInfo, CUnsensitiveSStringLessPred > Icons;
/*
*
*/
class CMainStat
{
public:
///
CMainStat() : SumNbFaberElemsFilled(0), MaxNbFaberElemsFilled(0), MinNbFaberElemsFilled(~0),
NbRMByFaberElem( NbFaberElements, 0 ) {}
/// Call it when families etc. are ready
void init()
{
NbRMByFaberElemByFamilyAndCiv.resize( families.size() );
for ( uint32 i=0; i!=families.size(); ++i )
{
NbRMByFaberElemByFamilyAndCiv[i].resize( NbCiv );
for ( uint32 c=0; c!=NbCiv; ++c )
NbRMByFaberElemByFamilyAndCiv[i][c].resize( NbFaberElements );
}
for ( uint32 iEcosystem=0; iEcosystem!=ecosystems.size(); ++iEcosystem )
{
for ( uint32 iLoc=0; iLoc!=NB_LOCATIONS; ++iLoc )
{
NbRMHavingProperty[iLoc][iEcosystem].resize( properties.size() );
NbRMByFaberElemByEcosystem[iEcosystem].resize( NbFaberElements );
}
}
}
///
bool updateCraftStatistics( uint32 rFaberElem, uint32 iEcosystem, uint32 iFam, TCiv civ );
///
void updateMainStats( uint32 nbFaberElemsFilled )
{
SumNbFaberElemsFilled += nbFaberElemsFilled;
if ( nbFaberElemsFilled < MinNbFaberElemsFilled )
MinNbFaberElemsFilled = nbFaberElemsFilled;
if ( nbFaberElemsFilled> MaxNbFaberElemsFilled )
MaxNbFaberElemsFilled = nbFaberElemsFilled;
}
// By property and by ecosystem and location
vu NbRMHavingProperty [NB_LOCATIONS][NbEcosystems];
uint32 SumNbFaberElemsFilled;
uint32 MaxNbFaberElemsFilled;
uint32 MinNbFaberElemsFilled;
vector<uint32> NbRMByFaberElem;;
vector<uint32> NbRMByFaberElemByEcosystem [NbEcosystems];
vector< vector < vector< uint32 > > > NbRMByFaberElemByFamilyAndCiv;
};
/*
* From georges2csv
*/
void loadSheetPath()
{
if (inputSheetPathLoaded)
return;
NLMISC::createDebug();
NLMISC::WarningLog->addNegativeFilter( "CPath::insertFileInMap" );
CPath::addSearchPath(inputSheetPath, true, false); // for Georges to work properly
vector<string> files;
CPath::getPathContent (inputSheetPath, true, false, true, files);
uint32 i;
for (i=0; i<files.size(); ++i)
{
string filename = files[i];
string filebase = CFile::getFilenameWithoutExtension(filename);
inputSheetPathContent[filebase] = filename;
}
inputSheetPathLoaded = true;
}
/*
* Get a random value in range [0..nbPossibleValues[
* Precondition: nbPossibleValues < 65536
*/
inline uint32 getRandomValue( uint32 nbPossibleValues )
{
/*double r = (double) rand();
r/= (double) (RAND_MAX+1); // exclude the ceiling value
return (uint32)(r * nbPossibleValues);*/
return RandomGenerator.rand( (uint16)(nbPossibleValues-1) );
}
/*
*
*/
struct CDfnFieldInfo
{
CDfnFieldInfo() {}
CDfnFieldInfo( const vector<string>& values, const vector<string>& labels ) : TypePredefinedValues(values), TypePredefinedLabels(labels) {}
vector<string> TypePredefinedValues;
vector<string> TypePredefinedLabels;
};
/*
*
*/
struct TIconMapping
{
const char *FamilyName;
const char *IconFilename;
};
/*
*
*/
sint getNomenclaturedInterestLevel( TFaberInterestLevel level, TFaberInterestLevel nbInterestLevels )
{
return (level == NAInterestLevel) ? 0 : (level * NbNomenclaturedFaberLevel / nbInterestLevels) + 1;
}
/*
*
*/
//struct CFaberCode
//{
// char Ch[NB_FABERELEMS_CODE_CHARS];
//};
/*
*
*/
//struct CFaberCombination
//{
// CFaberCombination( TFaberInterestLevel firstLevel, const string& code ) : FirstLevel(firstLevel)
// {
// memcpy( Code.Ch, &code[0], NB_FABERELEMS_CODE_CHARS );
// }
//
// TFaberInterestLevel FirstLevel;
// CFaberCode Code;
//};
/*
*
*/
//class CSheetNameRepository
//{
//public:
//
// ///
// void resize( uint32 nbEcosystems, uint32 nbFamilies )
// {
// _Container.resize( nbEcosystems );
// for ( uint32 i=0; i!=nbEcosystems; ++i )
// {
// _Container[i].resize( nbFamilies );
// }
// }
//
// ///
// void insert( uint32 iEcosystem, uint32 iFamily, uint32 iCreature, TFaberInterestLevel level, const string& faberCombinationCode )
// {
// // nlassert( faberCombinationCode.size() == NB_FABERELEMS_CODE_CHARS );
// _Container[iEcosystem][iFamily][iCreature].push_back( CFaberCombination( level, faberCombinationCode ) );
// }
//
// ///
// void getFaberCombinationCodes( uint32 iEcosystem, uint32 iFamily, uint32 iCreature, vector<CFaberCombination> **codes )
// {
// map < uint32, vector< CFaberCombination > >::iterator im;
// /*nldebug( "%u %u -> %u cr (searching for %u)", iEcosystem, iFamily, _Container[iEcosystem][iFamily].size(), iCreature );
// for ( im=_Container[iEcosystem][iFamily].begin(); im!=_Container[iEcosystem][iFamily].end(); ++im )
// nldebug( "cr %u -- %u combinations", (*im).first, (*im).second.size() );*/
// im = _Container[iEcosystem][iFamily].find( iCreature );
// if ( im == _Container[iEcosystem][iFamily].end() )
// *codes = NULL;
// else
// *codes = &((im)->second);
// }
//
//private:
//
// /// Indexs: iEcosystem, iFamily, rCreatureSpecialization, rFaberCombination
// vector< vector < map < uint32, vector< CFaberCombination > > > > _Container;
//};
//void CSheetNameRepository::getFaberCombinationCodes( uint32 iEcosystem, uint32 iFamily, uint32 iCreature, vector<CFaberCombination> **codes )
//CSheetNameRepository RawMaterialRepository;
/**
* Characteristics.
* When adding a new characteristic, ADD IT INTO "v3_source_tables.xls!Item Parts v3"/"rm_item_parts.csv" and mark compatible item parts
*/
enum TFaberCharacteristic {
Durability, Weight, SapLoad, DMG, Speed, Range,
DodgeModifier, ParryModifier, AdversaryDodgeModifier, AdversaryParryModifier,
ProtectionFactor, MaxSlashProtect, MaxBluntProtect, MaxPierceProtect,
ECTF, EPF,
OACTF, OAPF,
HCTP, HPF,
DACTF, DAPF,
JewelProtection,
CraftCivSpec,
NbCharacs };
const char *sCharacs [NbCharacs] = {
"Durability", "Weight", "SapLoad", "DMG", "Speed", "Range",
"DodgeModifier", "ParryModifier", "AdversaryDodgeModifier", "AdversaryParryModifier",
"ProtectionFactor", "MaxSlashingProtection", "MaxBluntProtection", "MaxPiercingProtection",
"ElementalCastingTimeFactor", "ElementalPowerFactor",
"OffensiveAfflictionCastingTimeFactor", "OffensiveAfflictionPowerFactor",
"HealCastingTimeFactor", "HealPowerFactor",
"DefensiveAfflictionCastingTimeFactor", "DefensiveAfflictionPowerFactor",
"JewelProtectionType",
"CraftCivSpec" };
//const bool PositiveCharacs [NbCharacs] = { true, false, true, false, true, true };
//const float MinCharacValues [NbCharacs] = { 100, 0.1f, 10, 0.2f, 100, 0 };
//const float MaxCharacValues [NbCharacs] = { 500, 1.5f, 400, 2.0f, 500, 60 };
//const float PeakCharacValues [NbCharacs] = { 2000, 2.5f, 800, 5.0f, 2000, 80 };
bool PositiveCharacs [NbCharacs];
float MinCharacValues [NbCharacs];
float MaxCharacValues [NbCharacs];
float PeakCharacValues [NbCharacs];
vector<bool> CharacSlotFilter [NbCharacs]; // it's a positive filter
/*
*
*/
struct TFamInfo
{
vs Properties; // ex: propForA, propForB, propForC
CSString CompatibleCraftParts; // ex: ABC
vu CraftPartsByProp; // ex: 0, 1, 2 (indices in ompatibleCraftParts)
vector<TCiv> Civs; // ex: Fyros, All, All
vu Freqs; // ex: 1, 2, 2
TGroup Group;
bool IsActive; // False if not in rm_fam_prop.csv
bool IsInDeposits;
bool IsInCreatures;
CSString SpecialCreatureTag;
bool GenerateOnly;
bool IsForMission;
sint8 RemarkableStatIndex [NB_REMARKABLE_STAT_INDICES];
sint8 ColorIndex;
sint8 JewelProtIndex;
static uint UseGenerateOnly; // if 0, generate all; otherwise, generate only families that have GenerateOnly set to true
///
TFamInfo() : Group(~0), IsInDeposits(false), IsActive(false), IsInCreatures(false), SpecialCreatureTag(), GenerateOnly(false), IsForMission(false), ColorIndex(-1), JewelProtIndex(-1) {}
///
uint getCompatibleCraftPart( uint iCompatibleCP ) const
{
return (uint)(CompatibleCraftParts[iCompatibleCP] - 'A');
}
/// whichProp: index in Properties
uint getBeginCraftPartForProp( uint whichProp ) const
{
return CraftPartsByProp[whichProp];
}
/// whichProp: index in Properties
uint getEndCraftPartForProp( uint whichProp ) const
{
if ( whichProp == Properties.size()-1 )
return CompatibleCraftParts.size();
else
return CraftPartsByProp[whichProp+1];
}
/// whichProp: index in Properties
CSString getCraftPartForProp( uint whichProp ) const
{
uint start = getBeginCraftPartForProp( whichProp );
return CompatibleCraftParts.substr( start, getEndCraftPartForProp( whichProp ) - start );
}
/** With the returned index, you can get elt in Property, CraftPartsByProp, Civs and Freqs.
* Returns ~0 if not found.
*/
uint getPropIndexByCraftPart( char itemPart ) const
{
for ( uint i=0; i!=CraftPartsByProp.size(); ++i )
{
char itemPartCode [2];
itemPartCode[0] = itemPart;
itemPartCode[1] = '\0';
if ( getCraftPartForProp( i ).find( itemPartCode ) != string::npos )
return i;
}
return ~0;
}
///
bool existsInEcosystem( TEcosystem iEcosystem, TStatQuality statQuality ) const;
///
static bool mustGenerateFamily( uint iFamily );
};
const uint ITEM_PART_JEWEL_GEM = 17; // R
/*
*
*/
struct CFaberCharacteristics
{
/// Default constructor (for reading)
CFaberCharacteristics()
: FaberElement(~0), ActualEnergy(0.0f), ActualOriginality(0.0f)
{
for ( uint32 i=0; i!=NbCharacs; ++i )
Values[i] = 0.0f;
}
///
void serial( NLMISC::IStream& s )
{
s.serial( FaberElement );
s.serial( ActualEnergy );
s.serial( ActualOriginality );
for ( uint32 c=0; c!=NbCharacs; ++c )
s.serial( Values[c] );
}
///
void initFaberElement( uint32 rFaberElement ) { FaberElement = rFaberElement; }
/// Returns false if the RM must NOT be generated.
bool randomizeValues( TFaberInterestLevel interestLevel, TFaberInterestLevel nbInterestLevels, uint iVariant, float widthRatio, float peakOccurRatio, float baseBoost, TEcosystem iEcosystem, uint iFreq, uint iFamily );
/// Returns -1 if the RM must NOT be generated, otherwise return the stat average
sint32 computeValues( TStatQuality statQuality, const TFamInfo& famInfo, sint remarkableIndicesSetBaseIndex,
TEcosystem iEcosystem, uint iFreq, uint iFamily );
///
void calcQualitativeValues();
/// Index of faber element in "MpParam"
uint32 FaberElement;
/// Values
float Values [NbCharacs];
/// Average of the actual interest of the random values between 0 and 1
float ActualEnergy;
///
float ActualOriginality;
protected:
// Returns false if the RM must NOT be generated.
//bool randomizeJewelProtection( TStatQuality statQuality, TEcosystem iEcosystem, uint iFreq, uint iFamily );
void computeJewelProtection( TStatQuality statQuality, TEcosystem iEcosystem, uint iFamily );
};
//
void CFaberCharacteristics::calcQualitativeValues()
{
float actualInterests [NbCharacs];
// Calculate the average of ratio between [0,1]
float sumActualInterest = 0.0f;
uint nbCharacsUsed = 0;
for ( uint r=0; r!=NbCharacs; ++r )
{
if ( MaxCharacValues[r] == 0 )
continue;
if ( ! CharacSlotFilter[r][FaberElement] )
continue;
float interestRatio = (Values[r] / PeakCharacValues[r]); // new: Peak is taken as the max => the Energy is in [0..100]
if ( ! PositiveCharacs[r] )
interestRatio = 1.0f - interestRatio; // thus, can be negative
actualInterests[r] = interestRatio;
sumActualInterest += interestRatio;
++nbCharacsUsed;
}
if ( nbCharacsUsed == 0 )
return;
ActualEnergy = (sumActualInterest / (float)nbCharacsUsed);
if ( ActualEnergy > 1.0f )
ActualEnergy = 1.0f;
// Calculate the standard deviation (SQRT(SUM((Ai-Aavg)<29>)/N))
float varianceSum = 0.0f;
for ( uint r=0; r!=NbCharacs; ++r )
{
if ( MaxCharacValues[r] == 0 )
continue;
if ( ! CharacSlotFilter[r][FaberElement] )
continue;
varianceSum += sqr( actualInterests[r] - ActualEnergy );
}
// Don't normalize standard deviation, otherwise low energy materials will be considered more
// original (by average) than high energy materials. They wouldn't be comparable.
//if ( ActualEnergy != 0.0f )
ActualOriginality = (float)sqrt( (double)(varianceSum / (float)nbCharacsUsed) ); // / ActualEnergy;
//else
// nlinfo( "Null energy for craft slot %u", FaberElement );
}
/*
* Fill childrenToGet if rootNameForGetChildren is not null
*/
void fillFromDFN( UFormLoader *formLoader, map<string, CDfnFieldInfo>& dfnFields, UFormDfn *formDfn, const string& rootName, const string& dfnFilename,
const char *rootNameForGetChildren=NULL, vector<string>& childrenToGet=vector<string>() )
{
uint32 i;
for ( i=0; i!=formDfn->getNumEntry(); ++i )
{
string entryName, rootBase;
formDfn->getEntryName( i, entryName );
rootBase = rootName.empty() ? "" : (rootName+".");
UFormDfn::TEntryType entryType;
bool array;
formDfn->getEntryType( i, entryType, array );
switch ( entryType )
{
case UFormDfn::EntryVirtualDfn:
{
CSmartPtr<UFormDfn> subFormDfn = formLoader->loadFormDfn( (entryName + ".dfn").c_str() );
if ( ! subFormDfn )
nlwarning( "Can't load virtual DFN %s", entryName.c_str() );
else
fillFromDFN( formLoader, dfnFields, subFormDfn, rootBase + entryName, entryName + ".dfn", rootNameForGetChildren, childrenToGet ); // recurse
break;
}
case UFormDfn::EntryDfn: // .dfn
{
UFormDfn *subFormDfn;
if ( formDfn->getEntryDfn( i, &subFormDfn) )
{
string filename;
formDfn->getEntryFilename( i, filename );
fillFromDFN( formLoader, dfnFields, subFormDfn, rootBase + entryName, filename, rootNameForGetChildren, childrenToGet ); // recurse
}
if ( rootNameForGetChildren && (rootName == rootNameForGetChildren) )
{
childrenToGet.push_back( rootBase + entryName );
}
break;
}
case UFormDfn::EntryType: // .typ
{
vector<string> values, labels;
UType *subType;
if ( formDfn->getEntryType( i, &subType ) )
{
uint32 listSize = subType->getNumDefinition();
if ( listSize > 0 )
{
string label, value;
for ( uint32 j=0; j!=listSize; ++j )
{
subType->getDefinition( j, label, value );
if ( (subType->getIncrement() == "1") && (subType->getType() == UType::UnsignedInt || subType->getType() == UType::SignedInt) )
{
// Fill blank entry for skipped identifier values (to allow indexing by identifier value)
sint num = atoi( value.c_str() );
while ( num - (sint)values.size() > 0 )
{
values.push_back( "" );
labels.push_back( "" );
}
}
values.push_back( value );
labels.push_back( label );
}
}
}
dfnFields.insert( make_pair( rootBase + entryName, CDfnFieldInfo(values, labels) ) );
//nlinfo( "DFN entry: %s (in %s)", (rootBase + entryName).c_str(), dfnFilename.c_str() );
break;
}
}
}
}
/*
*
*/
CForm *loadTemplateForm( UFormLoader *formLoader, const string& sheetType )
{
CForm *form = (CForm*)formLoader->loadForm( (string("_empty.")+sheetType).c_str() );
if ( ! form )
nlerror( "Can't load sheet _empty.%s", sheetType.c_str() );
return form;
}
/*
*
*/
void eraseCarriageReturns( string& s )
{
const char CR = '\n';
string::size_type p = s.find( CR );
while ( (p=s.find( CR )) != string::npos )
s.erase( p, 1 );
}
/*
*
*/
string getNomenclatureCode( const string& longName, set<string>& usedCodes, uint32 nbLetters )
{
if ( nbLetters > longName.size() )
nlerror( "Wrong nbLetters for %s", longName.c_str() );
// Start with beginning of name
string code = strlwr(longName.substr( 0, nbLetters ));
uint32 i = nbLetters-1;
while ( usedCodes.find( code ) != usedCodes.end() )
{
++i;
if ( i < longName.size() )
{
// Substitute last code char by a char from the name (except ' ')
if ( longName[i] != ' ' )
code[nbLetters-1] = tolower(longName[i]);
else
continue;
}
else
{
// If no char from the name is suitable, increment the last char of the code until suitable
char c=1;
while ( usedCodes.find( code ) != usedCodes.end() )
{
code[nbLetters-1] = tolower(longName[nbLetters-1]) + c;
++c;
if ( code[1] > 'z' )
nlerror( "Impossible to make code for %s", longName.c_str() );
}
}
}
strlwr( code );
usedCodes.insert( code );
return code;
}
/*
* Displays mapping if title not null.
*/
void buildNomenclatureCodes( const char *title, const vector<string>& longNames, vector<string>& codes, uint32 nbLetters )
{
set<string> usedCodeSet;
uint32 i;
for ( i=0; i!=longNames.size(); ++i )
{
codes[i] = getNomenclatureCode( longNames[i], usedCodeSet, nbLetters );
if ( title )
nlinfo( "%s %s -> %s", title, longNames[i].c_str(), codes[i].c_str() );
//DebugLog->displayRawNL( "%s", longNames[i].c_str() );
}
}
/*
* Set the size of a family code to NB_FAMILY_CODE_CHARS
*/
void normalizeFamilyCode( std::string& s )
{
if ( s.size() > NB_FAMILY_CODE_CHARS )
{
nlerror( "Family codes limited to %u chars (%s)", NB_FAMILY_CODE_CHARS, s.c_str() );
}
else
{
uint p = s.size();
while ( p < NB_FAMILY_CODE_CHARS )
{
s = "0" + s;
++p;
}
}
}
/*
*
*/
void loadNomenclatureCodes( const char *title, const vector<string>& longNames, vector<string>& codes, const char *filename )
{
if ( longNames.empty() )
{
nlwarning( "No nomenclature codes to load. %s", title ? title : "" );
return;
}
codes.resize( longNames.size() );
char lineBuffer[2048];
FILE *rulesFile;
const char *SEPARATOR = ";";
vector<string> args;
vector<string>::iterator iarg;
vector<string>::const_iterator ivs;
if ( (rulesFile = fopen( filename, "r" )) == NULL )
{
nlwarning( "Can't find file %s", filename );
}
else
{
while ( ! feof(rulesFile) )
{
// Get from file
fgets( lineBuffer, 2048, rulesFile );
explode( lineBuffer, SEPARATOR, args );
// Get rid of carriage returns!
for ( iarg=args.begin(); iarg!=args.end(); ++iarg )
{
eraseCarriageReturns( *iarg );
}
// Read
const uint32 MIN_COLS = 6;
const uint32 NAME_COL = 4;
const uint32 C_COL = 2;
const uint32 R_COL = 3;
const uint32 NB_CODE_CHARS = 2;
if ( (args.size()>=MIN_COLS) && (! args[0].empty()) && (args[0].find( "name" )==string::npos) ) // skip blank lines, and lines with blank header or "name" in the first column
{
if ( args[NAME_COL].empty() )
continue;
ivs = find( longNames.begin(), longNames.end(), args[NAME_COL] );
if ( ivs == longNames.end() )
nlwarning( "Name %s is not in the names array", args[NAME_COL].c_str() );
else
{
string code = args[C_COL] + args[R_COL];
if ( code.size() < NB_CODE_CHARS )
{
nlwarning( "Invalid partial code for %s: %s", (*ivs).c_str(), code.c_str() );
continue;
}
else if ( code.size() > NB_CODE_CHARS )
{
nlinfo( "Compacting code '%s' for %s", code.c_str(), (*ivs).c_str() );
string::size_type p;
while ( (p = code.find( ' ' )) != string::npos )
{
code.erase( p, 1 );
}
}
if ( codes[ivs-longNames.begin()].empty() )
{
if ( title )
nlinfo( "%s %s -> %s", title, (*ivs).c_str(), code.c_str() );
codes[ivs-longNames.begin()] = code;
}
else
{
if ( code != codes[ivs-longNames.begin()] )
nlwarning( "Invalid nomenclature: (%s and %s for %s: ", codes[ivs-longNames.begin()].c_str(), code.c_str(), (*ivs).c_str() );
}
}
}
}
for ( ivs=codes.begin(); ivs!=codes.end(); ++ivs )
{
if ( (*ivs).empty() )
nlwarning( "No code found for %s", (*(longNames.begin() + (ivs - codes.begin()))).c_str() );
}
}
}
/*
*
*/
inline sint getLastUsedPropertySlot( uint32 *iProperties, sint lastPropertySlot, uint32 undefinedProperty )
{
for ( sint r=lastPropertySlot; r>=0; --r )
{
if ( iProperties[r] != undefinedProperty )
return r;
}
return -1;
}
/*
*
*/
inline bool passNegativeFilter( const vector<uint32>& incompatibilityList, uint32 iValue )
{
vector<uint32>::const_iterator ip = find( incompatibilityList.begin(), incompatibilityList.end(), iValue );
return (ip == incompatibilityList.end());
}
/*
*
*/
inline bool passPositiveFilter( const vector<uint32>& compatibilityList, uint32 iValue )
{
vector<uint32>::const_iterator ip = find( compatibilityList.begin(), compatibilityList.end(), iValue );
return (ip != compatibilityList.end());
}
/*
* Reject a prop if it is in the incompatibility list of a family
*/
bool passPropFamilyFilter( const vector<uint32>& iFamilyRelatedProperties, uint32 iProp )
{
return passNegativeFilter( iFamilyRelatedProperties, iProp );
}
/*
* Reject a creature if NOT in the creature list of a family
*/
/*bool passCreatureFilter( const vector<uint32>& iFamilyRelatedCreatures, uint32 iCreature )
{
//nldebug( "%u related creatures, %s", iFamilyRelatedCreatures.size(), passPositiveFilter( iFamilyRelatedCreatures, iCreature ) ? "TRUE": "FALSE" );
return passPositiveFilter( iFamilyRelatedCreatures, iCreature );
}*/
/*
*
*/
class CStrIComparator : public binary_function<string, string, bool>
{
public:
bool operator() ( const string& s1, const string& s2 ) const
{
return (nlstricmp( s1, s2 ) == 0);
}
};
/*
*
*/
void displayList( const vector<string>& v, CLog *log=DebugLog )
{
vector<string>::const_iterator ist;
for ( ist=v.begin(); ist!=v.end(); ++ist )
log->displayRaw( "%s ", (*ist).c_str() );
log->displayRawNL( "" );
}
/*
*
*/
uint32 getIndexFromString( const string& s, const vector<string>& v, bool displayWarning=true )
{
if ( v.empty() )
{
if ( displayWarning )
nlwarning( "Can't find '%s' in empty array", s.c_str() );
return ~0;
}
else
{
vector<string>::const_iterator ist = find_if( v.begin(), v.end(), bind2nd(CStrIComparator(), s) );
if ( ist == v.end() )
{
if ( displayWarning )
{
nlwarning( "Can't find '%s' in:", s.c_str() );
displayList( v, WarningLog );
}
return ~0;
}
else
return ist - v.begin();
}
}
/*
*
*/
uint32 getIndexFromString( const string& s, const char **array, uint arraySize, bool displayWarning=true )
{
if ( arraySize == 0 )
{
if ( displayWarning )
nlwarning( "Can't find '%s' in empty array", s.c_str() );
return ~0;
}
else
{
for ( uint i=0; i!=arraySize; ++i )
{
if ( strlwr(string(array[i])) == strlwr(s) )
return i;
}
if ( displayWarning )
{
nlwarning( "Can't find '%s' in:", s.c_str() );
//displayList( v, WarningLog );
}
return ~0;
}
}
/*
* Returns the index of the erased element, ~0 if not found
*/
uint32 removeEntryFromList( vector<string>& v, const string& entry )
{
vector<string>::iterator ivs;
ivs = find( v.begin(), v.end(), entry );
uint32 index;
if ( ivs != v.end() )
{
index = ivs - v.begin();
v.erase( ivs );
return index;
}
else
return ~0;
}
/*
*
*/
bool removeEntryFromListByIndex( vector<string>& v, uint32 index )
{
if ( index < v.size() )
{
v.erase( v.begin() + index );
return true;
}
else
return false;
}
typedef void (*TMapDeliveryCallback) ( mss& );
typedef void (*TVectorDeliveryCallback) ( vs& );
/*
*
*/
void loadCSVFile( const char *filename, TMapDeliveryCallback deliveryCallback, bool firstColWithoutName=false )
{
char lineBuffer[2048];
FILE *file;
const char *SEPARATOR = ";";
vector<string> args;
vector<string>::iterator iarg;
if ( (file = fopen( filename, "r" )) == NULL )
{
nlwarning( "Can't find file %s", filename );
}
else
{
// Read first line as header with column names
lineBuffer[0] = '\0';
fgets( lineBuffer, 2048, file );
explode( lineBuffer, SEPARATOR, args );
// Store column names (and get rid of carriage returns!)
vector < string > columnNames;
mss valuesByName;
for ( iarg=args.begin(); iarg!=args.end(); ++iarg )
{
if ( firstColWithoutName && (iarg == args.begin()) )
{
*iarg = "<>"; // override column name for the 1st column
}
eraseCarriageReturns( *iarg );
columnNames.push_back( *iarg );
valuesByName.insert( make_pair( *iarg, string("") ) );
}
while ( ! feof(file) )
{
// Get from file
lineBuffer[0] = '\0';
fgets( lineBuffer, 2048, file );
explode( lineBuffer, SEPARATOR, args );
// Set values (and get rid of carriage returns!)
for ( iarg=args.begin(); iarg!=args.end(); ++iarg )
{
eraseCarriageReturns( *iarg );
valuesByName[columnNames[iarg-args.begin()]] = *iarg;
}
// Deliver the wanted fields
deliveryCallback( valuesByName );
}
}
}
/*
*
*/
void loadCSVFile( const char *filename, TVectorDeliveryCallback deliveryCallback )
{
char lineBuffer[2048];
FILE *file;
const char *SEPARATOR = ";";
vs args;
vs::iterator iarg;
if ( (file = fopen( filename, "r" )) == NULL )
{
nlwarning( "Can't find file %s", filename );
}
else
{
while ( ! feof(file) )
{
// Get from file
lineBuffer[0] = '\0';
fgets( lineBuffer, 2048, file );
explode( lineBuffer, SEPARATOR, args );
// Get rid of carriage returns!
for ( iarg=args.begin(); iarg!=args.end(); ++iarg )
{
eraseCarriageReturns( *iarg );
}
// Deliver the wanted fields
deliveryCallback( args );
}
}
}
/*
*
*/
void loadValueFile( const char *filename, const vector<string>& keyStrings,
vector<sint>& contents, sint defaultValue )
{
nlassert( keyStrings.size() == contents.size() );
char lineBuffer[2048];
FILE *rulesFile;
const char *SEPARATOR = ";";
vector<string> args;
vector<string>::iterator iarg;
if ( (rulesFile = fopen( filename, "r" )) == NULL )
{
nlwarning( "Can't find file %s", filename );
}
else
{
while ( ! feof(rulesFile) )
{
// Get from file
lineBuffer[0] = '\0';
fgets( lineBuffer, 2048, rulesFile );
explode( lineBuffer, SEPARATOR, args );
// Get rid of carriage returns!
for ( iarg=args.begin(); iarg!=args.end(); ++iarg )
{
eraseCarriageReturns( *iarg );
}
// Read
if ( (! args.empty()) && (! args[0].empty()) ) // skip blank lines, and lines with blank header
{
sint value = defaultValue;
for ( uint32 a=0; a!=args.size()-1; ++a )
{
if ( ! args[a+1].empty() ) // skip blank entries
value = atoi( args[a+1].c_str() );
}
uint32 index = getIndexFromString( args[0], keyStrings );
if ( index != ~0 )
{
contents[index] = value;
}
}
}
fclose( rulesFile );
}
}
/*
*
*/
void loadRulesFile( const char *filename, const vector<string>& keyStrings,
const vector<string>& contentStrings, CRulesFilter& filter,
const string& matchExtKeyAtFirstColumn=string() )
{
char lineBuffer[2048];
FILE *rulesFile;
const char *SEPARATOR = ";";
uint32 firstColumn = matchExtKeyAtFirstColumn.empty() ? 0 : 1;
vector<string> args;
vector<string>::iterator iarg;
if ( (rulesFile = fopen( filename, "r" )) == NULL )
{
nlwarning( "Can't find file %s", filename );
}
else
{
while ( ! feof(rulesFile) )
{
// Get from file
lineBuffer[0] = '\0';
fgets( lineBuffer, 2048, rulesFile );
explode( lineBuffer, SEPARATOR, args );
// Get rid of carriage returns!
for ( iarg=args.begin(); iarg!=args.end(); ++iarg )
{
eraseCarriageReturns( *iarg );
}
// Match with ext key string if set
if ( (! matchExtKeyAtFirstColumn.empty()) && (args[0]!=matchExtKeyAtFirstColumn) )
continue;
// Read
if ( (! args.empty()) && (! args[firstColumn].empty()) ) // skip blank lines, and lines with blank header
{
vector<uint32> contents;
for ( uint32 a=firstColumn; a!=args.size()-1; ++a )
{
if ( ! args[a+1].empty() ) // skip blank entries
contents.push_back( getIndexFromString( args[a+1], contentStrings ) );
}
filter.insert( make_pair( getIndexFromString( args[firstColumn], keyStrings ), contents ) );
}
}
fclose( rulesFile );
}
}
/*
* 1st column: extKeyStrings (corresponding to the filters 'vector'); 2nd: keyStrings
*/
void loadRulesFileMulti( const char *filename, const vector<string>& extKeyStrings, const vector<string>& keyStrings, const vector<string>& contentStrings, vector<CRulesFilter>& filters )
{
filters.resize( extKeyStrings.size() );
for ( uint32 i=0; i!=filters.size(); ++i )
{
loadRulesFile( filename, keyStrings, contentStrings, filters[i], extKeyStrings[i] );
/*CRulesFilter::const_iterator irf;
nldebug( "%s", extKeyStrings[i].c_str() );
for ( irf=filters[i].begin(); irf!=filters[i].end(); ++irf )
{
nldebug( "%s", keyStrings[(*irf).first].c_str() );
vector<uint32>::const_iterator ivi;
for ( ivi=(*irf).second.begin(); ivi!=(*irf).second.end(); ++ivi )
{
nldebug( "%u", *ivi );
}
}*/
}
}
/*
* Clear the form to reuse it (and all contents below node)
*/
void clearSheet( CForm *form, UFormElm* node )
{
((CFormElm*)node)->clean();
form->clean();
}
/*
* Saves to disk if bool WriteSheetsToDisk is true
*/
void flushSheetToDisk( const string& fullFilename, UForm *form )
{
if ( WriteSheetsToDisk )
{
COFile output( fullFilename );
form->write( output, false );
}
}
/*
*
*/
string::size_type findCapital( const string& s, string::size_type startPos )
{
string::size_type p;
for ( p=startPos; p!=s.size(); ++p )
{
if ( (s[p] >= 'A') && (s[p] <= 'Z') )
return p;
}
return string::npos;
}
/*
* Transform "MyString " into "My string"
*/
void detachValue( string& s )
{
if ( s.size() < 2 )
return;
string::size_type p;
while ( (p = findCapital( s, 1 )) != string::npos )
{
s.insert( p, " " );
s[p+1] = tolower( s[p+1] );
}
// Rip off any blank at the end
if ( s[s.size()-1] == ' ' )
{
s.resize( s.size()-1 );
}
}
/*
*
*/
void getTransposedMap( CRulesFilter& dest, const CRulesFilter& src )
{
CRulesFilter::const_iterator im;
for ( im=src.begin(); im!=src.end(); ++im )
{
vector<uint32>::const_iterator iv;
for ( iv=(*im).second.begin(); iv!=(*im).second.end(); ++iv )
{
dest[*iv].push_back( (*im).first );
}
}
}
/*
*
*/
string makeFaberElementCode( uint32 iFaberElement, TFaberInterestLevel level, TFaberInterestLevel nbInterestLevels )
{
return toString( "%c%d", 'a' + iFaberElement, getNomenclaturedInterestLevel( level, nbInterestLevels ) );
}
/*
*
*/
inline bool hasMatchingFaberLevel( TFaberInterestLevel storedLevel, TFaberInterestLevel submittedLevel )
{
return storedLevel <= submittedLevel;
}
/*
*
*/
//void keepOnlyHighestLevel( vector<CFaberCombination*>& codes )
//{
// nlassert( ! codes.empty() );
// sint maxLevel = -1;
// uint32 i;
// for ( i=0; i!=codes.size(); ++i )
// {
// if ( codes[i]->FirstLevel > maxLevel )
// {
// maxLevel = codes[i]->FirstLevel;
// }
// }
// vector<CFaberCombination*> remainingCodes;
// for ( i=0; i!=codes.size(); ++i )
// {
// if ( codes[i]->FirstLevel == maxLevel )
// remainingCodes.push_back( codes[i] );
// }
//
// //nldebug( "%u codes, highest level = %u with %u occurences", codes.size(), maxLevel, remainingCodes.size() );
// //nlassert( remainingCodes.size() <= codes.size() );
// codes = remainingCodes;
// nlassert( ! codes.empty() );
//}
/*
*
*/
bool allIncludedIn( const vu& subset, const vu& bigset )
{
vu::const_iterator iv;
for ( iv=subset.begin(); iv!=subset.end(); ++iv )
{
if ( find( bigset.begin(), bigset.end(), *iv ) == bigset.end() )
return false;
}
return true;
}
/*
*
*/
void loadConfigFlag( CConfigFile& configFile, const char *varTitle, bool &flag )
{
CConfigFile::CVar *var = configFile.getVarPtr( varTitle );
if ( var )
flag = (var->asInt() == 1);
}
/*
*
*/
string::size_type getCapitalFromPos( const string& s, string::size_type startPos )
{
//nldebug( "%s %u", s.c_str(), startPos );
string::size_type p;
for ( p=startPos; p<s.size(); ++p )
{
if ( (s[p] >= 'A') && (s[p] <= 'Z') )
return p;
}
return string::npos;
}
/*
* Also used to make system_mp filenames.
* Converts "My Identifier" or "MyIdentifier" to "my_identifier" ("My identifier" to "Myidentifier")
*/
string conventionalDirectory( const string& dirname )
{
if ( dirname.empty() )
return "";
string result = dirname;
// Remove blanks
string::size_type p = 0;
while ( (p = result.find( ' ' )) != string::npos )
{
result.erase( p, 1 );
}
// Convert capitals to underscores
result[0] = tolower( result[0] );
p = 1;
while ( (p = getCapitalFromPos( result, p )) != string::npos )
{
result.insert( p, "_" );
++p;
result[p] = tolower( result[p] );
}
return result;
}
mss UniqueRMNamesAndSheetCodeHead;
/*
*
*/
void readRMNames( mss& values )
{
string& name = values["basics.name"];
if ( ! name.empty() )
{
string radix = values["FILE"].substr( 0, 5 );
UniqueRMNamesAndSheetCodeHead.insert( make_pair( name, radix ) );
}
}
/*
*
*/
void loadTitles( const string& sourceWords, const string& sourceBase, const string& languageCode, CTitles& dest )
{
STRING_MANAGER::TWorksheet worksheet;
STRING_MANAGER::loadExcelSheet( TranslationPath + sourceBase + "/" + sourceWords + "_words_" + languageCode + ".txt", worksheet );
uint cp, cn, nbTitles = 0;
if ( worksheet.findCol( ucstring(sourceWords + " ID"), cp ) && worksheet.findCol( ucstring("name"), cn ) )
{
for ( std::vector<STRING_MANAGER::TWorksheet::TRow>::iterator ip = worksheet.begin(); ip!=worksheet.end(); ++ip )
{
if ( ip == worksheet.begin() ) // skip first row
continue;
STRING_MANAGER::TWorksheet::TRow& row = *ip;
dest.insert( make_pair( row[cp].toString(), row[cn].toUtf8() ) );
++nbTitles;
}
}
else
nlwarning( "%s ID or name not found", sourceWords.c_str() );
nlinfo( "Loaded %u %s titles", nbTitles, sourceWords.c_str() );
}
/*
*
*/
void extractRawMaterialNames()
{
loadCSVFile( ExtractNamesCsv.c_str(), readRMNames );
FILE *output = fopen( (CFile::getFilenameWithoutExtension( ExtractNamesCsv ) + "_output.csv").c_str(), "wt" );
fprintf( output, "Code;Name\n" );
for ( mss::const_iterator iun=UniqueRMNamesAndSheetCodeHead.begin(); iun!=UniqueRMNamesAndSheetCodeHead.end(); ++iun )
{
const string& codeRadix = (*iun).second;
const string& name = (*iun).first;
fprintf( output, "%s;%s\n", codeRadix.c_str(), name.c_str() );
}
}
/*
*
*/
void cleanExteriorWhitespace( vs& line )
{
for ( vs::iterator it=line.begin(); it!=line.end(); ++it )
{
CSString& s = (*it);
string::size_type p;
for ( p=0; p!=s.size(); ++p )
{
if ( s[p] != ' ' )
break;
}
if ( (p != 0) && (p != s.size()) )
s = s.substr( p );
for ( p=0; p!=s.size(); ++p )
{
if ( s[s.size()-1-p] != ' ' )
break;
}
if ( (p != 0) && (p != s.size()) )
s = s.rightCrop( p );
}
}
uint TFamInfo::UseGenerateOnly = 0;
// Only used for deposits; for creature, works with the creature sheets found
/*bool TFamInfo::existsInEcosystem( TEcosystem iEcosystem, TStatQuality statQuality ) const
{
switch ( iEcosystem )
{
case CommonEcosystem: // The Common rm exists if the rm family has a freq=2 (or 0 but only in Supreme)
return ( (find( Freqs.begin(), Freqs.end(), 2 ) != Freqs.end())
|| ((find( Freqs.begin(), Freqs.end(), 0 ) != Freqs.end()) && (statQuality == Supreme)) );
// was: find_if ... bind2nd( equals<uint>(), 1 )
break;
case PrimeRoots: // Only freq 1 families exist if the PrimeRoots
return find( Freqs.begin(), Freqs.end(), 1 ) != Freqs.end();
break;
default: // A rm family exists in the ecosystem matching a civ if the corresponding freq is 1 or 3
{
uint iCiv = getIndexFromString( ecosystemCodes[iEcosystem], CivEcosystemCodes, NbCiv, false );
vector<TCiv>::const_iterator it = find( Civs.begin(), Civs.end(), (TCiv)iCiv );
if ( it != Civs.end() )
return (Freqs[it-Civs.begin()] == 1) || (Freqs[it-Civs.begin()] == 3);
else
return false;
}
}
}*/
// Only used for deposits;
bool TFamInfo::existsInEcosystem( TEcosystem iEcosystem, TStatQuality statQuality ) const
{
if ( find( Freqs.begin(), Freqs.end(), 0 ) != Freqs.end() )
{
// Freq 0 => only Common/Supreme
return (statQuality == Supreme) && (iEcosystem == CommonEcosystem);
}
else if ( statQuality <= Fine )
{
// Basic, Fine => Common
return (iEcosystem == CommonEcosystem);
}
else
{
// Choice to Supreme => One per ecosystem
return (iEcosystem != CommonEcosystem) && (iEcosystem < NbEcosystems);
}
}
/*
*
*/
struct TCraftPartInfo
{
CSString Name;
CSString Path;
uint8 PartIndex;
bool Enabled;
};
/*
*
*/
class CCraftParts
{
public:
///
CCraftParts() : CraftParts( NbFaberElements )
{
for ( uint i=0; i!=NbFaberElements; ++i )
{
CraftParts[i].PartIndex = i;
CraftParts[i].Enabled = false;
}
}
///
void registerPartChars( const CSString& parts )
{
for ( string::size_type p=0; p!=parts.size(); ++p )
{
uint index = (uint)(parts[p] - 'A');
CraftParts[index].Enabled = true;
}
}
///
bool isEnabled( uint index ) const
{
return CraftParts[index].Enabled;
}
///
void getNamesAndPaths( const vector<string>& paths )
{
uint i = 0;
vector<string>::const_iterator ip;
for ( ip=paths.begin(); ip!=paths.end(); ++ip )
{
if ( i >= CraftParts.size() )
nlerror( "Mismatch between sitem DFN and constant (nb of craft parts)" );
CraftParts[i].Path = (*ip);
string::size_type p = (*ip).rfind( '.' ) + 1; // string::npos+1 gives 0
CraftParts[i].Name = (*ip).substr( p );
nldebug( "%u: %s", ip-paths.begin(), CraftParts[i].Name.c_str() );
++i;
}
}
///
TCraftPartInfo& operator[] ( uint index ) { return CraftParts[index]; }
vector< TCraftPartInfo > CraftParts;
};
typedef map<CSString, TFamInfo, CUnsensitiveSStringLessPred > CFamMap;
CFamMap FamSet;
CCraftParts CraftParts;
enum TFamAndPropLine {
LFam, LGroup, LCraftParts, LCiv, LFreq, LLoc,
LIconMain, LIconBk, LIconOv1, LIconOv2, LIconSpecial,
LCraftPlans, LGenerateOnly,
LBaseOfRemarkableStatIndices,
LColorIndex = LBaseOfRemarkableStatIndices + NB_REMARKABLE_STAT_INDICES,
LJewelProtIndex,
NbFamAndPropCols };
// static
bool TFamInfo::mustGenerateFamily( uint iFamily )
{
if ( families[iFamily].empty() )
return false;
else if ( ! TFamInfo::UseGenerateOnly )
return true;
else
{
TFamInfo& famInfo = FamSet[families[iFamily]];
return ( famInfo.GenerateOnly );
}
}
/*
*
*/
CSString getShortFaberElemString( uint rFaberElem )
{
string& longString = CraftParts[rFaberElem].Name;
return reinterpret_cast<CSString&>(longString.substr( longString.find( "(" ) + 1 )).rightCrop( 1 );
}
/*
*
*/
TCiv getCivFromStr( const CSString& civStr )
{
if ( civStr.empty() )
return AllCiv;
else
{
for ( uint i=0; i!=NbCiv; ++i )
{
if ( civStr == CSString(CivNames[i]) )
return (TCiv)i;
}
nlwarning( "Unknown civ '%s'", civStr.c_str() );
return AllCiv;
}
}
/*
*
*/
uint getFreqFromStr( const CSString& freqStr )
{
uint f = atoi( freqStr.c_str() );
if ( (f < 1) && (f > 5) )
nlwarning( "Unknown freq '%s'", freqStr.c_str() );
return f;
}
/*
* Returns ~0 if s is empty
*/
TGroup getNewOrExistingGroupFromStr( const CSString& s )
{
uint i = getIndexFromString( s, groups, false );
if ( i == ~0 )
{
if ( s.empty() )
return ~0;
else
{
i = groups.size();
groups.push_back( s );
nlinfo( "New group: %s (%u)", s.c_str(), i );
}
}
return i;
}
/*
*
*/
void deliverFamAndProp( vs& line )
{
if ( line.size() < NbFamAndPropCols )
line.resize( NbFamAndPropCols );
cleanExteriorWhitespace( line );
if ( line[LFam].empty() )
{
// Load special icons
if ( (line.size() >= LIconSpecial+1) && (! line[LIconSpecial].empty()) && (line[LIconMain].empty()) )
{
/*if ( line.size() >= LIconMain+1 )
Icons[line[LIconSpecial]].Icon = line[LIconMain];*/
if ( line.size() >= LIconBk+1 )
Icons[line[LIconSpecial]].IconBackground = line[LIconBk];
if ( line.size() >= LIconOv1+1 )
Icons[line[LIconSpecial]].IconOver = line[LIconOv1];
}
return;
}
// Load icons of families
if ( line.size() >= LIconMain+1 )
{
Icons[line[LFam]].Icon = line[LIconMain];
if ( ! line[LGroup].empty() )
{
// For group, set icon of first family of group found! (for forage source knowledge)
if ( Icons.find( line[LGroup] ) == Icons.end() )
{
Icons[line[LGroup]].Icon = line[LIconMain];
}
}
}
if ( line.size() >= LIconBk+1 )
Icons[line[LFam]].IconBackground = line[LIconBk];
if ( line.size() >= LIconOv1+1 )
Icons[line[LFam]].IconOver = line[LIconOv1];
TFamInfo& famInfo = FamSet[line[LFam]];
famInfo.IsActive = true;
/*if ( ! line[LCraftParts].empty() )
{
// Store by property (line[LProp])
famInfo.Properties.push_back( line[LProp] );
famInfo.CraftPartsByProp.push_back( famInfo.CompatibleCraftParts.size() ); // beginning of craft parts chars
famInfo.CompatibleCraftParts += line[LCraftParts];
CraftParts.registerPartChars( line[LCraftParts] );
famInfo.Civs.push_back( getCivFromStr( line[LCiv] ) );
famInfo.Freqs.push_back( getFreqFromStr( line[LFreq] ) );
famInfo.IsInDeposits = line[LLoc].contains( "D" );
famInfo.IsInCreatures = line[LLoc].contains( "C" );
if ( ! (famInfo.IsInDeposits || famInfo.IsInCreatures) )
nlwarning( "Unknown loc for %s", line[LFam].c_str() );
}*/
for ( string::size_type p=0; p!=line[LCraftParts].size(); ++p )
{
// Store by property = craft part (each char of line[LCraftParts])
CSString craftPart = string( 1, line[LCraftParts][p]);
famInfo.Properties.push_back( craftPart );
famInfo.CraftPartsByProp.push_back( famInfo.CompatibleCraftParts.size() );
famInfo.CompatibleCraftParts += craftPart;
CraftParts.registerPartChars( craftPart );
famInfo.Civs.push_back( getCivFromStr( line[LCiv] ) );
famInfo.Freqs.push_back( getFreqFromStr( line[LFreq] ) );
}
if ( line[LCraftParts].empty() )
{
famInfo.Freqs.push_back( getFreqFromStr( line[LFreq] ) ); // freq needed for Rarity computation
}
famInfo.Group = getNewOrExistingGroupFromStr( line[LGroup] );
famInfo.IsInDeposits = line[LLoc].contains( "D" );
famInfo.IsInCreatures = line[LLoc].contains( "C" );
if ( ! (famInfo.IsInDeposits || famInfo.IsInCreatures) )
{
famInfo.SpecialCreatureTag = line[LLoc];
if ( (famInfo.SpecialCreatureTag[0] != 'G') && (famInfo.SpecialCreatureTag[0] != 'I') )
nlwarning( "Unknown loc %s for %s", line[LLoc].c_str(), line[LFam].c_str() );
}
famInfo.IsForMission = line[LCraftParts].empty();
for ( uint i=0; i!=NB_REMARKABLE_STAT_INDICES; ++i )
{
if ( line[LBaseOfRemarkableStatIndices+i].empty() && (! line[LCraftParts].empty()) && (line[LFreq] != "0") )
nlerror( "%s has empty stat index %u", line[LFam].c_str(), i );
famInfo.RemarkableStatIndex[i] = atoi( line[LBaseOfRemarkableStatIndices+i].c_str() );
}
if ( ! line[LColorIndex].empty() )
famInfo.ColorIndex = atoi( line[LColorIndex].c_str() );
if ( ! line[LJewelProtIndex].empty() )
famInfo.JewelProtIndex = atoi( line[LJewelProtIndex].c_str() );
bool markedForGeneration = (line[LGenerateOnly] == "X");
if ( (!markedForGeneration) && famInfo.GenerateOnly )
{
nlwarning( "Found duplicate family line with different GenerateOnly setting" );
}
else
{
famInfo.GenerateOnly = markedForGeneration;
}
if ( famInfo.GenerateOnly )
++TFamInfo::UseGenerateOnly;
}
typedef map< TGroup, set<uint32> > CGroupMap;
/*
*
*/
void loadFamAndProp( const string& filename, bool displayAll )
{
loadCSVFile( filename.c_str(), deliverFamAndProp );
if ( displayAll )
{
set<CSString, CUnsensitiveSStringLessPred> propSet;
CGroupMap groupMap;
/// Generate contents of item_mp_family.typ (and fill group map)
nlinfo( "item_mp_family.typ:" );
InfoLog->displayRawNL( "<DEFINITION Label=\"Undefined\" Value=\"0\"/>" );
uint i = 1;
for ( CFamMap::iterator iss=FamSet.begin(); iss!=FamSet.end(); ++iss )
{
const CSString& famStr = (*iss).first;
TFamInfo& famInfo = (*iss).second;
InfoLog->displayRawNL( "<DEFINITION Label=\"%s\" Value=\"%u\"/>", famStr.c_str(), i );
// Get info about props and group
for ( vs::iterator ip=famInfo.Properties.begin(); ip!=famInfo.Properties.end(); ++ip )
{
propSet.insert( *ip );
}
groupMap[ famInfo.Group ].insert( i ); // ~0 is for "no group" (creature's RMs only)
++i;
}
/*
/// Generate family-specialized forage search bricks (TODO)
nlinfo( "Family-specialized forage search bricks:");
i = 1;
for ( CGroupMap::iterator igm=groupMap.begin(); igm!=groupMap.end(); ++igm )
{
CSString skill = toString( "SHFM%u", i );
CSString rmgrpBrickCode = toString( "BHFPMB%02u", i );
CSString rmfamBrickFamCode = "BHFPMI" + string( 1, (char)'A' + ((char)(i-1)) );
uint j = 1;
for ( set<uint32>:::iterator ifs=(*igm).begin(); ifs!=(*igm).end(); ++ifs )
{
// TODO: modifier of modifier
CSString brickCode = rmfamBrickFamCode + toString( "%02u", j );
InfoLog->displayRawNL( "%s\t80\t%s\t%u\t\t%s\t\tFG_RMFAM_FILT: %u\t", brickCode.c_str(), rmgrpBrickCode.c_str(), j, skill.c_str(), (*ifs) );
++j;
}
}
/// Generate family-specialized forage search phrases (TODO)
nlinfo( "Family-specialized forage search phrases:");
i = 1;
for ( CFamMap::iterator iss=FamSet.begin(); iss!=FamSet.end(); ++iss )
{
const CSString& famStr = (*iss).first;
TFamInfo& famInfo = (*iss).second;
InfoLog->displayRawNL( "<DEFINITION Label=\"%s\" Value=\"%u\"/>", famStr.c_str(), i );
}
/// Generate family-specialized forage extraction bricks (TODO)
nlinfo( "Family-specialized forage extraction bricks:");
i = 1;
for ( CFamMap::iterator iss=FamSet.begin(); iss!=FamSet.end(); ++iss )
{
const CSString& famStr = (*iss).first;
TFamInfo& famInfo = (*iss).second;
InfoLog->displayRawNL( "<DEFINITION Label=\"%s\" Value=\"%u\"/>", famStr.c_str(), i );
++i;
}
/// Generate family-specialized forage extraction phrases (TODO)
nlinfo( "Family-specialized forage extraction phrases:");
i = 1;
for ( CFamMap::iterator iss=FamSet.begin(); iss!=FamSet.end(); ++iss )
{
const CSString& famStr = (*iss).first;
TFamInfo& famInfo = (*iss).second;
InfoLog->displayRawNL( "<DEFINITION Label=\"%s\" Value=\"%u\"/>", famStr.c_str(), i );
++i;
}*/
/// Generate item_mp_property.typ
nlinfo( "Item parts as props:" );
InfoLog->displayRawNL( "<DEFINITION Label=\"Undefined\" Value=\"0\"/>" );
i = 1;
for ( set<CSString, CUnsensitiveSStringLessPred>::iterator iss=propSet.begin(); iss!=propSet.end(); ++iss )
{
InfoLog->displayRawNL( "<DEFINITION Label=\"%s\" Value=\"%u\"/>", (*iss).c_str(), i );
++i;
}
/// Generate item_mp_group.typ
nlinfo( "Groups:" );
InfoLog->displayRawNL( "<DEFINITION Label=\"Undefined\" Value=\"0\"/>" );
i = 1;
for ( CGroupMap::iterator igm=groupMap.begin(); igm!=groupMap.end(); ++igm )
{
if ( (*igm).first != ~0 )
{
InfoLog->displayRawNL( "<DEFINITION Label=\"%s\" Value=\"%u\"/>", (groups[(*igm).first]).c_str(), i );
++i;
}
}
/*
/// Generate group-specialized forage search bricks (TODO)
nlinfo( "Group-specialized forage search bricks:");
i = 1;
for ( CGroupMap::iterator igm=groupMap.begin(); igm!=groupMap.end(); ++igm )
{
CSString skill = toString( "SHFM%u", i );
CSString rmgrpBrickCode = toString( "BHFPMB%02u", i );
++i;
}
/// Generate group-specialized forage search phrases
nlinfo( "Group-specialized forage search phrases:");
i = 1;
for ( set<CSString, CUnsensitiveSStringLessPred>::iterator iss=groupSet.begin(); iss!=groupSet.end(); ++iss )
{
if ( (*iss).empty() )
continue;
InfoLog->displayRawNL( "<DEFINITION Label=\"%s\" Value=\"%u\"/>", (*iss).c_str(), i );
++i;
}
/// Generate group-specialized forage extraction bricks
nlinfo( "Group-specialized forage extraction bricks:");
i = 1;
for ( set<CSString, CUnsensitiveSStringLessPred>::iterator iss=groupSet.begin(); iss!=groupSet.end(); ++iss )
{
if ( (*iss).empty() )
continue;
InfoLog->displayRawNL( "<DEFINITION Label=\"%s\" Value=\"%u\"/>", (*iss).c_str(), i );
++i;
}
/// Generate group-specialized forage extraction phrases
nlinfo( "Group-specialized forage extraction phrases:");
i = 1;
for ( set<CSString, CUnsensitiveSStringLessPred>::iterator iss=groupSet.begin(); iss!=groupSet.end(); ++iss )
{
if ( (*iss).empty() )
continue;
InfoLog->displayRawNL( "<DEFINITION Label=\"%s\" Value=\"%u\"/>", (*iss).c_str(), i );
++i;
}*/
nlinfo( "TODO: Keep old values when adding new entries" );
nlinfo( "Don't forget to regen craft plans and to map localized texts" );
}
}
/*
* Multi-indexed array.
* NC is the number of columns.
*/
template <uint32 NC>
class CSortableData
{
public:
/// A row is made of fields, usually 1 per column but there may be more than one (each one is a key)
struct TSortableItem
{
std::vector<std::string> Fields [NC];
///
void push( uint32 column, const std::string& f, bool allowDuplicates=false )
{
if ( (allowDuplicates) || (find( Fields[column].begin(), Fields[column].end(), f ) == Fields[column].end()) )
Fields[column].push_back( f );
}
/**
* Display the item as a row of a HTML table.
* If (key!=previousKey) and (name==previousName), the row will not be displayed entirely to save space
*
* \param keyColumn If not ~0, column used for sorting => this column displays only the field matching the key
* \param key The key used for sorting (see keyColumn)
* \param previousKey Previous key
* \param nameColumn If not ~0, column used for the unique name (column must have exaclty one element)
* \param previousName Previous name
*/
std::string toHTMLRow( uint32 keyColumn=~0, const string& key=string(), const string& previousKey=string(),
uint32 nameColumn=~0, const string& previousName=string() ) const
{
std::string s = "<tr>";
bool lightMode = (nameColumn == ~0) ? false : ((key != previousKey) && (Fields[nameColumn][0] == previousName));
for ( uint32 c=0; c!=NC; ++c )
{
s += "<td>";
if ( c == keyColumn )
s += key; // key should be a substr of toString( c )
else
{
if ( lightMode )
s += "\"";
else
s += columnToString( c );
}
s += "</td>";
}
s += "</tr>\n";
return s;
}
///
std::string toCSVLine( char columnSeparator=',', string internalSeparator=" - ", uint32 keyColumn=~0, const string& key=string(), const string& previousKey=string(),
uint32 nameColumn=~0, const string& previousName=string() ) const
{
std::string s;
bool lightMode = (nameColumn == ~0) ? false : ((key != previousKey) && (Fields[nameColumn][0] == previousName));
for ( uint32 c=0; c!=NC; ++c )
{
if ( c == keyColumn )
s += key; // key should be a substr of columnToString( c )
else
{
if ( lightMode )
s += "\"";
else
s += columnToString( c, internalSeparator );
}
s += columnSeparator;
}
s += "\n";
return s;
}
///
std::string columnToString( uint32 column, const std::string& internalSeparator=", " ) const
{
std::string s;
std::vector<std::string>::const_iterator ivs;
for ( ivs=Fields[column].begin(); ivs!=Fields[column].end(); ++ivs )
{
if ( ivs!=Fields[column].begin() )
s += internalSeparator;
s += (*ivs);
}
return s;
}
};
typedef std::multimap< std::string, uint32 > CLookup; // key to index (not pt because reallocation invalidates pointers)
typedef std::vector< TSortableItem > CItems;
/// Init
void init( bool enabled )
{
_Enabled = enabled;
}
/// Add a row
void addItem( const TSortableItem& item )
{
if ( ! _Enabled )
return;
_Items.push_back( item );
for ( uint32 c=0; c!=NC; ++c )
{
for ( std::vector<std::string>::const_iterator ik=item.Fields[c].begin(); ik!=item.Fields[c].end(); ++ik )
{
_Indices[c].insert( make_pair( *ik, _Items.size()-1 ) );
}
}
}
/**
* Update a row (found by the first column, which must have exactly one element).
* Returns true if it existed before, false if it's being created.
* If it existed before:
* - Does not remove elements that already exist and are not in the new item
* - Adds the new elements found in the new item at the specified columns, and updates lookup map
*/
bool updateItemAppend( const TSortableItem& item, uint32 column )
{
if ( ! _Enabled )
return true; // quiet
uint32 nameColumn = 0;
CLookup::iterator ilk = _Indices[nameColumn].find( item.Fields[nameColumn][0] );
if ( ilk != _Indices[nameColumn].end() )
{
uint32& index = (*ilk).second;
// Update map for the specified column
// and update item column
for ( std::vector<std::string>::const_iterator ivs=item.Fields[column].begin(); ivs!=item.Fields[column].end(); ++ivs )
{
ilk = _Indices[column].find( *ivs );
if ( (ilk == _Indices[column].end()) || ( getRow( (*ilk).second ).Fields[nameColumn][0] != item.Fields[nameColumn][0]) )
{
_Indices[column].insert( make_pair( *ivs, index ) );
_Items[index].Fields[column].push_back( *ivs );
}
}
return true;
}
else
{
addItem( item );
return false;
}
}
/**
* Update a row (found by the first column, which must have exactly one element).
* Returns true if it existed before, false if it's being created.
* If it existed before:
* - Does not update lookup maps or item for columns that were already present.
* - Adds entries in lookup maps and updates item for new columns (fields that were empty).
*/
/*bool updateItemAppend( const TSortableItem& item )
{
if ( ! _Enabled )
return true; // quiet
CLookup::iterator ilk = _Indices[0].find( item.Fields[0][0] );
if ( ilk != _Indices[0].end() )
{
uint32& index = (*ilk).second;
for ( uint32 c=1; c!=NC; ++c )
{
// Update maps for previously empty columns
if ( _Items[index].Fields[c].empty() )
{
for ( std::vector<std::string>::iterator ivs=item.Fields[c].begin(); ivs!=item.Fields[c].end(); ++ivs )
_Indices[c].insert( make_pair( *ivs, index ) );
}
// Update item column
_Items[index].Fields[c] = item.Fields[c];
}
return true;
}
else
{
addItem( item );
return false;
}
}*/
/// Find or browse by key
CLookup& lookup( uint32 column )
{
return _Indices[column];
}
/// Browse by adding order
CItems& items()
{
return _Items;
}
/// Get a row by index
TSortableItem& getRow( uint32 index )
{
return _Items[index];
}
private:
CLookup _Indices [NC];
CItems _Items;
bool _Enabled;
};
typedef CSortableData<DtNbCols> CRMData;
typedef CRMData::TSortableItem TRMItem;
/**
*
*/
class CProducedDocHtml
{
public:
///
CProducedDocHtml() : _File(NULL), _Enabled(false) {}
///
void open( const std::string& filename, const std::string& title, bool enableFlag )
{
_Enabled = enableFlag;
if ( ! _Enabled )
return;
_File = fopen( filename.c_str(), "wt" );
fprintf( _File, ("<html><head>\n<meta http-equiv=\"content-type\" content=\"text/html; charset=UTF-8\">\n<title>" + title + "</title>\n</head><body>\n").c_str() );
}
///
void write( const std::string& htmlCode )
{
if ( ! _Enabled )
return;
fprintf( _File, htmlCode.c_str() );
}
///
void writeln( const std::string& htmlCode )
{
write( htmlCode + "\n" );
}
///
void writebln( const std::string& htmlCode )
{
write( htmlCode + "<br>\n" );
}
///
void writepln( const std::string& htmlCode )
{
write( "<p>" + htmlCode + "</p>\n" );
}
///
void save()
{
if ( ! _Enabled )
return;
fprintf( _File, "</body></html>\n" );
fclose( _File );
}
private:
FILE *_File;
bool _Enabled;
};
/**
*
*/
class CProducedDocCSV
{
public:
///
CProducedDocCSV() : _File(NULL), _Enabled(false) {}
///
void open( const std::string& filename, bool enableFlag )
{
_Enabled = enableFlag;
if ( ! _Enabled )
return;
_File = fopen( filename.c_str(), "wt" );
}
///
void write( const std::string& data )
{
if ( ! _Enabled )
return;
fprintf( _File, data.c_str() );
}
///
void writeln( const std::string& data )
{
write( data + "\n" );
}
///
void save()
{
if ( ! _Enabled )
return;
fclose( _File );
}
private:
FILE *_File;
bool _Enabled;
};
/**
*
*/
class CGenRawMaterial
{
public:
/// Constructor
CGenRawMaterial( const std::string& sheetName = std::string() ) : SheetName(sheetName), ILocation(~0), IFamily(~0), IEcosystem(NbEcosystems), StatQuality(InvalidStatQuality), Color(InvalidColor), StatEnergyAvg(0)
{}
/// Serial
void serial( NLMISC::IStream& s )
{
s.serial( SheetName );
s.serial( (uint32&)ILocation );
s.serial( (uint32&)IFamily );
s.serial( (uint32&)Group );
s.serial( (uint32&)IEcosystem );
s.serial( (uint32&)StatQuality );
s.serial( (sint32&)Color );
//s.serial( (uint32&)SapLoadLevel );
//s.serial( (uint32&)Rarity );
s.serial( (sint32&)StatEnergyAvg );
s.serial( (uint32&)MaxLevel );
s.serialCont( RMProperties );
s.serialCont( IPropertyDepths );
s.serialCont( RMCraftCharacs );
}
/// Computes randomly RMCraftCharacs, IPropertyDepths... Returns false if the RM must NOT be generated.
bool computeCraftCharacs( uint iVariant, const CSString& sheetName );
///
void writeSheet( CForm *form );
///
void loadSheet( CForm *form, const std::string& sheetName, bool full );
///
void collectStats( TRMItem& item, CMainStat& mainStats );
/// Return average of energies (including max quality as half of the balance)
/*float getEnergyAvg() const
{
if ( RMCraftCharacs.empty() )
return 0.0f;
else
{
float sum = 0.0f;
for ( list<CFaberCharacteristics>::const_iterator ics=RMCraftCharacs.begin(); ics!=RMCraftCharacs.end(); ++ics )
{
sum += (*ics).ActualEnergy;
}
//return (sum + (float)MaxQuality / 250.0f) / ((float)RMCraftCharacs.size() + 1);
return (sum / (float)RMCraftCharacs.size()); // now, MaxQuality is not part of the average
}
}*/
///
float getOriginalityAvg() const
{
float sum = 0.0f;
for ( list<CFaberCharacteristics>::const_iterator ics=RMCraftCharacs.begin(); ics!=RMCraftCharacs.end(); ++ics )
{
sum += (*ics).ActualOriginality;
}
return sum / (float)RMCraftCharacs.size();
}
///
float getOriginalityMax() const
{
float maxOriginality = 0.0f;
for ( list<CFaberCharacteristics>::const_iterator ics=RMCraftCharacs.begin(); ics!=RMCraftCharacs.end(); ++ics )
{
if ( (*ics).ActualOriginality > maxOriginality )
maxOriginality = (*ics).ActualOriginality;
}
return maxOriginality;
}
///
void fillPropertiesFromFamily()
{
vs& props = FamSet[familyStr()].Properties;
RMProperties.resize( props.size() );
for ( vs::iterator ip=props.begin(); ip!=props.end(); ++ip )
{
RMProperties[ip-props.begin()] = getIndexFromString( *ip, properties );
}
}
///
bool hasCraftPart( uint craftPartIndex )
{
return CraftParts.isEnabled( craftPartIndex ) && (FamSet[familyStr()].CompatibleCraftParts.find( string( 1, (char)'A' + craftPartIndex ).c_str() ) != string::npos);
}
///
/*TCiv getCivSpec( uint craftPartIndex, const TFamInfo& famInfo )
{
TCiv civ = NbCiv;
for ( vector<TCiv>::const_iterator ivc=famInfo.Civs.begin(); ivc!=famInfo.Civs.end(); ++ivc )
{
// Skip those not matching the current rFaberElem
if ( famInfo.getCraftPartForProp( ivc-famInfo.Civs.begin() ).find( string( 1, (char)('A' + craftPartIndex) ).c_str() ) != string::npos )
{
if ( (civ != NbCiv) && ((*ivc) != civ) )
{
nlwarning( "Different civ specializations for %s, %s (%s and %s)", familyStr().c_str(), getShortFaberElemString( craftPartIndex ).c_str(), CivNames[civ], CivNames[*ivc] );
return AllCiv;
}
civ = (*ivc);
}
}
if ( civ == NbCiv )
return AllCiv;
else if ( civ =
return civ;
}*/
///
TCiv getCivSpec( TEcosystem iEcosystem, TStatQuality statQuality )
{
if ( (statQuality <= Fine) || (iEcosystem >= NbEcosystems) )
return AllCiv;
else
return EcosystemToCiv[iEcosystem];
}
///
/*TCiv getMainCivSpec( const TFamInfo& famInfo )
{
TCiv civ = NbCiv;
for ( list<CFaberCharacteristics>::const_iterator ics=RMCraftCharacs.begin(); ics!=RMCraftCharacs.end(); ++ics )
{
TCiv civOfCraftPart = getCivSpec( (*ics).FaberElement, famInfo );
if ( (civ != NbCiv) && (civOfCraftPart != civ) )
{
return AllCiv;
}
civ = civOfCraftPart;
}
if ( civ == NbCiv )
return AllCiv;
else
return civ;
}*/
///
/*const char * getMainEcosystemSpec( const TFamInfo& famInfo )
{
return CivEcosystemCodes[getMainCivSpec( famInfo )];
}*/
/// Code
CSString SheetName;
/// Index in locations
uint32 ILocation;
/// Index in families
uint32 IFamily;
///
CSString familyStr() const { return families[IFamily]; }
/// Group number
TGroup Group;
///
CSString groupStr() const { return Group==~0 ? "" : groups[Group]; }
/// Index in ecosystems
TEcosystem IEcosystem;
///
CSString ecosystemStr() const { return ecosystems[IEcosystem]; }
/// From Basic) to Supreme)
TStatQuality StatQuality;
/// From 'b' (Basic) to 'f' (Supreme)
char levelZoneLChar() const { return 'b' + (char)StatQuality; }
/// Same
void setStatQuality( char levelZoneChar ) { StatQuality = (TStatQuality)(levelZoneChar - 'b'); }
/// For creatures
uint32 ILevelZone;
/// Index in colors
TColor Color;
///
CSString colorStr() const { return colors[Color]; }
/// Sap load level
//uint32 SapLoadLevel;
/// Rarity
//uint32 Rarity;
sint32 StatEnergyAvg;
/// Max quality
uint32 MaxLevel;
/// Indices in properties
vu RMProperties;
///
CSString propertyStr( uint32 p ) const { return properties[RMProperties[p]]; }
///
vu IPropertyDepths;
///
CSString propertyDepthStr( uint32 p ) const { return PropertyDepths[IPropertyDepths[p]]; }
///
CFaberCharacteristics *getCraftSlot( uint rFaberElem )
{
std::list< CFaberCharacteristics >::iterator icl;
for ( icl=RMCraftCharacs.begin(); icl!=RMCraftCharacs.end(); ++icl )
{
if ( (*icl).FaberElement == rFaberElem )
return &(*icl);
}
return NULL;
}
/// Randomly generated characs
std::list< CFaberCharacteristics > RMCraftCharacs;
};
/**
*
*/
class COriginalitySorter
{
public:
typedef std::set< CGenRawMaterial* > CRMSet;
typedef std::multimap< uint32, CGenRawMaterial*, std::greater<uint32> > CMultiMapByOriginality;
///
COriginalitySorter() : RMByOriginalityByCraftSlot( NbFaberElements ) {}
///
void pushRM( CGenRawMaterial *rawMaterial )
{
RawMaterials.insert( rawMaterial );
//InfoLog->displayRawNL( "Inserting RM" );
std::list< CFaberCharacteristics >::const_iterator ilc;
for ( ilc=rawMaterial->RMCraftCharacs.begin(); ilc!=rawMaterial->RMCraftCharacs.end(); ++ilc )
{
//InfoLog->displayRawNL( " %u: %s orig=%u", (*ilc).FaberElement, rawMaterial->SheetName.c_str(), (uint32)((*ilc).ActualOriginality*100.0f) );
RMByOriginalityByCraftSlot[(*ilc).FaberElement].insert( make_pair( (uint32)((*ilc).ActualOriginality*100.0f), rawMaterial ) );
}
}
///
void popAndDeleteRM( CGenRawMaterial *rawMaterial )
{
delete rawMaterial;
RawMaterials.erase( rawMaterial );
}
///
bool alreadyPopped( CGenRawMaterial *rawMaterial ) const
{
return RawMaterials.find( rawMaterial ) == RawMaterials.end();
}
/// fromPos and the returned iterator are the pos internal to the COriginalitySorter RM set
/*CRMSet::const_iterator getFirstRMNotInFamilyListFromPos( const set<uint>& familyList, TStatQuality statQuality, CRMSet::const_iterator fromPos ) const
{
CRMSet::const_iterator irm;
for ( irm=fromPos; irm!=RawMaterials.end(); ++irm )
{
if ( ((*irm)->StatQuality == statQuality) &&
(familyList.find( (*irm)->IFamily ) == familyList.end()) )
return irm;
}
return RawMaterials.end();
}*/
///
CRMSet::iterator getRMSetBegin() const { return RawMaterials.begin(); }
///
CRMSet::iterator getRMSetEnd() const { return RawMaterials.end(); }
///
void deleteAllRemainingRM()
{
CRMSet::iterator irm;
for ( irm=RawMaterials.begin(); irm!=RawMaterials.end(); ++irm )
{
delete (*irm);
}
RawMaterials.clear();
// Does not clear the maps by originality
}
std::vector< CMultiMapByOriginality > RMByOriginalityByCraftSlot;
private:
CRMSet RawMaterials;
};
#define checkColor( c ) nlassert( colors[c] == #c );
/*
*
*/
void loadDFNs( UFormLoader *formLoader )
{
map<string, CDfnFieldInfo> dfnFields;
NLMISC::CSmartPtr<UFormDfn> formDfn;
formDfn = formLoader->loadFormDfn( (rmSheetType + ".dfn").c_str() );
if ( ! formDfn )
nlerror( "Can't find DFN for %s", rmSheetType.c_str() );
vector<string> craftPartsPaths;
fillFromDFN( formLoader, dfnFields, formDfn, "", rmSheetType, "mp.MpParam", craftPartsPaths );
// Get craft parts
CraftParts.getNamesAndPaths( craftPartsPaths );
formDfn = formLoader->loadFormDfn( (crSheetType + ".dfn").c_str() );
if ( ! formDfn )
nlerror( "Can't find DFN for %s", crSheetType.c_str() );
fillFromDFN( formLoader, dfnFields, formDfn, "", crSheetType );
// Get lists of predefined values from sitem and creature DFN
families = dfnFields["mp.Family"].TypePredefinedLabels;
familyCodes = dfnFields["mp.Family"].TypePredefinedValues;
groups = dfnFields["mp.Group"].TypePredefinedLabels;
//properties = dfnFields["mp.Material property 1"].TypePredefinedLabels;
//nlverify( removeEntryFromList( properties, "Undefined" ) != ~0 );
properties.resize( craftPartsPaths.size() );
for ( uint i=0; i!=properties.size(); ++i ) // now, use properties as item part list
properties[i] = string( 1, (char)('A' + i) );
ecosystems = dfnFields["mp.Ecosystem"].TypePredefinedLabels,
colors = dfnFields["mp.MpColor"].TypePredefinedLabels,
creatures = dfnFields["Basics.Race"].TypePredefinedLabels;
seasons.push_back( "Winter" );
seasons.push_back( "Spring" );
seasons.push_back( "Summer" );
seasons.push_back( "Autumn" );
//removeEntryFromList( families, "Undefined" );
//removeEntryFromList( familyCodes, "0" );
nlverify( removeEntryFromList( ecosystems, "unknown" ) != ~0 );
nlverify( removeEntryFromList( ecosystems, "Goo" ) != ~0 );
nlassert( ecosystems[0] == "Common" );
nlassert( ecosystems[1] == "Desert" ); // ensure we match with enum TEcosystem!
nlassert( ecosystems[2] == "Forest" );
nlassert( ecosystems[3] == "Lacustre" );
nlassert( ecosystems[4] == "Jungle" );
nlassert( ecosystems[5] == "PrimeRoots" );
//removeEntryFromList( ecosystems, "Common" ); // TODO
nlassert( NbEcosystems == ecosystems.size() );
nlverify( removeEntryFromList( colors, "None" ) != ~0 );
nlverify( removeEntryFromList( colors, "UserColor") != ~0 );
nlassert( colors.size() == NbColors );
checkColor( Red );
checkColor( Beige );
checkColor( Green );
checkColor( Turquoise );
checkColor( Blue );
checkColor( Violet );
checkColor( White );
checkColor( Black );
/*UndefinedProperty = getIndexFromString( "Undefined", properties );
nlassert( UndefinedProperty != ~0 );*/
}
/*
* Build RMFamilyIndicesByCreatureModel and DepositFamilyIndices
*/
void dispatchFamiliesToLocations()
{
for ( CFamMap::iterator iss=FamSet.begin(); iss!=FamSet.end(); ++iss )
{
const CSString& famStr = (*iss).first;
TFamInfo& famInfo = (*iss).second;
uint iFam = getIndexFromString( famStr, families );
if ( famInfo.IsInDeposits )
{
// Deposits
nlassert( iFam != ~0 );
DepositFamilyIndices.push_back( iFam );
}
if ( famInfo.IsInCreatures )
{
// Extract creature name from left of family name (ASSUMES there's no blank in creature name)
CSString creaNameForRMFamily = famStr.splitTo( ' ' );
// Dispatch
for ( CSkeletonMap::iterator icm=CreatureModels.begin(); icm!=CreatureModels.end(); ++icm )
{
const CSString& creaModel = (*icm).first;
TSkeletonInfo& modelInfo = (*icm).second;
if ( modelInfo.Name == creaNameForRMFamily )
{
RMFamilyIndicesByCreatureModel[creaModel].push_back( iFam );
//nlinfo( "+ %s for %s (now %u models registered)", famStr.c_str(), creaModel.c_str(), RMFamilyIndicesByCreatureModel.size() );
modelInfo.IsUsed = true; // Name and AbbrevName are set by deliverCreatureModels()
}
}
}
else switch ( famInfo.SpecialCreatureTag[0] )
{
// Goo & invasion/raid creatures
case 'G':
{
GooCreatureFamilyIndices.push_back( iFam );
nldebug( "Family %s selected for goo creatures", famStr.c_str() );
break;
}
case 'I':
{
if ( famInfo.SpecialCreatureTag.size() == 1 )
{
InvasionRaidCreatureFamilyIndices['*'].push_back( iFam );
nldebug( "Family %s selected for all invasion creatures", famStr.c_str() );
}
else
{
for ( uint c=1; c!=famInfo.SpecialCreatureTag.size(); ++c )
{
InvasionRaidCreatureFamilyIndices[famInfo.SpecialCreatureTag[c]].push_back( iFam );
nldebug( "Family %s selected for invasion creature of type %c", famStr.c_str(), famInfo.SpecialCreatureTag[c] );
}
}
break;
}
}
}
}
/*
* Returns the number of models used
*/
uint checkSkeletons()
{
uint32 nbSkeUsed = 0;
for ( CSkeletonMap::const_iterator isc=CreatureModels.begin(); isc!=CreatureModels.end(); ++isc )
{
const string& skeFilename = (*isc).first;
const TSkeletonInfo& ske = (*isc).second;
const bool& used = (*isc).second.IsUsed;
if ( used )
{
nldebug( "Model %s (%s) %s", skeFilename.c_str(), ske.AbbrevName.c_str(), used?"used":"NOT USED" );
++nbSkeUsed;
}
else
nlwarning( "Model %s %s", skeFilename.c_str(), used?"":"NOT USED" );
}
return nbSkeUsed;
}
/*
*
*/
void createDirectoryStructure()
{
// Create the directory structure
if ( WriteSheetsToDisk )
{
for ( uint32 i=0; i!=ecosystems.size(); ++i )
{
string dirname = conventionalDirectory( ecosystems[i] );
if ( ! CFile::isExists( rawMaterialPath + dirname ) )
{
CFile::createDirectory( rawMaterialPath + dirname );
}
else
{
if ( ! CFile::isDirectory( rawMaterialPath + dirname ) )
{
nlwarning( "%s already existing but not a directory!", (rawMaterialPath + dirname).c_str() );
}
}
}
string dirname = "_parent";
if ( ! CFile::isExists( rawMaterialPath + dirname ) )
{
CFile::createDirectory( rawMaterialPath + dirname );
}
else
{
if ( ! CFile::isDirectory( rawMaterialPath + dirname ) )
{
nlwarning( "%s already existing but not a directory!", (rawMaterialPath + dirname).c_str() );
}
}
}
}
#endif // NL_SRG_UTILITIES_H
/* End of srg_utilities.h */
Reference in a new issue View git blame Copy permalink