#include "StaticDataMgr.h"

Inheritance diagram for StaticDataMgr:

Collaboration diagram for StaticDataMgr:

Public Member Functions
PyObject *	GetKeyMap ()

PyObjectEx *	GetAgents ()

PyObjectEx *	GetOperands ()

PyObject *	GetBillTypes ()

PyObject *	GetEntryTypes ()

PyTuple *	GetFactionInfo ()

PyObject *	GetNPCDivisions ()

Public Member Functions inherited from Singleton< StaticDataMgr >
	Singleton ()
	Primary constructor. More...

Private Types
typedef std::vector< uint16 >	rt_typeIDs

typedef std::map< uint16, rt_typeIDs >	rt_groups

Private Attributes
PyTuple *	m_factionInfo

PyObject *	m_keyMap

PyObject *	m_entryTypes

PyObject *	m_billTypes

PyObject *	m_npcDivisions

PyObjectEx *	m_agents

PyObjectEx *	m_operands

std::map< uint16, Inv::CatData >	m_catData

std::map< uint16, Inv::GrpData >	m_grpData

std::map< uint16, Inv::TypeData >	m_typeData

std::map< uint16, PyDict * >	m_bpMatlData

std::map< uint32, uint8 >	m_whRegions

std::map< uint32, uint32 >	m_regions

std::map< uint32, uint32 >	m_ratRegions

std::map< uint32, SystemData >	m_systemData

std::map< uint32, uint32 >	m_agentSystem

std::map< uint32, uint32 >	m_corpFaction

std::map< uint32, uint8 >	m_stationCount

std::map< uint32, std::vector < uint32 > >	m_stationList

std::map< uint32, uint32 >	m_stationRegion

std::map< uint32, uint32 >	m_stationConst

std::map< uint32, uint32 >	m_stationSystem

std::map< uint32, uint8 >	m_factionRaces

std::map< uint16, EvERam::bpTypeData >	m_bpTypeData

std::map< uint16, uint8 >	m_moonGoo

std::map< uint16, std::string >	m_skills

std::map< uint32, StaticData >	m_staticData

std::multimap< uint16, EvERam::RamMaterials >	m_ramMatl

std::multimap< uint16, EvERam::RamRequirements >	m_ramReq

std::multimap< std::string, OreTypeChance >	m_oreBySecClass

std::multimap< uint16, DmgTypeAttribute >	m_typeAttrMap

std::multimap< uint8, rt_groups >	m_npcTypes

std::multimap< uint8, RatSpawnClass >	m_npcClasses

std::multimap< uint32, RatFactionGroups >	m_npcGroups

std::multimap< uint32, uint32 >	m_salvageMap

std::map< uint32, uint32 >	m_WrecksToTypesMap

std::multimap< uint32, LootGroup >	m_LootGroupMap

std::multimap< uint32, LootGroupType >	m_LootGroupTypeMap

std::map< uint16, std::string >	m_salvage

std::map< uint16, std::string >	m_minerals

std::map< uint16, std::string >	m_compounds

std::map< uint16, std::string >	m_resources

std::map< uint16, std::string >	m_components

std::map< uint16, std::string >	m_commodities

std::map< uint16, std::string >	m_miscCommodities

std::map< uint16, EvERam::bpTypeData >	m_bpProductData

StaticDataMgr.cpp
memory object caching system for retrieving, managing and saving ingame data : Allan Date : 1Jul15 / 1Aug16 Original Idea - 1 July 15 Code completion and implementation - 1 August 2016
	StaticDataMgr ()

	~StaticDataMgr ()

int	Initialize ()

void	Clear ()

void	Close ()

void	GetInfo ()

void	GetCategory (uint8 catID, Inv::CatData &into)

void	GetGroup (uint16 grpID, Inv::GrpData &into)

void	GetType (uint16 typeID, Inv::TypeData &into)

void	GetTypes (std::map< uint16, Inv::TypeData > &into)

const char *	GetTypeName (uint16 typeID)

const char *	GetGroupName (uint16 grpID)

const char *	GetCategoryName (uint8 catID)

void	GetMineralData (std::map< uint16, Market::matlData > &into)

void	GetSalvageData (std::map< uint16, Market::matlData > &into)

void	GetCompoundData (std::map< uint16, Market::matlData > &into)

void	GetComponentData (std::map< uint16, Market::matlData > &into)

void	GetPIResourceData (std::map< uint16, Market::matlData > &into)

void	GetPICommodityData (std::map< uint16, Market::matlData > &into)

void	GetMiscCommodityData (std::map< uint16, Market::matlData > &into)

void	GetMoonResouces (std::map< uint16, uint8 > &data)

bool	IsSkillTypeID (uint16 typeID)

bool	GetSkillName (uint16 skillID, std::string &name)

bool	GetNPCTypes (uint16 groupID, std::vector< uint16 > &typeVec)

bool	GetNPCGroups (uint32 factionID, std::map< uint8, uint16 > &groupMap)

bool	GetNPCClasses (uint8 sClass, std::vector< RatSpawnClass > &classMap)

uint16	GetRandRatType (uint8 sClass, uint16 groupID)

uint32	GetWreckID (uint32 typeID)

void	GetLoot (uint32 groupID, std::vector< LootList > &lootList)

bool	IsRefinable (uint16 typeID)

bool	IsRecyclable (uint16 typeID)

void	GetRamReturns (uint16 typeID, int8 activityID, std::vector< EvERam::RequiredItem > &ramReqs)

void	GetRamMaterials (uint16 typeID, std::vector< EvERam::RamMaterials > &ramMatls)

void	GetRamRequirements (uint16 typeID, std::vector< EvERam::RamRequirements > &ramReqs)

void	GetRamRequiredItems (const uint32 typeID, const int8 activity, std::vector< EvERam::RequiredItem > &into)

bool	GetStaticInfo (uint32 itemID, StaticData &data)

uint16	GetStaticType (uint32 itemID)

const char *	GetSystemName (uint32 locationID)

bool	GetSystemData (uint32 locationID, SystemData &data)

PyRep *	GetStationCount ()

uint32	GetStationRegion (uint32 stationID)

uint32	GetStationConstellation (uint32 stationID)

uint32	GetStationSystem (uint32 stationID)

uint8	GetStationCount (uint32 systemID)

bool	GetStationList (uint32 systemID, std::vector< uint32 > &data)

bool	GetRoidDist (const char *secClass, std::unordered_multimap< float, uint16 > &roids)

uint8	GetRegionQuarter (uint32 regionID)

uint32	GetRegionFaction (uint32 regionID)

uint32	GetRegionRatFaction (uint32 regionID)

uint8	GetWHSystemClass (uint32 systemID)

void	GetDgmTypeAttrVec (uint16 typeID, std::vector< DmgTypeAttribute > &typeAttrVec)

PyDict *	SetBPMatlType (int8 catID, uint16 typeID, uint16 prodID)

PyDict *	GetBPMatlData (uint16 typeID)

void	GetBpTypeData (uint16 typeID, EvERam::bpTypeData &tData)

bool	GetBpDataForItem (uint16 typeID, EvERam::bpTypeData &tData)

uint32	GetFactionCorp (uint32 factionID)

uint32	GetCorpFaction (uint32 corpID)

uint32	GetRaceFaction (uint8 raceID)

uint8	GetFactionRace (uint32 factionID)

std::string	GetCorpName (uint32 corpID)

std::string	GetFactionName (uint32 factionID)

const char *	GetRaceName (uint8 raceID)

void	GetSalvage (uint32 factionID, std::vector< uint32 > &itemList)

const char *	GetFlagName (uint16 flag)

const char *	GetFlagName (EVEItemFlags flag)

const char *	GetRigSizeName (uint8 size)

PyInt *	GetAgentSystemID (int32 agentID)

std::string	GetOwnerName (int32 ownerID)

const char *	GetProcStateName (int8 state)

uint32	GetWreckFaction (uint32 typeID)

bool	IsStation (uint32 stationID=0)

bool	IsSolarSystem (uint32 systemID=0)

DBRowDescriptor *	CreateHeader ()

void	Populate ()

Additional Inherited Members
Static Public Member Functions inherited from Singleton< StaticDataMgr >
static StaticDataMgr &	get ()

Static Protected Attributes inherited from Singleton< StaticDataMgr >
static std::shared_ptr < StaticDataMgr >	mInstance

Detailed Description

Definition at line 28 of file StaticDataMgr.h.

Member Typedef Documentation

typedef std::map<uint16, rt_typeIDs> StaticDataMgr::rt_groups

private

Definition at line 193 of file StaticDataMgr.h.

typedef std::vector<uint16> StaticDataMgr::rt_typeIDs

private

Definition at line 192 of file StaticDataMgr.h.

Constructor & Destructor Documentation

StaticDataMgr::StaticDataMgr ( )

Definition at line 29 of file StaticDataMgr.cpp.

References m_agentSystem, m_bpMatlData, m_compounds, m_corpFaction, m_LootGroupMap, m_LootGroupTypeMap, m_minerals, m_moonGoo, m_oreBySecClass, m_ramMatl, m_ramReq, m_regions, m_salvageMap, m_staticData, m_stationConst, m_stationCount, m_stationRegion, m_stationSystem, m_systemData, m_typeAttrMap, and m_WrecksToTypesMap.

 : m_keyMap(nullptr),
 m_agents(nullptr),
 m_operands(nullptr),
 m_billTypes(nullptr),
 m_entryTypes(nullptr),
 m_factionInfo(nullptr),
 m_npcDivisions(nullptr)
 {
     m_ramReq.clear();
     m_moonGoo.clear();
     m_ramMatl.clear();
     m_regions.clear();
     m_compounds.clear();
     m_minerals.clear();
     m_bpMatlData.clear();
     m_systemData.clear();
     m_staticData.clear();
     m_salvageMap.clear();
     m_agentSystem.clear();
     m_corpFaction.clear();
     m_typeAttrMap.clear();
     m_LootGroupMap.clear();
     m_stationCount.clear();
     m_stationConst.clear();
     m_stationRegion.clear();
     m_stationSystem.clear();
     m_oreBySecClass.clear();
     m_LootGroupTypeMap.clear();
     m_WrecksToTypesMap.clear();
 }

StaticDataMgr::~StaticDataMgr ( )

Definition at line 61 of file StaticDataMgr.cpp.

 {
     //Clear();
 }

Member Function Documentation

void StaticDataMgr::Clear ( )

Definition at line 90 of file StaticDataMgr.cpp.

References m_agents, m_agentSystem, m_billTypes, m_bpMatlData, m_compounds, m_corpFaction, m_entryTypes, m_factionInfo, m_keyMap, m_LootGroupMap, m_LootGroupTypeMap, m_minerals, m_moonGoo, m_npcDivisions, m_operands, m_oreBySecClass, m_ramMatl, m_ramReq, m_regions, m_salvageMap, m_staticData, m_stationConst, m_stationCount, m_stationRegion, m_stationSystem, m_systemData, m_typeAttrMap, m_WrecksToTypesMap, and PySafeDecRef.

 {
     m_ramReq.clear();
     m_moonGoo.clear();
     m_ramMatl.clear();
     m_regions.clear();
     m_compounds.clear();
     m_minerals.clear();
     m_systemData.clear();
     m_staticData.clear();
     m_salvageMap.clear();
     m_agentSystem.clear();
     m_corpFaction.clear();
     m_typeAttrMap.clear();
     m_stationCount.clear();
     m_stationConst.clear();
     m_LootGroupMap.clear();
     m_stationRegion.clear();
     m_stationSystem.clear();
     m_oreBySecClass.clear();
     m_LootGroupTypeMap.clear();
     m_WrecksToTypesMap.clear();
 
     PySafeDecRef(m_keyMap);
     PySafeDecRef(m_agents);
     PySafeDecRef(m_operands);
     PySafeDecRef(m_billTypes);
     PySafeDecRef(m_entryTypes);
     PySafeDecRef(m_factionInfo);
     PySafeDecRef(m_npcDivisions);
 
     for (auto cur : m_bpMatlData)
         PySafeDecRef(cur.second);
     m_bpMatlData.clear();
 }

void StaticDataMgr::Close ( )

Definition at line 66 of file StaticDataMgr.cpp.

References m_agents, m_billTypes, m_bpMatlData, m_entryTypes, m_factionInfo, m_keyMap, m_npcDivisions, m_operands, PySafeDecRef, and sLog.

 {
     PySafeDecRef(m_keyMap);
     PySafeDecRef(m_agents);
     PySafeDecRef(m_operands);
     PySafeDecRef(m_billTypes);
     PySafeDecRef(m_entryTypes);
     PySafeDecRef(m_factionInfo);
     PySafeDecRef(m_npcDivisions);
 
     for (auto cur : m_bpMatlData)
         PySafeDecRef(cur.second);
 
     sLog.Warning("    StaticDataMgr", "Static Data Manager has been closed." );
 }

DBRowDescriptor * StaticDataMgr::CreateHeader ( )

Definition at line 1234 of file StaticDataMgr.cpp.

References DBRowDescriptor::AddColumn(), PyList::AddItem(), DBTYPE_I2, DBTYPE_I4, DBTYPE_I8, DBTYPE_STR, and new_tuple().

                                              {
     // this is correct data for crucible.  dont alter
     PyList *keywords = new PyList();
         keywords->AddItem(new_tuple(new PyString("stacksize"), new PyToken("util.StackSize")));
         keywords->AddItem(new_tuple(new PyString("singleton"), new PyToken("util.Singleton")));
     DBRowDescriptor* header = new DBRowDescriptor(keywords);
         header->AddColumn("itemID",     DBTYPE_I8);
         header->AddColumn("typeID",     DBTYPE_I4);
         header->AddColumn("ownerID",    DBTYPE_I4);
         header->AddColumn("locationID", DBTYPE_I4);
         header->AddColumn("flagID",     DBTYPE_I2);
         header->AddColumn("quantity",   DBTYPE_I4);
         header->AddColumn("groupID",    DBTYPE_I4);
         header->AddColumn("categoryID", DBTYPE_I4);
         header->AddColumn("customInfo", DBTYPE_STR);
     return header;
 }

Here is the call graph for this function:

PyObjectEx* StaticDataMgr::GetAgents ( )

inline

Definition at line 42 of file StaticDataMgr.h.

References m_agents, and PyIncRef.

42 { PyIncRef(m_agents); return m_agents; }

PyIncRef

#define PyIncRef(op)

Definition: PyRep.h:56

StaticDataMgr::m_agents

PyObjectEx * m_agents

Definition: StaticDataMgr.h:159

PyInt * StaticDataMgr::GetAgentSystemID ( int32 agentID )

