mirror of
https://port.numenaute.org/aleajactaest/khanat-opennel-code.git
synced 2024-12-17 14:48:42 +00:00
402 lines
14 KiB
C++
402 lines
14 KiB
C++
// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
|
|
// Copyright (C) 2010 Winch Gate Property Limited
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Affero General Public License as
|
|
// published by the Free Software Foundation, either version 3 of the
|
|
// License, or (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Affero General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Affero General Public License
|
|
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
|
|
|
|
|
|
#ifndef GS_FAME_H
|
|
#define GS_FAME_H
|
|
|
|
#include "nel/misc/string_mapper.h"
|
|
#include "mirrored_data_set.h"
|
|
#include "mirror_prop_value.h"
|
|
#include "pvp_clan.h"
|
|
#include "nel/misc/variable.h"
|
|
|
|
/** NB : if you change the MAX_FACTION, you MUST also do the following :
|
|
* 1 - change the mirror description file data_share/mirror_sheet/fame.dataset to add the additionnal entry (or remove if you reduce the value)
|
|
* 2 - change the excel worksheet \\server\leveldesign\static_fame.xls :
|
|
* * resize the sheet (on x and y axis, the sheet must remain square),
|
|
* * update the macro Module1.ExportFame ligne 6 : Range("A1:CV100").Select : update the range to the new worksheet size
|
|
*/
|
|
const uint MAX_FACTION = 100;
|
|
const sint32 NO_FAME = 0x7FFFFFFF;
|
|
extern NLMISC::CVariable<bool> UseAsymmetricStaticFames;
|
|
|
|
|
|
/** Give a simple access to
|
|
* all the static fame values.
|
|
* Static fames values include tribe to tribe and tribe to civilisation fames.
|
|
*/
|
|
class CStaticFames
|
|
{
|
|
public:
|
|
class CTribeCultThreshold
|
|
{
|
|
public:
|
|
CTribeCultThreshold()
|
|
{
|
|
Kami = 0;
|
|
Karavan = 0;
|
|
Neutral = 0;
|
|
}
|
|
|
|
void setKami(sint32 t) { Kami = t; }
|
|
void setKaravan(sint32 t) { Karavan = t; }
|
|
void setNeutral(sint32 t) { Neutral = t; }
|
|
|
|
sint32 getKami() const { return Kami; }
|
|
sint32 getKaravan() const { return Karavan; }
|
|
sint32 getNeutral() const { return Neutral; }
|
|
|
|
private:
|
|
sint32 Kami;
|
|
sint32 Karavan;
|
|
sint32 Neutral;
|
|
};
|
|
|
|
class CTribeCultThresholdPerCiv
|
|
{
|
|
public:
|
|
bool getCultThresholdForCiv( PVP_CLAN::TPVPClan civ, sint32& kami, sint32& karavan, sint32& neutral) const
|
|
{
|
|
const CTribeCultThreshold * tc = 0;
|
|
switch( civ )
|
|
{
|
|
case PVP_CLAN::Matis:
|
|
tc = &Matis;
|
|
break;
|
|
case PVP_CLAN::Fyros:
|
|
tc = &Fyros;
|
|
break;
|
|
case PVP_CLAN::Tryker:
|
|
tc = &Tryker;
|
|
break;
|
|
case PVP_CLAN::Neutral:
|
|
tc = &Neutral;
|
|
break;
|
|
default:
|
|
return false;
|
|
}
|
|
kami = tc->getKami();
|
|
karavan = tc->getKaravan();
|
|
neutral = tc->getNeutral();
|
|
return true;
|
|
}
|
|
|
|
uint32 FameIndex;
|
|
CTribeCultThreshold Matis;
|
|
CTribeCultThreshold Fyros;
|
|
CTribeCultThreshold Tryker;
|
|
CTribeCultThreshold Zorai;
|
|
CTribeCultThreshold Neutral;
|
|
};
|
|
|
|
// declare scoped constant value
|
|
enum
|
|
{
|
|
/// Tag value for invalid faction index.
|
|
INVALID_FACTION_INDEX = 0xffffffff
|
|
};
|
|
|
|
static CStaticFames &getInstance()
|
|
{
|
|
if (_Instance == NULL)
|
|
_Instance = new CStaticFames();
|
|
|
|
return *_Instance;
|
|
}
|
|
|
|
// release singleton
|
|
static void releaseInstance();
|
|
|
|
// destructor
|
|
~CStaticFames();
|
|
|
|
/// Get the list of faction mapped names.
|
|
const std::vector<NLMISC::TStringId> &getFactionNames() { return _FactionNames; }
|
|
|
|
/// Get the name of a faction.
|
|
const std::string &getFactionName(uint32 factionIndex);
|
|
|
|
/// Convert the mapped name of a faction into an indexed value (allowing very fast access).
|
|
uint getFactionIndex(NLMISC::TStringId factionName);
|
|
/// Same as above but with that name as a string.
|
|
uint getFactionIndex(const std::string &factionName);
|
|
|
|
/** Get the fame value between two factions. There is no constraint on faction order because
|
|
* fame values are reciprocal.
|
|
*/
|
|
sint32 getStaticFame(NLMISC::TStringId faction1, NLMISC::TStringId faction2);
|
|
|
|
/// Same as above but with string name instead of mapped string.
|
|
sint32 getStaticFame(const std::string &faction1, const std::string &faction2);
|
|
|
|
/// Same as above but direct index instead of mapped string.
|
|
sint32 getStaticFameIndexed(uint factionIndex1, uint factionIndex2);
|
|
|
|
/** Get the propagation factor value between two factions. There is no constraint on faction order because
|
|
* values are reciprocal.
|
|
*/
|
|
float getPropagationFactorIndexed(uint factionIndex1, uint factionIndex2) const;
|
|
|
|
/// get the sheet associated with a faction
|
|
const NLMISC::CSheetId & getFactionSheet(uint32 factionIndex)
|
|
{
|
|
if (factionIndex < _FactionSheets.size())
|
|
return _FactionSheets[factionIndex];
|
|
else
|
|
return NLMISC::CSheetId::Unknown;
|
|
}
|
|
|
|
/// get the sheet associated with a faction
|
|
uint getFactionIndexFromSheet(const NLMISC::CSheetId & sheet)
|
|
{
|
|
TFactionNameSheetList::iterator it = _FactionSheetIndex.find( sheet );
|
|
if ( it != _FactionSheetIndex.end() )
|
|
return (*it).second;
|
|
else
|
|
return INVALID_FACTION_INDEX;
|
|
}
|
|
|
|
// get client database index from fame index
|
|
uint getDatabaseIndex( uint fameIndex ) { nlassert( _FameIndexToDatabaseIndex.size() > fameIndex ); return _FameIndexToDatabaseIndex[ fameIndex ]; }
|
|
|
|
// get first tribe fame index
|
|
uint getFirstTribeFameIndex() { return _FirstTribeFameIndex; }
|
|
|
|
// get number of tribe fame index
|
|
uint getNbTribeFameIndex() { return _FameTableSize - _FirstTribeFameIndex; }
|
|
|
|
// return number of fame in table
|
|
uint getNbFame() { return _FameTableSize; }
|
|
|
|
// get tribe threshold per civ allegiance
|
|
const std::vector<CTribeCultThresholdPerCiv>& getTribeThresholdVector() const { return _TribeCultThresholdPerCiv; }
|
|
|
|
private:
|
|
|
|
/// private ctor
|
|
CStaticFames();
|
|
|
|
/// static fame loader
|
|
void loadStaticFame( const std::string& filename );
|
|
|
|
/// static fame tribe threshold
|
|
void loadTribeThreshold( const std::string& filename );
|
|
|
|
/// singleton instance
|
|
static CStaticFames *_Instance;
|
|
|
|
/// faction name index table
|
|
typedef CHashMap<NLMISC::TStringId, uint, NLMISC::CStringIdHashMapTraits> TFactionNameIndexList;
|
|
TFactionNameIndexList _FactionNameIndex;
|
|
std::vector<NLMISC::TStringId> _FactionNames;
|
|
|
|
// faction databaseIndex <=> fameIndex translation table
|
|
std::vector< uint > _FameIndexToDatabaseIndex;
|
|
uint _FirstTribeFameIndex;
|
|
|
|
/// faction sheet - name table
|
|
typedef CHashMap<NLMISC::CSheetId, uint, NLMISC::CSheetIdHashMapTraits> TFactionNameSheetList;
|
|
TFactionNameSheetList _FactionSheetIndex;
|
|
std::vector<NLMISC::CSheetId> _FactionSheets;
|
|
|
|
/// cult threshold for tribe depending of civilization allegiance
|
|
std::vector<CTribeCultThresholdPerCiv> _TribeCultThresholdPerCiv;
|
|
|
|
/// Size of the fame table (the table is a square)
|
|
uint _FameTableSize;
|
|
/// fame table
|
|
sint32 *_FameTable;
|
|
/// propagation factor table
|
|
float *_PropagationFactorTable;
|
|
};
|
|
|
|
/** Access and effect on all the fame in the world.
|
|
* This class can either static fame or dynamic fame.
|
|
* Static fame are initial fame between civilisation,
|
|
* fame between civilisation and tribe and beween tribe.
|
|
* Dynamic fame include civilisation to civilisation,
|
|
* guild to civilisation, guild to tribe, player to
|
|
* civilisation and player to tribe.
|
|
*/
|
|
class CFameInterface
|
|
{
|
|
public:
|
|
friend class CFameManager;
|
|
/// Singleton accessor
|
|
static CFameInterface &getInstance()
|
|
{
|
|
if (_Instance == NULL)
|
|
{
|
|
_Instance = new CFameInterface;
|
|
}
|
|
|
|
return *_Instance;
|
|
}
|
|
|
|
/// Initialise the dataset pointer (call this when mirror is ready).
|
|
void setFameDataSet(CMirroredDataSet *fameDataSet, bool declareProperty = true);
|
|
|
|
/// get back the fame dataset
|
|
CMirroredDataSet *getFameDataSet() { return _FameDataSet; }
|
|
|
|
/** Method to call when a fame entry is created in the mirror.
|
|
* This method is called from the service mirror notification callback.
|
|
*/
|
|
void createFameOwner(CMirroredDataSet& dataSet, const TDataSetRow& entityRow)
|
|
{
|
|
nlassertex(_FameDataSet, ("You must set the fame dataset pointer before calling this function"));
|
|
nlassert(_FamesOwners.find(entityRow) == _FamesOwners.end());
|
|
|
|
TFameOwner *fo = new TFameOwner(dataSet, entityRow);
|
|
_FamesOwners.insert(std::make_pair(entityRow, fo));
|
|
}
|
|
/** Method to call when a fame entry is deleted from the mirror.
|
|
* This method is called from the service mirror notification callback.
|
|
*/
|
|
void removeFameOwner(CMirroredDataSet& /* dataSet */, const TDataSetRow& entityRow)
|
|
{
|
|
nlassertex(_FameDataSet, ("You must set the fame dataset pointer before calling this function"));
|
|
TFameContainer::iterator it(_FamesOwners.find(entityRow));
|
|
|
|
nlassert(it != _FamesOwners.end());
|
|
delete it->second;
|
|
_FamesOwners.erase(it);
|
|
}
|
|
|
|
//@{
|
|
//@name Fame querying
|
|
/** Get the fame of a civilisation, guild or player versus a tribe or civilisation
|
|
* The name is a mapped name and is the same as in CStaticFame class.
|
|
*/
|
|
sint32 getFame(const NLMISC::CEntityId &entityId, NLMISC::TStringId faction, bool modulated = false, bool returnUnknowValue = false);
|
|
/** Get the fame of a civilisation, guild or player versus a tribe or civilisation
|
|
* The name is a mapped name and is the same as in CStaticFame class.
|
|
*/
|
|
sint32 getFameIndexed(const NLMISC::CEntityId &entityId, uint32 factionIndex, bool modulated = false, bool returnUnknowValue = false);
|
|
//@}
|
|
|
|
//@{
|
|
//@name Fame modification
|
|
/** Add some fame value for a civilisation, a guild or a player vs a tribe or civilisation.
|
|
* The value can positive or negative.
|
|
* Fame modifications are not immediately received because it's the EGS that apply the value.
|
|
*/
|
|
void addFame(const NLMISC::CEntityId &entityId, NLMISC::TStringId faction, sint32 deltaFame, bool propagate = false);
|
|
/** Add some fame value for a civilisation, a guild or a player vs a tribe or civilisation.
|
|
* The value can positive or negative.
|
|
* Fame modifications are not immediately received because it's the EGS that apply the value.
|
|
*/
|
|
void addFameIndexed(const NLMISC::CEntityId &entityId, uint32 factionIndex, sint32 deltaFame, bool propagate = false);
|
|
/** Set the value of the fame.
|
|
*/
|
|
//void setFame(const NLMISC::CEntityId &entityId, NLMISC::TStringId faction, sint32 fameValue);
|
|
//@}
|
|
|
|
//@{
|
|
//@name Indirect fame feature querying.
|
|
/// Get the civilisation datasetrow for the given entity.
|
|
const TDataSetRow &getCivilisationIndex(const NLMISC::CEntityId &entityId);
|
|
/// Get the guild datasetrow for the given entity.
|
|
const TDataSetRow &getGuildIndex(const NLMISC::CEntityId &entityId);
|
|
/// Get the fame memory datasetrow for the given entity.
|
|
const TDataSetRow &getFameMemoryIndex(const NLMISC::CEntityId &entityId);
|
|
//@}
|
|
|
|
/** Interface class designed to implemented and registered in the FameInterface by the
|
|
* EGS services.
|
|
* This class directly receive fame delta from addFame.
|
|
* You must not use this feature with more than one service ! (only the EGS actualy).
|
|
*/
|
|
class IFameOverload
|
|
{
|
|
public:
|
|
/** Receive fame delta value.
|
|
* @param entityIndex index inside the fame dataset.
|
|
* @param factionIndex index of the faction (as defined in CStaticFame).
|
|
* @param deltaFame The delta fame value.
|
|
*/
|
|
virtual void addFameIndexed(const NLMISC::CEntityId &entityId, uint factionIndex, sint32 deltaFame, bool propagate) =0;
|
|
/** Get the fame of a civilisation, guild or player versus a tribe or civilisation
|
|
* The name is a mapped name and is the same as in CStaticFame class.
|
|
*/
|
|
virtual sint32 getFameIndexed(const NLMISC::CEntityId &entityId, uint32 factionIndex, bool modulated = true, bool returnUnknownValue = false) =0;
|
|
virtual const TDataSetRow &getCivilisationIndex(const NLMISC::CEntityId &entityId) =0;
|
|
virtual const TDataSetRow &getGuildIndex(const NLMISC::CEntityId &entityId) =0;
|
|
virtual const TDataSetRow &getFameMemoryIndex(const NLMISC::CEntityId &entityId) =0;
|
|
};
|
|
/// Register the fame adder interface.
|
|
void registerFameOverload(IFameOverload *fameOverload) { _FameOverload = fameOverload; }
|
|
|
|
// get faction index from faction name
|
|
sint32 getFactionIndex(NLMISC::TStringId faction);
|
|
|
|
private:
|
|
|
|
CFameInterface()
|
|
: _FameDataSet(NULL),
|
|
_FameOverload(NULL)
|
|
{}
|
|
|
|
// fame data for civilisation, guild or player entity
|
|
struct TFameOwner
|
|
{
|
|
/// Civilisation index inside the fame dataset (valid for player and guild entity)
|
|
CMirrorPropValueRO<TDataSetRow> Civilisation;
|
|
/// Guild index inside the fame dataset (valid for player only)
|
|
CMirrorPropValueRO<TDataSetRow> Guild;
|
|
/// Fame memory index inside the fame dataset (valid for player only)
|
|
CMirrorPropValueRO<TDataSetRow> FameMemory;
|
|
// declare the 100 fame mirror value
|
|
CMirrorPropValueRO<sint32> Fames[MAX_FACTION];
|
|
|
|
TFameOwner(CMirroredDataSet& dataSet, const TDataSetRow& entityRow)
|
|
{
|
|
// WARNING : you must initialise your property in the same order as they are declared in the dataset
|
|
Civilisation.init(dataSet, entityRow, CivilisationPropIndex);
|
|
Guild.init(dataSet, entityRow, GuildPropIndex);
|
|
FameMemory.init(dataSet, entityRow, FameMemoryPropIndex);
|
|
|
|
for (uint i=0; i<MAX_FACTION; ++i)
|
|
{
|
|
Fames[i].init(dataSet, entityRow, FirstFamePropIndex+i);
|
|
}
|
|
}
|
|
|
|
/// Property index
|
|
static sint16 CivilisationPropIndex;
|
|
static sint16 GuildPropIndex;
|
|
static sint16 FameMemoryPropIndex;
|
|
static sint16 FirstFamePropIndex;
|
|
};
|
|
|
|
/// pointer to the fame dataset
|
|
CMirroredDataSet *_FameDataSet;
|
|
|
|
typedef CHashMap<TDataSetRow, TFameOwner*, TDataSetRow::CHashCode> TFameContainer;
|
|
/// storage for fame owner
|
|
TFameContainer _FamesOwners;
|
|
|
|
/// EGS local fame adder.
|
|
IFameOverload *_FameOverload;
|
|
|
|
/// Singleton instance pointer.
|
|
static CFameInterface *_Instance;
|
|
};
|
|
|
|
#endif // GS_FAME_H
|