mirror of
https://port.numenaute.org/aleajactaest/khanat-code-old.git
synced 2024-12-04 17:24:47 +00:00
1046 lines
27 KiB
C++
1046 lines
27 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 //
|
|
/////////////
|
|
#include "stdpch.h" // First include for pre-compiled headers.
|
|
// Misc
|
|
#include "nel/misc/path.h"
|
|
#include "nel/misc/file.h"
|
|
#include "nel/misc/smart_ptr.h"
|
|
#include "nel/misc/sheet_id.h"
|
|
// Georges
|
|
#include "nel/georges/u_form.h"
|
|
#include "nel/georges/u_form_elm.h"
|
|
#include "nel/georges/u_form_loader.h"
|
|
#include "nel/georges/u_type.h"
|
|
#include "nel/georges/load_form.h"
|
|
// Client
|
|
#include "sheet_manager.h"
|
|
//#include "client_cfg.h"
|
|
#include "client_sheets/entity_sheet.h"
|
|
#include "client_sheets/faction_sheet.h"
|
|
// Game Share
|
|
#include "game_share/visual_slot_manager.h"
|
|
|
|
|
|
///////////
|
|
// USING //
|
|
///////////
|
|
using namespace NLMISC;
|
|
using namespace std;
|
|
using namespace NLGEORGES;
|
|
|
|
|
|
/////////////
|
|
// GLOBALS //
|
|
/////////////
|
|
// Sheet manager.
|
|
CSheetManager SheetMngr;
|
|
UFormLoader *CSheetManager::FormLoader = NULL;
|
|
//COFile fItemAssoc;
|
|
//bool ItemAssocFileOpen = false;
|
|
|
|
// there can be several instance of CSheetManager (for reload operations) -> ctruct the loader here rather than in CSheetManager ctor
|
|
class CFormLoaderInit
|
|
{
|
|
public:
|
|
CFormLoaderInit()
|
|
{
|
|
nlassert (CSheetManager::FormLoader == NULL);
|
|
CSheetManager::FormLoader = UFormLoader::createLoader ();
|
|
nlassert (CSheetManager::FormLoader != NULL);
|
|
}
|
|
~CFormLoaderInit()
|
|
{
|
|
if (CSheetManager::FormLoader)
|
|
{
|
|
UFormLoader::releaseLoader (CSheetManager::FormLoader);
|
|
CSheetManager::FormLoader = NULL;
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
static CFormLoaderInit FormLoadInit;
|
|
|
|
class CTypeVersion
|
|
{
|
|
public:
|
|
std::string Type;
|
|
uint Version;
|
|
|
|
CTypeVersion(std::string type, uint version) {Type=type; Version=version;}
|
|
};
|
|
|
|
CTypeVersion TypeVersion [] =
|
|
{
|
|
CTypeVersion("creature", 17),
|
|
// CTypeVersion("player", 0),
|
|
CTypeVersion("fx", 0),
|
|
CTypeVersion("building", 2),
|
|
CTypeVersion("sitem", 42),
|
|
CTypeVersion("item", 42),
|
|
CTypeVersion("plant", 5),
|
|
CTypeVersion("death_impact", 0),
|
|
// CTypeVersion("mission", 0),
|
|
CTypeVersion("race_stats", 3),
|
|
CTypeVersion("light_cycle", 0),
|
|
CTypeVersion("weather_setup", 1),
|
|
CTypeVersion("continent", 12),
|
|
CTypeVersion("world", 1),
|
|
CTypeVersion("weather_function_params", 2),
|
|
CTypeVersion("mission_icon", 0),
|
|
CTypeVersion("sbrick", 32),
|
|
CTypeVersion("sphrase", 4),
|
|
CTypeVersion("skill_tree", 5),
|
|
CTypeVersion("titles", 1),
|
|
CTypeVersion("succes_chances_table", 1),
|
|
CTypeVersion("automaton_list", 23),
|
|
CTypeVersion("animset_list", 25),
|
|
CTypeVersion("animation_fx", 4),
|
|
CTypeVersion("id_to_string_array", 1),
|
|
CTypeVersion("emot", 1),
|
|
CTypeVersion("forage_source", 2),
|
|
CTypeVersion("flora", 0),
|
|
CTypeVersion("animation_fx_set", 3),
|
|
CTypeVersion("attack_list", 9),
|
|
CTypeVersion("text_emotes", 1),
|
|
CTypeVersion("sky", 5),
|
|
CTypeVersion("outpost", 0),
|
|
CTypeVersion("outpost_building", 1),
|
|
CTypeVersion("outpost_squad", 1),
|
|
CTypeVersion("faction", 0),
|
|
};
|
|
// This is just a value for CVS conflict generation.
|
|
const char *LastPackedFilenameVersionIncrementer= "nico";
|
|
|
|
|
|
|
|
/////////////
|
|
// MEMBERS //
|
|
/////////////
|
|
static uint Version = 2;
|
|
|
|
|
|
////////////////////////
|
|
// CSheetManagerEntry //
|
|
////////////////////////
|
|
|
|
// ***************************************************************************
|
|
CSheetManagerEntry::CSheetManagerEntry () : EntitySheet(NULL)
|
|
{
|
|
}
|
|
|
|
//-----------------------------------------------
|
|
// ~CSheetManagerEntry :
|
|
//-----------------------------------------------
|
|
CSheetManagerEntry::~CSheetManagerEntry ()
|
|
{
|
|
// Release the sheet.
|
|
if(EntitySheet != 0)
|
|
{
|
|
delete EntitySheet;
|
|
EntitySheet = 0;
|
|
}
|
|
}// ~CSheetManagerEntry //
|
|
|
|
|
|
// ***************************************************************************
|
|
void CSheetManagerEntry::readGeorges (const NLMISC::CSmartPtr<NLGEORGES::UForm> &form, const NLMISC::CSheetId &sheetId)
|
|
{
|
|
// Load the form with given sheet id
|
|
if (form)
|
|
{
|
|
// if (EntitySheet != NULL)
|
|
// delete EntitySheet;
|
|
|
|
CEntitySheet *sheet = NULL;
|
|
|
|
std::string extension = NLMISC::CSheetId::fileExtensionFromType(sheetId.getSheetType());
|
|
|
|
// create the new structure
|
|
if (extension == "creature")
|
|
sheet = new CCharacterSheet;
|
|
else if(extension == "player")
|
|
sheet = new CPlayerSheet;
|
|
else if(extension == "fx")
|
|
sheet = new CFXSheet;
|
|
else if(extension == "building")
|
|
sheet = new CBuildingSheet;
|
|
else if(extension == "sitem" || extension == "item" )
|
|
sheet = new CItemSheet;
|
|
else if(extension == "plant")
|
|
sheet = new CPlantSheet;
|
|
else if(extension == "death_impact")
|
|
sheet = new CPactSheet;
|
|
else if(extension == "mission")
|
|
sheet = new CMissionSheet;
|
|
else if(extension == "race_stats")
|
|
sheet = new CRaceStatsSheet;
|
|
else if(extension == "light_cycle")
|
|
sheet = new CLightCycleSheet;
|
|
else if(extension == "weather_setup")
|
|
sheet = new CWeatherSetupSheet;
|
|
else if(extension == "continent")
|
|
sheet = new CContinentSheet;
|
|
else if(extension == "world")
|
|
sheet = new CWorldSheet;
|
|
else if(extension == "weather_function_params")
|
|
sheet = new CWeatherFunctionParamsSheet;
|
|
else if(extension == "mission_icon")
|
|
sheet = new CMissionIconSheet;
|
|
else if(extension == "sbrick")
|
|
sheet = new CSBrickSheet;
|
|
else if(extension == "sphrase")
|
|
sheet = new CSPhraseSheet;
|
|
else if(extension == "skill_tree")
|
|
sheet = new CSkillsTreeSheet;
|
|
else if(extension == "titles")
|
|
sheet = new CUnblockTitlesSheet;
|
|
else if(extension == "succes_chances_table")
|
|
sheet = new CSuccessTableSheet;
|
|
else if(extension == "automaton_list")
|
|
sheet = new CAutomatonListSheet;
|
|
else if(extension == "animset_list")
|
|
sheet = new CAnimationSetListSheet;
|
|
else if(extension == "animation_fx")
|
|
sheet = new CAnimationFXSheet;
|
|
else if(extension == "id_to_string_array")
|
|
sheet = new CIDToStringArraySheet;
|
|
else if(extension == "emot")
|
|
sheet = new CEmotListSheet;
|
|
else if(extension == "forage_source")
|
|
sheet = new CForageSourceSheet;
|
|
else if(extension == "flora")
|
|
sheet = new CFloraSheet;
|
|
else if(extension == "animation_fx_set")
|
|
sheet = new CAnimationFXSetSheet;
|
|
else if(extension == "attack_list")
|
|
sheet = new CAttackListSheet;
|
|
else if(extension == "text_emotes")
|
|
sheet = new CTextEmotListSheet;
|
|
else if(extension == "sky")
|
|
sheet = new CSkySheet;
|
|
else if(extension == "outpost")
|
|
sheet = new COutpostSheet;
|
|
else if(extension == "outpost_building")
|
|
sheet = new COutpostBuildingSheet;
|
|
else if(extension == "outpost_squad")
|
|
sheet = new COutpostSquadSheet;
|
|
else if(extension == "faction")
|
|
sheet = new CFactionSheet;
|
|
else
|
|
{
|
|
nlwarning("CSheetManager::loadSheet: Do not know how to create the class from the sheet '%s'.", sheetId.toString().c_str());
|
|
return;
|
|
}
|
|
|
|
// Build the sheet from an external file.
|
|
sheet->Id = sheetId;
|
|
sheet->build(form->getRootNode());
|
|
|
|
EntitySheet = sheet;
|
|
SheetMngr.processSheet(EntitySheet);
|
|
}
|
|
// Error while loading the form.
|
|
else
|
|
{
|
|
// nlwarning("CSheetManager::loadSheet: Cannot load the form '%s'.", filename.c_str());
|
|
EntitySheet = 0;
|
|
}
|
|
}
|
|
|
|
// ***************************************************************************
|
|
void CSheetManagerEntry::initSheet(CEntitySheet *pES, NLMISC::IStream &s, CEntitySheet::TType type)
|
|
{
|
|
if (pES != NULL)
|
|
{
|
|
pES->Id.serial(s);
|
|
pES->serial(s);
|
|
pES->Type = type;
|
|
SheetMngr.processSheet(pES);
|
|
}
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
void CSheetManagerEntry::serial (NLMISC::IStream &s)
|
|
{
|
|
if (s.isReading())
|
|
{
|
|
// if (EntitySheet != NULL)
|
|
// delete EntitySheet;
|
|
|
|
CEntitySheet::TType type = CEntitySheet::TypeCount;
|
|
s.serialEnum(type);
|
|
|
|
switch(type)
|
|
{
|
|
case CEntitySheet::FAUNA:
|
|
{
|
|
EntitySheet = new CCharacterSheet;
|
|
initSheet(EntitySheet, s, type);
|
|
}
|
|
break;
|
|
case CEntitySheet::FLORA:
|
|
{
|
|
EntitySheet = new CFloraSheet;
|
|
initSheet(EntitySheet, s, type);
|
|
}
|
|
break;
|
|
case CEntitySheet::CHAR:
|
|
{
|
|
EntitySheet = new CPlayerSheet;
|
|
initSheet(EntitySheet, s, type);
|
|
}
|
|
break;
|
|
case CEntitySheet::FX:
|
|
{
|
|
EntitySheet = new CFXSheet;
|
|
initSheet(EntitySheet, s, type);
|
|
}
|
|
break;
|
|
case CEntitySheet::BUILDING:
|
|
{
|
|
EntitySheet = new CBuildingSheet;
|
|
initSheet(EntitySheet, s, type);
|
|
}
|
|
break;
|
|
case CEntitySheet::ITEM:
|
|
{
|
|
EntitySheet = new CItemSheet;
|
|
initSheet(EntitySheet, s, type);
|
|
}
|
|
break;
|
|
case CEntitySheet::PLANT:
|
|
{
|
|
EntitySheet = new CPlantSheet;
|
|
initSheet(EntitySheet, s, type);
|
|
}
|
|
break;
|
|
case CEntitySheet::PACT:
|
|
{
|
|
EntitySheet = new CPactSheet;
|
|
initSheet(EntitySheet, s, type);
|
|
}
|
|
break;
|
|
case CEntitySheet::MISSION:
|
|
{
|
|
EntitySheet = new CMissionSheet;
|
|
initSheet(EntitySheet, s, type);
|
|
}
|
|
break;
|
|
case CEntitySheet::MISSION_ICON:
|
|
{
|
|
EntitySheet = new CMissionIconSheet;
|
|
initSheet(EntitySheet, s, type);
|
|
}
|
|
break;
|
|
case CEntitySheet::RACE_STATS:
|
|
{
|
|
EntitySheet = new CRaceStatsSheet;
|
|
initSheet(EntitySheet, s, type);
|
|
}
|
|
break;
|
|
case CEntitySheet::LIGHT_CYCLE:
|
|
{
|
|
EntitySheet = new CLightCycleSheet;
|
|
initSheet(EntitySheet, s, type);
|
|
}
|
|
break;
|
|
case CEntitySheet::WEATHER_SETUP:
|
|
{
|
|
EntitySheet = new CWeatherSetupSheet;
|
|
initSheet(EntitySheet, s, type);
|
|
}
|
|
break;
|
|
case CEntitySheet::CONTINENT:
|
|
{
|
|
EntitySheet = new CContinentSheet;
|
|
initSheet(EntitySheet, s, type);
|
|
}
|
|
break;
|
|
case CEntitySheet::WORLD:
|
|
{
|
|
EntitySheet = new CWorldSheet;
|
|
initSheet(EntitySheet, s, type);
|
|
}
|
|
break;
|
|
case CEntitySheet::WEATHER_FUNCTION_PARAMS:
|
|
{
|
|
EntitySheet = new CWeatherFunctionParamsSheet;
|
|
initSheet(EntitySheet, s, type);
|
|
}
|
|
break;
|
|
case CEntitySheet::SBRICK:
|
|
{
|
|
EntitySheet = new CSBrickSheet;
|
|
initSheet(EntitySheet, s, type);
|
|
}
|
|
break;
|
|
case CEntitySheet::SPHRASE:
|
|
{
|
|
EntitySheet = new CSPhraseSheet;
|
|
initSheet(EntitySheet, s, type);
|
|
}
|
|
break;
|
|
case CEntitySheet::SKILLS_TREE:
|
|
{
|
|
EntitySheet = new CSkillsTreeSheet;
|
|
initSheet(EntitySheet, s, type);
|
|
}
|
|
break;
|
|
case CEntitySheet::UNBLOCK_TITLES:
|
|
{
|
|
EntitySheet = new CUnblockTitlesSheet;
|
|
initSheet(EntitySheet, s, type);
|
|
}
|
|
break;
|
|
case CEntitySheet::SUCCESS_TABLE:
|
|
{
|
|
EntitySheet = new CSuccessTableSheet;
|
|
initSheet(EntitySheet, s, type);
|
|
}
|
|
break;
|
|
case CEntitySheet::AUTOMATON_LIST:
|
|
{
|
|
EntitySheet = new CAutomatonListSheet;
|
|
initSheet(EntitySheet, s, type);
|
|
}
|
|
break;
|
|
case CEntitySheet::ANIMATION_SET_LIST:
|
|
{
|
|
EntitySheet = new CAnimationSetListSheet;
|
|
initSheet(EntitySheet, s, type);
|
|
}
|
|
break;
|
|
case CEntitySheet::ANIMATION_FX:
|
|
{
|
|
EntitySheet = new CAnimationFXSheet;
|
|
initSheet(EntitySheet, s, type);
|
|
}
|
|
break;
|
|
case CEntitySheet::ID_TO_STRING_ARRAY:
|
|
{
|
|
EntitySheet = new CIDToStringArraySheet;
|
|
initSheet(EntitySheet, s, type);
|
|
}
|
|
break;
|
|
case CEntitySheet::EMOT:
|
|
{
|
|
EntitySheet = new CEmotListSheet;
|
|
initSheet(EntitySheet, s, type);
|
|
}
|
|
break;
|
|
case CEntitySheet::FORAGE_SOURCE:
|
|
{
|
|
EntitySheet = new CForageSourceSheet;
|
|
initSheet(EntitySheet, s, type);
|
|
}
|
|
break;
|
|
case CEntitySheet::ANIMATION_FX_SET:
|
|
{
|
|
EntitySheet = new CAnimationFXSetSheet;
|
|
initSheet(EntitySheet, s, type);
|
|
}
|
|
break;
|
|
case CEntitySheet::ATTACK_LIST:
|
|
{
|
|
EntitySheet = new CAttackListSheet;
|
|
initSheet(EntitySheet, s, type);
|
|
}
|
|
break;
|
|
case CEntitySheet::TEXT_EMOT:
|
|
{
|
|
EntitySheet = new CTextEmotListSheet;
|
|
initSheet(EntitySheet, s, type);
|
|
}
|
|
break;
|
|
case CEntitySheet::SKY:
|
|
{
|
|
EntitySheet = new CSkySheet;
|
|
initSheet(EntitySheet, s, type);
|
|
}
|
|
break;
|
|
case CEntitySheet::OUTPOST:
|
|
{
|
|
EntitySheet = new COutpostSheet;
|
|
initSheet(EntitySheet, s, type);
|
|
}
|
|
break;
|
|
case CEntitySheet::OUTPOST_BUILDING:
|
|
{
|
|
EntitySheet = new COutpostBuildingSheet;
|
|
initSheet(EntitySheet, s, type);
|
|
}
|
|
break;
|
|
case CEntitySheet::OUTPOST_SQUAD:
|
|
{
|
|
EntitySheet = new COutpostSquadSheet;
|
|
initSheet(EntitySheet, s, type);
|
|
}
|
|
break;
|
|
case CEntitySheet::FACTION:
|
|
{
|
|
EntitySheet = new CFactionSheet;
|
|
initSheet(EntitySheet, s, type);
|
|
}
|
|
break;
|
|
default:
|
|
nlwarning("CSheetManager::load: Unknown type '%d' in the packed file. Rebuild=true and Ignore this sheet.", type);
|
|
EntitySheet = NULL;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (EntitySheet != NULL)
|
|
{
|
|
s.serialEnum(EntitySheet->Type);
|
|
EntitySheet->Id.serial(s);
|
|
EntitySheet->serial(s);
|
|
}
|
|
else
|
|
{
|
|
// write a speudo entry into the stream
|
|
CEntitySheet::TType tmp = CEntitySheet::UNKNOWN;
|
|
s.serialEnum(tmp);
|
|
}
|
|
}
|
|
}
|
|
|
|
// ***************************************************************************
|
|
void CSheetManagerEntry::removed()
|
|
{
|
|
// any action that is needed if the sheet no more exist.
|
|
if (EntitySheet != 0)
|
|
{
|
|
delete EntitySheet;
|
|
EntitySheet = 0;
|
|
}
|
|
}
|
|
|
|
// ***************************************************************************
|
|
uint CSheetManagerEntry::getVersion ()
|
|
{
|
|
return Version;
|
|
}
|
|
|
|
//-----------------------------------------------
|
|
//-----------------------------------------------
|
|
void CSheetManagerEntry::setVersion(uint version)
|
|
{
|
|
Version = version;
|
|
}// setVersion //
|
|
|
|
|
|
/////////////
|
|
// METHODS //
|
|
/////////////
|
|
//-----------------------------------------------
|
|
// CSheetManager :
|
|
// Constructor.
|
|
//-----------------------------------------------
|
|
CSheetManager::CSheetManager()
|
|
{
|
|
_NbEyesColor = 0; // Default is no color available for the eyes.
|
|
|
|
// Slot 0 is invalid.
|
|
for(uint i=0; i<SLOTTYPE::NB_SLOT; ++i)
|
|
{
|
|
TItemVector slotList;
|
|
slotList.push_back(0);
|
|
_VisualSlots.push_back(slotList);
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------
|
|
// CSheetManager :
|
|
// Destructor.
|
|
//-----------------------------------------------
|
|
CSheetManager::~CSheetManager()
|
|
{
|
|
release();
|
|
}
|
|
|
|
//-----------------------------------------------
|
|
void CSheetManager::release()
|
|
{
|
|
_VisualSlots.clear();
|
|
|
|
_EntitySheetContainer.clear();
|
|
|
|
_SheetToVS.clear();
|
|
}
|
|
|
|
//-----------------------------------------------
|
|
// load :
|
|
// Load all sheets.
|
|
//-----------------------------------------------
|
|
void CSheetManager::load(NLMISC::IProgressCallback &callBack, bool updatePackedSheet, bool needComputeVS, bool dumpVSIndex)
|
|
{
|
|
// Open The Item Association File
|
|
// if(!fItemAssoc.open(getLogDirectory() + "item_association.dbg", false, true))
|
|
// nlwarning("CSheetManager::load: Cannot Open the 'item_association.txt'.");
|
|
// else
|
|
// ItemAssocFileOpen = true;
|
|
|
|
// Initialize the Sheet DB.
|
|
loadAllSheet(callBack, updatePackedSheet, needComputeVS, dumpVSIndex);
|
|
|
|
// Close the Item Association File.
|
|
// fItemAssoc.close();
|
|
// ItemAssocFileOpen = false;
|
|
|
|
// Optimize memory taken by all strings of all sheets
|
|
ClientSheetsStrings.memoryCompress();
|
|
|
|
return;
|
|
}// load //
|
|
|
|
|
|
//-----------------------------------------------
|
|
// loadAllSheet :
|
|
// Load all sheets.
|
|
//-----------------------------------------------
|
|
void CSheetManager::loadAllSheet(NLMISC::IProgressCallback &callBack, bool updatePackedSheet, bool needComputeVS, bool dumpVSIndex, bool forceRecompute /*= false*/, const std::vector<std::string> *userExtensions /*= NULL*/)
|
|
{
|
|
|
|
callBack.progress (0);
|
|
callBack.pushCropedValues (0, 0.5f);
|
|
|
|
// Get some information from typ files.
|
|
loadTyp();
|
|
|
|
// prepare a list of sheets extension to load.
|
|
vector<string> extensions;
|
|
|
|
uint sizeTypeVersion = sizeof(TypeVersion);
|
|
uint sizeCTypeVersion = sizeof(CTypeVersion);
|
|
uint nb = sizeTypeVersion/sizeCTypeVersion;
|
|
{
|
|
if (!userExtensions)
|
|
{
|
|
_EntitySheetContainer.clear();
|
|
}
|
|
TEntitySheetMap entitySheetContainer;
|
|
for(uint i=0; i<nb; ++i)
|
|
{
|
|
// see if extension is wanted
|
|
bool found = false;
|
|
if (userExtensions)
|
|
{
|
|
for(uint l = 0; l < userExtensions->size(); ++l)
|
|
{
|
|
if (stricmp((*userExtensions)[l].c_str(), TypeVersion[i].Type.c_str()) == 0)
|
|
{
|
|
found = true;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
found = true;
|
|
}
|
|
if (found)
|
|
{
|
|
entitySheetContainer.clear();
|
|
extensions.clear();
|
|
extensions.push_back(TypeVersion[i].Type);
|
|
CSheetManagerEntry::setVersion(TypeVersion[i].Version);
|
|
string path = CPath::lookup(TypeVersion[i].Type + ".packed_sheets", false);
|
|
if (forceRecompute && !path.empty())
|
|
{
|
|
// delete previous packed sheets
|
|
NLMISC::CFile::deleteFile(path);
|
|
path.clear();
|
|
}
|
|
if(path.empty())
|
|
path = CPath::standardizePath(_OutputDataPath) + TypeVersion[i].Type + ".packed_sheets";
|
|
::loadForm(extensions, path, entitySheetContainer, updatePackedSheet);
|
|
|
|
TEntitySheetMap::iterator it = entitySheetContainer.begin();
|
|
while(it != entitySheetContainer.end())
|
|
{
|
|
_EntitySheetContainer[(*it).first] = (*it).second;
|
|
(*it).second.EntitySheet = 0;
|
|
// Next
|
|
++it;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// Re-compute Visual Slot
|
|
if(needComputeVS)
|
|
computeVS();
|
|
|
|
// Compute Visual Slots
|
|
{
|
|
for(uint i=0; i<SLOTTYPE::NB_SLOT; ++i)
|
|
_VisualSlots[i].resize(CVisualSlotManager::getInstance()->getNbIndex((SLOTTYPE::EVisualSlot)i)+1, 0); // Nb Index +1 because index 0 is reserve for empty.
|
|
|
|
//
|
|
TEntitySheetMap::iterator it = _EntitySheetContainer.begin();
|
|
while(it != _EntitySheetContainer.end())
|
|
{
|
|
std::vector<CVisualSlotManager::TIdxbyVS> result;
|
|
CVisualSlotManager::getInstance()->sheet2Index((*it).first, result);
|
|
|
|
for(uint i=0; i<result.size(); ++i)
|
|
{
|
|
if(dynamic_cast<CItemSheet *>((*it).second.EntitySheet))
|
|
{
|
|
_SheetToVS[dynamic_cast<CItemSheet *>((*it).second.EntitySheet)].push_back(std::make_pair(result[i].VisualSlot, result[i].Index));
|
|
_VisualSlots[result[i].VisualSlot][result[i].Index] = dynamic_cast<CItemSheet *>((*it).second.EntitySheet);
|
|
}
|
|
}
|
|
|
|
++it;
|
|
}
|
|
}
|
|
|
|
// Dump visual slots
|
|
// nb : if a new visual_slot.tab has just been generated don't forget
|
|
// to move it in data_common before dump.
|
|
if(dumpVSIndex)
|
|
dumpVisualSlotsIndex();
|
|
|
|
//
|
|
callBack.popCropedValues();
|
|
}// loadAllSheet //
|
|
|
|
|
|
// ***************************************************************************
|
|
void CSheetManager::loadAllSheetNoPackedSheet(NLMISC::IProgressCallback &callBack, const std::vector<std::string> &extensions, const std::string &wildcardFilter)
|
|
{
|
|
|
|
callBack.progress (0);
|
|
callBack.pushCropedValues (0, 0.5f);
|
|
|
|
// load all forms
|
|
::loadFormNoPackedSheet(extensions, _EntitySheetContainer, wildcardFilter);
|
|
|
|
//
|
|
callBack.popCropedValues();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------
|
|
// computeVS :
|
|
// compute Visual Slots for this sheet.
|
|
//-----------------------------------------------
|
|
void CSheetManager::computeVS()
|
|
{
|
|
static std::map< std::string, uint16 > ProcessedItem;
|
|
map< string, uint16 >::iterator it;
|
|
|
|
CVisualSlotManager::TVisualSlot vs;
|
|
vs.resize(SLOTTYPE::NB_SLOT);
|
|
|
|
//
|
|
TEntitySheetMap::iterator itS = _EntitySheetContainer.begin();
|
|
while(itS != _EntitySheetContainer.end())
|
|
{
|
|
// Visual Slots are only valid for Items.
|
|
CItemSheet *item = dynamic_cast<CItemSheet *>((*itS).second.EntitySheet);
|
|
if (item && (*itS).first.getSheetType()==CSheetId::typeFromFileExtension(std::string("sitem")))
|
|
{
|
|
for(uint j=0; j<SLOTTYPE::NB_SLOT_TYPE; ++j)
|
|
{
|
|
SLOTTYPE::TSlotType slotType= (SLOTTYPE::TSlotType)j;
|
|
if( item->hasSlot(slotType) )
|
|
{
|
|
SLOTTYPE::EVisualSlot visualSlot = SLOTTYPE::convertTypeToVisualSlot(slotType);
|
|
if(visualSlot != SLOTTYPE::HIDDEN_SLOT)
|
|
{
|
|
string currentSheet = ((*itS).first).toString();
|
|
|
|
CVisualSlotManager::TElement vsElmt;
|
|
|
|
string sheetName = toString("%s%d", currentSheet.c_str(), visualSlot);
|
|
|
|
// Is the sheet already process (could be process by a sheet with a different lvl)
|
|
it = ProcessedItem.find( sheetName );
|
|
// Insert if not found
|
|
if(it == ProcessedItem.end())
|
|
{
|
|
uint itemNumber;
|
|
if(vs[visualSlot].Element.size() == 0)
|
|
itemNumber = 1;
|
|
else
|
|
itemNumber = vs[visualSlot].Element[vs[visualSlot].Element.size()-1].Index+1;
|
|
|
|
// Item Processed
|
|
ProcessedItem.insert(make_pair(sheetName, itemNumber));
|
|
|
|
vsElmt.Index = itemNumber;
|
|
}
|
|
else
|
|
{
|
|
vsElmt.Index = (*it).second;
|
|
}
|
|
//
|
|
vsElmt.SheetId = (*itS).first;
|
|
vs[visualSlot].Element.push_back(vsElmt);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Next Sheet
|
|
++itS;
|
|
}
|
|
|
|
|
|
// Open the file.
|
|
NLMISC::COFile f;
|
|
if(f.open("visual_slot.tab"))
|
|
{
|
|
// Dump entities.
|
|
f.serialCont(vs);
|
|
|
|
// Close the File.
|
|
f.close();
|
|
}
|
|
else
|
|
nlwarning("SheetMngr:load: cannot open/create the file 'visual_slot.tab'.");
|
|
}// computeVS //
|
|
|
|
//-----------------------------------------------
|
|
// processSheet :
|
|
// Porcessing the sheet.
|
|
// \param sheet : sheet to process.
|
|
//-----------------------------------------------
|
|
void CSheetManager::processSheet (CEntitySheet * /* sheet */)
|
|
{
|
|
// For now: no op
|
|
}// processSheet //
|
|
|
|
//=======================================================================
|
|
const CSheetManager::TVisualSlotItemArray *CSheetManager::getVSItems(CItemSheet *sheet) const
|
|
{
|
|
TItemSheet2SlotItemArray::const_iterator it = _SheetToVS.find(sheet);
|
|
if (it == _SheetToVS.end())
|
|
return NULL;
|
|
return &(it->second);
|
|
}
|
|
|
|
//=======================================================================
|
|
sint CSheetManager::getVSIndex(const std::string &itemName, SLOTTYPE::EVisualSlot slot)
|
|
{
|
|
NLMISC::CSheetId si;
|
|
if (!si.buildSheetId(itemName))
|
|
{
|
|
nlwarning("<CSheetManager::getVSIndex> : cannot build id from item %s for the slot %d.", itemName.c_str(), slot);
|
|
return -1;
|
|
}
|
|
|
|
TEntitySheetMap::iterator it = _EntitySheetContainer.find(si);;
|
|
if (it == _EntitySheetContainer.end())
|
|
{
|
|
nlwarning("<CSheetManager::getVSIndex> : cannot find %s for the slot %d.", itemName.c_str(), slot);
|
|
return -1;
|
|
}
|
|
if (it->second.EntitySheet == 0 || it->second.EntitySheet->type() != CEntitySheet::ITEM)
|
|
{
|
|
nlwarning("<CSheetManager::getVSIndex> : %s is not an item for the slot %d.", itemName.c_str(), slot);
|
|
return -1;
|
|
}
|
|
|
|
CItemSheet *is = static_cast<CItemSheet *>(it->second.EntitySheet);
|
|
|
|
const TVisualSlotItemArray *ia = getVSItems(is);
|
|
if (ia == NULL)
|
|
{
|
|
nlwarning("<CSheetManager::getVSIndex> : no items for the slot %d. while looking for %s", slot, itemName.c_str());
|
|
return -1;
|
|
}
|
|
|
|
TVisualSlotItemArray::const_iterator first(ia->begin()), last(ia->end());
|
|
for(; first != last; ++first)
|
|
{
|
|
if (first->first == slot)
|
|
{
|
|
return first->second;
|
|
}
|
|
}
|
|
|
|
nlwarning("<CSheetManager::getVSIndex> : cannot find %s for the slot %d.", itemName.c_str(), slot);
|
|
return -1;
|
|
}
|
|
|
|
//-----------------------------------------------
|
|
// get :
|
|
// Get a sheet from its number.
|
|
// \param uint32 num : sheet number.
|
|
// \return CEntitySheet * : pointer on the sheet according to the param or 0 if any pb.
|
|
//-----------------------------------------------
|
|
CEntitySheet *CSheetManager::get(CSheetId num)
|
|
{
|
|
TEntitySheetMap::iterator it = _EntitySheetContainer.find(num);
|
|
if(it != _EntitySheetContainer.end())
|
|
return it->second.EntitySheet;
|
|
else
|
|
return NULL;
|
|
}// get //
|
|
|
|
|
|
//-----------------------------------------------
|
|
uint CSheetManager::getNumItem(SLOTTYPE::EVisualSlot slot)
|
|
{
|
|
// The slot is not a visible one.
|
|
if (slot == SLOTTYPE::HIDDEN_SLOT)
|
|
return 0;
|
|
// Convert into an uint to remove warnings.
|
|
uint s = (uint)slot;
|
|
|
|
// Check slot.
|
|
if(s < _VisualSlots.size())
|
|
{
|
|
return (uint)_VisualSlots[s].size();
|
|
}
|
|
else
|
|
{
|
|
nlwarning("CSheetManager::getNumItem : invalid slot %d.", slot);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------
|
|
// getItem :
|
|
// Get the real.
|
|
//-----------------------------------------------
|
|
CItemSheet *CSheetManager::getItem(SLOTTYPE::EVisualSlot slot, uint index)
|
|
{
|
|
// The slot is not a visible one.
|
|
if(slot == SLOTTYPE::HIDDEN_SLOT)
|
|
return 0;
|
|
|
|
// Convert into an uint to remove warnings.
|
|
uint s = (uint)slot;
|
|
|
|
// Check slot.
|
|
if(s < _VisualSlots.size())
|
|
{
|
|
// Check index.
|
|
if(index < _VisualSlots[s].size())
|
|
{
|
|
// Not the default Item.
|
|
if(index != 0)
|
|
return _VisualSlots[s][index];
|
|
// Default Item.
|
|
else
|
|
return NULL;
|
|
}
|
|
// Bad index.
|
|
else
|
|
{
|
|
//nlwarning("CSheetManager::getItem : invalid index %d for the slot %d.", index, slot);
|
|
return NULL;
|
|
}
|
|
}
|
|
// Bad slot.
|
|
else
|
|
{
|
|
nlwarning("CSheetManager::getItem : invalid slot %d.", slot);
|
|
return NULL;
|
|
}
|
|
}// getItem //
|
|
|
|
|
|
//-----------------------------------------------
|
|
// loadTyp :
|
|
// Get Some information from 'typ' files.
|
|
//-----------------------------------------------
|
|
void CSheetManager::loadTyp()
|
|
{
|
|
// Read the Eyes Color 'typ'
|
|
NLMISC::CSmartPtr<NLGEORGES::UType> smartPtr = FormLoader->loadFormType("_creature_3d_eyes_color.typ");
|
|
if(smartPtr)
|
|
{
|
|
string maxStr = smartPtr->getMax();
|
|
fromString(maxStr, _NbEyesColor);
|
|
if(_NbEyesColor <= 0)
|
|
nlwarning("CSheetManager::loadTyp: There no is Color available for the eyes.");
|
|
}
|
|
else
|
|
nlwarning("CSheetManager::loadTyp: Cannot load the '_creature_3d_eyes_color.typ' file.");
|
|
|
|
// Read the Hair Color 'typ'
|
|
smartPtr = FormLoader->loadFormType("_creature_3d_hair_color.typ");
|
|
if(smartPtr)
|
|
{
|
|
string maxStr = smartPtr->getMax();
|
|
fromString(maxStr, _NbHairColor);
|
|
if(_NbHairColor <= 0)
|
|
nlwarning("CSheetManager::loadTyp: There is no Color available for the hair.");
|
|
}
|
|
else
|
|
nlwarning("CSheetManager::loadTyp: Cannot load the '_creature_3d_hair_color.typ' file.");
|
|
}// initTyp //
|
|
|
|
|
|
// ***************************************************************************
|
|
void CSheetManager::dumpVisualSlots()
|
|
{
|
|
for(uint k = 0; k < _VisualSlots.size(); ++k)
|
|
{
|
|
TItemVector &iv = _VisualSlots[k];
|
|
for(uint l = 0; l < iv.size(); ++l)
|
|
{
|
|
if (iv[l])
|
|
{
|
|
nlinfo("Slot %d, item %d = %s", (int) k, (int) l, iv[l]->Id.toString().c_str());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
void CSheetManager::dumpVisualSlotsIndex()
|
|
{
|
|
FILE * vsIndexFile = fopen(std::string(getLogDirectory() + "vs_index.txt").c_str(),"w");
|
|
if( vsIndexFile )
|
|
{
|
|
for (uint i=0; i < SLOTTYPE::NB_SLOT; ++i)
|
|
{
|
|
fprintf(vsIndexFile,"VISUAL SLOT : %d\n", i);
|
|
TItemVector &rVTmp = _VisualSlots[i];
|
|
for (uint j = 0; j < rVTmp.size(); ++j)
|
|
{
|
|
CItemSheet *pIS = rVTmp[j];
|
|
if (pIS != NULL)
|
|
{
|
|
fprintf(vsIndexFile,"%d : %s\n", j, pIS->Id.toString().c_str());
|
|
}
|
|
//nlSleep(100);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
nlwarning("<CSheetManager::loadAllSheet> Can't open file to dump VS index");
|
|
}
|
|
fclose(vsIndexFile);
|
|
}
|