Definition at line 643 of file StaticDataMgr.cpp.

References _log, and m_agentSystem.

 {
     std::map<uint32, uint32>::iterator itr = m_agentSystem.find(agentID);
     if (itr != m_agentSystem.end())
         return new PyInt(itr->second);
 
     _log(DATA__WARNING, "Failed to query system info for agent %u: Agent not found.", agentID);
     return new PyInt(0);
 }

PyObject* StaticDataMgr::GetBillTypes ( )

inline

Definition at line 44 of file StaticDataMgr.h.

References m_billTypes, and PyIncRef.

44 { PyIncRef(m_billTypes); return m_billTypes; }

StaticDataMgr::m_billTypes

PyObject * m_billTypes

Definition: StaticDataMgr.h:157

PyIncRef

#define PyIncRef(op)

Definition: PyRep.h:56

bool StaticDataMgr::GetBpDataForItem	(	uint16	typeID,
		EvERam::bpTypeData &	tData
	)

Definition at line 912 of file StaticDataMgr.cpp.

References m_bpProductData.

 {
     std::map<uint16, EvERam::bpTypeData>::iterator itr = m_bpProductData.find(typeID);
     if (itr != m_bpProductData.end()) {
         tData = itr->second;
         return true;
     }
     return false;
 }

PyDict * StaticDataMgr::GetBPMatlData ( uint16 typeID )

Definition at line 1252 of file StaticDataMgr.cpp.

References m_bpMatlData, and PyIncRef.

 {
     auto itr = m_bpMatlData.find(typeID);
     if (itr != m_bpMatlData.end()) {
         PyIncRef(itr->second);
         itr->second->Dump(MANUF__DEBUG, "    ");
         return itr->second;
     }
     return nullptr;
 }

void StaticDataMgr::GetBpTypeData	(	uint16	typeID,
		EvERam::bpTypeData &	tData
	)

Definition at line 902 of file StaticDataMgr.cpp.

References _log, and m_bpTypeData.

 {
     std::map<uint16, EvERam::bpTypeData>::iterator itr = m_bpTypeData.find(typeID);
     if (itr != m_bpTypeData.end()) {
         tData = itr->second;
     } else {
         _log(DATA__MESSAGE, "Failed to query info for bpType %u: Type not found.", typeID);
     }
 }

void StaticDataMgr::GetCategory	(	uint8	catID,
		Inv::CatData &	into
	)

Definition at line 586 of file StaticDataMgr.cpp.

References m_catData.

 {
     std::map<uint16, Inv::CatData>::const_iterator itr = m_catData.find(catID);
     if (itr != m_catData.end())
         into = itr->second;
 }

const char * StaticDataMgr::GetCategoryName ( uint8 catID )

Definition at line 593 of file StaticDataMgr.cpp.

References _log, and m_catData.

 {
     std::map<uint16, Inv::CatData>::const_iterator itr = m_catData.find(catID);
     if (itr != m_catData.end())
         return itr->second.name.c_str();
 
     _log(DATA__ERROR, "GetCategoryName() - Category %u not found in map", catID);
     return "None";
 }

void StaticDataMgr::GetComponentData ( std::map< uint16, Market::matlData > & into )

Definition at line 693 of file StaticDataMgr.cpp.

References m_components, Market::matlData::name, and Market::matlData::typeID.

 {
     for (auto cur : m_components) {
         Market::matlData data = Market::matlData();
         data.typeID = cur.first;
         data.name = cur.second;
         into[cur.first] = data;
     }
 }

void StaticDataMgr::GetCompoundData ( std::map< uint16, Market::matlData > & into )

Definition at line 713 of file StaticDataMgr.cpp.

References m_compounds, Market::matlData::name, and Market::matlData::typeID.

 {
     for (auto cur : m_compounds) {
         Market::matlData data = Market::matlData();
         data.typeID = cur.first;
         data.name = cur.second;
         into[cur.first] = data;
     }
 }

uint32 StaticDataMgr::GetCorpFaction ( uint32 corpID )

Definition at line 1595 of file StaticDataMgr.cpp.

References _log, GetCorpName(), if(), IsNPCCorp, and m_corpFaction.

 {
     std::map<uint32, uint32>::iterator itr = m_corpFaction.find(corpID);
     if (itr != m_corpFaction.end())
         return itr->second;
 
     if (IsNPCCorp(corpID))
         _log(DATA__ERROR, "Faction not found for NPC corp %s", GetCorpName(corpID).c_str());
 
     return 0;
 }

Here is the call graph for this function:

std::string StaticDataMgr::GetCorpName ( uint32 corpID )

Definition at line 1578 of file StaticDataMgr.cpp.

References _log, corpArchangels, corpBloodRaider, corpGuristas, corpRogueDrones, corpSerpentis, corpSerpentisInquest, corpTrueCreations, and corpTruePower.

Referenced by GetCorpFaction().

 {
     switch (corpID) {
         case corpArchangels:        return "Angel Cartel";
         case corpTrueCreations:     return "True Creations/Sansha";    // sansha's nation
         case corpTruePower:         return "True Power/Sansha";   // sansha's nation
         case corpBloodRaider:       return "Blood Raiders";
         case corpGuristas:          return "Guristas";
         case corpSerpentis:         return "Serpentis";
         case corpSerpentisInquest:  return "Serpentis Inquest";
         case corpRogueDrones:       return "Rogue Drones";
     }
 
     _log(DATA__ERROR, "Name not found for corp %u", corpID);
     return "Undefined - WIP";
 }

Here is the caller graph for this function:

void StaticDataMgr::GetDgmTypeAttrVec	(	uint16	typeID,
		std::vector< DmgTypeAttribute > &	typeAttrVec
	)

Definition at line 669 of file StaticDataMgr.cpp.

References m_typeAttrMap.

 {
     auto itr = m_typeAttrMap.equal_range(typeID);
     for (auto it = itr.first; it != itr.second; ++it)
         typeAttrVec.push_back(it->second);
 }

PyObject* StaticDataMgr::GetEntryTypes ( )

inline

Definition at line 45 of file StaticDataMgr.h.

References m_entryTypes, and PyIncRef.

45 { PyIncRef(m_entryTypes); return m_entryTypes; }

StaticDataMgr::m_entryTypes

PyObject * m_entryTypes

Definition: StaticDataMgr.h:156

PyIncRef

#define PyIncRef(op)

Definition: PyRep.h:56

uint32 StaticDataMgr::GetFactionCorp ( uint32 factionID )

Definition at line 1541 of file StaticDataMgr.cpp.

References corpAmarrNavy, corpAmmatarConsulate, corpArchangels, corpBloodRaider, corpCaldariNavy, corpCONCORD, corpGuristas, corpInterbus, corpJovianDirectorate, corpKhanidNavy, corpMordusLegion, corpORE, corpRogueDrones, corpSerpentis, corpSocietyofCT, corpSoE, corpThukkerMix, corpTruePower, factionAmarr, factionAmmatar, factionAngel, factionBloodRaider, factionCaldari, factionCONCORD, factionGallente, factionGuristas, factionInterBus, factionJove, factionKhanid, factionMordusLegion, factionNoFaction, factionORE, factionRogueDrones, factionSanshas, factionSerpentis, factionSistersOfEVE, factionSociety, and factionThukker.

 {
     switch (factionID) {
         case factionAngel:          return corpArchangels;
         case factionSanshas:        return corpTruePower;
         case factionBloodRaider:    return corpBloodRaider;
         case factionGuristas:       return corpGuristas;
         case factionSerpentis:      return corpSerpentis;
         case factionRogueDrones:    return corpRogueDrones;
 
         case factionCONCORD:        return corpCONCORD;
         case factionInterBus:       return corpInterbus;
         case factionSociety:        return corpSocietyofCT;
         case factionMordusLegion:   return corpMordusLegion;
 
         case factionCaldari:        return corpCaldariNavy;
         case factionORE:            return corpORE;
         case factionAmarr:          return corpAmarrNavy;
         case factionGallente:       return corpGuristas;
         case factionJove:           return corpJovianDirectorate;
         case factionAmmatar:        return corpAmmatarConsulate;
 
         case factionKhanid:         return corpKhanidNavy;
         case factionThukker:        return corpThukkerMix;
         case factionSistersOfEVE:   return corpSoE;
 
         case factionNoFaction:
         default:                    return 0;
 
         //case factionSleepers:    return corpRogueDrones;
         //case factionMinmatar:        return corp;
         //case factionSyndicate:    return corps;
     }
 
     return 0;
 }

PyTuple* StaticDataMgr::GetFactionInfo ( )

inline

Definition at line 46 of file StaticDataMgr.h.

References m_factionInfo, and PyIncRef.

46 { PyIncRef(m_factionInfo); return m_factionInfo; }

StaticDataMgr::m_factionInfo

PyTuple * m_factionInfo

Definition: StaticDataMgr.h:154

PyIncRef

#define PyIncRef(op)

Definition: PyRep.h:56

std::string StaticDataMgr::GetFactionName ( uint32 factionID )

Definition at line 1607 of file StaticDataMgr.cpp.

References factionAngel, factionBloodRaider, factionGuristas, factionRogueDrones, factionSanshas, and factionSerpentis.

 {
     switch (factionID) {
         case factionAngel:          return "Angel Cartel";
         case factionSanshas:        return "Sansha Nation";
         case factionBloodRaider:    return "Blood Raiders";
         case factionGuristas:       return "Guristas Pirates";
         case factionSerpentis:      return "Serpentis";
         case factionRogueDrones:    return "Drone";
     }
     return "Undefined";
 }

uint8 StaticDataMgr::GetFactionRace ( uint32 factionID )

Definition at line 1652 of file StaticDataMgr.cpp.

References Char::Race::Amarr, Char::Race::Ammatar, Char::Race::Caldari, factionAmarr, factionAmmatar, factionCaldari, factionGallente, factionJove, factionMinmatar, factionNoFaction, factionORE, factionSleepers, Char::Race::Gallente, Char::Race::Jove, Char::Race::Minmatar, Char::Race::ORE, Char::Race::Pirate, and Char::Race::Sleepers.

 {
     switch (factionID) {
         case factionCaldari:        return Char::Race::Caldari;
         case factionMinmatar:       return Char::Race::Minmatar;
         case factionAmarr:          return Char::Race::Amarr;
         case factionGallente:       return Char::Race::Gallente;
         case factionJove:           return Char::Race::Jove;
         case factionNoFaction:      return Char::Race::Pirate;
         case factionSleepers:       return Char::Race::Sleepers;
         case factionORE:            return Char::Race::ORE;
         case factionAmmatar:        return Char::Race::Ammatar;
     }
     // default to Gallente
     return Char::Race::Gallente;
 }

const char * StaticDataMgr::GetFlagName ( uint16 flag )

Definition at line 1700 of file StaticDataMgr.cpp.

 {
     return GetFlagName((EVEItemFlags)flag);
 }

const char * StaticDataMgr::GetFlagName ( EVEItemFlags flag )

Definition at line 1705 of file StaticDataMgr.cpp.

References flagAmmoHold, flagBoardingGate, flagBonus, flagBooster, flagBriefcase, flagCapsule, flagCaptainsQuarters, flagCargoHold, flagClone, flagCommandCenterHold, flagConnected, flagCorpHangar2, flagCorpHangar3, flagCorpHangar4, flagCorpHangar5, flagCorpHangar6, flagCorpHangar7, flagCorpMarket, flagCrew, flagDisconnected, flagDroneBay, flagDustCharacterBackpack, flagDustCharacterBattle, flagFactoryActive, flagFactoryBlueprint, flagFactoryMinerals, flagFactoryOperation, flagFactoryOutput, flagFixedSlot, flagFleetHangar, flagFuelBay, flagGasHold, flagHangar, flagHiSlot0, flagHiSlot1, flagHiSlot2, flagHiSlot3, flagHiSlot4, flagHiSlot5, flagHiSlot6, flagHiSlot7, flagIllegal, flagImplant, flagImpounded, flagIndustrialShipHold, flagJunkyardReprocessed, flagJunkyardTrashed, flagLargeShipHold, flagLocked, flagLowSlot0, flagLowSlot1, flagLowSlot2, flagLowSlot3, flagLowSlot4, flagLowSlot5, flagLowSlot6, flagLowSlot7, flagMaterialBay, flagMediumShipHold, flagMidSlot0, flagMidSlot1, flagMidSlot2, flagMidSlot3, flagMidSlot4, flagMidSlot5, flagMidSlot6, flagMidSlot7, flagMineralHold, flagMissile, flagNone, flagOffice, flagOreHold, flagPassenger, flagPilot, flagPlanetaryCommoditiesHold, flagPlanetSurface, flagProperty, flagQuafeBay, flagResearchFacilitySlotFirst, flagResearchFacilitySlotLast, flagReward, flagRigSlot0, flagRigSlot1, flagRigSlot2, flagRigSlot3, flagRigSlot4, flagRigSlot5, flagRigSlot6, flagRigSlot7, flagSalvageHold, flagSecondaryStorage, flagShipHangar, flagShipHold, flagShipOffline, flagSkill, flagSkillInTraining, flagSmallShipHold, flagStructureActive, flagStructureInactive, flagSubSystem0, flagSubSystem1, flagSubSystem2, flagSubSystem3, flagSubSystem4, flagSubSystem5, flagSubSystem6, flagSubSystem7, flagUnlocked, flagWallet, flagWardrobe, and flagWisPromenade.

 {
     switch (flag) {
         case flagNone:                          return "AutoFit";
         case flagWallet:                        return "Wallet";
         //case flagFactory:                       return "Factory";
         case flagWardrobe:                      return "Wardrobe";
         case flagHangar:                        return "Hangar";
         case flagCargoHold:                     return "Cargo Hold";
         case flagBriefcase:                     return "Briefcase";
         case flagSkill:                         return "Skill";
         case flagReward:                        return "Reward";
         case flagConnected:                     return "Connected";
         case flagDisconnected:                  return "Disconnected";
         case flagLowSlot0:                      return "First Low Slot";
         case flagLowSlot1:                      return "Second Low Slot";
         case flagLowSlot2:                      return "Third Low Slot";
         case flagLowSlot3:                      return "Fourth Low Slot";
         case flagLowSlot4:                      return "Fifth Low Slot";
         case flagLowSlot5:                      return "Sixth Low Slot";
         case flagLowSlot6:                      return "Seventh Low Slot";
         case flagLowSlot7:                      return "Eighth Low Slot";
         case flagMidSlot0:                      return "First Mid Slot";
         case flagMidSlot1:                      return "Second Mid Slot";
         case flagMidSlot2:                      return "Third Mid Slot";
         case flagMidSlot3:                      return "Fourth Mid Slot";
         case flagMidSlot4:                      return "Fifth Mid Slot";
         case flagMidSlot5:                      return "Sixth Mid Slot";
         case flagMidSlot6:                      return "Seventh Mid Slot";
         case flagMidSlot7:                      return "Eighth Mid Slot";
         case flagHiSlot0:                       return "First Hi Slot";
         case flagHiSlot1:                       return "Second Hi Slot";
         case flagHiSlot2:                       return "Third Hi Slot";
         case flagHiSlot3:                       return "Fourth Hi Slot";
         case flagHiSlot4:                       return "Fifth Hi Slot";
         case flagHiSlot5:                       return "Sixth Hi Slot";
         case flagHiSlot6:                       return "Seventh Hi Slot";
         case flagHiSlot7:                       return "Eighth Hi Slot";
         case flagFixedSlot:                     return "Fixed Slot";
         case flagFactoryBlueprint:              return "Factory Blueprint";
         case flagFactoryMinerals:               return "Factory Minerals";
         case flagFactoryOutput:                 return "Factory Output";
         case flagFactoryActive:                 return "Factory Active";
         //case flagPromenadeSlot1:                return "PromenadeSlot1";
         case flagCapsule:                       return "Capsule";
         case flagPilot:                         return "Pilot";
         case flagPassenger:                     return "Passenger";
         case flagBoardingGate:                  return "Boarding Gate";
         case flagCrew:                          return "Crew";
         case flagSkillInTraining:               return "Skill In Training";
         case flagCorpMarket:                    return "Corp Market";
         case flagLocked:                        return "Locked";
         case flagUnlocked:                      return "Unlocked";
         case flagOffice:                        return "Office";
         case flagImpounded:                     return "Impounded";
         case flagProperty:                      return "Property";
         //case flagDelivery:                      return "Delivery";
         case flagBonus:                         return "Bonus";
         case flagDroneBay:                      return "Drone Bay";
         case flagBooster:                       return "Booster";
         case flagImplant:                       return "Implant";
         case flagShipHangar:                    return "Ship Hangar";
         case flagShipOffline:                   return "Ship Offline";
         case flagRigSlot0:                      return "First Rig Slot";
         case flagRigSlot1:                      return "Second Rig Slot";
         case flagRigSlot2:                      return "Third Rig Slot";
         case flagRigSlot3:                      return "Fourth Rig Slot";
         case flagRigSlot4:                      return "Fifth Rig Slot";
         case flagRigSlot5:                      return "Sixth Rig Slot";
         case flagRigSlot6:                      return "Seventh Rig Slot";
         case flagRigSlot7:                      return "Eighth Rig Slot";
         case flagFactoryOperation:              return "Factory Operation";
         case flagCorpHangar2:                   return "CorpHangar2";
         case flagCorpHangar3:                   return "CorpHangar3";
         case flagCorpHangar4:                   return "CorpHangar4";
         case flagCorpHangar5:                   return "CorpHangar5";
         case flagCorpHangar6:                   return "CorpHangar6";
         case flagCorpHangar7:                   return "CorpHangar7";
         case flagSecondaryStorage:              return "Secondary Storage";
         case flagCaptainsQuarters:              return "Captains Quarters";
         case flagWisPromenade:                  return "Promenade";
         //case flagWorldSpace:                  return "WorldSpace";
         case flagSubSystem0:                    return "First SubSystem";
         case flagSubSystem1:                    return "Second SubSystem";
         case flagSubSystem2:                    return "Third SubSystem";
         case flagSubSystem3:                    return "Fourth SubSystem";
         case flagSubSystem4:                    return "Fifth SubSystem";
         case flagSubSystem5:                    return "Sixth SubSystem";
         case flagSubSystem6:                    return "Seventh SubSystem";
         case flagSubSystem7:                    return "Eighth SubSystem";
         case flagFuelBay:                       return "Fuel Bay";
         case flagOreHold:                       return "Ore Hold";
         case flagGasHold:                       return "Gas Hold";
         case flagMineralHold:                   return "Mineral Hold";
         case flagSalvageHold:                   return "Salvage Hold";
         case flagShipHold:                      return "Ship Hold";
         case flagSmallShipHold:                 return "Small Ship Hold";
         case flagMediumShipHold:                return "Medium Ship Hold";
         case flagLargeShipHold:                 return "Large Ship Hold";
         case flagIndustrialShipHold:            return "Industrial Ship Hold";
         case flagAmmoHold:                      return "Ammunition Hold";
         case flagStructureActive:               return "Structure Active";
         case flagStructureInactive:             return "Structure Inactive";
         case flagJunkyardReprocessed:           return "Junkyard Reprocessed";
         case flagJunkyardTrashed:               return "Junkyard Trashed";
         case flagCommandCenterHold:             return "Command Center Hold";
         case flagPlanetaryCommoditiesHold:      return "Planetary Commodities Hold";
         case flagPlanetSurface:                 return "Planet Surface";
         case flagMaterialBay:                   return "Material Bay";
         case flagDustCharacterBackpack:         return "DustCharacterBackpack";
         case flagDustCharacterBattle:           return "DustCharacterBattle";
         case flagQuafeBay:                      return "Quafe Bay";
         case flagFleetHangar:                   return "Fleet Hangar";
         case flagResearchFacilitySlotFirst:     return "ResearchFacilitySlotFirst";
         case flagResearchFacilitySlotLast:      return "ResearchFacilitySlotLast";
         case flagMissile:                       return "Missile";
         case flagClone:                         return "Clone";
         case flagIllegal:                       return "Illegal";
     }
     return "Undefined";
 }

void StaticDataMgr::GetGroup	(	uint16	grpID,
		Inv::GrpData &	into
	)

Definition at line 603 of file StaticDataMgr.cpp.

References m_grpData.

 {
     std::map<uint16, Inv::GrpData>::const_iterator itr = m_grpData.find(grpID);
     if (itr != m_grpData.end())
         into = itr->second;
 }

const char * StaticDataMgr::GetGroupName ( uint16 grpID )

Definition at line 610 of file StaticDataMgr.cpp.

References _log, and m_grpData.

 {
     std::map<uint16, Inv::GrpData>::const_iterator itr = m_grpData.find(grpID);
     if (itr != m_grpData.end())
         return itr->second.name.c_str();
 
     _log(DATA__ERROR, "GetGroupName() - Group %u not found in map", grpID);
     return "None";
 }

void StaticDataMgr::GetInfo ( )

Definition at line 576 of file StaticDataMgr.cpp.

 {
     /* return info about loaded items? */
     /*
      * m_systemData;
      * m_staticData;
      *
      */
 }

PyObject* StaticDataMgr::GetKeyMap ( )

inline

Definition at line 41 of file StaticDataMgr.h.

References m_keyMap, and PyIncRef.

41 { PyIncRef(m_keyMap); return m_keyMap; }

StaticDataMgr::m_keyMap

PyObject * m_keyMap

Definition: StaticDataMgr.h:155

PyIncRef

#define PyIncRef(op)

Definition: PyRep.h:56

void StaticDataMgr::GetLoot	(	uint32	groupID,
		std::vector< LootList > &	lootList
	)

Definition at line 847 of file StaticDataMgr.cpp.

References GetTimeUSeconds(), LootList::itemID, Profile::loot, m_LootGroupMap, m_LootGroupTypeMap, MakeRandomFloat(), MakeRandomInt(), LootList::maxDrop, LootList::minDrop, sConfig, and sProfiler.

                                                                          {
     double profileStartTime = GetTimeUSeconds();
 
     float randChance(0.0f);
     uint8 metaLevel(0);
     std::vector<LootGroupType> lootGrpVec;
     lootGrpVec.clear();
 
     // Finds a range containing all elements whose key is k.
     // pair<iterator, iterator> equal_range(const key_type& k)
     auto range = m_LootGroupMap.equal_range(groupID);
     for ( auto it = range.first; it != range.second; ++it ) {
         // make lootMap of lootGroupID's
         if (MakeRandomFloat(0, 1) < it->second.dropChance) {
             randChance = MakeRandomFloat(0, 1);
             metaLevel = 0;
             if (randChance < 0.1) {
                 metaLevel = 4;
             } else if (randChance < 0.25) {
                 metaLevel = 3;
             } else if (randChance < 0.4) {
                 metaLevel = 2;
             } else if (randChance < 0.6) {
                 metaLevel = 1;
             }
             /*need to figure out how to get faction loot for faction wrecks
              *    elif meta_level == 7:
              *        drop_chance = 0.15   # Faction stuff = 15%
              *    elif meta_level == 8:
              *        drop_chance = 0.15   # Faction projectiles = 15%
              *    elif meta_level == 9:
              *        drop_chance = 0.15   # Faction SB's and Missile launchers
              */
 
             auto range2 = m_LootGroupTypeMap.equal_range(it->second.lootGroupID);
             for (auto it2 = range2.first; it2 != range2.second; ++it2)
                 if (it2->second.metaLevel == metaLevel)
                     lootGrpVec.push_back(it2->second);
 
             if (!lootGrpVec.empty()) {
                 LootList loot_list;
                 uint16 i = MakeRandomInt(0, lootGrpVec.size());
                 loot_list.itemID = lootGrpVec[i].typeID;
                 loot_list.minDrop = lootGrpVec[i].minQuantity;
                 loot_list.maxDrop = lootGrpVec[i].maxQuantity;
                 lootList.push_back(loot_list);
                 lootGrpVec.clear();
             }
         }
     }
 
     if (sConfig.debug.UseProfiling)
         sProfiler.AddTime(Profile::loot, GetTimeUSeconds() - profileStartTime);
 }

Here is the call graph for this function:

void StaticDataMgr::GetMineralData ( std::map< uint16, Market::matlData > & into )

Definition at line 703 of file StaticDataMgr.cpp.

References m_minerals, Market::matlData::name, and Market::matlData::typeID.

 {
     for (auto cur : m_minerals) {
         Market::matlData data = Market::matlData();
         data.typeID = cur.first;
         data.name = cur.second;
         into[cur.first] = data;
     }
 }

void StaticDataMgr::GetMiscCommodityData ( std::map< uint16, Market::matlData > & into )

Definition at line 753 of file StaticDataMgr.cpp.

References m_miscCommodities, Market::matlData::name, and Market::matlData::typeID.

 {
     for (auto cur : m_miscCommodities) {
         Market::matlData data = Market::matlData();
         data.typeID = cur.first;
         data.name = cur.second;
         into[cur.first] = data;
     }
 }

void StaticDataMgr::GetMoonResouces ( std::map< uint16, uint8 > & data )

Definition at line 763 of file StaticDataMgr.cpp.

References m_moonGoo.

 {
     // make copy
     for (auto cur : m_moonGoo)
         data.emplace(cur.first, cur.second);
 }

bool StaticDataMgr::GetNPCClasses	(	uint8	sClass,
		std::vector< RatSpawnClass > &	classMap
	)

Definition at line 812 of file StaticDataMgr.cpp.

References RatSpawnClass::ac, RatSpawnClass::af, RatSpawnClass::bc, RatSpawnClass::bs, RatSpawnClass::c, RatSpawnClass::cbc, RatSpawnClass::cbs, RatSpawnClass::cc, RatSpawnClass::cd, RatSpawnClass::cf, RatSpawnClass::d, RatSpawnClass::f, RatSpawnClass::h, m_npcClasses, RatSpawnClass::o, RatSpawnClass::sub, and RatSpawnClass::type.

 {
     auto classRange = m_npcClasses.equal_range(sClass);
     for (auto it = classRange.first; it != classRange.second; ++it) {
         RatSpawnClass spawnClass = RatSpawnClass();
         spawnClass.type = it->second.type;
         spawnClass.sub = it->second.sub;
         spawnClass.f = it->second.f;
         spawnClass.af = it->second.af;
         spawnClass.d = it->second.d;
         spawnClass.c = it->second.c;
         spawnClass.ac = it->second.ac;
         spawnClass.bc = it->second.bc;
         spawnClass.bs = it->second.bs;
         spawnClass.h = it->second.h;
         spawnClass.o = it->second.o;
         spawnClass.cf = it->second.cf;
         spawnClass.cd = it->second.cd;
         spawnClass.cc = it->second.cc;
         spawnClass.cbc = it->second.cbc;
         spawnClass.cbs = it->second.cbs;
         classMap.push_back(spawnClass);
     }
 
     return !classMap.empty();
 }

PyObject* StaticDataMgr::GetNPCDivisions ( )

inline

Definition at line 47 of file StaticDataMgr.h.

References m_npcDivisions, and PyIncRef.

47 { PyIncRef(m_npcDivisions); return m_npcDivisions; }

PyIncRef

#define PyIncRef(op)

Definition: PyRep.h:56

StaticDataMgr::m_npcDivisions

PyObject * m_npcDivisions

Definition: StaticDataMgr.h:158

bool StaticDataMgr::GetNPCGroups	(	uint32	factionID,
		std::map< uint8, uint16 > &	groupMap
	)

Definition at line 803 of file StaticDataMgr.cpp.

References m_npcGroups.

 {
     auto groupRange = m_npcGroups.equal_range(factionID);
     for (auto it = groupRange.first; it != groupRange.second; ++it)
         groupMap.emplace(it->second.shipClass, it->second.groupID);
 
     return !groupMap.empty();
 }

bool StaticDataMgr::GetNPCTypes	(	uint16	groupID,
		std::vector< uint16 > &	typeVec
	)

Definition at line 791 of file StaticDataMgr.cpp.

 {
     /*  this is now invalid.....
     auto groupRange = m_npcTypes.equal_range(groupID);
     for (auto it = groupRange.first; it != groupRange.second; ++it)
         typeVec.push_back(it->second);
 
     return !typeVec.empty();
     */
     return false;
 }

PyObjectEx* StaticDataMgr::GetOperands ( )

inline

Definition at line 43 of file StaticDataMgr.h.

References m_operands, and PyIncRef.

43 { PyIncRef(m_operands); return m_operands; }

StaticDataMgr::m_operands

PyObjectEx * m_operands

Definition: StaticDataMgr.h:160

PyIncRef

#define PyIncRef(op)

Definition: PyRep.h:56

std::string StaticDataMgr::GetOwnerName ( int32 ownerID )

Todo:: finish this.

Definition at line 1494 of file StaticDataMgr.cpp.

 {
     if (ownerID == 1)
         return "System";
 
     return "Unknown - WIP";
 }

void StaticDataMgr::GetPICommodityData ( std::map< uint16, Market::matlData > & into )

Definition at line 743 of file StaticDataMgr.cpp.

References m_commodities, Market::matlData::name, and Market::matlData::typeID.

 {
     for (auto cur : m_commodities) {
         Market::matlData data = Market::matlData();
         data.typeID = cur.first;
         data.name = cur.second;
         into[cur.first] = data;
     }
 }

void StaticDataMgr::GetPIResourceData ( std::map< uint16, Market::matlData > & into )

Definition at line 733 of file StaticDataMgr.cpp.

References m_resources, Market::matlData::name, and Market::matlData::typeID.

 {
     for (auto cur : m_resources) {
         Market::matlData data = Market::matlData();
         data.typeID = cur.first;
         data.name = cur.second;
         into[cur.first] = data;
     }
 }

const char * StaticDataMgr::GetProcStateName ( int8 state )

Definition at line 1681 of file StaticDataMgr.cpp.

References EVEPOS::ProcState::Anchoring, EVEPOS::ProcState::ArmorReinforcing, Calendar::Flag::Invalid, EVEPOS::ProcState::Offlining, Online, EVEPOS::ProcState::Onlining, EVEPOS::ProcState::Operating, EVEPOS::ProcState::Reinforcing, EVEPOS::ProcState::SheildReinforcing, and EVEPOS::ProcState::Unanchoring.

 {
     using namespace EVEPOS;
     switch(state) {
         case ProcState::Invalid:            return "Invalid";
         case ProcState::Unanchoring:        return "Unanchoring";
         case ProcState::Anchoring:          return "Anchoring";
         case ProcState::Offlining:          return "Offlining";
         case ProcState::Onlining:           return "Onlining";
         case ProcState::Online:             return "Online";
         case ProcState::Operating:          return "Operating";
         case ProcState::Reinforcing:        return "Reinforcing";
         case ProcState::SheildReinforcing:  return "SheildReinforcing";
         case ProcState::ArmorReinforcing:   return "ArmorReinforcing";
         default:                            return "Bad State";
     }
     return "Undefined";
 }

uint32 StaticDataMgr::GetRaceFaction ( uint8 raceID )

Definition at line 1636 of file StaticDataMgr.cpp.

References Char::Race::Amarr, Char::Race::Caldari, factionAmarr, factionCaldari, factionGallente, factionJove, factionMinmatar, factionNoFaction, factionORE, factionSleepers, Char::Race::Gallente, Char::Race::Jove, Char::Race::Minmatar, Char::Race::ORE, Char::Race::Pirate, and Char::Race::Sleepers.

 {
     switch (raceID) {
         case Char::Race::Caldari:       return factionCaldari;
         case Char::Race::Minmatar:      return factionMinmatar;
         case Char::Race::Amarr:         return factionAmarr;
         case Char::Race::Gallente:      return factionGallente;
         case Char::Race::Jove:          return factionJove;
         case Char::Race::Pirate:        return factionNoFaction;
         case Char::Race::Sleepers:      return factionSleepers;
         case Char::Race::ORE:           return factionORE;
     }
     // default to none
     return factionNoFaction;
 }

const char * StaticDataMgr::GetRaceName ( uint8 raceID )

Definition at line 1620 of file StaticDataMgr.cpp.

References Char::Race::Amarr, Char::Race::Caldari, Char::Race::Gallente, Char::Race::Jove, Char::Race::Minmatar, Char::Race::ORE, Char::Race::Pirate, and Char::Race::Sleepers.

 {
     switch (raceID) {
         case Char::Race::Caldari:       return "Caldari";
         case Char::Race::Minmatar:      return "Minmatar";
         case Char::Race::Amarr:         return "Amarr";
         case Char::Race::Gallente:      return "Gallente";
         case Char::Race::Jove:          return "Jove";
         case Char::Race::Pirate:        return "Pirate";
         case Char::Race::Sleepers:      return "Sleeper";
         case Char::Race::ORE:           return "ORE";
     }
     // default to none
     return "Race Not Defined";
 }

void StaticDataMgr::GetRamMaterials	(	uint16	typeID,
		std::vector< EvERam::RamMaterials > &	ramMatls
	)

Definition at line 953 of file StaticDataMgr.cpp.

References m_ramMatl.

Referenced by SetBPMatlType().

 {
     auto itr = m_ramMatl.equal_range(typeID);
     for (auto it = itr.first; it != itr.second; ++it)
         ramMatls.push_back(it->second);
 }

Here is the caller graph for this function:

void StaticDataMgr::GetRamRequiredItems	(	const uint32	typeID,
		const int8	activity,
		std::vector< EvERam::RequiredItem > &	into
	)

Definition at line 967 of file StaticDataMgr.cpp.

References EvERam::RequiredItem::damagePerJob, EvERam::RequiredItem::extra, EvERam::RequiredItem::isSkill, IsSkillTypeID(), m_bpTypeData, m_ramMatl, m_ramReq, EvERam::Activity::Manufacturing, EvERam::RequiredItem::quantity, and EvERam::RequiredItem::typeID.

 {
     if (activity == EvERam::Activity::Manufacturing) {
         std::map<uint16, EvERam::bpTypeData>::iterator itr = m_bpTypeData.find(typeID);
         if (itr != m_bpTypeData.end()) {
             auto range = m_ramMatl.equal_range(itr->second.productTypeID);
             for (auto it = range.first; it != range.second; ++it) {
                 EvERam::RequiredItem data = EvERam::RequiredItem();
                 data.typeID = it->second.materialTypeID;
                 data.quantity = it->second.quantity;
                 into.push_back(data);
             }
         }
     }
 
     auto itr = m_ramReq.equal_range(typeID);
     for (auto it = itr.first; it != itr.second; ++it)
         if (it->second.activityID == activity) {
             EvERam::RequiredItem data = EvERam::RequiredItem();
             data.typeID = it->second.requiredTypeID;
             data.quantity = it->second.quantity;
             data.damagePerJob = it->second.damagePerJob;
             data.isSkill = IsSkillTypeID(it->second.requiredTypeID);
             data.extra = it->second.extra;
             into.push_back(data);
         }
 }

Here is the call graph for this function:

void StaticDataMgr::GetRamRequirements	(	uint16	typeID,
		std::vector< EvERam::RamRequirements > &	ramReqs
	)

Definition at line 960 of file StaticDataMgr.cpp.

References m_ramReq.

Referenced by SetBPMatlType().

 {
     auto itr = m_ramReq.equal_range(typeID);
     for (auto it = itr.first; it != itr.second; ++it)
         ramReqs.push_back(it->second);
 }

Here is the caller graph for this function:

void StaticDataMgr::GetRamReturns	(	uint16	typeID,
		int8	activityID,
		std::vector< EvERam::RequiredItem > &	ramReqs
	)

Definition at line 938 of file StaticDataMgr.cpp.

References EvERam::RequiredItem::damagePerJob, EvERam::RequiredItem::extra, EvERam::RequiredItem::isSkill, IsSkillTypeID(), m_ramReq, EvERam::RequiredItem::quantity, and EvERam::RequiredItem::typeID.

 {
     auto itr = m_ramReq.equal_range(typeID);
     for (auto it = itr.first; it != itr.second; ++it)
         if ((it->second.activityID == activityID) and (it->second.extra) and !(IsSkillTypeID(it->second.requiredTypeID))) {
             EvERam::RequiredItem data = EvERam::RequiredItem();
             data.typeID = it->second.requiredTypeID;
             data.quantity = it->second.quantity;
             data.damagePerJob = it->second.damagePerJob;
             data.isSkill = IsSkillTypeID(it->second.requiredTypeID);
             data.extra = it->second.extra;
             ramReqs.push_back(data);
         }
 }

Here is the call graph for this function:

uint16 StaticDataMgr::GetRandRatType	(	uint8	sClass,
		uint16	groupID
	)

Definition at line 770 of file StaticDataMgr.cpp.

References _log, m_npcTypes, and MakeRandomInt().

 {
     if (groupID == 0)
         return 0;
     std::vector< uint16 > typeVec;
     auto classRange = m_npcTypes.equal_range(sClass);
     for (auto it = classRange.first; it != classRange.second; ++it) {
         for (auto itr : it->second)
             if (itr.first == groupID) {
                 for (auto tItr : itr.second)
                     typeVec.push_back(tItr);
                 break;
             }
     }
     if (typeVec.size())
         return typeVec.at(MakeRandomInt(0, typeVec.size()));
 
     _log(DATA__WARNING, "Failed to get random rat for sClass %u and groupID %u", sClass, groupID);
     return 0;
 }

Here is the call graph for this function:

uint32 StaticDataMgr::GetRegionFaction ( uint32 regionID )

Definition at line 1141 of file StaticDataMgr.cpp.

References _log, and m_regions.

 {
     std::map<uint32, uint32>::iterator itr = m_regions.find(regionID);
     if (itr != m_regions.end())
         return itr->second;
 
     _log(DATA__MESSAGE, "Failed to query faction for region %u: region not found.", regionID);
     return 0;
 }

uint8 StaticDataMgr::GetRegionQuarter ( uint32 regionID )

Definition at line 1502 of file StaticDataMgr.cpp.

References factionAmarr, factionAmmatar, factionAngel, factionBloodRaider, factionCaldari, factionCONCORD, factionGallente, factionGuristas, factionInterBus, factionJove, factionKhanid, factionMinmatar, factionMordusLegion, factionORE, factionSanshas, factionSerpentis, factionSistersOfEVE, factionSociety, factionSyndicate, factionThukker, and m_regions.

 {
     uint32 factionID = 0;
     std::map<uint32, uint32>::iterator itr = m_regions.find(regionID);
     if (itr != m_regions.end())
         factionID = (*itr).second;
 
     // caldari=1, minmatar=2, amarr=3, gallente=4, none=5
     switch (factionID) {
         case factionCaldari:        //Caldari State
         case factionGuristas:       //Guristas Pirates
             return 1;
         case factionMinmatar:       //Minmatar Republic
         case factionAngel:          //Angel Cartel
             return 2;
         case factionAmarr:          //Amarr Empire
         case factionAmmatar:        //Ammatar Mandate
         case factionKhanid:         //Khanid Kingdom
         case factionBloodRaider:    //Blood Raider Covenant
         case factionSanshas:        //Sansha's Nation
             return 3;
         case factionGallente:       //Gallente Federation
         case factionSerpentis:      //Serpentis
             return 4;
         case factionJove:           //Jove Empire
         case factionCONCORD:        //CONCORD Assembly
         case factionSyndicate:      //The Syndicate
         case factionInterBus:       //The InterBus
         case factionORE:            //ORE
         case factionThukker:        //Thukker Tribe
         case factionSistersOfEVE:   //Servant Sisters of EVE
         case factionSociety:        //The Society of Conscious Thought
         case factionMordusLegion:   //Mordu's Legion Command
             return 5;
     }
     // default to 'none'
     return 5;
 }

uint32 StaticDataMgr::GetRegionRatFaction ( uint32 regionID )

Definition at line 1151 of file StaticDataMgr.cpp.

References _log, and m_ratRegions.

 {
     std::map<uint32, uint32>::iterator itr = m_ratRegions.find(regionID);
     if (itr != m_ratRegions.end())
         return itr->second;
 
     _log(DATA__MESSAGE, "Failed to query rat faction for region %u: region not found.", regionID);
     return 0;
 
 /*
 def GetPirateFactionsOfRegion(self, regionID):
 return {10000001: (500019,),
     10000002: (500010,),
     10000003: (500010,),
     10000005: (500011,),
     10000006: (500011,),
     10000007: (500011,),
     10000008: (500011,),
     10000009: (500011,),
     10000010: (500010,),
     10000011: (500011,),
     10000012: (500011,),
     10000014: (500019,),
     10000015: (500010,),
     10000016: (500010,),
     10000020: (500019,),
     10000022: (500019,),
     10000023: (500010,),
     10000025: (500011,),
     10000028: (500011,),
     10000029: (500010,),
     10000030: (500011,),
     10000031: (500011,),
     10000032: (500020,),
     10000033: (500010,),
     10000035: (500010,),
     10000036: (500019,),
     10000037: (500020,),
     10000038: (500012,),
     10000039: (500019,),
     10000041: (500020,),
     10000042: (500011,),
     10000043: (500019,),
     10000044: (500020,),
     10000045: (500010,),
     10000046: (500020,),
     10000047: (500019,),
     10000048: (500020,),
     10000049: (500012, 500019),
     10000050: (500012,),
     10000051: (500020,),
     10000052: (500012,),
     10000054: (500012,),
     10000055: (500010,),
     10000056: (500011,),
     10000057: (500020,),
     10000058: (500020,),
     10000059: (500019,),
     10000060: (500012,),
     10000061: (500011,),
     10000062: (500011,),
     10000063: (500012,),
     10000064: (500020,),
     10000065: (500012,),
     10000067: (500012,),
     10000068: (500020,)}
     */
 }

const char * StaticDataMgr::GetRigSizeName ( uint8 size )

Definition at line 1669 of file StaticDataMgr.cpp.

 {
     switch (size) {
         case 0:      return "Undefined";
         case 1:      return "Small";
         case 2:      return "Medium";
         case 3:      return "Large";
         case 4:      return "Capitol";
     }
     return "Undefined";
 }

bool StaticDataMgr::GetRoidDist	(	const char *	secClass,
		std::unordered_multimap< float, uint16 > &	roids
	)

Definition at line 659 of file StaticDataMgr.cpp.

References _log, and m_oreBySecClass.

                                                                                                  {
     auto groupRange = m_oreBySecClass.equal_range(secClass);
     for (auto it = groupRange.first; it != groupRange.second; ++it) {
         _log(MINING__INFO, "GetRoidDist - adding %u with chance %.3f", it->second.typeID, it->second.chance);
         roids.insert(std::pair<float, uint32>(it->second.chance, it->second.typeID));
     }
 
     return !roids.empty();
 }

void StaticDataMgr::GetSalvage	(	uint32	factionID,
		std::vector< uint32 > &	itemList
	)

Definition at line 653 of file StaticDataMgr.cpp.

References m_salvageMap.

                                                                             {
     auto itr = m_salvageMap.equal_range(factionID);
     for (auto it = itr.first; it != itr.second; ++it)
         itemList.push_back(it->second);
 }

void StaticDataMgr::GetSalvageData ( std::map< uint16, Market::matlData > & into )

Definition at line 723 of file StaticDataMgr.cpp.

References m_salvage, Market::matlData::name, and Market::matlData::typeID.

 {
     for (auto cur : m_salvage) {
         Market::matlData data = Market::matlData();
         data.typeID = cur.first;
         data.name = cur.second;
         into[cur.first] = data;
     }
 }

bool StaticDataMgr::GetSkillName	(	uint16	skillID,
		std::string &	name
	)

Definition at line 681 of file StaticDataMgr.cpp.

References _log, and m_skills.

 {
     std::map<uint16, std::string>::iterator itr = m_skills.find(skillID);
     if (itr != m_skills.end()) {
         name = itr->second;
         return true;
     }
 
     _log(DATA__MESSAGE, "Failed to query name for skill %u: Skill not found.", skillID);
     return false;
 }

bool StaticDataMgr::GetStaticInfo	(	uint32	itemID,
		StaticData &	data
	)

Definition at line 1121 of file StaticDataMgr.cpp.

References _log, and m_staticData.

 {
     std::map<uint32, StaticData>::iterator itr = m_staticData.find(itemID);
     if (itr != m_staticData.end()) {
         data = itr->second;
         return true;
     }
 
     _log(DATA__MESSAGE, "Failed to query info for static item %u: Item not found.", itemID);
     return false;
 }

uint16 StaticDataMgr::GetStaticType ( uint32 itemID )

Definition at line 1133 of file StaticDataMgr.cpp.

References m_staticData.

 {
     std::map<uint32, StaticData>::iterator itr = m_staticData.find(itemID);
     if (itr != m_staticData.end())
         return itr->second.typeID;
     return 0;
 }

uint32 StaticDataMgr::GetStationConstellation ( uint32 stationID )

Definition at line 1039 of file StaticDataMgr.cpp.

References _log, and m_stationConst.

 {
     std::map<uint32, uint32>::iterator itr = m_stationConst.find(stationID);
     if (itr != m_stationConst.end())
         return itr->second;
 
     _log(DATA__MESSAGE, "Failed to query constellation info for station %u: Station not found.", stationID);
     return 0;
 }

PyRep * StaticDataMgr::GetStationCount ( )

Definition at line 995 of file StaticDataMgr.cpp.

References PyList::AddItem(), m_stationCount, and PyTuple::SetItem().

 {
     PyList* list = new PyList();
     std::map<uint32, uint8>::iterator itr = m_stationCount.begin(), end = m_stationCount.end();
     while (itr != end) {
         PyTuple* tuple = new PyTuple(2);
         tuple->SetItem(0, new PyInt(itr->first));
         tuple->SetItem(1, new PyInt(itr->second));
         list->AddItem(tuple);
         ++itr;
     }
     return list;
 }

Here is the call graph for this function:

uint8 StaticDataMgr::GetStationCount ( uint32 systemID )

Definition at line 1009 of file StaticDataMgr.cpp.

References _log, and m_stationCount.

 {
     std::map<uint32, uint8>::iterator itr = m_stationCount.find(systemID);
     if (itr != m_stationCount.end())
         return itr->second;
 
     _log(DATA__MESSAGE, "Failed to query station count for system %u: System not found.", systemID);
     return 0;
 }

bool StaticDataMgr::GetStationList	(	uint32	systemID,
		std::vector< uint32 > &	data
	)

Definition at line 1019 of file StaticDataMgr.cpp.

References m_stationList.

 {
     std::map<uint32, std::vector<uint32>>::iterator itr = m_stationList.find(systemID);
     if (itr != m_stationList.end()) {
         data = itr->second;
         return true;
     }
     return false;
 }

uint32 StaticDataMgr::GetStationRegion ( uint32 stationID )

Definition at line 1029 of file StaticDataMgr.cpp.

References _log, and m_stationRegion.

 {
     std::map<uint32, uint32>::iterator itr = m_stationRegion.find(stationID);
     if (itr != m_stationRegion.end())
         return itr->second;
 
     _log(DATA__MESSAGE, "Failed to query region info for station %u: Station not found.", stationID);
     return 0;
 }

uint32 StaticDataMgr::GetStationSystem ( uint32 stationID )

Definition at line 1049 of file StaticDataMgr.cpp.

References _log, and m_stationSystem.

Referenced by GetSystemData(), GetSystemName(), and Populate().

 {
     std::map<uint32, uint32>::iterator itr = m_stationSystem.find(stationID);
     if (itr != m_stationSystem.end())
         return itr->second;
 
     _log(DATA__MESSAGE, "Failed to query system info for station %u: Station not found.", stationID);
     return 0;
 }

Here is the caller graph for this function:

bool StaticDataMgr::GetSystemData	(	uint32	locationID,
		SystemData &	data
	)

Definition at line 1083 of file StaticDataMgr.cpp.

References _log, GetStationSystem(), IsSolarSystem(), IsStation(), and m_systemData.

 {
     if (IsStation(locationID)) {
         locationID = GetStationSystem(locationID);
     }
     if (!IsSolarSystem(locationID)) {
         _log(DATA__MESSAGE, "Failed to query info:  locationID %u is neither station nor system.", locationID);
         return false;
     }
 
     std::map<uint32, SystemData>::iterator itr = m_systemData.find(locationID);
     if (itr != m_systemData.end()) {
         data = itr->second;
         return true;
     }
 
     _log(DATA__MESSAGE, "Failed to query info for system %u: System not found.", locationID);
     return false;
 }

Here is the call graph for this function:

const char * StaticDataMgr::GetSystemName ( uint32 locationID )

Definition at line 1103 of file StaticDataMgr.cpp.

References _log, GetStationSystem(), IsSolarSystem(), IsStation(), and m_systemData.

 {
     if (IsStation(locationID)) {
         locationID = GetStationSystem(locationID);
     }
     if (!IsSolarSystem(locationID)) {
         _log(DATA__MESSAGE, "Failed to query info:  locationID %u is neither station nor system.", locationID);
         return "Error";
     }
 
     std::map<uint32, SystemData>::iterator itr = m_systemData.find(locationID);
     if (itr != m_systemData.end())
         return itr->second.name.c_str();
 
     _log(DATA__MESSAGE, "Failed to query info for system %u: System not found.", locationID);
     return "Invalid";
 }

Here is the call graph for this function:

void StaticDataMgr::GetType	(	uint16	typeID,
		Inv::TypeData &	into
	)

Definition at line 620 of file StaticDataMgr.cpp.

References m_typeData.

 {
     std::map<uint16, Inv::TypeData>::const_iterator itr = m_typeData.find(typeID);
     if (itr != m_typeData.end())
         into = itr->second;
 }

const char * StaticDataMgr::GetTypeName ( uint16 typeID )

Definition at line 627 of file StaticDataMgr.cpp.

References _log, and m_typeData.

 {
     std::map<uint16, Inv::TypeData>::const_iterator itr = m_typeData.find(typeID);
     if (itr != m_typeData.end())
         return itr->second.name.c_str();
 
     _log(DATA__ERROR, "GetGroupName() - Group %u not found in map", typeID);
     return "None";
 }

void StaticDataMgr::GetTypes ( std::map< uint16, Inv::TypeData > & into )

Definition at line 637 of file StaticDataMgr.cpp.

References m_typeData.

 {
     into = m_typeData;
 }

uint8 StaticDataMgr::GetWHSystemClass ( uint32 systemID )

Definition at line 1059 of file StaticDataMgr.cpp.

References _log, IsKSpaceID, IsWSpaceID, m_whRegions, and sEntityList.

 {
     std::map<uint32, uint8>::iterator itr = m_whRegions.find(systemID);
     if (itr != m_whRegions.end())
         return itr->second;
 
     SystemManager* pSysMgr(sEntityList.FindOrBootSystem(systemID));
     if (pSysMgr == nullptr)
         return 0;
 
     itr = m_whRegions.find(pSysMgr->GetRegionID());
     if (itr != m_whRegions.end())
         return itr->second;
 
     // dont have data for systemID nor regionID...throw error and ?something else?
     _log(DATA__MESSAGE, "Failed to query WH Class for systemID %u: System not found.", systemID);
     if (IsKSpaceID(systemID))
         return 0;
     if (IsWSpaceID(systemID))
         return 0;
 
     return 0;
 }

uint32 StaticDataMgr::GetWreckFaction ( uint32 typeID )

Definition at line 1827 of file StaticDataMgr.cpp.

References factionAmarr, factionAngel, factionBloodRaider, factionCaldari, factionCONCORD, factionGallente, factionGuristas, factionKhanid, factionMinmatar, factionMordusLegion, factionORE, factionRogueDrones, factionSanshas, factionSerpentis, factionSleepers, factionThukker, and factionUnknown.

 {
     // these will need to be separated and updated after detailed salvage table is completed
     switch(typeID) {
         case 26469:  //   Amarr Battlecruiser Wreck
         case 26470:  //   Amarr Battleship Wreck
         case 26472:  //   Amarr Carrier Wreck
         case 26473:  //   Amarr Cruiser Wreck
         case 26474:  //   Amarr Destroyer Wreck
         case 26475:  //   Amarr Dreadnought Wreck
         case 26476:  //  Amarr Elite Battlecruiser Wreck
         case 26477:  //   Amarr Elite Battleship Wreck
         case 26478:  //   Amarr Elite Cruiser Wreck
         case 26479:   //  Amarr Elite Destroyer Wreck
         case 26480:   //  Amarr Elite Frigate Wreck
         case 26481:   //  Amarr Elite Industrial Wreck
         case 26482:   //  Amarr Elite Mining Barge Wreck
         case 26483:   //  Amarr Freighter Wreck
         case 26484:   //  Amarr Frigate Wreck
         case 26485:  //  Amarr Industrial Wreck
         case 26486:   //  Amarr Mining Barge Wreck
         case 26487:   //  Amarr Supercarrier Wreck
         case 26488:   //  Amarr Rookie ship Wreck
         case 26489:   //  Amarr Shuttle Wreck
         case 26490:   //  Amarr Titan Wreck
         case 27050:   //  Amarr Large Wreck
         case 27051:   // Amarr Medium Wreck
         case 27052:   //  Amarr Small Wreck
         case 29033:   // Amarr Elite Freighter Wreck
         case 27927:  //  Mission Amarr Carrier Wreck
         case 30822: { //   Amarr Advanced Cruiser Wreck
             return factionAmarr;
         } break;
 
         case 26491:  //    Caldari Battlecruiser Wreck
         case 26492:  //    Caldari Battleship Wreck
         case 26494:  //    Caldari Carrier Wreck
         case 26495:  //   Caldari Cruiser Wreck
         case 26496:  //    Caldari Destroyer Wreck
         case 26497:  //    Caldari Dreadnought Wreck
         case 26498:  //    Caldari Elite Battlecruiser Wreck
         case 26499:  //   Caldari Elite Battleship Wreck
         case 26500:  //   Caldari Elite Cruiser Wreck
         case 26501:  //   Caldari Elite Destroyer Wreck
         case 26502:  //   Caldari Elite Frigate Wreck
         case 26503:  //   Caldari Elite Industrial Wreck
         case 26504:  //   Caldari Elite Mining Barge Wreck
         case 26505:  //    Caldari Freighter Wreck
         case 26506:  //    Caldari Frigate Wreck
         case 26507:  //    Caldari Industrial Wreck
         case 26508:  //    Caldari Mining Barge Wreck
         case 26509:  //    Caldari Supercarrier Wreck
         case 26510:  //   Caldari Rookie ship Wreck
         case 26511:  //    Caldari Shuttle Wreck
         case 26512:  //    Caldari Titan Wreck
         case 27926:  //    Mission Caldari Carrier Wreck
         case 30823:  //    Caldari Advanced Cruiser Wreck
         case 29034:  //   Caldari Elite Freighter Wreck
         case 27047:  //    Caldari Large Wreck
         case 27048:  //    Caldari Medium Wreck
         case 27049: {  //    Caldari Small Wreck
             return factionCaldari;
         } break;
 
         case 29035:  //    Gallente Elite Freighter Wreck
         case 30824:  //    Gallente Advanced Cruiser Wreck
         case 27929:  //    Mission Gallente Carrier Wreck
         case 27053:  //    Gallente Large Wreck
         case 27054:  //    Gallente Medium Wreck
         case 27055:  //    Gallente Small Wreck
         case 26513:  //    Gallente Battlecruiser Wreck
         case 26514:  //    Gallente Battleship Wreck
         case 26516:  //    Gallente Carrier Wreck
         case 26517:  //    Gallente Cruiser Wreck
         case 26518:  //    Gallente Destroyer Wreck
         case 26519:  //    Gallente Dreadnought Wreck
         case 26520:  //    Gallente Elite Battlecruiser Wreck
         case 26521:  //    Gallente Elite Battleship Wreck
         case 26522:  //    Gallente Elite Cruiser Wreck
         case 26523:  //    Gallente Elite Destroyer Wreck
         case 26524:  //    Gallente Elite Frigate Wreck
         case 26525:  //    Gallente Elite Industrial Wreck
         case 26526:  //    Gallente Elite Mining Barge Wreck
         case 26527:  //    Gallente Freighter Wreck
         case 26528:  //    Gallente Frigate Wreck
         case 26529:  //    Gallente Industrial Wreck
         case 26530:  //    Gallente Mining Barge Wreck
         case 26531:  //    Gallente Supercarrier Wreck
         case 26532:  //    Gallente Rookie ship Wreck
         case 26533:  //    Gallente Shuttle Wreck
         case 26534: { //   Gallente Titan Wreck
             return factionGallente;
         } break;
 
         case 26535:  //    Minmatar Battlecruiser Wreck
         case 26536:  //    Minmatar Battleship Wreck
         case 26538:  //    Minmatar Carrier Wreck
         case 26539:  //    Minmatar Cruiser Wreck
         case 26540:  //    Minmatar Destroyer Wreck
         case 26541:  //    Minmatar Dreadnought Wreck
         case 26542:  //    Minmatar Elite Battlecruiser Wreck
         case 26543:  //    Minmatar Elite Battleship Wreck
         case 26544:  //    Minmatar Elite Cruiser Wreck
         case 26545:  //    Minmatar Elite Destroyer Wreck
         case 26546:  //    Minmatar Elite Frigate Wreck
         case 26547:  //    Minmatar Elite Industrial Wreck
         case 26548:  //    Minmatar Elite Mining Barge Wreck
         case 29036:  //    Minmatar Elite Freighter Wreck
         case 26549:  //    Minmatar Freighter Wreck
         case 26550:  //    Minmatar Frigate Wreck
         case 26551:  //    Minmatar Industrial Wreck
         case 26552:  //    Minmatar Mining Barge Wreck
         case 26553:  //    Minmatar Supercarrier Wreck
         case 26554:  //    Minmatar Rookie ship Wreck
         case 26555:  //    Minmatar Shuttle Wreck
         case 26556:  //    Minmatar Titan Wreck
         case 27928:  //    Mission Minmatar Carrier Wreck
         case 30825:  //    Minmatar Advanced Cruiser Wreck
         case 27041:  //    Minmatar Large Wreck
         case 27042:  //    Minmatar Medium Wreck
         case 27043: { //   Minmatar Small Wreck
             return factionMinmatar;
         } break;
 
         case 26972:  //    Faction Drone Wreck   - faction police drones
         case 26939:  //   CONCORD Large Wreck
         case 26940:  //    CONCORD Medium Wreck
         case 26941: { //    CONCORD Small Wreck
             return factionCONCORD;
         } break;
 
         case 27044:  //    Khanid Large Wreck
         case 27045:  //    Khanid Medium Wreck
         case 27046: { //   Khanid Small Wreck
             return factionKhanid;
         } break;
 
         case 27056:  //    Thukker Large Wreck
         case 27057:  //    Thukker Medium Wreck
         case 27058: { //    Thukker Small Wreck
             return factionThukker;
         } break;
 
         case 27060:  //   Mordu Large Wreck
         case 27061:  //   Mordu Medium Wreck
         case 27062: { //    Mordu Small Wreck
             return factionMordusLegion;
         } break;
 
         case 28603:  //   Rorqual Wreck
         case 29639: { //    Orca Wreck
             return factionORE;
         } break;
 
         case 30457:  //    Sleeper Small Advanced Wreck
         case 30458:  //    Sleeper Medium Advanced Wreck
         case 30459:  //    Sleeper Large Wreck
         case 30484:  //    Sleeper Small Basic Wreck
         case 30485:  //    Sleeper Small Intermediate Wreck
         case 30492:  //   Sleeper Medium Basic Wreck
         case 30493:  //    Sleeper Medium Intermediate Wreck
         case 30494:  //   Sleeper Large Basic Wreck
         case 30495:  //   Sleeper Large Intermediate Wreck
         case 30496: { //    Sleeper Large Advanced Wreck
             return factionSleepers;
         } break;
 
         case 26561:  //   Angel Small Wreck
         case 26562:  //   Angel Medium Wreck
         case 26563:  //   Angel Large Wreck
         case 26564:  //   Angel Small Commander Wreck
         case 26699:  //   Angel Medium Commander Wreck
         case 26565:  //   Angel Large Commander Wreck
         case 26566: { //   Angel Officer Wreck
             return factionAngel;
         } break;
 
         case 26567:  //   Blood Small Wreck
         case 26568:  //   Blood Medium Wreck
         case 26569:  //   Blood Large Wreck
         case 26570:  //   Blood Small Commander Wreck
         case 26571:  //   Blood Medium Commander Wreck
         case 26700:  //   Blood Large Commander Wreck
         case 26572: { //   Blood Officer Wreck
             return factionBloodRaider;
         } break;
 
         case 26573:  //   Guristas Small Wreck
         case 26574:  //   Guristas Medium Wreck
         case 26575:  //   Guristas Large Wreck
         case 26576:  //   Guristas Small Commander Wreck
         case 26577:  //   Guristas Medium Commander Wreck
         case 26701:  //   Guristas Large Commander Wreck
         case 26578: { //   Guristas Officer Wreck
             return factionGuristas;
         } break;
 
         case 26579:  //   Sanshas Small Wreck
         case 26580:  //   Sanshas Medium Wreck
         case 26581:  //   Sanshas Large Wreck
         case 26582:  //   Sanshas Small Commander Wreck
         case 26583:  //   Sanshas Medium Commander Wreck
         case 26702:  //   Sanshas Large Commander Wreck
         case 26584:  //   Sanshas Officer Wreck
         case 3260: { //   Sanshas Supercarrier Wreck
             return factionSanshas;
         } break;
 
         case 26585:  //   Serpentis Small Wreck
         case 26586:  //   Serpentis Medium Wreck
         case 26587:  //   Serpentis Large Wreck
         case 26588:  //   Serpentis Small Commander Wreck
         case 26589:  //   Serpentis Medium Commander Wreck
         case 26703:  //   Serpentis Large Commander Wreck
         case 26590: { //   Serpentis Officer Wreck
             return factionSerpentis;
         } break;
 
         case 26591:  //   Rogue Small Wreck
         case 26592:  //   Rogue Medium Wreck
         case 26593:  //   Rogue Large Wreck
         case 26594:  //   Rogue Elite Small Wreck
         case 26595:  //   Rogue Elite Medium Wreck
         case 26596:  //   Rogue Officer Wreck
         case 28221:  //   Rogue Large Commander Wreck
         case 28222:  //   Rogue Medium Commander Wreck
         case 28223: { //   Rogue Small Commander Wreck
             return factionRogueDrones;
         } break;
 
         // generic wrecks
         case 26468:  //   Capsule Wreck
         case 26557:  //   Frigate Wreck
         case 26558:  //   Cruiser Wreck
         case 26559:  //   Battleship Wreck
         case 26918:  //   Overseer Frigate Wreck
         case 26919:  //   Overseer Cruiser Wreck
         case 26920:  //   Overseer Battleship Wreck
         case 27202:  //   Convoy Wreck
         case 27286:  //   Pirate Drone Wreck
         case 26560: { //   Pirate Wreck
             return factionUnknown;
         } break;
     }
 
     // safe default
     return factionUnknown;
 
     /*
      *    28255 :  //   Mission Faction Freighter Wreck
      *    29347:  //    Mission Faction Vessels Wreck
      *    29365:  //    Mission Faction Industrials Wreck
      */
 }

uint32 StaticDataMgr::GetWreckID ( uint32 typeID )

Definition at line 839 of file StaticDataMgr.cpp.

References m_WrecksToTypesMap.

 {
     std::map<uint32, uint32>::const_iterator itr = m_WrecksToTypesMap.find(typeID);
     if (itr != m_WrecksToTypesMap.end())
         return itr->second;
     return 0;
 }

int StaticDataMgr::Initialize ( )

Definition at line 83 of file StaticDataMgr.cpp.

References Populate(), and sLog.

 {
     Populate();
     sLog.Blue("    StaticDataMgr", "Static Data Manager Initialized.");
     return 1;
 }

Here is the call graph for this function:

bool StaticDataMgr::IsRecyclable ( uint16 typeID )

Definition at line 922 of file StaticDataMgr.cpp.

References m_typeData.

 {
     std::map<uint16, Inv::TypeData>::iterator itr = m_typeData.find(typeID);
     if (itr != m_typeData.end())
         return itr->second.isRecyclable;
     return false;
 }

bool StaticDataMgr::IsRefinable ( uint16 typeID )

Definition at line 930 of file StaticDataMgr.cpp.

References m_typeData.

 {
     std::map<uint16, Inv::TypeData>::iterator itr = m_typeData.find(typeID);
     if (itr != m_typeData.end())
         return itr->second.isRefinable;
     return false;
 }

bool StaticDataMgr::IsSkillTypeID ( uint16 typeID )

Definition at line 676 of file StaticDataMgr.cpp.

References m_skills.

Referenced by GetRamRequiredItems(), GetRamReturns(), and SetBPMatlType().

 {
     return (m_skills.find(typeID) != m_skills.end());
 }

Here is the caller graph for this function:

bool StaticDataMgr::IsSolarSystem ( uint32 systemID = 0 )

Definition at line 1220 of file StaticDataMgr.cpp.

References m_systemData.

Referenced by GetSystemData(), and GetSystemName().

 {
     // if systemID has entry here, it is valid
     std::map<uint32, SystemData>::iterator itr = m_systemData.find(systemID);
     return (itr != m_systemData.end());
 }

Here is the caller graph for this function:

bool StaticDataMgr::IsStation ( uint32 stationID = 0 )

Definition at line 1227 of file StaticDataMgr.cpp.

References m_stationRegion.

Referenced by GetSystemData(), and GetSystemName().

 {
     // if stationID has entry here, it is valid
     std::map<uint32, uint32>::iterator itr = m_stationRegion.find(stationID);
     return (itr != m_stationRegion.end());
 }

Here is the caller graph for this function:

void StaticDataMgr::Populate ( )

protected

Definition at line 126 of file StaticDataMgr.cpp.

Referenced by Initialize().

 {
     double beginTime = GetTimeMSeconds();
     double startTime = GetTimeMSeconds();
 
     m_keyMap = ManagerDB::GetKeyMap();
     if (m_keyMap == nullptr)
         sLog.Error("    StaticDataMgr", "m_keyMap is null");
 
     m_agents = ManagerDB::GetAgents();
     if (m_agents == nullptr)
         sLog.Error("    StaticDataMgr", "m_agents is null");
 
     m_operands = ManagerDB::GetOperands();
     if (m_operands == nullptr)
         sLog.Error("    StaticDataMgr", "m_operands is null");
 
     m_billTypes = ManagerDB::GetBillTypes();
     if (m_billTypes == nullptr)
         sLog.Error("    StaticDataMgr", "m_billTypes is null");
 
     m_entryTypes = ManagerDB::GetEntryTypes();
     if (m_entryTypes == nullptr)
         sLog.Error("    StaticDataMgr", "m_entryTypes is null");
 
     m_npcDivisions = ManagerDB::GetNPCDivisions();
     if (m_npcDivisions == nullptr)
         sLog.Error("    StaticDataMgr", "m_npcDivisions is null");
 
     sLog.Cyan("    StaticDataMgr", "Base Static data sets loaded in %.3fms.", (GetTimeMSeconds() - startTime));
 
     startTime = GetTimeMSeconds();
     GetFactionInfoRsp rsp;
     ManagerDB::LoadCorpFactions(rsp.factionIDbyNPCCorpID);
     ManagerDB::LoadFactionStationCounts(rsp.factionStationCount);
     ManagerDB::LoadFactionSystemCounts(rsp.factionSolarSystemCount);
     ManagerDB::LoadFactionRegions(rsp.factionRegions);
     ManagerDB::LoadFactionConstellations(rsp.factionConstellations);
     ManagerDB::LoadFactionSolarSystems(rsp.factionSolarSystems);
     ManagerDB::LoadFactionRaces(rsp.factionRaces);
     rsp.npcCorpInfo = ManagerDB::LoadNPCCorpInfo();
     m_factionInfo = rsp.Encode();
     if (m_factionInfo == nullptr) {
         sLog.Error("    StaticDataMgr", "m_factionInfo is null");
     } else {
         sLog.Cyan("    StaticDataMgr", "Faction data sets loaded in %.3fms.", (GetTimeMSeconds() - startTime));
     }
 
     DBQueryResult* res = new DBQueryResult();
     DBResultRow row;
 
     startTime = GetTimeMSeconds();
     ManagerDB::LoadNPCCorpFactionData(*res);
     while (res->GetRow(row)) {
         //SELECT corporationID, factionID FROM crpNPCCorporations
         m_corpFaction.emplace(row.GetUInt(0), row.GetUInt(1));
     }
     sLog.Cyan("    StaticDataMgr", "%u Corps in NPC Corp Faction map loaded in %.3fms.", m_corpFaction.size(), (GetTimeMSeconds() - startTime));
 
     startTime = GetTimeMSeconds();
     ManagerDB::GetCategoryData(*res);
     while (res->GetRow(row)) {
         //SELECT categoryID, categoryName, description, published FROM invCategories
         Inv::CatData data       = Inv::CatData();
             data.id             = row.GetUInt(0);
             data.name           = row.GetText(1);
             data.description    = row.GetText(2);
             data.published      = (sConfig.server.AllowNonPublished ? true : row.GetBool(3));
         m_catData.emplace(row.GetUInt(0), data);
     }
     sLog.Cyan("    StaticDataMgr", "%u Inventory Categories loaded in %.3fms.", m_catData.size(), (GetTimeMSeconds() - startTime));
 
     startTime = GetTimeMSeconds();
     ManagerDB::GetGroupData(*res);
     while (res->GetRow(row)) {
         //SELECT groupID, categoryID, groupName, description, useBasePrice, allowManufacture, allowRecycler,
         //  anchored, anchorable, fittableNonSingleton, published FROM invGroups
         Inv::GrpData data               = Inv::GrpData();
             data.id                     = row.GetUInt(0);
             data.catID                  = row.GetUInt(1);
             data.name                   = row.GetText(2);
             data.description            = row.GetText(3);
             data.useBasePrice           = row.GetBool(4);
             data.allowManufacture       = row.GetBool(5);
             data.allowRecycler          = row.GetBool(6);
             data.anchored               = row.GetBool(7);
             data.anchorable             = row.GetBool(8);
             data.fittableNonSingleton   = row.GetBool(9);
             data.published              = (sConfig.server.AllowNonPublished ? true : row.GetBool(10));
         m_grpData.emplace(row.GetUInt(0), data);
     }
     sLog.Cyan("    StaticDataMgr", "%u Inventory Groups loaded in %.3fms.", m_grpData.size(), (GetTimeMSeconds() - startTime));
 
     startTime = GetTimeMSeconds();
     ManagerDB::GetTypeData(*res);
     while (res->GetRow(row)) {
         Inv::TypeData data              = Inv::TypeData();
             data.id                     = row.GetUInt(0);
             data.groupID                = row.GetUInt(1);
             data.name                   = row.GetText(2);
             data.description            = row.GetText(3);
             data.radius                 = row.GetFloat(4);
             data.mass                   = row.GetFloat(5);
             data.volume                 = row.GetFloat(6);
             data.capacity               = row.GetFloat(7);
             data.portionSize            = row.GetUInt(8);
             data.race                   = row.GetUInt(9);
             data.basePrice              = row.GetDouble(10);
             data.published              = (sConfig.server.AllowNonPublished ? true : row.GetBool(11));
             data.marketGroupID          = (row.IsNull(11) ? 0 : row.GetUInt(12));
             data.chanceOfDuplicating    = row.GetFloat(13);
             data.metaLvl                = (row.IsNull(14) ? 0 : row.GetUInt(14));
             // these will take a bit of work, but will eliminate multiple db hits on inventory/menu loading ingame
             data.isRecyclable           = FactoryDB::IsRecyclable(data.id);   // +30s to startup
             data.isRefinable            = FactoryDB::IsRefinable(data.id);     // +8s to startup
         m_typeData.emplace(row.GetUInt(0), data);
     }
     sLog.Cyan("    StaticDataMgr", "%u Inventory Types loaded in %.3fms.", m_typeData.size(), (GetTimeMSeconds() - startTime));
 
     startTime = GetTimeMSeconds();
     ManagerDB::GetSystemData(*res);
     while (res->GetRow(row)) {
         //SELECT solarSystemID, solarSystemName, constellationID, regionID, securityClass, security FROM mapSolarSystems
         SystemData sysData        = SystemData();
         sysData.systemID          = row.GetInt(0);
         sysData.name              = row.GetText(1);
         sysData.constellationID   = row.GetInt(2);
         sysData.regionID          = row.GetInt(3);
         sysData.securityClass     = (row.IsNull(4) ? "0" : row.GetText(4));
         sysData.securityRating    = row.GetFloat(5);    // this gives system trueSec
         sysData.factionID         = (row.IsNull(6) ? 0 : row.GetUInt(6));
         m_systemData.emplace(row.GetInt(0), sysData);
     }
     sLog.Cyan("    StaticDataMgr", "%u Static System data sets loaded in %.3fms.", m_systemData.size(), (GetTimeMSeconds() - startTime));
 
     //res->Reset();  <<---  this is redundant.  object is reset in dbcore on each call
     startTime = GetTimeMSeconds();
     ManagerDB::GetWHSystemClass(*res);
     while (res->GetRow(row)) {
         //SELECT locationID, wormholeClassID FROM mapLocationWormholeClasses
         m_whRegions.emplace(row.GetInt(0), row.GetInt(1));
     }
     sLog.Cyan("    StaticDataMgr", "%u WH System Classes loaded in %.3fms.", m_whRegions.size(), (GetTimeMSeconds() - startTime));
 
     startTime = GetTimeMSeconds();
     ManagerDB::GetStaticData(*res);
     while (res->GetRow(row)) {
         //SELECT itemID, regionID, constellationID, solarSystemID, typeID, radius, x, y, z FROM mapDenormalize
         StaticData data         = StaticData();
         data.itemID             = row.GetInt(0);
         data.regionID           = row.GetInt(1);
         data.constellationID    = row.GetInt(2);
         data.systemID           = row.GetInt(3);
         data.typeID             = row.GetInt(4);
         data.radius             = row.GetFloat(5);
         data.position           = GPoint(row.GetDouble(6),row.GetDouble(7),row.GetDouble(8));
         m_staticData.emplace(row.GetInt(0), data);
     }
     sLog.Cyan("    StaticDataMgr", "%u Static Entity data sets loaded in %.3fms.", m_staticData.size(), (GetTimeMSeconds() - startTime));
 
     startTime = GetTimeMSeconds();
     MapDB::GetStationCount(*res);
     while (res->GetRow(row)) {
         //SELECT map.solarSystemID, count(sta.stationID) FROM staStations sta
         m_stationCount.emplace(row.GetInt(0), row.GetInt(1));
     }
     StationDB::GetStationRegion(*res);
     while (res->GetRow(row)) {
         //SELECT stationID, regionID FROM staStations
         m_stationRegion.emplace(row.GetInt(0), row.GetInt(1));
     }
     StationDB::GetStationConstellation(*res);
     while (res->GetRow(row)) {
         //SELECT stationID, constellationID FROM staStations
         m_stationConst.emplace(row.GetInt(0), row.GetInt(1));
     }
     StationDB::GetStationSystem(*res);
     while (res->GetRow(row)) {
         //SELECT stationID, solarSystemID FROM staStations
         m_stationSystem.emplace(row.GetInt(0), row.GetInt(1));
     }
 
     std::map<uint32, std::vector<uint32>>::iterator itr = m_stationList.begin();
     for (auto cur : m_stationSystem) {
         itr = m_stationList.find(cur.second);
         if (itr != m_stationList.end()) {
             itr->second.push_back(cur.first);
         } else {
             std::vector<uint32> sVec;
             sVec.push_back(cur.first);
             m_stationList.emplace(std::pair<uint32, std::vector<uint32>>(cur.second, sVec));
         }
     }
     sLog.Cyan("    StaticDataMgr", "%u Static Station query sets loaded in %.3fms.", (m_stationConst.size() + m_stationRegion.size() + m_stationSystem.size() + m_stationList.size()), (GetTimeMSeconds() - startTime));
 
     startTime = GetTimeMSeconds();
     ManagerDB::GetTypeAttributes(*res);
     while (res->GetRow(row)) {
         //SELECT typeID, attributeID, valueInt, valueFloat FROM dgmTypeAttributes
         DmgTypeAttribute typeAttr = DmgTypeAttribute();
         typeAttr.attributeID = row.GetInt(1);
         if (row.IsNull(2)) {
             typeAttr.value = row.GetDouble(3);
         } else {
             typeAttr.value = row.GetInt(2); // highest value seen is 2,000,000,000 (struct HP)
         }
 
         m_typeAttrMap.emplace(row.GetInt(0), typeAttr);
     }
     sLog.Cyan("    StaticDataMgr", "%u Type Attribute Sets loaded in %.3fms", m_typeAttrMap.size(), (GetTimeMSeconds() - startTime));
 
     startTime = GetTimeMSeconds();
     ManagerDB::GetSkillList(*res);
     while (res->GetRow(row)) {
         //SELECT typeID, typeName FROM invTypes [where type=skill]
         m_skills.insert(std::pair<uint16, std::string>(row.GetInt(0), row.GetText(1)));
     }
     sLog.Cyan("    StaticDataMgr", "%u Skills loaded in %.3fms.", m_skills.size(), (GetTimeMSeconds() - startTime));
 
     startTime = GetTimeMSeconds();
     FactoryDB::GetComponents(*res);     //766
     while (res->GetRow(row)) {
         //SELECT typeID, typeName FROM invTypes [where type=composite or component]
         m_components.insert(std::pair<uint16, std::string>(row.GetInt(0), row.GetText(1)));
     }
     FactoryDB::GetMinerals(*res);       //8
     while (res->GetRow(row)) {
         //SELECT typeID, typeName FROM invTypes [where type=mineral]
         m_minerals.insert(std::pair<uint16, std::string>(row.GetInt(0), row.GetText(1)));
     }
     FactoryDB::GetCompounds(*res);      //181
     while (res->GetRow(row)) {
         //SELECT typeID, typeName FROM invTypes [where type=compound]
         m_compounds.insert(std::pair<uint16, std::string>(row.GetInt(0), row.GetText(1)));
     }
     FactoryDB::GetSalvage(*res);        //53
     while (res->GetRow(row)) {
         //SELECT typeID, typeName FROM invTypes [where type=salvage]
         m_salvage.insert(std::pair<uint16, std::string>(row.GetInt(0), row.GetText(1)));
     }
     FactoryDB::GetResources(*res);      //15
     while (res->GetRow(row)) {
         //SELECT typeID, typeName FROM invTypes [where type=pi resource]
         m_resources.insert(std::pair<uint16, std::string>(row.GetInt(0), row.GetText(1)));
     }
     FactoryDB::GetCommodities(*res);    //66
     while (res->GetRow(row)) {
         //SELECT typeID, typeName FROM invTypes [where type=pi commodity]
         m_commodities.insert(std::pair<uint16, std::string>(row.GetInt(0), row.GetText(1)));
     }
     FactoryDB::GetMiscCommodities(*res);    //456
     while (res->GetRow(row)) {
         //SELECT typeID, typeName FROM invTypes [where type=misc commodity]
         m_miscCommodities.insert(std::pair<uint16, std::string>(row.GetInt(0), row.GetText(1)));
     }
     FactoryDB::GetRAMMaterials(*res);
     while (res->GetRow(row)) {
         //SELECT typeID, materialTypeID, quantity FROM invTypeMaterials
         EvERam::RamMaterials ramMatls = EvERam::RamMaterials();
         ramMatls.quantity       = row.GetInt(2);
         ramMatls.materialTypeID = row.GetInt(1);
         m_ramMatl.emplace(row.GetInt(0), ramMatls);
     }
     FactoryDB::GetRAMRequirements(*res);
     while (res->GetRow(row)) {
         //SELECT typeID, activityID, requiredTypeID, quantity, damagePerJob, extra FROM ramTypeRequirements
         EvERam::RamRequirements ramReq = EvERam::RamRequirements();
         ramReq.activityID       = row.GetInt(1);
         ramReq.requiredTypeID   = row.GetInt(2);
         ramReq.quantity         = row.GetInt(3);
         ramReq.damagePerJob     = row.GetFloat(4);
         ramReq.extra            = row.GetBool(5);
         m_ramReq.emplace(row.GetInt(0), ramReq);
     }
     sLog.Cyan("    StaticDataMgr", "%u R.A.M. defs loaded in %.3fms.", (m_ramMatl.size() + m_ramReq.size()), (GetTimeMSeconds() - startTime));
 
     startTime = GetTimeMSeconds();
     FactoryDB::GetBlueprintType(*res);
     while (res->GetRow(row)) {
         //SELECT blueprintTypeID, parentBlueprintTypeID, productTypeID, productionTime, techLevel, researchProductivityTime, researchMaterialTime, researchCopyTime,
         //  researchTechTime, productivityModifier, materialModifier, wasteFactor, maxProductionLimit, chanceOfRE, catID FROM invBlueprintTypes
         EvERam::bpTypeData bpTypeData = EvERam::bpTypeData();
             bpTypeData.parentBlueprintTypeID    = row.GetInt(1);
             bpTypeData.productTypeID            = row.GetInt(2);
             bpTypeData.productionTime           = row.GetInt(3);
             bpTypeData.techLevel                = row.GetInt(4);
             bpTypeData.researchProductivityTime = row.GetInt(5);
             bpTypeData.researchMaterialTime     = row.GetInt(6);
             bpTypeData.researchCopyTime         = row.GetInt(7);
             bpTypeData.researchTechTime         = row.GetInt(8);
             bpTypeData.productivityModifier     = row.GetInt(9);
             bpTypeData.materialModifier         = row.GetInt(10);
             bpTypeData.wasteFactor              = row.GetInt(11);
             bpTypeData.maxProductionLimit       = row.GetInt(12);
             bpTypeData.chanceOfRE               = row.GetFloat(13);
             bpTypeData.catID                    = (row.IsNull(14) ? 0 : row.GetInt(14));
         m_bpTypeData.emplace(row.GetInt(0), bpTypeData);
         m_bpProductData.emplace(row.GetInt(2), bpTypeData);
     }
     for (auto cur : m_bpTypeData)
         m_bpMatlData[cur.first] = SetBPMatlType(cur.second.catID, cur.first, cur.second.productTypeID);
     sLog.Cyan("    StaticDataMgr", "%u BP Type defs loaded in %.3fms.", m_bpTypeData.size(), (GetTimeMSeconds() - startTime));
 
     startTime = GetTimeMSeconds();
     ManagerDB::GetMoonResouces(*res);
     while (res->GetRow(row)) {
         //SELECT typeID,volume FROM invTypes [where group=moongoo]
         m_moonGoo.emplace(row.GetInt(0), (uint8)(row.GetFloat(1) *10));
     }
     sLog.Cyan("    StaticDataMgr", "%u Moon Resources loaded in %.3fms.", m_moonGoo.size(), (GetTimeMSeconds() - startTime));
 
     startTime = GetTimeMSeconds();
     ManagerDB::GetOreBySSC(*res);
     while (res->GetRow(row)) {
         //SELECT systemSec, roidID, percent FROM roidDistribution
         OreTypeChance oreChance = OreTypeChance();
             oreChance.typeID  = row.GetInt(1);
             oreChance.chance  = row.GetFloat(2);
         m_oreBySecClass.emplace(row.GetText(0), oreChance);
     }
     sLog.Cyan("    StaticDataMgr", "%u Ore defs loaded in %.3fms.", m_oreBySecClass.size(), (GetTimeMSeconds() - startTime));
 
     startTime = GetTimeMSeconds();
     //SELECT factionID, itemID FROM facSalvage
     ManagerDB::GetSalvageGroups(*res);
     while (res->GetRow(row))
         m_salvageMap.emplace(row.GetInt(0), row.GetInt(1));
     sLog.Cyan("    StaticDataMgr", "%u salvage definitions loaded in %.3fms.", m_salvageMap.size(), (GetTimeMSeconds() - startTime));
 
     startTime = GetTimeMSeconds();
     ManagerDB::GetRegionFaction(*res);
     while (res->GetRow(row)) {
         //SELECT regionID, factionID FROM mapRegions
         m_regions.emplace(row.GetInt(0), row.GetInt(1));
     }
 
     ManagerDB::GetRegionRatFaction(*res);
     while (res->GetRow(row)) {
         //SELECT regionID, ratFactionID FROM mapRegions WHERE ratFactionID != 0
         m_ratRegions.emplace(row.GetInt(0), row.GetInt(1));
     }
     sLog.Cyan("    StaticDataMgr", "%u Region Faction Data Sets loaded in %.3fms.", (m_regions.size() + m_ratRegions.size()), (GetTimeMSeconds() - startTime));
 
     startTime = GetTimeMSeconds();
     ManagerDB::GetFactionGroups(*res);
     DBQueryResult* res2 = new DBQueryResult();
     DBResultRow row2;
     RatFactionGroups factionGroup;
     uint16 typeCount = 0;
     while (res->GetRow(row)) {
         //SELECT shipClass, groupID, factionID FROM npcClassGroup
         factionGroup.shipClass = row.GetInt(0);
         factionGroup.groupID = (uint16)row.GetInt(1);
         m_npcGroups.emplace(row.GetInt(2), factionGroup);
 
         rt_typeIDs rtt;
         ManagerDB::GetGroupTypeIDs((uint8)row.GetInt(0), (uint16)row.GetInt(1), row.GetInt(2), *res2);
         while (res2->GetRow(row2)) {
             //SELECT typeID FROM invTypes WHERE groupID = %u (plus specific checks) ORDER BY typeID
             rtt.push_back((uint16)row2.GetInt(0));
             ++typeCount;
         }
         rt_groups rtg;
         rtg.emplace((uint16)row.GetInt(1), rtt);
         m_npcTypes.emplace((uint8)row.GetInt(0), rtg);
     }
 
     ManagerDB::GetSpawnClasses(*res);
     while (res->GetRow(row)) {
         //SELECT type, sub, f, af, d, c, ac, bc, bs, h, o, cf, cd, cc, cbc, cbs FROM npcSpawnClass
         RatSpawnClass spawnClass = RatSpawnClass();
         spawnClass.type = row.GetInt(0);
         spawnClass.sub = row.GetInt(1);
         spawnClass.f = row.GetInt(2);
         spawnClass.af = row.GetInt(3);
         spawnClass.d = row.GetInt(4);
         spawnClass.c = row.GetInt(5);
         spawnClass.ac = row.GetInt(6);
         spawnClass.bc = row.GetInt(7);
         spawnClass.bs = row.GetInt(8);
         spawnClass.h = row.GetInt(9);
         spawnClass.o = row.GetInt(10);
         spawnClass.cf = row.GetInt(11);
         spawnClass.cd = row.GetInt(12);
         spawnClass.cc = row.GetInt(13);
         spawnClass.cbc = row.GetInt(14);
         spawnClass.cbs = row.GetInt(15);
         m_npcClasses.emplace((uint8)row.GetInt(0), spawnClass);
     }
     sLog.Cyan("    StaticDataMgr", "%u Rat Groups, %u Rat Classes, and %u Rat Types for %u regions loaded in %.3fms.",\
               m_npcGroups.size(), m_npcClasses.size(), typeCount, m_ratRegions.size(), (GetTimeMSeconds() - startTime));
 
     startTime = GetTimeMSeconds();
     SystemDB::GetWrecksToTypes(*res);
     while (res->GetRow(row)) {
         //SELECT typeID, wreckTypeID FROM invTypesToWrecks
         m_WrecksToTypesMap[row.GetInt(0)] = row.GetInt(1);
     }
     sLog.Cyan("    StaticDataMgr", "%u wreck objects loaded in %.3fms.", m_WrecksToTypesMap.size(), (GetTimeMSeconds() - startTime));
 
     startTime = GetTimeMSeconds();
     SystemDB::GetLootGroups(*res);
     while (res->GetRow(row)) {
         //SELECT npcGroupID, itemGroupID, groupDropChance FROM lootGroup
         LootGroup lootGroup = LootGroup();
         lootGroup.lootGroupID = row.GetInt(1);
         lootGroup.dropChance = row.GetDouble(2);
         m_LootGroupMap.emplace(row.GetInt(0), lootGroup);
     }
 
     startTime = GetTimeMSeconds();
     SystemDB::GetLootGroupTypes(*res);
     while (res->GetRow(row)) {
         //SELECT itemGroupID, itemID, itemMetaLevel, minAmount, maxAmount FROM lootItemGroup
         LootGroupType GroupType = LootGroupType();
         GroupType.lootGroupID = row.GetInt(0);
         GroupType.typeID =  row.GetInt(1);
         GroupType.metaLevel = row.GetInt(2);
         GroupType.minQuantity = row.GetInt(3);
         GroupType.maxQuantity = row.GetInt(4);
         m_LootGroupTypeMap.emplace(row.GetInt(0), GroupType);
     }
     sLog.Cyan("    StaticDataMgr", "%u loot groups and %u loot group types loaded in %.3fms.",
               m_LootGroupMap.size(), m_LootGroupTypeMap.size(), (GetTimeMSeconds() - startTime));
 
     startTime = GetTimeMSeconds();
     uint32 locationID = 0;
     ManagerDB::GetAgentLocation(*res);
     while (res->GetRow(row)) {
         //SELECT agentID, locationID FROM agtAgents
         locationID = row.GetInt(1);
         if (IsStationID(locationID)) {
             locationID = GetStationSystem(locationID);
         }
         if (!IsSolarSystemID(locationID)) {
             _log(DATA__MESSAGE, "Failed to query info:  locationID %u is neither station nor system.", locationID);
             continue;
         }
 
         m_agentSystem.emplace(row.GetInt(0), locationID);
     }
     sLog.Cyan("    StaticDataMgr", "%u Agent Data Sets loaded in %.3fms.", m_agentSystem.size(), (GetTimeMSeconds() - startTime));
 
     //cleanup
     SafeDelete(res);
     SafeDelete(res2);
 
     sLog.Cyan("    StaticDataMgr", "Static Data loaded in %.3fms.", (GetTimeMSeconds() - beginTime));
 }

Here is the caller graph for this function:

PyDict * StaticDataMgr::SetBPMatlType	(	int8	catID,
		uint16	typeID,
		uint16	prodID
	)

Todo:: this needs work. dunno how to remove 'extra' materials from this list

Definition at line 1263 of file StaticDataMgr.cpp.

References DBRowDescriptor::AddColumn(), PyList::AddItem(), PyRep::AsPackedRow(), PyList::begin(), EVEDB::invCategories::Blueprint, EvERam::Activity::Copying, DBResultToCRowset(), DBTYPE_I4, DBTYPE_R4, EvERam::Activity::Duplicating, PyList::end(), PyPackedRow::GetField(), GetRamMaterials(), GetRamRequirements(), EvERam::Activity::Invention, IsSkillTypeID(), Corp::Division::Manufacturing, CRowSet::NewRow(), PyDecRef, PyIncRef, EvERam::Activity::ResearchMaterial, EvERam::Activity::ResearchTech, EvERam::Activity::ResearchTime, EvERam::Activity::ReverseEngineering, PyPackedRow::SetField(), PyDict::SetItem(), and PyDict::SetItemString().

Referenced by Populate().

 {
     // dunno how to do this part better...
     PyList* matlListManuf = new PyList();
     PyList* skillListManuf = new PyList();
     PyList* extraListManuf = new PyList();
     PyList* matlListTE = new PyList();
     PyList* skillListTE = new PyList();
     PyList* matlListME = new PyList();
     PyList* skillListME = new PyList();
     PyList* matlListCopy = new PyList();
     PyList* skillListCopy = new PyList();
     PyList* matlListDup = new PyList();
     PyList* skillListDup = new PyList();
     PyList* extraListDup = new PyList();
     PyList* matlListRE = new PyList();
     PyList* skillListRE = new PyList();
     PyList* matlListInvent = new PyList();
     PyList* skillListInvent = new PyList();
 
     DBRowDescriptor* header = new DBRowDescriptor();
         header->AddColumn( "quantity",          DBTYPE_I4 );
         header->AddColumn( "requiredTypeID",    DBTYPE_I4 );
         header->AddColumn( "damagePerJob",      DBTYPE_R4 );
 
     // NOTE: this is for BLUEPRINTS ONLY and is always populated (ancient relic error fix)
     if (catID == EVEDB::invCategories::Blueprint) {
         // ramMaterials is only for manufacturing the bp product
         std::vector<EvERam::RamMaterials> ramMatls;
         ramMatls.clear();
         GetRamMaterials(prodID, ramMatls);
         for (auto cur : ramMatls) {
             PyPackedRow* row = new PyPackedRow( header );
                 row->SetField( "quantity",        new PyInt(cur.quantity));
                 row->SetField( "requiredTypeID",  new PyInt(cur.materialTypeID));
                 row->SetField( "damagePerJob",    new PyFloat(1.0f));
             matlListManuf->AddItem(row);
         }
     }
 
     // booleans to only set items that are populated  NOTE: manuf is always populated for blueprints
     bool manuf(false), copy(false), invent(false), dup(false), me(false), re(false), te(false), tech(false);
     //  get R.A.M. skills and materials for both bp typeID and product typeID
     // the ramRequirements table holds ALL skill/item data for all aspects of RAM per BlueprintTypeID.
     std::vector<EvERam::RamRequirements> ramReqs;
     ramReqs.clear();
     GetRamRequirements(typeID, ramReqs);
     //GetRamRequirements(prodID, ramReqs);
     for (auto cur : ramReqs) {
         PyPackedRow* row = new PyPackedRow( header );
             row->SetField("quantity",        new PyInt(cur.quantity));
             row->SetField("requiredTypeID",  new PyInt(cur.requiredTypeID));
             row->SetField("damagePerJob",    new PyFloat(cur.damagePerJob));
 
         using namespace EvERam;
         switch(cur.activityID) {
             case Activity::Manufacturing: {         //1
                 manuf = true;
                 if (IsSkillTypeID(cur.requiredTypeID)) {
                     skillListManuf->AddItem(row);
                 } else if (cur.extra) {
                     extraListManuf->AddItem(row);
                 } else {
                     matlListManuf->AddItem(row);
                 }
             } break;
             case Activity::ResearchTech: {          //2
                 // not used.  not defined in client.  no data for this activity
             } break;
             case Activity::ResearchTime: {          //3
                 te = true;
                 if (IsSkillTypeID(cur.requiredTypeID)) {
                     skillListTE->AddItem(row);
                 } else {
                     matlListTE->AddItem(row);
                 }
             } break;
             case Activity::ResearchMaterial: {      //4
                 me = true;
                 if (IsSkillTypeID(cur.requiredTypeID)) {
                     skillListME->AddItem(row);
                 } else {
                     matlListME->AddItem(row);
                 }
             } break;
             case Activity::Copying: {               //5
                 copy = true;
                 if (IsSkillTypeID(cur.requiredTypeID)) {
                     skillListCopy->AddItem(row);
                 } else {
                     matlListCopy->AddItem(row);
                 }
             } break;
             case Activity::Duplicating: {           //6
                 dup = true;
                 if (IsSkillTypeID(cur.requiredTypeID)) {
                     skillListDup->AddItem(row);
                 } else if (cur.extra) {
                     extraListDup->AddItem(row);
                 } else {
                     matlListDup->AddItem(row);
                 }
             } break;
             case Activity::ReverseEngineering: {    //7
                 re = true;
                 if (IsSkillTypeID(cur.requiredTypeID)) {
                     skillListRE->AddItem(row);
                 } else {
                     matlListRE->AddItem(row);
                 }
             } break;
             case Activity::Invention: {             //8
                 invent = true;
                 if (IsSkillTypeID(cur.requiredTypeID)) {
                     skillListInvent->AddItem(row);
                 } else {
                     matlListInvent->AddItem(row);
                 }
             } break;
         }
     }
 
     // this is the response.  test for items populated above and create an ItemString in the dict for that item.
     // items not populated will not be shown in the BP info.
     DBQueryResult mtRes;
     PyRep* mtCRowSet = DBResultToCRowset(mtRes);
     PyDict* rsp = new PyDict();
     // activity '0' should stay empty
     //activityNone = 0
     //rsp->SetItem(0, new PyDict());
 
     if (manuf) {        //activityManufacturing = 1
         PyDict* Manufacturing = new PyDict();
             Manufacturing->SetItemString("skills", skillListManuf);
             Manufacturing->SetItemString("rawMaterials", matlListManuf);
             CRowSet *rowset = new CRowSet( &header );
             PyList::const_iterator itr = extraListManuf->begin();
             for (; itr != extraListManuf->end(); ++itr) {
                 PyPackedRow* from = (*itr)->AsPackedRow();
                 PyPackedRow* into = rowset->NewRow();
                 into->SetField((uint32)0, from->GetField(0));
                 into->SetField((uint32)1, from->GetField(1));
                 into->SetField((uint32)2, from->GetField(2));
             }
         Manufacturing->SetItemString("extras", rowset);     // have to build a crowset for this
         rsp->SetItem(new PyInt(1), new PyObject("util.KeyVal", Manufacturing));
     }
     if (tech) {        //activityResearchingTechnology = 2
         // not used.  not defined in client.  no data for this activity
     }
     if (te) {        //activityResearchingTimeProductivity = 3
         PyDict* ResearchTime = new PyDict();
             ResearchTime->SetItemString("skills", skillListTE);
             ResearchTime->SetItemString("rawMaterials", matlListTE);
             PyIncRef(mtCRowSet);
         ResearchTime->SetItemString("extras", mtCRowSet);
         rsp->SetItem(new PyInt(3), new PyObject("util.KeyVal", ResearchTime));
     }
     if (me) {        //activityResearchingMaterialProductivity = 4
         PyDict* ResearchMaterial = new PyDict();
             ResearchMaterial->SetItemString("skills", skillListME);
             ResearchMaterial->SetItemString("rawMaterials", matlListME);
             PyIncRef(mtCRowSet);
         ResearchMaterial->SetItemString("extras", mtCRowSet);
         rsp->SetItem(new PyInt(4), new PyObject("util.KeyVal", ResearchMaterial));
     }
     if (copy) {        //activityCopying = 5
         PyDict* Copying = new PyDict();
             Copying->SetItemString("skills", skillListCopy);
             Copying->SetItemString("rawMaterials", matlListCopy);
             PyIncRef(mtCRowSet);
         Copying->SetItemString("extras", mtCRowSet);
         rsp->SetItem(new PyInt(5), new PyObject("util.KeyVal", Copying));
     }
     if (dup) {       //activityDuplicating = 6
         // no longer used...updated to "copying" after RMR
         PyDict* Duplicating = new PyDict();
             Duplicating->SetItemString("skills", skillListDup);
             Duplicating->SetItemString("rawMaterials", matlListDup);
             CRowSet *rowset = new CRowSet( &header );
             PyList::const_iterator itr = extraListDup->begin();
             for (; itr != extraListDup->end(); ++itr) {
                 PyPackedRow* from = (*itr)->AsPackedRow();
                 PyPackedRow* into = rowset->NewRow();
                 into->SetField((uint32)0, from->GetField(0));
                 into->SetField((uint32)1, from->GetField(1));
                 into->SetField((uint32)2, from->GetField(2));
             }
         Duplicating->SetItemString("extras", rowset);    // have to build a crowset for this
         rsp->SetItem(new PyInt(6), new PyObject("util.KeyVal", Duplicating));
     }
     if (re) {        //activityReverseEngineering = 7
         PyDict* ReverseEngineering = new PyDict();
             ReverseEngineering->SetItemString("skills", skillListRE);
             ReverseEngineering->SetItemString("rawMaterials", matlListRE);
             PyIncRef(mtCRowSet);
         ReverseEngineering->SetItemString("extras", mtCRowSet);
         rsp->SetItem(new PyInt(7), new PyObject("util.KeyVal", ReverseEngineering));
     }
     if (invent) {     //activityInvention = 8
         PyDict* Invention = new PyDict();
             Invention->SetItemString("skills", skillListInvent);
             Invention->SetItemString("rawMaterials", matlListInvent);
             PyIncRef(mtCRowSet);
         Invention->SetItemString("extras", mtCRowSet);
         rsp->SetItem(new PyInt(8), new PyObject("util.KeyVal", Invention));
     }
 
     // cleanup
     PyDecRef(matlListManuf);
     PyDecRef(skillListManuf);
     PyDecRef(extraListManuf);
     PyDecRef(matlListTE);
     PyDecRef(skillListTE);
     PyDecRef(matlListME);
     PyDecRef(skillListME);
     PyDecRef(matlListCopy);
     PyDecRef(skillListCopy);
     PyDecRef(matlListDup);
     PyDecRef(skillListDup);
     PyDecRef(extraListDup);
     PyDecRef(matlListRE);
     PyDecRef(skillListRE);
     PyDecRef(matlListInvent);
     PyDecRef(skillListInvent);
 
     return rsp;
 }