Changed: #1135 Merge changes from Ryzom patch 1.10

This commit is contained in:
kervala 2010-10-23 14:29:27 +02:00
parent 75e49ffcce
commit 4970e14ef6
35 changed files with 1497 additions and 506 deletions

View file

@ -311,6 +311,7 @@ public:
uint32 getChildIndexByAlias(uint32 alias) const; uint32 getChildIndexByAlias(uint32 alias) const;
TChld* getChildByAlias(uint32 alias) const; TChld* getChildByAlias(uint32 alias) const;
TChld* getChildByName(std::string const& name) const; TChld* getChildByName(std::string const& name) const;
TChld* getFirstChild() const;
CAliasTreeOwner* getAliasChildByAlias(uint32 alias) const; CAliasTreeOwner* getAliasChildByAlias(uint32 alias) const;
CAliasTreeOwner* addAliasChild(CAliasTreeOwner* child); CAliasTreeOwner* addAliasChild(CAliasTreeOwner* child);
@ -523,6 +524,19 @@ TChld* CAliasCont<TChld>::getChildByName(std::string const& name) const
return NULL; return NULL;
} }
template <class TChld>
TChld* CAliasCont<TChld>::getFirstChild() const
{
size_t size = this->_Childs.size();
for (size_t i=0; i<size; ++i)
{
TChld* child = this->_Childs[i];
if (child!=NULL)
return child;
}
return NULL;
}
template <class TChld> template <class TChld>
CAliasTreeOwner* CAliasCont<TChld>::getAliasChildByAlias(uint32 alias) const CAliasTreeOwner* CAliasCont<TChld>::getAliasChildByAlias(uint32 alias) const
{ {

View file

@ -1280,18 +1280,30 @@ void setPlayerController_ss_(CStateInstance* entity, CScriptStack& stack)
{ {
CGroup* grp = NULL; CGroup* grp = NULL;
CSpawnBotNpc* bot = NULL; CSpawnBotNpc* bot = NULL;
if ((bot = dynamic_cast<CSpawnBotNpc*>(CAIEntityPhysicalLocator::getInstance()->getEntity(botId))) CAIEntityPhysicalLocator *inst = CAIEntityPhysicalLocator::getInstance();
&& (&bot->getPersistent().getGroup())==entity->getGroup()) if (inst)
{ {
CBotPlayer* player = NULL; CAIEntityPhysical *botEntity = inst->getEntity(botId);
if (playerId!=NLMISC::CEntityId::Unknown if (botEntity)
&& (player = dynamic_cast<CBotPlayer*>(CAIEntityPhysicalLocator::getInstance()->getEntity(playerId))))
{ {
bot->setPlayerController(player); if ((bot = dynamic_cast<CSpawnBotNpc*>(botEntity))
&& (&bot->getPersistent().getGroup())==entity->getGroup())
{
CBotPlayer* player = NULL;
if (playerId!=NLMISC::CEntityId::Unknown
&& (player = dynamic_cast<CBotPlayer*>(CAIEntityPhysicalLocator::getInstance()->getEntity(playerId))))
{
bot->setPlayerController(player);
}
else
bot->setPlayerController(NULL);
}
} }
else else
bot->setPlayerController(NULL); nlwarning("Bot entity not found");
} }
else
nlwarning("Instance not found");
} }
} }
@ -2002,7 +2014,12 @@ static CSpawnBot* getSpawnBotFromGroupByName(CGroupNpc* const group, const std::
CSpawnBot* spawnBot=0; CSpawnBot* spawnBot=0;
CAliasCont<CBot> const& bots = group->bots(); CAliasCont<CBot> const& bots = group->bots();
CBot* child=bots.getChildByName(botname); CCont<CBot> & cc_bots = group->bots();
CBot* child;
if (botname == "")
child = bots.getFirstChild();
else
child = bots.getChildByName(botname);
if (!child) { return 0; } if (!child) { return 0; }
spawnBot = child->getSpawnObj(); spawnBot = child->getSpawnObj();
@ -2291,6 +2308,37 @@ void emote_css_(CStateInstance* entity, CScriptStack& stack)
NLNET::CUnifiedNetwork::getInstance()->send( "EGS", msgout ); NLNET::CUnifiedNetwork::getInstance()->send( "EGS", msgout );
} }
void emote_ss_(CStateInstance* entity, CScriptStack& stack)
{
string emoteName = (string)stack.top(); stack.pop();
NLMISC::CEntityId botId = NLMISC::CEntityId((std::string)stack.top());
if (botId == NLMISC::CEntityId::Unknown)
{
return;
}
// Is the emote valid
uint32 emoteId = CAIS::instance().getEmotNumber(emoteName);
if (emoteId == ~0)
{
return;
}
// Get the behaviour Id
MBEHAV::EBehaviour behaviourId = (MBEHAV::EBehaviour)(emoteId + MBEHAV::EMOTE_BEGIN);
// Change the behaviour
NLNET::CMessage msgout("SET_BEHAVIOUR");
msgout.serial(botId);
MBEHAV::CBehaviour bh(behaviourId);
bh.Data = (uint16)(CTimeInterface::gameCycle());
msgout.serial(bh);
NLNET::CUnifiedNetwork::getInstance()->send( "EGS", msgout );
}
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
/** @page code /** @page code
@ -2429,6 +2477,7 @@ std::map<std::string, FScrptNativeFunc> nfGetNpcGroupNativeFunctions()
REGISTER_NATIVE_FUNC(functions, talkTo_sc_); REGISTER_NATIVE_FUNC(functions, talkTo_sc_);
REGISTER_NATIVE_FUNC(functions, facing_cscs_); REGISTER_NATIVE_FUNC(functions, facing_cscs_);
REGISTER_NATIVE_FUNC(functions, emote_css_); REGISTER_NATIVE_FUNC(functions, emote_css_);
REGISTER_NATIVE_FUNC(functions, emote_ss_);
REGISTER_NATIVE_FUNC(functions, npcSay_css_); REGISTER_NATIVE_FUNC(functions, npcSay_css_);
REGISTER_NATIVE_FUNC(functions, dssMessage_fsss_); REGISTER_NATIVE_FUNC(functions, dssMessage_fsss_);
REGISTER_NATIVE_FUNC(functions, despawnBotByAlias_s_); REGISTER_NATIVE_FUNC(functions, despawnBotByAlias_s_);

View file

@ -30,6 +30,8 @@
#include "nf_helpers.h" #include "nf_helpers.h"
#include "nel/misc/md5.h"
using std::string; using std::string;
using std::vector; using std::vector;
using namespace NLMISC; using namespace NLMISC;
@ -655,6 +657,31 @@ void pow_ff_f(CStateInstance* entity, CScriptStack& stack)
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
/** @page code /** @page code
@subsection md5sum_s_s
Returns the md5 sum of a string.
Arguments: s(string) -> s(string)
@param[in] string is a string
@param[out] md5sum is a string
@code
($sum)strlen($str);
@endcode
*/
// none
void md5sum_s_s(CStateInstance* entity, CScriptStack& stack)
{
std::string str = (std::string)stack.top();
std::string value = NLMISC::getMD5((uint8*)&str[0], str.size() ).toString();
nlinfo(value.c_str());
stack.top() = value;
}
//----------------------------------------------------------------------------
/** @page code
@subsection strlen_s_f @subsection strlen_s_f
Returns the length of a string. Returns the length of a string.
@ -1291,6 +1318,7 @@ std::map<std::string, FScrptNativeFunc> nfGetStaticNativeFunctions()
REGISTER_NATIVE_FUNC(functions, sqrt_f_f); REGISTER_NATIVE_FUNC(functions, sqrt_f_f);
REGISTER_NATIVE_FUNC(functions, exp_f_f); REGISTER_NATIVE_FUNC(functions, exp_f_f);
REGISTER_NATIVE_FUNC(functions, pow_ff_f); REGISTER_NATIVE_FUNC(functions, pow_ff_f);
REGISTER_NATIVE_FUNC(functions, md5sum_s_s);
REGISTER_NATIVE_FUNC(functions, strlen_s_f); REGISTER_NATIVE_FUNC(functions, strlen_s_f);
REGISTER_NATIVE_FUNC(functions, substr_sff_s); REGISTER_NATIVE_FUNC(functions, substr_sff_s);
REGISTER_NATIVE_FUNC(functions, strtof_s_f); REGISTER_NATIVE_FUNC(functions, strtof_s_f);

View file

@ -91,6 +91,7 @@
#include "dyn_chat_egs.h" #include "dyn_chat_egs.h"
#include "pvp_manager/pvp.h" #include "pvp_manager/pvp.h"
#include "pvp_manager/pvp_manager_2.h"
#include "player_manager/admin_properties.h" #include "player_manager/admin_properties.h"
#include "shop_type/offline_character_command.h" #include "shop_type/offline_character_command.h"
#include "player_manager/item_service_manager.h" #include "player_manager/item_service_manager.h"
@ -107,6 +108,10 @@
// Externs // Externs
// //
// Max number of user channel character can be have
#define NB_MAX_USER_CHANNELS 2
extern CPlayerManager PlayerManager; extern CPlayerManager PlayerManager;
extern CCreatureManager CreatureManager; extern CCreatureManager CreatureManager;
extern CPlayerService *PS; extern CPlayerService *PS;
@ -158,6 +163,8 @@ AdminCommandsInit[] =
// player character accessible commands // player character accessible commands
"teamInvite", true, "teamInvite", true,
"guildInvite", true, "guildInvite", true,
"roomInvite", true,
"roomKick", true,
"setGuildMessage", true, "setGuildMessage", true,
"clearGuildMessage", true, "clearGuildMessage", true,
"dodge", true, "dodge", true,
@ -166,6 +173,8 @@ AdminCommandsInit[] =
"resurrected", true, "resurrected", true,
"validateRespawnPoint", true, "validateRespawnPoint", true,
"summonPet", true, "summonPet", true,
"connectUserChannel", true,
"addPetAnimal", true, "addPetAnimal", true,
"addSkillPoints", true, "addSkillPoints", true,
@ -344,12 +353,14 @@ AdminCommandsInit[] =
"eventSetBotName", true, "eventSetBotName", true,
"eventSetBotScale", true, "eventSetBotScale", true,
"eventSetNpcGroupAggroRange", true, "eventSetNpcGroupAggroRange", true,
"eventSetNpcGroupEmote", true,
"eventSetFaunaBotAggroRange", true, "eventSetFaunaBotAggroRange", true,
"eventResetFaunaBotAggroRange", true, "eventResetFaunaBotAggroRange", true,
"eventSetBotCanAggro", true, "eventSetBotCanAggro", true,
"eventSetItemCustomText", true, "eventSetItemCustomText", true,
"eventResetItemCustomText", true, "eventResetItemCustomText", true,
"eventSetBotSheet", true, "eventSetBotSheet", true,
// "eventSetBotVPx", true,
"eventSetBotFaction", true, "eventSetBotFaction", true,
"eventSetBotFameByKill", true, "eventSetBotFameByKill", true,
"dssTarget", true, //ring stuff "dssTarget", true, //ring stuff
@ -2812,6 +2823,13 @@ void cbClientAdmin (NLNET::CMessage& msgin, const std::string &serviceName, NLNE
return; return;
} }
if (onTarget && !c->haveAnyPrivilege())
{
nlinfo("ADMIN: Player %s doesn't have privilege to execute /b command onTarget '%s' ", eid.toString().c_str(), cmdName.c_str());
chatToPlayer (eid, "You don't have privilege to execute this command");
return;
}
if (!cmd->ForwardToservice.empty()) if (!cmd->ForwardToservice.empty())
{ {
// we need to forward the command to another service // we need to forward the command to another service
@ -2849,12 +2867,14 @@ void cbClientAdmin (NLNET::CMessage& msgin, const std::string &serviceName, NLNE
{ {
log_Command_ExecOnTarget(c->getTarget(), cmdName, arg); log_Command_ExecOnTarget(c->getTarget(), cmdName, arg);
res += c->getTarget().toString(); res += c->getTarget().toString();
targetEid = c->getTarget();
targetName = NLMISC::toString("(%s,%s)", c->getTarget().toString().c_str(), CEntityIdTranslator::getInstance()->getByEntity(c->getTarget()).toString().c_str()); targetName = NLMISC::toString("(%s,%s)", c->getTarget().toString().c_str(), CEntityIdTranslator::getInstance()->getByEntity(c->getTarget()).toString().c_str());
} }
else else
{ {
log_Command_Exec(cmdName, arg); log_Command_Exec(cmdName, arg);
res += eid.toString(); res += eid.toString();
targetEid = eid;
targetName = string("Himself"); targetName = string("Himself");
} }
res += " "; res += " ";
@ -2866,6 +2886,10 @@ void cbClientAdmin (NLNET::CMessage& msgin, const std::string &serviceName, NLNE
TLogContext_Character_BuyRolemasterPhrase characterCtx(onTarget ? c->getTarget() : eid); TLogContext_Character_BuyRolemasterPhrase characterCtx(onTarget ? c->getTarget() : eid);
std::string csName = CEntityIdTranslator::getInstance()->getByEntity(eid).toString(); std::string csName = CEntityIdTranslator::getInstance()->getByEntity(eid).toString();
NLMISC::CSString cs_res = CSString(res);
cs_res = cs_res.replace("#player", eid.toString().c_str());
cs_res = cs_res.replace("#target", targetEid.toString().c_str());
res = (string)cs_res;
nlinfo ("ADMIN: Player (%s,%s) will execute client admin command '%s' on target %s", eid.toString().c_str(), csName.c_str(), res.c_str(), targetName.c_str()); nlinfo ("ADMIN: Player (%s,%s) will execute client admin command '%s' on target %s", eid.toString().c_str(), csName.c_str(), res.c_str(), targetName.c_str());
CLightMemDisplayer *CmdDisplayer = new CLightMemDisplayer("CmdDisplayer"); CLightMemDisplayer *CmdDisplayer = new CLightMemDisplayer("CmdDisplayer");
@ -2941,6 +2965,13 @@ void cbClientAdminOffline (NLNET::CMessage& msgin, const std::string &serviceNam
return; return;
} }
if (!c->haveAnyPrivilege())
{
nlinfo("ADMIN: Player %s doesn't have privilege to execute /c command '%s' ", eid.toString().c_str(), cmdName.c_str());
chatToPlayer (eid, "You don't have privilege to execute this command");
return;
}
// find the character eid // find the character eid
CEntityId charEid = CEntityIdTranslator::getInstance()->getByEntity(characterName); CEntityId charEid = CEntityIdTranslator::getInstance()->getByEntity(characterName);
if (charEid == CEntityId::Unknown) if (charEid == CEntityId::Unknown)
@ -4161,22 +4192,80 @@ ENTITY_VARIABLE (Invulnerable, "Invulnerable mode, invulnerability too all")
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
ENTITY_VARIABLE (ShowFactionChannels, "Show faction channels") NLMISC_COMMAND (ShowFactionChannels, "Show faction channels", "<csr id> <channel> <0|1>")
{ {
ENTITY_GET_CHARACTER if (args.size() != 3)
return false;
GET_CHARACTER
if (get) // PVP_CLAN::TPVPClan channelClan = PVP_CLAN::fromString( args[1] );
bool display = (args[2]=="1" || strlwr(args[2])=="on" || strlwr(args[2])=="true" );
TChanID channel = CPVPManager2::getInstance()->getFactionDynChannel(args[1]);
if (channel == DYN_CHAT_INVALID_CHAN)
{ {
value = c->showFactionChannelsMode()?"1":"0"; log.displayNL("Invalid Faction name: '%s'", args[1].c_str());
return false;
} }
CPVPManager2::getInstance()->addRemoveFactionChannelToUserWithPriviledge(channel, c, display);
nlinfo ("%s %s now in show %s channel mode", eid.toString().c_str(), display?"is":"isn't", channel.toString().c_str());
return true;
}
//----------------------------------------------------------------------------
// If channel not exists create it
NLMISC_COMMAND (connectUserChannel, "Connect to user channels", "<user id> <channel_name> [<pass>]")
{
if ((args.size() < 2) || (args.size() > 3))
return false;
GET_CHARACTER
CPVPManager2 *inst = CPVPManager2::getInstance();
string pass;
string name = NLMISC::toLower(args[1]);
TChanID channel = CPVPManager2::getInstance()->getUserDynChannel(name);
if (args.size() < 3)
pass = name;
else else
pass = args[2];
if ( (channel == DYN_CHAT_INVALID_CHAN) && (pass != string("*")) && (pass != string("***")) )
channel = inst->createUserChannel(name, pass);
if (channel != DYN_CHAT_INVALID_CHAN)
{ {
if (value=="1" || value=="on" || strlwr(value)=="true" ) string channelPass = inst->getPassUserChannel(channel);
c->setShowFactionChannelsMode(true);
else if (value=="0" || value=="off" || strlwr(value)=="false" ) if ( (channel != DYN_CHAT_INVALID_CHAN) && (pass == string("***")) && (c->havePriv(":DEV:") || c->havePriv(":SGM:") || c->havePriv(":GM:") || c->havePriv(":EM:")))
c->setShowFactionChannelsMode(false); {
nlinfo ("%s %s now in show faction channel mode", entity.toString().c_str(), c->showFactionChannelsMode()?"is":"isn't"); inst->deleteUserChannel(name);
}
else if (channelPass == pass)
{
std::vector<TChanID> userChannels = inst->getCharacterUserChannels(c);
if (userChannels.size() >= NB_MAX_USER_CHANNELS)
{
inst->removeFactionChannelForCharacter(userChannels[0], c, true);
}
inst->addFactionChannelToCharacter(channel, c, true, true);
}
else if (pass == string("*"))
{
inst->removeFactionChannelForCharacter(channel, c, true);
}
else
log.displayNL("You don't have rights to connect to channel %s", name.c_str());
return true;
} }
return false;
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
@ -4194,6 +4283,8 @@ ENTITY_VARIABLE (PriviledgePVP, "Priviledge Pvp Mode")
c->setPriviledgePVP(true); c->setPriviledgePVP(true);
else if (value=="0" || value=="off" || strlwr(value)=="false" ) else if (value=="0" || value=="off" || strlwr(value)=="false" )
c->setPriviledgePVP(false); c->setPriviledgePVP(false);
// c->setPVPRecentActionFlag();
CPVPManager2::getInstance()->setPVPModeInMirror(c);
nlinfo ("%s %s now in pvp mode", entity.toString().c_str(), c->priviledgePVP()?"is":"isn't"); nlinfo ("%s %s now in pvp mode", entity.toString().c_str(), c->priviledgePVP()?"is":"isn't");
} }
} }
@ -4382,6 +4473,90 @@ NLMISC_COMMAND(listGuildMembers, "display guild members list", "<csr eid> <guild
return true; return true;
} }
//----------------------------------------------------------------------------
NLMISC_COMMAND(roomInvite, "send a room invite to a player character", "<eid> <member name>")
{
if(args.size() != 2 )
return false;
CEntityId eId;
eId.fromString(args[0].c_str());
CCharacter * user = PlayerManager.getChar( eId );
if (!user)
{
log.displayNL("<ROOMINVITE>'%s' is not a valid char. Cant process command",eId.toString().c_str());
return true;
}
if (!user->getEnterFlag())
{
log.displayNL("'%s' is not entered", eId.toString().c_str());
return true;
}
if (!TheDataset.isAccessible(user->getEntityRowId()))
{
log.displayNL("'%s' is not valid in mirror", eId.toString().c_str());
return true;
}
CCharacter * target = PlayerManager.getCharacterByName(CShardNames::getInstance().makeFullNameFromRelative(user->getHomeMainlandSessionId(), args[1]));
if(target == 0 || target->getEnterFlag() == false )
{
CCharacter::sendDynamicSystemMessage( user->getId(), "TEAM_INVITED_CHARACTER_MUST_BE_ONLINE" );
return true;
}
SM_STATIC_PARAMS_1(params, STRING_MANAGER::player);
params[0].setEIdAIAlias( user->getId(), CAIAliasTranslator::getInstance()->getAIAlias(user->getId()) );
CCharacter::sendDynamicSystemMessage(target->getId(), "ROOM_INVITED_BY", params);
params[0].setEIdAIAlias( target->getId(), CAIAliasTranslator::getInstance()->getAIAlias(target->getId()) );
CCharacter::sendDynamicSystemMessage(user->getId(), "ROOM_YOU_INVITE", params);
user->addRoomAccessToPlayer(target->getId());
return true;
}
//----------------------------------------------------------------------------
NLMISC_COMMAND(roomKick, "kick player from room", "<eid> <member name>")
{
if(args.size() != 2 )
return false;
CEntityId eId;
eId.fromString(args[0].c_str());
CCharacter * user = PlayerManager.getChar( eId );
if (!user)
{
log.displayNL("<ROOMKICK>'%s' is not a valid char. Cant process command",eId.toString().c_str());
return true;
}
if (!user->getEnterFlag())
{
log.displayNL("'%s' is not entered", eId.toString().c_str());
return true;
}
if (!TheDataset.isAccessible(user->getEntityRowId()))
{
log.displayNL("'%s' is not valid in mirror", eId.toString().c_str());
return true;
}
CCharacter * target = PlayerManager.getCharacterByName(CShardNames::getInstance().makeFullNameFromRelative(user->getHomeMainlandSessionId(), args[1]));
if(target == 0 || target->getEnterFlag() == false )
{
CCharacter::sendDynamicSystemMessage( user->getId(), "TEAM_KICKED_CHARACTER_MUST_BE_ONLINE" );
return true;
}
user->removeRoomAccesToPlayer(target->getId(), false);
return true;
}
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
NLMISC_COMMAND(guildInvite, "send a guild invite to a player character", "<eid> <member name>") NLMISC_COMMAND(guildInvite, "send a guild invite to a player character", "<eid> <member name>")
{ {
@ -5280,7 +5455,7 @@ NLMISC_COMMAND(eventCreateNpcGroup, "create an event npc group", "<player eid> <
{ {
orientation = (sint32)(e->getHeading() * 1000.0); orientation = (sint32)(e->getHeading() * 1000.0);
} }
else else if (args[5] != "random")
{ {
NLMISC::fromString(args[5], orientation); NLMISC::fromString(args[5], orientation);
orientation = (sint32)((double)orientation / 360.0 * (NLMISC::Pi * 2.0) * 1000.0); orientation = (sint32)((double)orientation / 360.0 * (NLMISC::Pi * 2.0) * 1000.0);
@ -5393,6 +5568,36 @@ NLMISC_COMMAND(eventSetNpcGroupAggroRange, "changes the aggro range of a npc gro
return true; return true;
} }
//----------------------------------------------------------------------------
NLMISC_COMMAND(eventSetNpcGroupEmote, "Set emote animation to a npc group", "<bot eid> <emote>")
{
if (args.size() < 2) return false;
GET_ENTITY
CEntityId entityId(args[0]);
uint32 instanceNumber = e->getInstanceNumber();
std::vector<std::string> args2;
args2.push_back(args[0]);
args2.push_back(NLMISC::toString("()emote(\"%s\",\"%s\");", entityId.toString().c_str(), args[1].c_str()));
uint32 nbString = (uint32)args2.size();
CMessage msgout("EVENT_NPC_GROUP_SCRIPT");
uint32 messageVersion = 1;
msgout.serial(messageVersion);
msgout.serial(nbString);
for (uint32 i=0; i<nbString; ++i)
{
string arg = args2[i];
msgout.serial(arg);
}
CWorldInstances::instance().msgToAIInstance2(instanceNumber, msgout);
return true;
}
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
NLMISC_COMMAND(eventSetFaunaBotAggroRange, "changes the aggro range of a fauna bot", "<bot eid> <not hungry range> [<hungry range> [<hunting range>]]") NLMISC_COMMAND(eventSetFaunaBotAggroRange, "changes the aggro range of a fauna bot", "<bot eid> <not hungry range> [<hungry range> [<hunting range>]]")
{ {
@ -5495,6 +5700,27 @@ NLMISC_COMMAND(eventSetBotSheet, "Change the sheet of a bot", "<bot eid> <sheet
return true; return true;
} }
//----------------------------------------------------------------------------
/*NLMISC_COMMAND(eventSetBotVPx, "Change the VPx of a bot", "<bot eid> <vpx>")
{
if (args.size() < 2) return false;
GET_ENTITY
uint32 instanceNumber = e->getInstanceNumber();
uint32 messageVersion = 3;
string botName = args[0];
string vpx = args[1];
CMessage msgout("EVENT_BOT_VPX");
msgout.serial(messageVersion);
msgout.serial(botName);
msgout.serial(vpx);
CWorldInstances::instance().msgToAIInstance2(instanceNumber, msgout);
return true;
}
*/
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
extern sint32 clientEventSetItemCustomText(CCharacter* character, INVENTORIES::TInventory inventory, uint32 slot, ucstring const& text); extern sint32 clientEventSetItemCustomText(CCharacter* character, INVENTORIES::TInventory inventory, uint32 slot, ucstring const& text);

View file

@ -753,8 +753,13 @@ void CBuildingManager::triggerTeleport(CCharacter * user, uint16 index)
IDestination * dest = entry.Destination; IDestination * dest = entry.Destination;
uint16 ownerIdx = entry.OwnerIndex; uint16 ownerIdx = entry.OwnerIndex;
// remove the request // remove the requests
_TriggerRequests.erase( it ); while ( it != _TriggerRequests.end() )
{
_TriggerRequests.erase( it );
it = _TriggerRequests.find( user->getEntityRowId() );
}
if ( !dest->isUserAllowed(user,ownerIdx) ) if ( !dest->isUserAllowed(user,ownerIdx) )
{ {
return; return;

View file

@ -75,7 +75,7 @@ bool IBuildingPhysical::build( const NLLIGO::IPrimitive* prim, CBuildingParseDat
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
bool IBuildingPhysical::addUser(CCharacter * user,uint16 roomIdx,uint16 ownerIdx, sint32 & cellId) bool IBuildingPhysical::addUser(CCharacter * user, uint16 roomIdx, uint16 ownerIdx, sint32 & cellId)
{ {
/// simply get the cell matching the parameters /// simply get the cell matching the parameters
if ( roomIdx >= _Rooms.size() ) if ( roomIdx >= _Rooms.size() )
@ -88,6 +88,18 @@ bool IBuildingPhysical::addUser(CCharacter * user,uint16 roomIdx,uint16 ownerIdx
nlwarning("<BUILDING>Invalid owner idx %u count is %u",ownerIdx,_Rooms[roomIdx].Cells.size()); nlwarning("<BUILDING>Invalid owner idx %u count is %u",ownerIdx,_Rooms[roomIdx].Cells.size());
return false; return false;
} }
CCharacter *owner;
if (ownerIdx < _Players.size())
{
owner = PlayerManager.getChar(_Players[ownerIdx] );
}
else
{
owner = user;
}
// if the room is not already instanciated, we have to do it // if the room is not already instanciated, we have to do it
if ( _Rooms[roomIdx].Cells[ownerIdx] == 0 ) if ( _Rooms[roomIdx].Cells[ownerIdx] == 0 )
{ {
@ -101,7 +113,7 @@ bool IBuildingPhysical::addUser(CCharacter * user,uint16 roomIdx,uint16 ownerIdx
// init the room // init the room
if( !roomInstance->create(this,roomIdx,ownerIdx, _Rooms[roomIdx].Cells[ownerIdx]) ) if( !roomInstance->create(this,roomIdx,ownerIdx, _Rooms[roomIdx].Cells[ownerIdx]) )
return false; return false;
roomInstance->addUser(user); roomInstance->addUser(user, owner);
} }
else else
{ {
@ -111,7 +123,7 @@ bool IBuildingPhysical::addUser(CCharacter * user,uint16 roomIdx,uint16 ownerIdx
nlwarning("<BUILDING>%s invalid room cell %d.",user->getId().toString().c_str(),_Rooms[roomIdx].Cells[ownerIdx]); nlwarning("<BUILDING>%s invalid room cell %d.",user->getId().toString().c_str(),_Rooms[roomIdx].Cells[ownerIdx]);
return false; return false;
} }
roomInstance->addUser(user); roomInstance->addUser(user, owner);
} }
user->setBuildingExitZone( _DefaultExitSpawn ); user->setBuildingExitZone( _DefaultExitSpawn );
@ -517,7 +529,12 @@ bool CBuildingPhysicalPlayer::isUserAllowed(CCharacter * user, uint16 ownerId, u
{ {
nlassert(user); nlassert(user);
nlassert(ownerId < _Players.size() ); nlassert(ownerId < _Players.size() );
return ( user->getId() == _Players[ownerId] );
CCharacter * owner = PlayerManager.getChar( _Players[ownerId] );
if (owner)
return ( (user->getId() == _Players[ownerId]) || owner->playerHaveRoomAccess(user->getId()) );
else
return false;
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------

View file

@ -110,6 +110,9 @@ protected:
/// the players in the building /// the players in the building
std::vector<TDataSetRow> _UsersInside; std::vector<TDataSetRow> _UsersInside;
// list of players
std::vector<NLMISC::CEntityId> _Players;
}; };
@ -191,7 +194,7 @@ public:
private: private:
virtual void initRooms(); virtual void initRooms();
std::vector<NLMISC::CEntityId> _Players;
}; };
#include "building_physical_inline.h" #include "building_physical_inline.h"

View file

@ -59,7 +59,7 @@ void CRoomInstanceCommon::removeUser( CCharacter* user )
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
void CRoomInstanceCommon::addUser( CCharacter* user ) void CRoomInstanceCommon::addUser( CCharacter* user, CCharacter* owner )
{ {
BOMB_IF( !user, "<BUILDING> null character!", return ); BOMB_IF( !user, "<BUILDING> null character!", return );
@ -100,7 +100,7 @@ void CRoomInstanceGuild::removeUser( CCharacter* user )
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
void CRoomInstanceGuild::addUser( CCharacter* user ) void CRoomInstanceGuild::addUser( CCharacter* user, CCharacter* owner )
{ {
BOMB_IF( !user, "<BUILDING> null character!", return ); BOMB_IF( !user, "<BUILDING> null character!", return );
@ -141,21 +141,64 @@ void CRoomInstancePlayer::removeUser( CCharacter* user )
return; return;
} }
TVectorParamCheck titleParams;
TVectorParamCheck textParams;
uint32 userId = PlayerManager.getPlayerId( user->getId() );
std::string name = "CLOSE_URL";
//send command to close webig
ucstring phrase = ucstring("CLOSE_URL(){[WEB : app_ryzhome action=quit_room]}");
NLNET::CMessage msgout("SET_PHRASE");
msgout.serial(name);
msgout.serial(phrase);
sendMessageViaMirror("IOS", msgout);
uint32 titleId = STRING_MANAGER::sendStringToUser(userId, "ANSWER_OK", titleParams);
uint32 textId = STRING_MANAGER::sendStringToUser(userId, "CLOSE_URL", textParams);
PlayerManager.sendImpulseToClient(user->getId(), "USER:POPUP", titleId, textId);
--_RefCount; --_RefCount;
if ( _RefCount == 0 ) if ( _RefCount == 0 )
{ {
playerBuilding->resetRoomCell( _RoomIdx , user->getId() ); playerBuilding->resetRoomCell( _RoomIdx , user->getInRoomOfPlayer());
release(); release();
} }
user->setInRoomOfPlayer(CEntityId::Unknown);
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
void CRoomInstancePlayer::addUser( CCharacter* user ) void CRoomInstancePlayer::addUser( CCharacter* user, CCharacter* owner )
{ {
BOMB_IF( !user, "<BUILDING> null character!", return ); BOMB_IF( !user, "<BUILDING> null character!", return );
// open room inventory window // open room inventory window
PlayerManager.sendImpulseToClient(user->getId(), "ITEM:OPEN_ROOM_INVENTORY"); PlayerManager.sendImpulseToClient(user->getId(), "ITEM:OPEN_ROOM_INVENTORY");
if (owner)
{
owner->removeRoomAccesToPlayer(user->getId(),false);
user->setInRoomOfPlayer(owner->getId());
}
else
{
// Very rare case
owner = user;
}
// solve bot names for title and text
TVectorParamCheck titleParams;
TVectorParamCheck textParams;
// send the popup message
uint32 userId = PlayerManager.getPlayerId( user->getId() );
std::string name = "RYZHOME_URL";
ucstring phrase = "RYZHOME_URL(){[WEB : app_ryzhome user=" + owner->getName().toString() + "]}";
NLNET::CMessage msgout("SET_PHRASE");
msgout.serial(name);
msgout.serial(phrase);
sendMessageViaMirror("IOS", msgout);
uint32 titleId = STRING_MANAGER::sendStringToUser(userId, "ANSWER_OK", titleParams);
uint32 textId = STRING_MANAGER::sendStringToUser(userId, "RYZHOME_URL", textParams);
PlayerManager.sendImpulseToClient(user->getId(), "USER:POPUP", titleId, textId);
++_RefCount; ++_RefCount;
} }

View file

@ -37,7 +37,7 @@ public:
/// remove a user from the room /// remove a user from the room
virtual void removeUser( CCharacter* user ) = 0; virtual void removeUser( CCharacter* user ) = 0;
/// add a user in the room /// add a user in the room
virtual void addUser( CCharacter* user ) = 0; virtual void addUser( CCharacter* user, CCharacter* owner ) = 0;
/// create the room from a building /// create the room from a building
virtual bool create( IBuildingPhysical * building, uint16 roomIdx, uint16 ownerIdx , sint32 cell); virtual bool create( IBuildingPhysical * building, uint16 roomIdx, uint16 ownerIdx , sint32 cell);
/// return true if the room is valid /// return true if the room is valid
@ -79,7 +79,7 @@ public:
private: private:
virtual void removeUser( CCharacter* user ); virtual void removeUser( CCharacter* user );
virtual void addUser( CCharacter* user ); virtual void addUser( CCharacter* user, CCharacter* owner );
}; };
/// a guild room /// a guild room
@ -99,7 +99,7 @@ public:
private: private:
virtual bool create( IBuildingPhysical * building, uint16 roomIdx, uint16 ownerIdx , sint32 cell); virtual bool create( IBuildingPhysical * building, uint16 roomIdx, uint16 ownerIdx , sint32 cell);
virtual void removeUser( CCharacter* user ); virtual void removeUser( CCharacter* user );
virtual void addUser( CCharacter* user ); virtual void addUser( CCharacter* user, CCharacter* owner );
EGSPD::TGuildId _GuildId; EGSPD::TGuildId _GuildId;
}; };
@ -117,7 +117,7 @@ public:
private: private:
virtual bool create( IBuildingPhysical * building, uint16 roomIdx, uint16 ownerIdx , sint32 cell); virtual bool create( IBuildingPhysical * building, uint16 roomIdx, uint16 ownerIdx , sint32 cell);
virtual void removeUser( CCharacter* user ); virtual void removeUser( CCharacter* user );
virtual void addUser( CCharacter* user ); virtual void addUser( CCharacter* user, CCharacter* owner );
/// owner player /// owner player
NLMISC::CEntityId _Player; NLMISC::CEntityId _Player;
}; };

View file

@ -359,6 +359,10 @@ void CBankAccessor_PLR::TUSER::init(ICDBStructNode *parent)
nlassert(node != NULL); nlassert(node != NULL);
_DEFAULT_WEIGHT_HANDS = node; _DEFAULT_WEIGHT_HANDS = node;
node = parent->getNode( ICDBStructNode::CTextId("IS_INVISIBLE"), false );
nlassert(node != NULL);
_IS_INVISIBLE = node;
node = parent->getNode( ICDBStructNode::CTextId("COUNTER"), false ); node = parent->getNode( ICDBStructNode::CTextId("COUNTER"), false );
nlassert(node != NULL); nlassert(node != NULL);
_COUNTER = node; _COUNTER = node;

View file

@ -490,6 +490,7 @@ inline void _getProp(const CCDBSynchronised &db, ICDBStructNode *node, NLMISC::C
ICDBStructNode *_IS_NEWBIE; ICDBStructNode *_IS_NEWBIE;
ICDBStructNode *_IS_TRIAL; ICDBStructNode *_IS_TRIAL;
ICDBStructNode *_DEFAULT_WEIGHT_HANDS; ICDBStructNode *_DEFAULT_WEIGHT_HANDS;
ICDBStructNode *_IS_INVISIBLE;
ICDBStructNode *_COUNTER; ICDBStructNode *_COUNTER;
TSKILL_POINTS_ _SKILL_POINTS_[4]; TSKILL_POINTS_ _SKILL_POINTS_[4];
TFACTION_POINTS_ _FACTION_POINTS_[6]; TFACTION_POINTS_ _FACTION_POINTS_[6];
@ -975,6 +976,20 @@ inline void _getProp(const CCDBSynchronised &db, ICDBStructNode *node, NLMISC::C
{ {
return _COUNTER; return _COUNTER;
} }
void setIS_INVISIBLE(CCDBSynchronised &dbGroup, bool value, bool forceSending = false)
{
_setProp(dbGroup, _IS_INVISIBLE, value, forceSending);
}
bool getIS_INVISIBLE(const CCDBSynchronised &dbGroup)
{
bool value;
_getProp(dbGroup, _IS_INVISIBLE, value);
return value;
}
TSKILL_POINTS_ &getSKILL_POINTS_(uint32 index) TSKILL_POINTS_ &getSKILL_POINTS_(uint32 index)
{ {
nlassert(index < 4); nlassert(index < 4);

View file

@ -197,8 +197,7 @@ bool CDynChatEGS::addSession(TChanID chan, const TDataSetRow &client, bool write
CEntityBase *eb = CEntityBaseManager::getEntityBasePtr(client); CEntityBase *eb = CEntityBaseManager::getEntityBasePtr(client);
if (!eb) if (!eb)
{ {
nlwarning("no client %s",client.toString().c_str()); return false;
addClient(client);
} }
CDynChatSession *session = _DynChat.addSession(chan, client); CDynChatSession *session = _DynChat.addSession(chan, client);
if (!session) if (!session)

View file

@ -389,6 +389,7 @@ CVariable<float> ForageExplosionDamage( "egs","ForageExplosionDamage", "Max HP h
CVariable<sint32> FameByKill( "egs","FameByKill", "Number of fame point lost for a kill", -5000, true ); CVariable<sint32> FameByKill( "egs","FameByKill", "Number of fame point lost for a kill", -5000, true );
CVariable<sint32> PVPFameRequired ("egs","PVPFameRequired", "Minimum of positive or negative fame for PVP", 25, 0, true );
NLMISC::CVariable<NLMISC::TGameCycle>DuelQueryDuration ("egs","DuelQueryDuration", "duration in ticks of a duel requests", 600, 0, true ); NLMISC::CVariable<NLMISC::TGameCycle>DuelQueryDuration ("egs","DuelQueryDuration", "duration in ticks of a duel requests", 600, 0, true );
NLMISC::CVariable<NLMISC::TGameCycle> PVPZoneEnterBufferTime ("egs","PVPZoneEnterBufferTime", "duration in ticks of the time buffer triggered when someone enters a PVP zone", 300, 0, true ); NLMISC::CVariable<NLMISC::TGameCycle> PVPZoneEnterBufferTime ("egs","PVPZoneEnterBufferTime", "duration in ticks of the time buffer triggered when someone enters a PVP zone", 300, 0, true );
NLMISC::CVariable<NLMISC::TGameCycle> PVPZoneLeaveBufferTime ("egs","PVPZoneLeaveBufferTime", "duration in ticks of the time buffer triggered when someone leaves a PVP zone", 9000, 0, true ); NLMISC::CVariable<NLMISC::TGameCycle> PVPZoneLeaveBufferTime ("egs","PVPZoneLeaveBufferTime", "duration in ticks of the time buffer triggered when someone leaves a PVP zone", 9000, 0, true );

View file

@ -318,6 +318,7 @@ extern NLMISC::CVariable<float> CristalMoneyFactor;
/// PVP /// PVP
extern NLMISC::CVariable<bool> AllowPVP; extern NLMISC::CVariable<bool> AllowPVP;
extern NLMISC::CVariable<sint32> PVPFameRequired;
extern NLMISC::CVariable<NLMISC::TGameCycle> DuelQueryDuration ; extern NLMISC::CVariable<NLMISC::TGameCycle> DuelQueryDuration ;
extern NLMISC::CVariable<NLMISC::TGameCycle> PVPZoneEnterBufferTime; extern NLMISC::CVariable<NLMISC::TGameCycle> PVPZoneEnterBufferTime;
extern NLMISC::CVariable<NLMISC::TGameCycle> PVPZoneLeaveBufferTime; extern NLMISC::CVariable<NLMISC::TGameCycle> PVPZoneLeaveBufferTime;

View file

@ -529,10 +529,6 @@ void cbClientReady( CMessage& msgin, const std::string &serviceName, NLNET::TSer
} }
} }
c->onConnection(); c->onConnection();
CPVPManager2::getInstance()->sendFactionWarsToClient( c );
CPVPManager2::getInstance()->addOrRemoveFactionChannel( c );
} // cbClientReady // } // cbClientReady //
@ -681,11 +677,16 @@ void finalizeClientReady( uint32 userId, uint32 index )
} }
} }
CPVPManager2::getInstance()->updateFactionChannel( c );
CPVPManager2::getInstance()->setPVPModeInMirror( c );
c->updatePVPClanVP();
// for GM player, trigger a 'infos' command to remember their persistent state // for GM player, trigger a 'infos' command to remember their persistent state
if (!PlayerManager.getPlayer(uint32(c->getId().getShortId())>>4)->getUserPriv().empty()) if (!PlayerManager.getPlayer(uint32(c->getId().getShortId())>>4)->getUserPriv().empty())
CCommandRegistry::getInstance().execute(toString("infos %s", c->getId().toString().c_str()).c_str(), InfoLog(), true); CCommandRegistry::getInstance().execute(toString("infos %s", c->getId().toString().c_str()).c_str(), InfoLog(), true);
c->setFinalized(true);
} // finalizeClientReady // } // finalizeClientReady //

View file

@ -336,7 +336,7 @@ void CGuildMemberModule::_inviteCharacterInGuild(CGuildCharProxy& invitor, CGuil
{ {
SM_STATIC_PARAMS_2( params, STRING_MANAGER::player, STRING_MANAGER::faction ); SM_STATIC_PARAMS_2( params, STRING_MANAGER::player, STRING_MANAGER::faction );
params[0].setEIdAIAlias( target.getId(), CAIAliasTranslator::getInstance()->getAIAlias( target.getId()) ); params[0].setEIdAIAlias( target.getId(), CAIAliasTranslator::getInstance()->getAIAlias( target.getId()) );
params[1].Enum = invitedAllegiance.first; params[1].Enum = PVP_CLAN::getFactionIndex(invitedAllegiance.first);
invitor.sendSystemMessage("GUILD_ICOMPATIBLE_ALLEGIANCE",params); invitor.sendSystemMessage("GUILD_ICOMPATIBLE_ALLEGIANCE",params);
return; return;
} }
@ -344,7 +344,7 @@ void CGuildMemberModule::_inviteCharacterInGuild(CGuildCharProxy& invitor, CGuil
{ {
SM_STATIC_PARAMS_2( params, STRING_MANAGER::player, STRING_MANAGER::faction ); SM_STATIC_PARAMS_2( params, STRING_MANAGER::player, STRING_MANAGER::faction );
params[0].setEIdAIAlias( target.getId(), CAIAliasTranslator::getInstance()->getAIAlias( target.getId()) ); params[0].setEIdAIAlias( target.getId(), CAIAliasTranslator::getInstance()->getAIAlias( target.getId()) );
params[1].Enum = invitedAllegiance.second; params[1].Enum = PVP_CLAN::getFactionIndex(invitedAllegiance.second);
invitor.sendSystemMessage("GUILD_ICOMPATIBLE_ALLEGIANCE",params); invitor.sendSystemMessage("GUILD_ICOMPATIBLE_ALLEGIANCE",params);
return; return;
} }

View file

@ -174,7 +174,7 @@ bool CMissionStepAIMsg::buildStep( uint32 line, const std::vector< std::string >
MISLOGSYNTAXERROR("<msg name>"); MISLOGSYNTAXERROR("<msg name>");
return false; return false;
} }
Msg = CMissionParser::getNoBlankString(script[1]); _Msg = CMissionParser::getNoBlankString(script[1]);
return true; return true;
} }
@ -185,8 +185,8 @@ uint CMissionStepAIMsg::processEvent( const TDataSetRow & userRow, const CMissio
if( event.Type == CMissionEvent::AIMsg ) if( event.Type == CMissionEvent::AIMsg )
{ {
CMissionEventAIMsg & eventSpe = (CMissionEventAIMsg &) event; CMissionEventAIMsg & eventSpe = (CMissionEventAIMsg &) event;
nlwarning("CMissionStepAIMsg : Message from event = '%s', message of mission = '%s'", eventSpe.Msg.c_str(), Msg.c_str()); nlwarning("CMissionStepAIMsg : Message from event = '%s', message of mission = '%s'", eventSpe.Msg.c_str(), _Msg.c_str());
if ( eventSpe.Msg == Msg ) if ( eventSpe.Msg == _Msg )
{ {
LOGMISSIONSTEPSUCCESS("wait_msg"); LOGMISSIONSTEPSUCCESS("wait_msg");
return 1; return 1;

View file

@ -56,7 +56,7 @@ class CMissionStepEscort : public IMissionStepTemplate
class CMissionStepAIMsg : public IMissionStepTemplate class CMissionStepAIMsg : public IMissionStepTemplate
{ {
std::string Msg; std::string _Msg;
virtual bool buildStep( uint32 line, const std::vector< std::string > & script, CMissionGlobalParsingData & globalData, CMissionSpecificParsingData & missionData ); virtual bool buildStep( uint32 line, const std::vector< std::string > & script, CMissionGlobalParsingData & globalData, CMissionSpecificParsingData & missionData );

View file

@ -52,7 +52,11 @@ void CMissionTeam::updateUsersJournalEntry()
void CMissionTeam::clearUsersJournalEntry() void CMissionTeam::clearUsersJournalEntry()
{ {
CTeam * team = TeamManager.getRealTeam( _TeamId ); CTeam * team = TeamManager.getRealTeam( _TeamId );
nlassert(team); if ( !team )
{
nlwarning( "<MISSIONS>cant find team ID : %d", _TeamId );
return;
}
for ( list<CEntityId>::const_iterator it = team->getTeamMembers().begin(); it != team->getTeamMembers().end();++it ) for ( list<CEntityId>::const_iterator it = team->getTeamMembers().begin(); it != team->getTeamMembers().end();++it )
{ {

View file

@ -1555,15 +1555,18 @@ uint32 CMissionTemplate::testPrerequisits( CCharacter * user, CPrerequisitInfos
logOnFail = false; logOnFail = false;
} }
} }
else
uint k = 0;
for ( ; k < team->getMissions().size(); k++ )
{ {
if ( team->getMissions()[k]->getTemplateId() == templ->Alias )
uint k = 0;
for ( ; k < team->getMissions().size(); k++ )
{
if ( team->getMissions()[k]->getTemplateId() == templ->Alias )
break;
}
if (k != team->getMissions().size())
break; break;
} }
if (k != team->getMissions().size())
break;
} }
} }
if ( j == Prerequisits.RunningMissions[i].Missions.size() ) if ( j == Prerequisits.RunningMissions[i].Missions.size() )

View file

@ -395,7 +395,7 @@ void CFaberPhrase::apply()
uint32 nbMpNeedeInPlan = 0; uint32 nbMpNeedeInPlan = 0;
uint32 neededMp = (uint32)_RootFaberPlan->Faber->NeededMps.size(); uint32 neededMp = (uint32)_RootFaberPlan->Faber->NeededMps.size();
for( uint mp = 0; mp < _RootFaberPlan->Faber->NeededMps.size(); ++mp ) for( uint mp = 0; mp < neededMp; ++mp )
{ {
//for each type of Mp needed //for each type of Mp needed
nbMpNeedeInPlan += _RootFaberPlan->Faber->NeededMps[ mp ].Quantity; nbMpNeedeInPlan += _RootFaberPlan->Faber->NeededMps[ mp ].Quantity;
@ -411,15 +411,15 @@ void CFaberPhrase::apply()
nbMp = (sint32)_MpsFormula.size(); nbMp = (sint32)_MpsFormula.size();
nbMpNeedeInPlan = 0; uint32 nbMpForumulaNeedeInPlan = 0;
neededMp = (uint32)_RootFaberPlan->Faber->NeededMpsFormula.size(); neededMp = (uint32)_RootFaberPlan->Faber->NeededMpsFormula.size();
for( uint mp = 0; mp < _RootFaberPlan->Faber->NeededMpsFormula.size(); ++mp ) for( uint mp = 0; mp < neededMp; ++mp )
{ {
//for each type of Mp needed //for each type of Mp needed
nbMpNeedeInPlan += _RootFaberPlan->Faber->NeededMpsFormula[ mp ].Quantity; nbMpForumulaNeedeInPlan += _RootFaberPlan->Faber->NeededMpsFormula[ mp ].Quantity;
} }
if( nbMpNeedeInPlan != _MpsFormula.size() ) if( nbMpForumulaNeedeInPlan != _MpsFormula.size() )
{ {
nlwarning("<CFaberPhrase::apply> Craft plan %s need %d Raw Material Formula and client send %d Raw Material Formula", c->getCraftPlan().toString().c_str(), _RootFaberPlan->Faber->NeededMpsFormula.size(), _MpsFormula.size() ); nlwarning("<CFaberPhrase::apply> Craft plan %s need %d Raw Material Formula and client send %d Raw Material Formula", c->getCraftPlan().toString().c_str(), _RootFaberPlan->Faber->NeededMpsFormula.size(), _MpsFormula.size() );
PHRASE_UTILITIES::sendDynamicSystemMessage(_ActorRowId, "RAW_MATERIAL_MISSING"); PHRASE_UTILITIES::sendDynamicSystemMessage(_ActorRowId, "RAW_MATERIAL_MISSING");
@ -454,6 +454,105 @@ void CFaberPhrase::apply()
return; return;
} }
neededMp = _RootFaberPlan->Faber->NeededMps.size();
EGSPD::CPeople::TPeople civRestriction = _RootFaberPlan->CivRestriction;
uint32 usedMp=0;
vector< const CStaticItem * > usedMps = _Mps;
for( uint mp = 0; mp < neededMp; ++mp )
{
nlinfo("MP #%d\n", mp);
//for each type of Mp needed
for( uint k = 0; k < _RootFaberPlan->Faber->NeededMps[ mp ].Quantity; ++k )
{
nlinfo(" usedmps : %d", usedMps.size());
bool found_mp = false;
for(uint u_mp = 0; u_mp < usedMps.size(); ++u_mp)
{
// for each Mp of one type (we have Quantity by type)
uint32 NumMpParameters = (uint32)usedMps[u_mp]->Mp->MpFaberParameters.size();
// for each Faber parameters in Mp
for( uint j = 0; j < NumMpParameters; ++j )
{
// check if Mp Type match with Faber waiting Type
if( _RootFaberPlan->Faber->NeededMps[mp].MpType == usedMps[u_mp]->Mp->MpFaberParameters[j].MpFaberType )
{
found_mp = true;
usedMp++;
break;
}
}
if (found_mp)
{
// Bypass if : Plan is common
if ( civRestriction != EGSPD::CPeople::Common )
{
switch (usedMps[u_mp]->Mp->Ecosystem)
{
// I can't found some thing to do this ugly translation.
case ECOSYSTEM::desert:
if (civRestriction != EGSPD::CPeople::Fyros)
{
nlwarning( "<CFaberPhrase build> bad civilisation mp for plan brick %s", _RootFaberPlan->SheetId.toString().c_str() );
stop();
return;
}
break;
case ECOSYSTEM::forest:
if (civRestriction != EGSPD::CPeople::Matis)
{
nlwarning( "<CFaberPhrase build> bad civilisation mp for plan brick %s", _RootFaberPlan->SheetId.toString().c_str() );
stop();
return;
}
break;
case ECOSYSTEM::lacustre:
if (civRestriction != EGSPD::CPeople::Tryker)
{
nlwarning( "<CFaberPhrase build> bad civilisation mp for plan brick %s", _RootFaberPlan->SheetId.toString().c_str() );
stop();
return;
}
break;
case ECOSYSTEM::jungle:
if (civRestriction != EGSPD::CPeople::Zorai)
{
nlwarning( "<CFaberPhrase build> bad civilisation mp for plan brick %s", _RootFaberPlan->SheetId.toString().c_str() );
stop();
return;
}
break;
}
}
usedMps.erase(usedMps.begin()+u_mp);
break;
}
}
if (!found_mp)
{
nlinfo("NOT FOUND : wanted %d\n", _RootFaberPlan->Faber->NeededMps[ mp ].MpType);
}
}
}
if (!usedMps.empty())
{
nlinfo("final usedmps : %d", usedMps.size());
nlwarning( "<CFaberPhrase build> could not build action for plan brick %s", _RootFaberPlan->SheetId.toString().c_str() );
stop();
return;
}
if (usedMp != nbMpNeedeInPlan)
{
nlwarning( "<CFaberPhrase build> could not build action for plan brick %s", _RootFaberPlan->SheetId.toString().c_str() );
stop();
return;
}
// spend energies // spend energies
SCharacteristicsAndScores &focus = c->getScores()._PhysicalScores[SCORES::focus]; SCharacteristicsAndScores &focus = c->getScores()._PhysicalScores[SCORES::focus];
if ( focus.Current != 0) if ( focus.Current != 0)

View file

@ -364,6 +364,13 @@ CCharacter::CCharacter(): CEntityBase(false),
_NbStaticActiveEffects = 0; _NbStaticActiveEffects = 0;
_StaticActionInProgress = false; _StaticActionInProgress = false;
_NbUserChannels = 0;
_LoadingFinish = false;
_PVPFlagAlly = 0;
_PVPFlagEnemy = 0;
// init faber plans // init faber plans
// _KnownFaberPlans.resize(64,(uint64)0); //64*64 bits // _KnownFaberPlans.resize(64,(uint64)0); //64*64 bits
@ -630,12 +637,13 @@ CCharacter::CCharacter(): CEntityBase(false),
_HaveToUpdatePVPMode = false; _HaveToUpdatePVPMode = false;
_SessionId = TSessionId(0); _SessionId = TSessionId(0);
_CurrentSessionId = _SessionId; _CurrentSessionId = _SessionId;
_FactionChannelMode = true;
_PvPSafeZoneActive = false; _PvPSafeZoneActive = false;
// For client/server contact list communication // For client/server contact list communication
_ContactIdPool= 0; _ContactIdPool= 0;
_inRoomOfPlayer = CEntityId::Unknown;
for(uint i = 0; i < BRICK_FAMILIES::NbFamilies; ++i ) for(uint i = 0; i < BRICK_FAMILIES::NbFamilies; ++i )
_BrickFamilyBitField[i] = 0; _BrickFamilyBitField[i] = 0;
_InterfacesFlagsBitField = 0; _InterfacesFlagsBitField = 0;
@ -762,17 +770,77 @@ void CCharacter::initPDStructs()
//----------------------------------------------- //-----------------------------------------------
void CCharacter::updatePVPClanVP() const void CCharacter::updatePVPClanVP() const
{ {
TYPE_PVP_CLAN propPvpClanTemp = 0;
uint32 maxFameCiv = 0;
uint8 civOfMaxFame = 255;
uint32 maxFameCult = 0;
uint8 cultOfMaxFame = 255;
for (uint8 fameIdx = 0; fameIdx < 7; fameIdx++)
{
sint32 fame = CFameInterface::getInstance().getFameIndexed(_Id, fameIdx);
if (fameIdx < 4)
{
if ((uint32)abs(fame) >= maxFameCiv)
{
civOfMaxFame = fameIdx;
maxFameCiv = abs(fame);
}
}
else
{
if ((uint32)abs(fame) >= maxFameCult)
{
cultOfMaxFame = fameIdx - 4;
maxFameCult = abs(fame);
}
}
if (fame >= PVPFameRequired*6000)
{
propPvpClanTemp |= (TYPE_PVP_CLAN(1) << (2*TYPE_PVP_CLAN(fameIdx)));
}
else if (fame <= -PVPFameRequired*6000)
{
propPvpClanTemp |= (TYPE_PVP_CLAN(1) << ((2*TYPE_PVP_CLAN(fameIdx))+1));
}
if (getPvPRecentActionFlag())
{
uint8 flagAlly = (_PVPFlagAlly & (1 << TYPE_PVP_CLAN(fameIdx))) >> TYPE_PVP_CLAN(fameIdx);
uint8 flagEnemy = (_PVPFlagEnemy & (1 << TYPE_PVP_CLAN(fameIdx))) >> TYPE_PVP_CLAN(fameIdx);
propPvpClanTemp |= flagAlly << (2*TYPE_PVP_CLAN(fameIdx));
propPvpClanTemp |= flagEnemy << ((2*TYPE_PVP_CLAN(fameIdx))+1);
}
}
propPvpClanTemp |= TYPE_PVP_CLAN(civOfMaxFame) << (2*TYPE_PVP_CLAN(7));
propPvpClanTemp |= TYPE_PVP_CLAN(cultOfMaxFame) << (2*TYPE_PVP_CLAN(8));
CMirrorPropValue<TYPE_PVP_CLAN> propPvpClan( TheDataset, TheDataset.getDataSetRow(_Id), DSPropertyPVP_CLAN ); CMirrorPropValue<TYPE_PVP_CLAN> propPvpClan( TheDataset, TheDataset.getDataSetRow(_Id), DSPropertyPVP_CLAN );
if( getAllegiance().first >= PVP_CLAN::BeginCults && getAllegiance().first <= PVP_CLAN::EndCults )
{ propPvpClan = (uint32)propPvpClanTemp;
propPvpClan = (uint8) getAllegiance().first;
}
else
{
propPvpClan = (uint8) getAllegiance().second;
}
} }
TYPE_PVP_CLAN CCharacter::getPVPFamesAllies()
{
TYPE_PVP_CLAN propPvpClanTemp = 0;
for (uint8 fameIdx = 0; fameIdx < 7; fameIdx++)
if (CFameInterface::getInstance().getFameIndexed(_Id, fameIdx) >= PVPFameRequired*6000)
propPvpClanTemp |= TYPE_PVP_CLAN(1) << TYPE_PVP_CLAN(fameIdx);
if (getPvPRecentActionFlag())
return propPvpClanTemp | _PVPFlagAlly;
return propPvpClanTemp;
}
TYPE_PVP_CLAN CCharacter::getPVPFamesEnemies()
{
TYPE_PVP_CLAN propPvpClanTemp = 0;
for (uint8 fameIdx = 0; fameIdx < 7; fameIdx++)
if (CFameInterface::getInstance().getFameIndexed(_Id, fameIdx) <= -PVPFameRequired*6000)
propPvpClanTemp |= TYPE_PVP_CLAN(1) << TYPE_PVP_CLAN(fameIdx);
if (getPvPRecentActionFlag())
return propPvpClanTemp | _PVPFlagEnemy;
return propPvpClanTemp;
}
//----------------------------------------------- //-----------------------------------------------
@ -1382,7 +1450,8 @@ uint32 CCharacter::tickUpdate()
if (_PVPFlagLastTimeChange + waitTime < CTickEventHandler::getGameCycle()) if (_PVPFlagLastTimeChange + waitTime < CTickEventHandler::getGameCycle())
{ {
CPVPManager2::getInstance()->setPVPModeInMirror(this); CPVPManager2::getInstance()->setPVPModeInMirror(this);
CPVPManager2::getInstance()->addOrRemoveFactionChannel(this); CPVPManager2::getInstance()->updateFactionChannel(this);
updatePVPClanVP();
_HaveToUpdatePVPMode = false; _HaveToUpdatePVPMode = false;
} }
} }
@ -1393,6 +1462,7 @@ uint32 CCharacter::tickUpdate()
if( propPvpMode.getValue()&PVP_MODE::PvpFactionFlagged ) if( propPvpMode.getValue()&PVP_MODE::PvpFactionFlagged )
{ {
CPVPManager2::getInstance()->setPVPModeInMirror(this); CPVPManager2::getInstance()->setPVPModeInMirror(this);
updatePVPClanVP();
} }
} }
} }
@ -2829,117 +2899,88 @@ void CCharacter::postLoadTreatment()
// if EId translator has been initialized by SU, check contact list // if EId translator has been initialized by SU, check contact list
{ {
H_AUTO(ValidateContactList); H_AUTO(ValidateContactList);
validateContactList(); validateContactList();
} }
{ {
H_AUTO(UpdateFlagForActiveEffect); H_AUTO(UpdateFlagForActiveEffect);
/* update flags for active effects */ /* update flags for active effects */
if( _ForbidAuraUseEndDate>0 && _ForbidAuraUseStartDate==0 ) if( _ForbidAuraUseEndDate>0 && _ForbidAuraUseStartDate==0 )
{ {
// thus timer won't look like infinte on client(can happen due to old save file where startDate didn't exist) // thus timer won't look like infinte on client(can happen due to old save file where startDate didn't exist)
_ForbidAuraUseStartDate = CTickEventHandler::getGameCycle(); _ForbidAuraUseStartDate = CTickEventHandler::getGameCycle();
} }
setPowerFlagDates(); setPowerFlagDates();
setAuraFlagDates(); setAuraFlagDates();
updateBrickFlagsDBEntry(); updateBrickFlagsDBEntry();
_ModifiersInDB.writeInDatabase(_PropertyDatabase); _ModifiersInDB.writeInDatabase(_PropertyDatabase);
} }
{ {
H_AUTO(AddCreationBricks); H_AUTO(AddCreationBricks);
/* add starting bricks if any modification has been done */ /* add starting bricks if any modification has been done */
addCreationBricks(); addCreationBricks();
} }
{ {
H_AUTO(CheckCharacterAndScoresValues); H_AUTO(CheckCharacterAndScoresValues);
/* check character and scores are as they are supposed to be according to bricks possessed */ /* check character and scores are as they are supposed to be according to bricks possessed */
checkCharacAndScoresValues(); checkCharacAndScoresValues();
} }
{ {
H_AUTO(ComputeBestSkill); H_AUTO(ComputeBestSkill);
/* compute player best skill */ /* compute player best skill */
computeBestSkill(); computeBestSkill();
} }
{ {
H_AUTO(ComputeSkillUsedForDodge); H_AUTO(ComputeSkillUsedForDodge);
/* compute player best skill to use for dodge */ /* compute player best skill to use for dodge */
computeSkillUsedForDodge(); computeSkillUsedForDodge();
} }
{ {
H_AUTO(UpdateMagicProtectionAndResistance); H_AUTO(UpdateMagicProtectionAndResistance);
/* compute resists scores*/ /* compute resists scores*/
updateMagicProtectionAndResistance(); updateMagicProtectionAndResistance();
} }
{ {
H_AUTO(LoadedMissionPostLoad); H_AUTO(LoadedMissionPostLoad);
/* Call the postLoad methods for the loaded missions */ /* Call the postLoad methods for the loaded missions */
for ( map<TAIAlias, CMission*>::iterator it = getMissionsBegin(); it != getMissionsEnd(); ++it ) for ( map<TAIAlias, CMission*>::iterator it = getMissionsBegin(); it != getMissionsEnd(); ++it )
{ {
BOMB_IF( (*it).second == NULL, "Mission is NULL after load", continue ); BOMB_IF( (*it).second == NULL, "Mission is NULL after load", continue );
(*it).second->onLoad(); (*it).second->onLoad();
} }
} }
/* setup the implicit visual property fields */ /* setup the implicit visual property fields */
SET_STRUCT_MEMBER(_VisualPropertyA,PropertySubData.Sex,getGender()); SET_STRUCT_MEMBER(_VisualPropertyA,PropertySubData.Sex,getGender());
{ {
H_AUTO(ComputeForageBonus); H_AUTO(ComputeForageBonus);
/* compute the forage bonuses */ /* compute the forage bonuses */
computeForageBonus(); computeForageBonus();
} }
{ {
H_AUTO(ComputeMiscBonus); H_AUTO(ComputeMiscBonus);
/* compute misc bonuses */ /* compute misc bonuses */
computeMiscBonus(); computeMiscBonus();
} }
{ {
H_AUTO(CItemServiceManager); H_AUTO(CItemServiceManager);
CItemServiceManager::getInstance()->initPersistentServices(this); CItemServiceManager::getInstance()->initPersistentServices(this);
} }
{ {
H_AUTO(CheckPvPTagValidity); H_AUTO(CheckPvPTagValidity);
if( _DeclaredCult == PVP_CLAN::Neutral || _DeclaredCult == PVP_CLAN::None )
{
if( _PVPFlag )
{
// if no cult declared and civ is not in war we remove pvp tag
if( CPVPManager2::getInstance()->isFactionInWar( _DeclaredCiv ) == false )
{
_PVPFlag = false;
_PVPFlagLastTimeChange = 0;
_PVPFlagTimeSettedOn = 0;
setPVPFlagDatabase();
_HaveToUpdatePVPMode = true;
}
}
}
if( _DeclaredCiv == PVP_CLAN::Neutral || _DeclaredCiv == PVP_CLAN::None ) _HaveToUpdatePVPMode = true;
{
if( _PVPFlag )
{
// if no civ declared and cult is not in war we remove pvp tag
if( CPVPManager2::getInstance()->isFactionInWar( _DeclaredCult ) == false )
{
_PVPFlag = false;
_PVPFlagLastTimeChange = 0;
_PVPFlagTimeSettedOn = 0;
setPVPFlagDatabase();
_HaveToUpdatePVPMode = true;
}
}
}
} }
} }
@ -13666,6 +13707,36 @@ void CCharacter::setFameValuePlayer(uint32 factionIndex, sint32 playerFame, sint
// _PropertyDatabase.setProp( toString("FAME:PLAYER%d:THRESHOLD", fameIndexInDatabase), sint64(float(fameMax)/FameAbsoluteMax*100) ); // _PropertyDatabase.setProp( toString("FAME:PLAYER%d:THRESHOLD", fameIndexInDatabase), sint64(float(fameMax)/FameAbsoluteMax*100) );
CBankAccessor_PLR::getFAME().getPLAYER(fameIndexInDatabase).setTHRESHOLD(_PropertyDatabase, checkedCast<sint8>(float(fameMax)/FameAbsoluteMax*100) ); CBankAccessor_PLR::getFAME().getPLAYER(fameIndexInDatabase).setTHRESHOLD(_PropertyDatabase, checkedCast<sint8>(float(fameMax)/FameAbsoluteMax*100) );
} }
bool canPvp = false;
for (uint8 fameIdx = 0; fameIdx < 7; fameIdx++)
{
sint32 fame = CFameInterface::getInstance().getFameIndexed(_Id, fameIdx);
if (fame >= PVPFameRequired*6000) {
canPvp = true;
} else if (fame <= -PVPFameRequired*6000) {
canPvp = true;
}
}
if (_LoadingFinish)
{
if(!canPvp && (_PVPFlag || getPvPRecentActionFlag()) )
{
_PVPFlag = false;
_PVPFlagLastTimeChange = 0;
_PVPFlagTimeSettedOn = 0;
_PVPRecentActionTime = 0;
_HaveToUpdatePVPMode = true;
}
updatePVPClanVP();
setPVPFlagDatabase();
// handle with faction channel
CPVPManager2::getInstance()->updateFactionChannel(this);
}
} }
//----------------------------------------------- //-----------------------------------------------
@ -14288,6 +14359,63 @@ void CCharacter::syncContactListWithCharNameChanges(const std::vector<NLMISC::CE
sendContactListInit(); sendContactListInit();
} }
void CCharacter::setInRoomOfPlayer(const NLMISC::CEntityId &id)
{
_inRoomOfPlayer = id;
}
const NLMISC::CEntityId& CCharacter::getInRoomOfPlayer()
{
return _inRoomOfPlayer;
}
//--------------------------------------------------------------
// CCharacter::havePlayerRoomAccess
//--------------------------------------------------------------
bool CCharacter::playerHaveRoomAccess(const NLMISC::CEntityId &id)
{
const uint size = (uint)_RoomersList.size();
for ( uint i =0 ; i < size ; ++i)
{
if ( _RoomersList[i].getShortId() == id.getShortId())
return true;
}
return false;
}
//--------------------------------------------------------------
// CCharacter::addRoomAccessToPlayer
//--------------------------------------------------------------
void CCharacter::addRoomAccessToPlayer(const NLMISC::CEntityId &id)
{
// if player not found
if (id == CEntityId::Unknown || PlayerManager.getChar(id)==NULL)
{
if ( ! (IShardUnifierEvent::getInstance() && IShardUnifierEvent::getInstance()->isCharacterOnlineAbroad(id)))
{
// player not found => message
PHRASE_UTILITIES::sendDynamicSystemMessage( _EntityRowId, "OPERATION_OFFLINE");
return;
}
}
// check not already in list
const uint size = (uint)_RoomersList.size();
for ( uint i =0 ; i < size ; ++i)
{
if ( _RoomersList[i].getShortId() == id.getShortId())
{
return;
}
}
uint32 playerId = PlayerManager.getPlayerId(id);
_RoomersList.push_back(id);
}
//-------------------------------------------------------------- //--------------------------------------------------------------
// CCharacter::addPlayerToFriendList() // CCharacter::addPlayerToFriendList()
//-------------------------------------------------------------- //--------------------------------------------------------------
@ -14296,9 +14424,12 @@ void CCharacter::addPlayerToFriendList(const NLMISC::CEntityId &id)
// if player not found // if player not found
if (id == CEntityId::Unknown || PlayerManager.getChar(id)==NULL) if (id == CEntityId::Unknown || PlayerManager.getChar(id)==NULL)
{ {
// player not found => message if ( ! (IShardUnifierEvent::getInstance() && IShardUnifierEvent::getInstance()->isCharacterOnlineAbroad(id)))
PHRASE_UTILITIES::sendDynamicSystemMessage( _EntityRowId, "OPERATION_OFFLINE"); {
return; // player not found => message
PHRASE_UTILITIES::sendDynamicSystemMessage( _EntityRowId, "OPERATION_OFFLINE");
return;
}
} }
// check not already in list // check not already in list
@ -14487,6 +14618,42 @@ void CCharacter::removePlayerFromIgnoreListByIndex(uint16 index)
sendMessageViaMirror ("IOS", msgName); sendMessageViaMirror ("IOS", msgName);
} }
//--------------------------------------------------------------
// CCharacter::removeRoomAccesToPlayer()
//--------------------------------------------------------------
void CCharacter::removeRoomAccesToPlayer(const NLMISC::CEntityId &id, bool kick)
{
if (id == NLMISC::CEntityId::Unknown)
return;
CCharacter *target = PlayerManager.getChar(id);
for ( uint i = 0 ; i < _RoomersList.size() ; ++i)
{
if ( _RoomersList[i].getShortId() == id.getShortId() )
{
_RoomersList.erase(_RoomersList.begin() + i);
return;
}
}
if (kick & (target->getInRoomOfPlayer().getShortId() == getId().getShortId()))
{
target->setInRoomOfPlayer(CEntityId::Unknown);
if (!TheDataset.isAccessible(getEntityRowId()))
return;
const CTpSpawnZone * zone = CZoneManager::getInstance().getTpSpawnZone(target->getBuildingExitZone());
if (zone)
{
sint32 x,y,z;
float heading;
zone->getRandomPoint(x,y,z,heading);
target->tpWanted(x,y,z,true,heading);
}
}
}
//-------------------------------------------------------------- //--------------------------------------------------------------
// CCharacter::removePlayerFromFriendListByEntityId() // CCharacter::removePlayerFromFriendListByEntityId()
//-------------------------------------------------------------- //--------------------------------------------------------------
@ -16568,7 +16735,21 @@ void CCharacter::setPVPFlag( bool pvpFlag )
if( pvpFlag == true ) if( pvpFlag == true )
{ {
if( (_DeclaredCult == PVP_CLAN::Neutral || _DeclaredCult == PVP_CLAN::None ) && (_DeclaredCiv == PVP_CLAN::Neutral || _DeclaredCiv == PVP_CLAN::None ) )
// NEW PVP : Check fames
bool havePvpFame = false;
for (uint8 fameIdx = 0; fameIdx < 7; fameIdx++)
{
sint32 fame = CFameInterface::getInstance().getFameIndexed(_Id, fameIdx);
if ((fame >= PVPFameRequired*6000) || (fame <= -PVPFameRequired*6000))
havePvpFame = true;
}
//- if( (_DeclaredCult == PVP_CLAN::Neutral || _DeclaredCult == PVP_CLAN::None ) && (_DeclaredCiv == PVP_CLAN::Neutral || _DeclaredCiv == PVP_CLAN::None ) )
if (!havePvpFame)
{ {
// character can set it's tag pvp on if he have no allegiance. // character can set it's tag pvp on if he have no allegiance.
SM_STATIC_PARAMS_1(params, STRING_MANAGER::integer); SM_STATIC_PARAMS_1(params, STRING_MANAGER::integer);
@ -16578,7 +16759,8 @@ void CCharacter::setPVPFlag( bool pvpFlag )
return; return;
} }
if( CPVPManager2::getInstance()->isFactionInWar( _DeclaredCult ) == false && // OLD PVP
/* if( CPVPManager2::getInstance()->isFactionInWar( _DeclaredCult ) == false &&
CPVPManager2::getInstance()->isFactionInWar( _DeclaredCiv ) == false) CPVPManager2::getInstance()->isFactionInWar( _DeclaredCiv ) == false)
{ {
// character can set it's tag pvp on if none of his clan is in war // character can set it's tag pvp on if none of his clan is in war
@ -16588,8 +16770,10 @@ void CCharacter::setPVPFlag( bool pvpFlag )
CBankAccessor_PLR::getCHARACTER_INFO().getPVP_FACTION_TAG().setCOUNTER(_PropertyDatabase, uint8(++_PvPDatabaseCounter)); CBankAccessor_PLR::getCHARACTER_INFO().getPVP_FACTION_TAG().setCOUNTER(_PropertyDatabase, uint8(++_PvPDatabaseCounter));
return; return;
} }
*/
} }
// if player changed it's decision before timer if finished // if player changed it's decision before timer if finished
if( pvpFlag != _PVPFlag && actualPvpFlag == pvpFlag ) if( pvpFlag != _PVPFlag && actualPvpFlag == pvpFlag )
{ {
@ -16711,12 +16895,28 @@ void CCharacter::setPVPFlagDatabase()
CBankAccessor_PLR::getCHARACTER_INFO().getPVP_FACTION_TAG().setACTIVATION_TIME(_PropertyDatabase, activationTime ); CBankAccessor_PLR::getCHARACTER_INFO().getPVP_FACTION_TAG().setACTIVATION_TIME(_PropertyDatabase, activationTime );
// _PropertyDatabase.setProp("CHARACTER_INFO:PVP_FACTION_TAG:COUNTER", ++_PvPDatabaseCounter ); // _PropertyDatabase.setProp("CHARACTER_INFO:PVP_FACTION_TAG:COUNTER", ++_PvPDatabaseCounter );
CBankAccessor_PLR::getCHARACTER_INFO().getPVP_FACTION_TAG().setCOUNTER(_PropertyDatabase, uint8(++_PvPDatabaseCounter) ); CBankAccessor_PLR::getCHARACTER_INFO().getPVP_FACTION_TAG().setCOUNTER(_PropertyDatabase, uint8(++_PvPDatabaseCounter) );
CBankAccessor_PLR::getCHARACTER_INFO().getPVP_FACTION_TAG().setFLAG_PVP_TIME_LEFT(_PropertyDatabase, _PVPRecentActionTime + PVPActionTimer );
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void CCharacter::setPVPRecentActionFlag() void CCharacter::setPVPRecentActionFlag(CCharacter *target)
{ {
if (!getPvPRecentActionFlag())
{
_PVPFlagAlly = 0;
_PVPFlagEnemy = 0;
}
_PVPRecentActionTime = CTickEventHandler::getGameCycle(); _PVPRecentActionTime = CTickEventHandler::getGameCycle();
if (target != NULL)
{
_PVPFlagAlly |= target->getPVPFamesAllies();
_PVPFlagEnemy |= target->getPVPFamesEnemies();
updatePVPClanVP();
}
// _PropertyDatabase.setProp("CHARACTER_INFO:PVP_FACTION_TAG:FLAG_PVP_TIME_LEFT", _PVPRecentActionTime + PVPActionTimer ); // _PropertyDatabase.setProp("CHARACTER_INFO:PVP_FACTION_TAG:FLAG_PVP_TIME_LEFT", _PVPRecentActionTime + PVPActionTimer );
CBankAccessor_PLR::getCHARACTER_INFO().getPVP_FACTION_TAG().setFLAG_PVP_TIME_LEFT(_PropertyDatabase, _PVPRecentActionTime + PVPActionTimer ); CBankAccessor_PLR::getCHARACTER_INFO().getPVP_FACTION_TAG().setFLAG_PVP_TIME_LEFT(_PropertyDatabase, _PVPRecentActionTime + PVPActionTimer );
@ -16750,7 +16950,7 @@ bool CCharacter::setDeclaredCult(PVP_CLAN::TPVPClan newClan)
CFameManager::getInstance().setAndEnforceTribeFameCap(this->getId(), this->getAllegiance()); CFameManager::getInstance().setAndEnforceTribeFameCap(this->getId(), this->getAllegiance());
// handle with faction channel // handle with faction channel
CPVPManager2::getInstance()->addOrRemoveFactionChannel(this); CPVPManager2::getInstance()->updateFactionChannel(this);
// write new allegiance in database // write new allegiance in database
// _PropertyDatabase.setProp("FAME:CULT_ALLEGIANCE", newClan); // _PropertyDatabase.setProp("FAME:CULT_ALLEGIANCE", newClan);
@ -16758,21 +16958,22 @@ bool CCharacter::setDeclaredCult(PVP_CLAN::TPVPClan newClan)
_LastCultPointWriteDB = ~0; _LastCultPointWriteDB = ~0;
if( _DeclaredCult == PVP_CLAN::Neutral || _DeclaredCult == PVP_CLAN::None ) // if( _DeclaredCult == PVP_CLAN::Neutral || _DeclaredCult == PVP_CLAN::None )
{ // {
if( _PVPFlag ) if( _PVPFlag || getPvPRecentActionFlag() )
{ {
// if no cult declared and civ is not in war we remove pvp tag // if no cult declared and civ is not in war we remove pvp tag
if( CPVPManager2::getInstance()->isFactionInWar( _DeclaredCiv ) == false ) // if( CPVPManager2::getInstance()->isFactionInWar( _DeclaredCiv ) == false )
{ // {
_PVPFlag = false; _PVPFlag = false;
_PVPFlagLastTimeChange = 0; _PVPFlagLastTimeChange = 0;
_PVPFlagTimeSettedOn = 0; _PVPFlagTimeSettedOn = 0;
_PVPRecentActionTime = 0;
setPVPFlagDatabase(); setPVPFlagDatabase();
_HaveToUpdatePVPMode = true; _HaveToUpdatePVPMode = true;
} // }
} }
} // }
// Update PvP clan in mirror for faction PvP // Update PvP clan in mirror for faction PvP
updatePVPClanVP(); updatePVPClanVP();
@ -16811,27 +17012,31 @@ bool CCharacter::setDeclaredCiv(PVP_CLAN::TPVPClan newClan)
// set tribe fame threshold and clamp fame if necessary // set tribe fame threshold and clamp fame if necessary
CFameManager::getInstance().setAndEnforceTribeFameCap(this->getId(), this->getAllegiance()); CFameManager::getInstance().setAndEnforceTribeFameCap(this->getId(), this->getAllegiance());
// handle with faction channel
CPVPManager2::getInstance()->updateFactionChannel(this);
// write new allegiance in database // write new allegiance in database
// _PropertyDatabase.setProp("FAME:CIV_ALLEGIANCE", newClan); // _PropertyDatabase.setProp("FAME:CIV_ALLEGIANCE", newClan);
CBankAccessor_PLR::getFAME().setCIV_ALLEGIANCE(_PropertyDatabase, newClan); CBankAccessor_PLR::getFAME().setCIV_ALLEGIANCE(_PropertyDatabase, newClan);
_LastCivPointWriteDB = ~0; _LastCivPointWriteDB = ~0;
if( _DeclaredCiv == PVP_CLAN::Neutral || _DeclaredCiv == PVP_CLAN::None ) // if( _DeclaredCiv == PVP_CLAN::Neutral || _DeclaredCiv == PVP_CLAN::None )
{ // {
if( _PVPFlag ) if( _PVPFlag || getPvPRecentActionFlag() )
{ {
// if no civ declared and cult is not in war we remove pvp tag // if no civ declared and cult is not in war we remove pvp tag
if( CPVPManager2::getInstance()->isFactionInWar( _DeclaredCult ) == false ) // if( CPVPManager2::getInstance()->isFactionInWar( _DeclaredCult ) == false )
{ // {
_PVPFlag = false; _PVPFlag = false;
_PVPFlagLastTimeChange = 0; _PVPFlagLastTimeChange = 0;
_PVPFlagTimeSettedOn = 0; _PVPFlagTimeSettedOn = 0;
_PVPRecentActionTime = 0;
setPVPFlagDatabase(); setPVPFlagDatabase();
_HaveToUpdatePVPMode = true; _HaveToUpdatePVPMode = true;
} // }
} }
} // }
// Update PvP clan in mirror for faction PvP // Update PvP clan in mirror for faction PvP
updatePVPClanVP(); updatePVPClanVP();
@ -19505,9 +19710,10 @@ void CCharacter::channelAdded( bool b )
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void CCharacter::setShowFactionChannelsMode(bool s) void CCharacter::setShowFactionChannelsMode(TChanID channel, bool s)
{ {
_FactionChannelMode = s; CPVPManager2::getInstance()->addRemoveFactionChannelToUserWithPriviledge(this); _FactionChannelsMode[channel] = s;
CPVPManager2::getInstance()->addRemoveFactionChannelToUserWithPriviledge(channel, this, s);
} }

View file

@ -1859,6 +1859,19 @@ public:
void removePlayerFromFriendListByContactId(uint32 contactId); void removePlayerFromFriendListByContactId(uint32 contactId);
void removePlayerFromFriendListByEntityId(const NLMISC::CEntityId &id); void removePlayerFromFriendListByEntityId(const NLMISC::CEntityId &id);
void setInRoomOfPlayer(const NLMISC::CEntityId &id);
const NLMISC::CEntityId& getInRoomOfPlayer();
/// get if player have acces to room
bool playerHaveRoomAccess(const NLMISC::CEntityId &id);
/// add room acces to player
void addRoomAccessToPlayer(const NLMISC::CEntityId &id);
/// remove room acces to player
void removeRoomAccesToPlayer(const NLMISC::CEntityId &id, bool kick);
/// remove player from ignore list /// remove player from ignore list
void removePlayerFromIgnoreListByContactId(uint32 contactId); void removePlayerFromIgnoreListByContactId(uint32 contactId);
void removePlayerFromIgnoreListByEntityId(const NLMISC::CEntityId &id); void removePlayerFromIgnoreListByEntityId(const NLMISC::CEntityId &id);
@ -2217,6 +2230,8 @@ public:
void enterPVPZone(uint32 pvpZoneType) const; void enterPVPZone(uint32 pvpZoneType) const;
/// character enter in versus pvp zone, player must choose a clan /// character enter in versus pvp zone, player must choose a clan
void openPVPVersusDialog() const; void openPVPVersusDialog() const;
/// get priviledgePvp
bool getPriviledgePVP() const {return _PriviledgePvp;};
/// get character pvp flag /// get character pvp flag
bool getPVPFlag( bool updatePVPModeInMirror = true ) const; bool getPVPFlag( bool updatePVPModeInMirror = true ) const;
/// change pvp flag /// change pvp flag
@ -2228,7 +2243,7 @@ public:
/// set database pvp flag /// set database pvp flag
void setPVPFlagDatabase(); void setPVPFlagDatabase();
/// set PVP recent action flag /// set PVP recent action flag
void setPVPRecentActionFlag(); void setPVPRecentActionFlag(CCharacter *target = NULL);
/// get PvP recent action flag (true if player involved in PVP action recently) /// get PvP recent action flag (true if player involved in PVP action recently)
bool getPvPRecentActionFlag() const; bool getPvPRecentActionFlag() const;
/// character are killed in PvP situation /// character are killed in PvP situation
@ -2250,6 +2265,10 @@ public:
void setPvPSafeZoneActive(); void setPvPSafeZoneActive();
/// clear pvp zone safe flag /// clear pvp zone safe flag
void clearSafeInPvPSafeZone(); void clearSafeInPvPSafeZone();
/// get pvp fames allies
TYPE_PVP_CLAN getPVPFamesAllies();
/// get pvp fames ennemys
TYPE_PVP_CLAN getPVPFamesEnemies();
/// update the clan in visuale property /// update the clan in visuale property
void updatePVPClanVP() const; void updatePVPClanVP() const;
//@} //@}
@ -2296,13 +2315,17 @@ public:
void channelAdded( bool b ); void channelAdded( bool b );
bool isChannelAdded(); bool isChannelAdded();
uint8 getNbUserChannels() { return _NbUserChannels; };
void addUserChannel() { _NbUserChannels++; };
void removeUserChannel() { _NbUserChannels--; };
std::vector<SItemSpecialEffect> lookForSpecialItemEffects(ITEM_SPECIAL_EFFECT::TItemSpecialEffect effectType) const; std::vector<SItemSpecialEffect> lookForSpecialItemEffects(ITEM_SPECIAL_EFFECT::TItemSpecialEffect effectType) const;
/// return true if the given item is an xp catalyser which has been activated /// return true if the given item is an xp catalyser which has been activated
bool isAnActiveXpCatalyser( CGameItemPtr item ); bool isAnActiveXpCatalyser( CGameItemPtr item );
void setShowFactionChannelsMode(bool s); void setShowFactionChannelsMode(TChanID channel, bool s);
bool showFactionChannelsMode(); bool showFactionChannelsMode(TChanID channel) const;
// from offline command // from offline command
void contactListRefChangeFromCommand(const NLMISC::CEntityId &id, const std::string &operation); void contactListRefChangeFromCommand(const NLMISC::CEntityId &id, const std::string &operation);
@ -2840,7 +2863,10 @@ public:
bool TestProgression; bool TestProgression;
bool isShopingListInProgress() const { return _ShoppingList != 0; } bool isShopingListInProgress() const { return _ShoppingList != 0; };
void setFinalized(bool isFinalized) { _LoadingFinish = isFinalized; };
bool isFinalized() const { return _LoadingFinish; };
////////////////// //////////////////
// Private members // Private members
@ -3193,7 +3219,10 @@ private:
NLMISC::CEntityId EntityId; // Id used for server/storage NLMISC::CEntityId EntityId; // Id used for server/storage
uint32 ContactId; // Id used for client/server communication uint32 ContactId; // Id used for client/server communication
}; };
uint32 _ContactIdPool; uint32 _ContactIdPool;
std::vector<NLMISC::CEntityId> _RoomersList; // Players who have acces to player's room
NLMISC::CEntityId _inRoomOfPlayer;
// friends list // friends list
std::vector<CContactId> _FriendsList; std::vector<CContactId> _FriendsList;
@ -3342,6 +3371,9 @@ private:
NLMISC::TGameCycle _PVPFlagTimeSettedOn; NLMISC::TGameCycle _PVPFlagTimeSettedOn;
// time of the last PVP action made (for prevent PVE / PVP exploits) // time of the last PVP action made (for prevent PVE / PVP exploits)
NLMISC::TGameCycle _PVPRecentActionTime; NLMISC::TGameCycle _PVPRecentActionTime;
// all pvp flags (ally and enemy) when players do a pvp curative action
uint32 _PVPFlagAlly;
uint32 _PVPFlagEnemy;
// character safe if is in pvp safe zone // character safe if is in pvp safe zone
bool _PvPSafeZoneActive; bool _PvPSafeZoneActive;
// player changed his faction tag, we have to update pvp mode // player changed his faction tag, we have to update pvp mode
@ -3362,8 +3394,10 @@ private:
bool _ChannelAdded; bool _ChannelAdded;
bool _LoadingFinish;
/// if true, enable display of channel faction for users with priviledge /// if true, enable display of channel faction for users with priviledge
bool _FactionChannelMode; std::map<TChanID, bool> _FactionChannelsMode;
/// time when user left outpost zone (0 means not valid) /// time when user left outpost zone (0 means not valid)
NLMISC::TGameCycle _OutpostLeavingTime; NLMISC::TGameCycle _OutpostLeavingTime;
@ -3574,7 +3608,11 @@ private:
public: public:
bool getInvisibility() const { return _Invisibility;} bool getInvisibility() const { return _Invisibility;}
/// Set the invisibility flag, NB : just for persistence, do not change nothing. /// Set the invisibility flag, NB : just for persistence, do not change nothing.
void setInvisibility(bool invisible) { _Invisibility = invisible;} void setInvisibility(bool invisible)
{
_Invisibility = invisible;
CBankAccessor_PLR::getUSER().setIS_INVISIBLE(_PropertyDatabase, _Invisibility);
}
sint8 getAggroableSave() const { return _AggroableSave;} sint8 getAggroableSave() const { return _AggroableSave;}
/// Set the aggroable save flag, NB : just for persistence, do not change nothing. /// Set the aggroable save flag, NB : just for persistence, do not change nothing.

View file

@ -896,9 +896,13 @@ inline bool CCharacter::isChannelAdded()
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
inline bool CCharacter::showFactionChannelsMode() inline bool CCharacter::showFactionChannelsMode(TChanID channel) const
{ {
return _FactionChannelMode; std::map<TChanID, bool>::const_iterator it = _FactionChannelsMode.find(channel);
if (it != _FactionChannelsMode.end())
return (*it).second;
else
return false;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------

View file

@ -1102,7 +1102,7 @@ void CDamageScoreManager::playerDeath(CCharacter * victimChar, const CCharacter
return; return;
// check if victim and final blower are in PvP Faction (by tag or by a pvp versus zone) // check if victim and final blower are in PvP Faction (by tag or by a pvp versus zone)
if(!CPVPManager2::getInstance()->factionWarOccurs(victimFaction, finalBlowerFaction)) /* if(!CPVPManager2::getInstance()->factionWarOccurs(victimFaction, finalBlowerFaction))
{ {
CPVPVersusZone * zone = dynamic_cast<CPVPVersusZone *>(const_cast<CPVPInterface &>(victimChar->getPVPInterface()).getPVPSession()); CPVPVersusZone * zone = dynamic_cast<CPVPVersusZone *>(const_cast<CPVPInterface &>(victimChar->getPVPInterface()).getPVPSession());
if( zone == 0 ) if( zone == 0 )
@ -1110,7 +1110,7 @@ void CDamageScoreManager::playerDeath(CCharacter * victimChar, const CCharacter
PVP_RELATION::TPVPRelation pvpRelation = zone->getPVPRelation(victimChar, const_cast<CCharacter*>(finalBlower)); PVP_RELATION::TPVPRelation pvpRelation = zone->getPVPRelation(victimChar, const_cast<CCharacter*>(finalBlower));
if( pvpRelation != PVP_RELATION::Ennemy ) if( pvpRelation != PVP_RELATION::Ennemy )
return; return;
} }*/
// a dead player loses his damage points // a dead player loses his damage points
clearDamages(victimChar, true); clearDamages(victimChar, true);
@ -1684,7 +1684,7 @@ bool CDamageScoreManager::playerInFactionPvP(const CCharacter * playerChar, PVP_
else if( playerChar->getPVPFlag() ) else if( playerChar->getPVPFlag() )
{ {
pair<PVP_CLAN::TPVPClan, PVP_CLAN::TPVPClan> allegiance = playerChar->getAllegiance(); pair<PVP_CLAN::TPVPClan, PVP_CLAN::TPVPClan> allegiance = playerChar->getAllegiance();
if( CPVPManager2::getInstance()->isFactionInWar( allegiance.first ) ) if( (allegiance.first != PVP_CLAN::Neutral) && (allegiance.first != PVP_CLAN::None) )
{ {
if (faction) if (faction)
*faction = allegiance.first; *faction = allegiance.first;
@ -1692,14 +1692,14 @@ bool CDamageScoreManager::playerInFactionPvP(const CCharacter * playerChar, PVP_
*withFactionPoints = true; *withFactionPoints = true;
return true; return true;
} }
if ( CPVPManager2::getInstance()->isFactionInWar( allegiance.second ) ) /*if ( allegiance.second != PVP_CLAN::Neutral)
{ {
if (faction) if (faction)
*faction = allegiance.second; *faction = allegiance.second;
if (withFactionPoints) if (withFactionPoints)
*withFactionPoints = true; *withFactionPoints = true;
return true; return true;
} }*/
} }
return false; return false;
} }

View file

@ -35,86 +35,84 @@ CVariable<bool> ResPawnPVPInSameRegionForbiden("egs","ResPawnPVPInSameRegionForb
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
PVP_RELATION::TPVPRelation CPVPFaction::getPVPRelation( CCharacter * actor, CEntityBase * target, bool curative ) const PVP_RELATION::TPVPRelation CPVPFaction::getPVPRelation( CCharacter * actor, CEntityBase * target, bool curative ) const
{ {
// init relation reminders // Init relation reminders
CPVPManager2::getInstance()->setPVPFactionAllyReminder( false ); CPVPManager2::getInstance()->setPVPFactionAllyReminder( false );
CPVPManager2::getInstance()->setPVPFactionEnemyReminder( false ); CPVPManager2::getInstance()->setPVPFactionEnemyReminder( false );
// check actor and target validity // Check actor and target validity
if( actor == 0 || target == 0 ) if (actor == 0 || target == 0)
{ {
nlwarning("<CPVPFaction::getPVPRelation> actor: %p target: %p",actor,target); nlwarning("<CPVPFaction::getPVPRelation> actor: %p target: %p", actor, target);
return PVP_RELATION::Unknown; return PVP_RELATION::Unknown;
} }
CCharacter * pTarget = dynamic_cast<CCharacter*>(target); CCharacter * pTarget = dynamic_cast<CCharacter*>(target);
if( pTarget == 0 ) if (pTarget == 0)
{
return PVP_RELATION::Unknown; return PVP_RELATION::Unknown;
}
// if target is not tagged then he's neutral // if target is not tagged then he's neutral
if( pTarget->getPVPFlag() == false && pTarget->getPvPRecentActionFlag() == false ) if (!pTarget->getPVPFlag() && !pTarget->getPvPRecentActionFlag())
{
return PVP_RELATION::Neutral; return PVP_RELATION::Neutral;
}
if( CPVPManager2::getInstance()->inSafeZone( pTarget->getPosition() ) ) // Check safe zones
if (CPVPManager2::getInstance()->inSafeZone(pTarget->getPosition()))
{ {
if( pTarget->getSafeInPvPSafeZone() ) if (pTarget->getSafeInPvPSafeZone())
{
return PVP_RELATION::NeutralPVP; return PVP_RELATION::NeutralPVP;
}
} }
// get Faction allegiance if( CPVPManager2::getInstance()->inSafeZone(actor->getPosition()))
pair<PVP_CLAN::TPVPClan, PVP_CLAN::TPVPClan> actorAllegiance = actor->getAllegiance();
pair<PVP_CLAN::TPVPClan, PVP_CLAN::TPVPClan> targetAllegiance = pTarget->getAllegiance();
if( CPVPManager2::getInstance()->inSafeZone( actor->getPosition() ) )
{ {
if( actor->getSafeInPvPSafeZone() ) if( actor->getSafeInPvPSafeZone())
{
return PVP_RELATION::NeutralPVP; return PVP_RELATION::NeutralPVP;
}
} }
// Check fames
if( actor->getPVPFlag() || actor->getPvPRecentActionFlag() ) if( actor->getPVPFlag() || actor->getPvPRecentActionFlag() )
{ {
// check if he's an enemy (or neutral pvp) // In same Team
if( actorAllegiance != targetAllegiance ) if ((pTarget->getTeamId() != CTEAM::InvalidTeamId) && (actor->getTeamId() != CTEAM::InvalidTeamId) && (actor->getTeamId() == pTarget->getTeamId()))
{ {
if( CPVPManager2::getInstance()->factionWarOccurs( actorAllegiance, targetAllegiance ) ) CPVPManager2::getInstance()->setPVPFactionAllyReminder( true );
return PVP_RELATION::Ally;
}
// In same Guild
if ((pTarget->getGuildId() != 0) && (actor->getGuildId() != 0) && (actor->getGuildId() == pTarget->getGuildId()))
{
CPVPManager2::getInstance()->setPVPFactionAllyReminder( true );
return PVP_RELATION::Ally;
}
// check if he's an ennemy
if ((actor->getPVPFamesAllies() & pTarget->getPVPFamesEnemies()) || (actor->getPVPFamesEnemies() & pTarget->getPVPFamesAllies()))
{
// Actor can heal an ennemi if not PvPRecentActionFlaged
if (curative && !pTarget->getPvPRecentActionFlag())
{ {
if( !curative || (curative && pTarget->getPvPRecentActionFlag()) ) return PVP_RELATION::Neutral;
{
CPVPManager2::getInstance()->setPVPFactionEnemyReminder( true );
return PVP_RELATION::Ennemy;
}
else
return PVP_RELATION::Neutral;
} }
else if( actorAllegiance.first != targetAllegiance.first && actorAllegiance.second != actorAllegiance.second ) else
{ {
if( pTarget->getPvPRecentActionFlag() ) CPVPManager2::getInstance()->setPVPFactionEnemyReminder(true);
{ return PVP_RELATION::Ennemy;
// here target is engaged in another faction war
return PVP_RELATION::NeutralPVP;
}
} }
} }
// they are ally // check if he's an ally
CPVPManager2::getInstance()->setPVPFactionAllyReminder( true ); else if ((actor->getPVPFamesAllies() & pTarget->getPVPFamesAllies()) || (actor->getPVPFamesEnemies() & pTarget->getPVPFamesEnemies()))
return PVP_RELATION::Ally; {
CPVPManager2::getInstance()->setPVPFactionAllyReminder(true);
return PVP_RELATION::Ally;
}
} }
else else
{ {
if( pTarget->getPvPRecentActionFlag() ) // Check if actor is not PvPFlag and try to heal a PvPRecentActionFlag
{ if (curative && pTarget->getPvPRecentActionFlag())
// here target is engaged in a faction war, but player is not tagged
return PVP_RELATION::NeutralPVP; return PVP_RELATION::NeutralPVP;
}
} }
// default is neutral
return PVP_RELATION::Neutral; return PVP_RELATION::Neutral;
} }

View file

@ -66,8 +66,8 @@ CPVPFactionRewardManager::CPVPFactionRewardManager()
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
void CPVPFactionRewardManager::_BuildTotemBasesRec( const IPrimitive* prim, void CPVPFactionRewardManager::_BuildTotemBasesRec( const IPrimitive* prim,
std::map<CTotemBase*, set<string> >& neighboursNames, std::map<CTotemBase*, set<string> >& neighboursNames,
map<std::string, CTotemBase*>& totemBasesPerName ) std::map<std::string, CTotemBase*>& totemBasesPerName )
{ {
if ( !prim ) if ( !prim )
return; return;
@ -441,11 +441,11 @@ bool CPVPFactionRewardManager::destroyTotem( uint16 regionIndex, TDataSetRow kil
// Send message to faction channel // Send message to faction channel
params[2].Int = 1; params[2].Int = 1;
TChanID channelId = CPVPManager2::getInstance()->getFactionDynChannel(pTotemBase->getOwnerFaction()); // TODO TChanID channelId = CPVPManager2::getInstance()->getFactionDynChannel(pTotemBase->getOwnerFaction());
if( channelId != DYN_CHAT_INVALID_CHAN ) // if( channelId != DYN_CHAT_INVALID_CHAN )
{ // {
// TODO Send message PVP_SPIRE_DESTROYED to faction channel and enemies factions // TODO Send message PVP_SPIRE_DESTROYED to faction channel and enemies factions
} // }
} }
@ -665,11 +665,11 @@ void CPVPFactionRewardManager::tickUpdate()
// Send it in faction channel too // Send it in faction channel too
params[2].Int = 1; params[2].Int = 1;
TChanID channelId = CPVPManager2::getInstance()->getFactionDynChannel(pTotem->getOwnerFaction()); //TODO TChanID channelId = CPVPManager2::getInstance()->getFactionDynChannel(pTotem->getOwnerFaction());
if( channelId != DYN_CHAT_INVALID_CHAN ) //if( channelId != DYN_CHAT_INVALID_CHAN )
{ //{
// TODO Send message PVP_SPIRE_BUILD_FINISHED to faction channel // TODO Send message PVP_SPIRE_BUILD_FINISHED to faction channel
} //}
} }
} }
} }

View file

@ -25,6 +25,7 @@
#include "game_share/utils.h" #include "game_share/utils.h"
#include "game_share/msg_client_server.h" #include "game_share/msg_client_server.h"
#include "game_share/fame.h"
#include "pvp_manager/pvp_manager_2.h" #include "pvp_manager/pvp_manager_2.h"
#include "pvp_manager/pvp_manager.h" #include "pvp_manager/pvp_manager.h"
@ -70,9 +71,6 @@ void CPVPManager2::init()
IPVPInterface * pvpFaction = new CPVPFaction(); IPVPInterface * pvpFaction = new CPVPFaction();
BOMB_IF(pvpFaction == 0, "Can't allocate CPVPFaction", nlstop ); BOMB_IF(pvpFaction == 0, "Can't allocate CPVPFaction", nlstop );
_Instance->_PVPInterface.push_back(pvpFaction); _Instance->_PVPInterface.push_back(pvpFaction);
// add war between kami and karavan faction (must be controled by GM tools later
_Instance->addFactionWar(PVP_CLAN::Kami, PVP_CLAN::Karavan);
// instantiate pvp duel class // instantiate pvp duel class
IPVPInterface * pvpDuel = new CPVPDuel(); IPVPInterface * pvpDuel = new CPVPDuel();
BOMB_IF(pvpDuel == 0, "Can't allocate CPVPDuel", nlstop ); BOMB_IF(pvpDuel == 0, "Can't allocate CPVPDuel", nlstop );
@ -144,146 +142,301 @@ void CPVPManager2::tickUpdate()
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
TChanID CPVPManager2::getFactionDynChannel( PVP_CLAN::TPVPClan faction ) // TODO : Add extra factions
//-------
TChanID CPVPManager2::getFactionDynChannel( const std::string& channelName)
{ {
TMAPFactionChannel::iterator it = _FactionChannel.find( faction ); // Search first in extra faction channels
if( it != _FactionChannel.end() ) TMAPExtraFactionChannel::iterator it = _ExtraFactionChannel.find(channelName);
if( it != _ExtraFactionChannel.end() )
{ {
return (*it).second; return (*it).second;
} }
return DYN_CHAT_INVALID_CHAN;
}
//----------------------------------------------------------------------------
TChanID CPVPManager2::getCharacterChannel(CCharacter * user)
{
// if( user->getPVPFlag(false) ) // new specs: we not need be tagged for have channel, only allegiance is required.
{
PVP_CLAN::TPVPClan faction = user->getAllegiance().first;
if( faction != PVP_CLAN::Neutral )
{
if( isFactionInWar(faction) )
{
TMAPFactionChannel::iterator it = _FactionChannel.find(faction);
if( it != _FactionChannel.end() )
{
return (*it).second;
}
}
}
}
return DYN_CHAT_INVALID_CHAN;
}
//----------------------------------------------------------------------------
TChanID CPVPManager2::getCharacterRegisteredChannel(CCharacter * user)
{
map< NLMISC::CEntityId, TChanID >::iterator it = _CharacterChannel.find(user->getId());
if( it != _CharacterChannel.end() )
{
return (*it).second;
}
return DYN_CHAT_INVALID_CHAN;
}
//----------------------------------------------------------------------------
void CPVPManager2::addOrRemoveFactionChannel(CCharacter * user, bool b )
{
TChanID channelHave = getCharacterRegisteredChannel(user);
TChanID channelMustHave = getCharacterChannel(user);
if( channelHave != DYN_CHAT_INVALID_CHAN )
{
if( channelHave != channelMustHave)
{
removeFactionChannelForCharacter(user);
}
}
if( channelMustHave != DYN_CHAT_INVALID_CHAN )
{
if(channelMustHave != channelHave )
{
addFactionChannelToCharacter(user);
}
}
if( b )
addRemoveFactionChannelToUserWithPriviledge(user);
}
//----------------------------------------------------------------------------
void CPVPManager2::addFactionChannelToCharacter(CCharacter * user)
{
TChanID channel = getCharacterChannel(user);
if( channel != DYN_CHAT_INVALID_CHAN )
{
DynChatEGS.addSession( channel, user->getEntityRowId(), true);
_CharacterChannel.insert( make_pair(user->getId(), channel) );
}
}
//----------------------------------------------------------------------------
void CPVPManager2::removeFactionChannelForCharacter(CCharacter * user)
{
TChanID channel = getCharacterRegisteredChannel(user);
if( channel != DYN_CHAT_INVALID_CHAN )
{
DynChatEGS.removeSession(channel, user->getEntityRowId());
std::map< NLMISC::CEntityId, TChanID >::iterator it = _CharacterChannel.find(user->getId());
if( it != _CharacterChannel.end() )
{
_CharacterChannel.erase(it);
}
}
}
//----------------------------------------------------------------------------
void CPVPManager2::addRemoveFactionChannelToUserWithPriviledge(CCharacter * user)
{
const CAdminCommand * cmd = findAdminCommand("ShowFactionChannels");
if (!cmd)
{
return;
}
if (!user->havePriv(cmd->Priv))
{
return;
}
if( user->showFactionChannelsMode() )
{
removeFactionChannelForCharacter(user);
bool writeRight = user->havePriv(FactionChannelModeratorWriteRight);
for( uint32 i = PVP_CLAN::BeginClans; i <= PVP_CLAN::EndClans; ++i )
{
if( isFactionInWar((PVP_CLAN::TPVPClan)i) )
{
TMAPFactionChannel::iterator it = _FactionChannel.find((PVP_CLAN::TPVPClan)i);
if( it != _FactionChannel.end() )
{
DynChatEGS.addSession((*it).second, user->getEntityRowId(), writeRight);
}
}
}
}
else else
{ {
for( uint32 i = PVP_CLAN::BeginClans; i <= PVP_CLAN::EndClans; ++i ) PVP_CLAN::TPVPClan channelClan = PVP_CLAN::fromString( channelName );
if( channelClan < PVP_CLAN::BeginClans || channelClan > PVP_CLAN::EndClans )
return DYN_CHAT_INVALID_CHAN;
TMAPFactionChannel::iterator it = _FactionChannel.find( channelClan );
if( it != _FactionChannel.end() )
{ {
if( isFactionInWar((PVP_CLAN::TPVPClan)i) ) return (*it).second;
}
}
return DYN_CHAT_INVALID_CHAN;
}
TChanID CPVPManager2::getUserDynChannel( const std::string& channelName)
{
// Search in user channels
TMAPExtraFactionChannel::iterator it = _UserChannel.find(channelName);
if( it != _UserChannel.end() )
return (*it).second;
else
return DYN_CHAT_INVALID_CHAN;
}
const std::string & CPVPManager2::getPassUserChannel( TChanID channelId)
{
// Search in user channels
TMAPPassChannel::iterator it = _PassChannels.find(channelId);
if( it != _PassChannels.end() )
return (*it).second;
else
return DYN_CHAT_INVALID_NAME;
}
//----------------------------------------------------------------------------
std::vector<TChanID> CPVPManager2::getCharacterChannels(CCharacter * user)
{
// if( user->getPVPFlag(false) ) // new specs: we not need be tagged for have channel, only allegiance is required.
// {
std::vector<TChanID> result;
result.clear();
PVP_CLAN::TPVPClan faction = user->getAllegiance().first;
if( faction != PVP_CLAN::Neutral )
{
TMAPFactionChannel::iterator it = _FactionChannel.find(faction);
if( it != _FactionChannel.end() )
{
result.push_back((*it).second);
}
}
faction = user->getAllegiance().second;
if( faction != PVP_CLAN::Neutral )
{
TMAPFactionChannel::iterator it = _FactionChannel.find(faction);
if( it != _FactionChannel.end() )
{
result.push_back((*it).second);
}
}
bool matis = CFameInterface::getInstance().getFameIndexed(user->getId(), 0) >= PVPFameRequired*6000;
bool fyros = CFameInterface::getInstance().getFameIndexed(user->getId(), 1) >= PVPFameRequired*6000;
bool tryker = CFameInterface::getInstance().getFameIndexed(user->getId(), 2) >= PVPFameRequired*6000;
bool zorai = CFameInterface::getInstance().getFameIndexed(user->getId(), 3) >= PVPFameRequired*6000;
bool kami = CFameInterface::getInstance().getFameIndexed(user->getId(), 4) >= PVPFameRequired*6000;
bool kara = CFameInterface::getInstance().getFameIndexed(user->getId(), 6) >= PVPFameRequired*6000;
bool amatis = CFameInterface::getInstance().getFameIndexed(user->getId(), 0) <= -PVPFameRequired*6000;
bool afyros = CFameInterface::getInstance().getFameIndexed(user->getId(), 1) <= -PVPFameRequired*6000;
bool atryker = CFameInterface::getInstance().getFameIndexed(user->getId(), 2) <= -PVPFameRequired*6000;
bool azorai = CFameInterface::getInstance().getFameIndexed(user->getId(), 3) <= -PVPFameRequired*6000;
bool akami = CFameInterface::getInstance().getFameIndexed(user->getId(), 4) <= -PVPFameRequired*6000;
bool akara = CFameInterface::getInstance().getFameIndexed(user->getId(), 6) <= -PVPFameRequired*6000;
if (matis && fyros && tryker && zorai)
{
TMAPExtraFactionChannel::iterator it = _ExtraFactionChannel.find("hominists");
if( it != _ExtraFactionChannel.end() )
{
result.push_back((*it).second);
}
}
if (amatis && afyros && atryker && azorai)
{
TMAPExtraFactionChannel::iterator it = _ExtraFactionChannel.find("marauders");
if( it != _ExtraFactionChannel.end() )
{
result.push_back((*it).second);
}
}
if (kami && kara)
{
TMAPExtraFactionChannel::iterator it = _ExtraFactionChannel.find("urasies");
if( it != _ExtraFactionChannel.end() )
{
result.push_back((*it).second);
}
}
if (akami && akara)
{
TMAPExtraFactionChannel::iterator it = _ExtraFactionChannel.find("agnos");
if( it != _ExtraFactionChannel.end() )
{
result.push_back((*it).second);
}
}
// }
return result;
}
//----------------------------------------------------------------------------
std::vector<TChanID> CPVPManager2::getCharacterRegisteredChannels(CCharacter * user)
{
std::vector<TChanID> result;
result.clear();
TCharacterChannels::iterator it = _CharacterChannels.find(user->getId());
if( it != _CharacterChannels.end() )
return (*it).second; // return a vector<TChanID>
return result;
}
//----------------------------------------------------------------------------
std::vector<TChanID> CPVPManager2::getCharacterUserChannels(CCharacter * user)
{
std::vector<TChanID> result;
result.clear();
TCharacterChannels::iterator it = _CharacterUserChannels.find(user->getId());
if( it != _CharacterUserChannels.end() )
return (*it).second; // return a vector<TChanID>
return result;
}
//----------------------------------------------------------------------------
void CPVPManager2::updateFactionChannel(CCharacter * user, bool b )
{
std::vector<TChanID> channelsHave = getCharacterRegisteredChannels(user);
std::vector<TChanID> channelsMustHave = getCharacterChannels(user);
std::vector<TChanID> userChannelsMustHave = getCharacterUserChannels(user);
// Remove unwanted channels
for (uint i = 0; i < channelsHave.size(); i++)
{
bool have = false;
for (uint j = 0; j < channelsMustHave.size(); j++)
if (channelsHave[i] == channelsMustHave[j])
have = true;
for (uint j = 0; j < userChannelsMustHave.size(); j++)
if (channelsHave[i] == userChannelsMustHave[j])
have = true;
if (!have)
removeFactionChannelForCharacter(channelsHave[i], user);
}
// Add wanted channels
for (uint i = 0; i < channelsMustHave.size(); i++)
{
bool have = false;
for (uint j = 0; j < channelsHave.size(); j++)
if( channelsMustHave[i] == channelsHave[j])
have = true;
if (!have)
addFactionChannelToCharacter(channelsMustHave[i], user);
}
// Add wanted user channels
for (uint i = 0; i < userChannelsMustHave.size(); i++)
{
bool have = false;
for (uint j = 0; j < channelsHave.size(); j++)
if (userChannelsMustHave[i] == channelsHave[j])
have = true;
if (!have)
addFactionChannelToCharacter(userChannelsMustHave[i], user);
}
/*if( b )
addRemoveFactionChannelToUserWithPriviledge(user);
*/
}
//----------------------------------------------------------------------------
void CPVPManager2::addFactionChannelToCharacter(TChanID channel, CCharacter * user, bool writeRight, bool userChannel)
{
if( channel != DYN_CHAT_INVALID_CHAN )
{
if (DynChatEGS.addSession(channel, user->getEntityRowId(), writeRight))
{
std::vector<TChanID> currentChannels = getCharacterRegisteredChannels(user);
currentChannels.push_back(channel);
_CharacterChannels.erase(user->getId());
_CharacterChannels.insert( make_pair(user->getId(), currentChannels) );
if (userChannel)
{ {
TMAPFactionChannel::iterator it = _FactionChannel.find((PVP_CLAN::TPVPClan)i); currentChannels = getCharacterUserChannels(user);
if( it != _FactionChannel.end() ) currentChannels.push_back(channel);
_CharacterUserChannels.erase(user->getId());
_CharacterUserChannels.insert( make_pair(user->getId(), currentChannels) );
}
}
}
}
//----------------------------------------------------------------------------
void CPVPManager2::removeFactionChannelForCharacter(TChanID channel, CCharacter * user, bool userChannel)
{
std::vector<TChanID> currentChannels = getCharacterRegisteredChannels(user);
for (uint i = 0; i < currentChannels.size(); i++)
{
if (currentChannels[i] == channel)
{
DynChatEGS.removeSession(channel, user->getEntityRowId());
if (userChannel && (DynChatEGS.getSessionCount(channel) == 0))
{
DynChatEGS.removeChan(channel);
TMAPPassChannel::iterator it = _PassChannels.find(channel);
if (it != _PassChannels.end())
_PassChannels.erase(it);
for (TMAPExtraFactionChannel::iterator it2 = _UserChannel.begin(); it2 != _UserChannel.end(); ++it2)
{ {
DynChatEGS.removeSession((*it).second, user->getEntityRowId()); if ((*it2).second == channel)
_UserChannel.erase(it2);
}
}
// Update channel list for player
currentChannels.erase(currentChannels.begin() + i);
std::map< NLMISC::CEntityId, std::vector<TChanID> >::iterator it = _CharacterChannels.find(user->getId());
if( it != _CharacterChannels.end() )
{
_CharacterChannels.erase(user->getId());
_CharacterChannels.insert(make_pair(user->getId(), currentChannels));
}
}
}
if (userChannel)
{
currentChannels = getCharacterUserChannels(user);
for (uint i = 0; i < currentChannels.size(); i++)
{
if (currentChannels[i] == channel)
{
// Update channel list for player
currentChannels.erase(currentChannels.begin() + i);
std::map< NLMISC::CEntityId, std::vector<TChanID> >::iterator it = _CharacterUserChannels.find(user->getId());
if( it != _CharacterUserChannels.end() )
{
_CharacterUserChannels.erase(user->getId());
_CharacterUserChannels.insert(make_pair(user->getId(), currentChannels));
} }
} }
} }
addOrRemoveFactionChannel( user, false );
} }
} }
//----------------------------------------------------------------------------
void CPVPManager2::addRemoveFactionChannelToUserWithPriviledge(TChanID channel, CCharacter * user, bool s)
{
const CAdminCommand * cmd = findAdminCommand("ShowFactionChannels");
if (!cmd)
return;
if (!user->havePriv(cmd->Priv))
return;
if (s)
addFactionChannelToCharacter(channel, user, user->havePriv(FactionChannelModeratorWriteRight));
else
removeFactionChannelForCharacter(channel, user);
}
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
void CPVPManager2::playerDisconnects(CCharacter * user) void CPVPManager2::playerDisconnects(CCharacter * user)
{ {
@ -293,7 +446,9 @@ void CPVPManager2::playerDisconnects(CCharacter * user)
CPVPManager::getInstance()->playerDisconnects(user); CPVPManager::getInstance()->playerDisconnects(user);
removeFactionChannelForCharacter(user); // Remove all channels
removeFactionChannelForCharacter(DYN_CHAT_INVALID_CHAN, user);
_CharacterChannels.erase(user->getId());
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
@ -316,6 +471,12 @@ void CPVPManager2::setPVPModeInMirror( const CCharacter * user ) const
nlassert(user); nlassert(user);
uint8 pvpMode = 0; uint8 pvpMode = 0;
// Full pvp
if ( user->getPriviledgePVP() )
{
pvpMode |= PVP_MODE::PvpChallenge;
}
// faction // faction
{ {
if( user->getPVPFlag(false) ) if( user->getPVPFlag(false) )
@ -377,9 +538,12 @@ bool CPVPManager2::inSafeZone(const NLMISC::CVector & v) const
return false; return false;
} }
//----------------------------------------------------------------------------
// Main method for get Pvp Relation
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
PVP_RELATION::TPVPRelation CPVPManager2::getPVPRelation( CCharacter * actor, CEntityBase * target, bool curative ) const PVP_RELATION::TPVPRelation CPVPManager2::getPVPRelation( CCharacter * actor, CEntityBase * target, bool curative ) const
{ {
// Default relation
PVP_RELATION::TPVPRelation relation = PVP_RELATION::Neutral; PVP_RELATION::TPVPRelation relation = PVP_RELATION::Neutral;
// init reminders, these help to know if faction pvp recent action flag need to be set // init reminders, these help to know if faction pvp recent action flag need to be set
@ -390,13 +554,27 @@ PVP_RELATION::TPVPRelation CPVPManager2::getPVPRelation( CCharacter * actor, CEn
_Instance->_PVPOutpostAllyReminder = false; _Instance->_PVPOutpostAllyReminder = false;
_Instance->_PVPOutpostEnemyReminder = false; _Instance->_PVPOutpostEnemyReminder = false;
/// temp : until new manager is finished we have to check the char pvp session too
CCharacter * pTarget = dynamic_cast<CCharacter*>(target); CCharacter * pTarget = dynamic_cast<CCharacter*>(target);
if( pTarget ) if( pTarget )
{ {
// priviledgePVP is Full PVP, only ally of teammates anf guildmates
if (pTarget->priviledgePVP() || actor->priviledgePVP())
{
if ((pTarget->getTeamId() != CTEAM::InvalidTeamId) && (actor->getTeamId() != CTEAM::InvalidTeamId) && (actor->getTeamId() == pTarget->getTeamId()))
return PVP_RELATION::Ally;
if ((pTarget->getGuildId() != 0) && (actor->getGuildId() != 0) && (actor->getGuildId() == pTarget->getGuildId()))
return PVP_RELATION::Ally;
return PVP_RELATION::Ennemy;
}
if( IsRingShard ) if( IsRingShard )
return relation; // disable PVP on Ring shards (only if target is a CCharacter, because we must let attack NPCs) return relation; // disable PVP on Ring shards (only if target is a CCharacter, because we must let attack NPCs)
// //////////////////////////////////////////////////////
// temp : until new manager is finished we have to check the char pvp session too
IPVP * pvpSession = pTarget->getPVPInterface().getPVPSession(); IPVP * pvpSession = pTarget->getPVPInterface().getPVPSession();
if( pvpSession ) if( pvpSession )
{ {
@ -424,24 +602,28 @@ PVP_RELATION::TPVPRelation CPVPManager2::getPVPRelation( CCharacter * actor, CEn
} }
} }
} }
////////////////////////////////////////////////////////
} }
PVP_RELATION::TPVPRelation relationTmp = PVP_RELATION::Neutral; PVP_RELATION::TPVPRelation relationTmp = PVP_RELATION::Neutral;
uint i; uint i;
for( i=0; i<_PVPInterface.size(); ++i ) for( i=0; i<_PVPInterface.size(); ++i )
{ {
// Get relation for this Pvp Interface (faction, zone, outpost, ...)
relationTmp = _PVPInterface[i]->getPVPRelation( actor, target, curative ); relationTmp = _PVPInterface[i]->getPVPRelation( actor, target, curative );
if( relationTmp == PVP_RELATION::Unknown ) if( relationTmp == PVP_RELATION::Unknown )
return PVP_RELATION::Unknown; return PVP_RELATION::Unknown;
// ennemy has the highest priority // Ennemy has the highest priority
if( relationTmp == PVP_RELATION::Ennemy ) if( relationTmp == PVP_RELATION::Ennemy )
return PVP_RELATION::Ennemy; return PVP_RELATION::Ennemy;
// neutral pvp
// Neutral pvp
if( relationTmp == PVP_RELATION::NeutralPVP ) if( relationTmp == PVP_RELATION::NeutralPVP )
relation = PVP_RELATION::NeutralPVP; relation = PVP_RELATION::NeutralPVP;
// check if ally (neutralpvp has priority over ally)
// Check if ally (neutralpvp has priority over ally)
if( relationTmp == PVP_RELATION::Ally && relation != PVP_RELATION::NeutralPVP ) if( relationTmp == PVP_RELATION::Ally && relation != PVP_RELATION::NeutralPVP )
relation = PVP_RELATION::Ally; relation = PVP_RELATION::Ally;
} }
@ -484,19 +666,20 @@ bool CPVPManager2::isCurativeActionValid( CCharacter * actor, CEntityBase * targ
if( actionValid && !checkMode ) if( actionValid && !checkMode )
{ {
CCharacter * pTarget = dynamic_cast<CCharacter*>(target);
if(pTarget)
actor->clearSafeInPvPSafeZone();
// propagate faction pvp flag
if( pvpRelation == PVP_RELATION::Ally ) if( pvpRelation == PVP_RELATION::Ally )
{ {
CCharacter * pTarget = dynamic_cast<CCharacter*>(target);
if(pTarget)
actor->clearSafeInPvPSafeZone();
// propagate faction pvp flag
if( _PVPFactionAllyReminder ) if( _PVPFactionAllyReminder )
{ {
if( pTarget ) if( pTarget )
{ {
if( pTarget->getPvPRecentActionFlag() ) if( pTarget->getPvPRecentActionFlag() )
{ {
actor->setPVPRecentActionFlag(); actor->setPVPRecentActionFlag(pTarget);
TeamManager.pvpHelpOccursInTeam( actor, pTarget ); TeamManager.pvpHelpOccursInTeam( actor, pTarget );
actor->pvpActionMade(); actor->pvpActionMade();
pTarget->pvpActionMade(); pTarget->pvpActionMade();
@ -509,6 +692,10 @@ bool CPVPManager2::isCurativeActionValid( CCharacter * actor, CEntityBase * targ
{ {
actor->refreshOutpostLeavingTimer(); actor->refreshOutpostLeavingTimer();
} }
// propagate full pvp
if( pTarget->priviledgePVP() )
actor->setPriviledgePVP(true);
} }
} }
return actionValid; return actionValid;
@ -592,13 +779,13 @@ bool CPVPManager2::canApplyAreaEffect(CCharacter* actor, CEntityBase * areaTarge
switch( pvpRelation ) switch( pvpRelation )
{ {
case PVP_RELATION::Ally : case PVP_RELATION::Ally :
actionValid = !offensive; actionValid = true;
break; break;
case PVP_RELATION::Ennemy : case PVP_RELATION::Ennemy :
actionValid = offensive; actionValid = offensive;
break; break;
case PVP_RELATION::Neutral : case PVP_RELATION::Neutral :
actionValid = !offensive; actionValid = true;
break; break;
case PVP_RELATION::NeutralPVP : case PVP_RELATION::NeutralPVP :
actionValid = false; actionValid = false;
@ -630,7 +817,7 @@ bool CPVPManager2::canApplyAreaEffect(CCharacter* actor, CEntityBase * areaTarge
{ {
if( pTarget->getPvPRecentActionFlag() ) if( pTarget->getPvPRecentActionFlag() )
{ {
actor->setPVPRecentActionFlag(); actor->setPVPRecentActionFlag(pTarget);
TeamManager.pvpHelpOccursInTeam( actor, pTarget ); TeamManager.pvpHelpOccursInTeam( actor, pTarget );
} }
} }
@ -753,40 +940,28 @@ bool CPVPManager2::addFactionWar( PVP_CLAN::TPVPClan clan1, PVP_CLAN::TPVPClan c
/// create the faction chat channel when IOS mirror ready /// create the faction chat channel when IOS mirror ready
void CPVPManager2::onIOSMirrorUp() void CPVPManager2::onIOSMirrorUp()
{ {
// for each pvp war, create the related char channel // create extra factions channels
for (uint i=0; i<_FactionWarOccurs.size(); ++i) createExtraFactionChannel("hominists");
createExtraFactionChannel("urasies");
createExtraFactionChannel("marauders");
createExtraFactionChannel("agnos");
for (uint i = PVP_CLAN::BeginClans; i <= PVP_CLAN::EndClans; i++)
{ {
PVP_CLAN::TPVPClan clan1 = _FactionWarOccurs[i].Clan1; //createFactionChannel(PVP_CLAN::getClanFromIndex(i));
PVP_CLAN::TPVPClan clan2 = _FactionWarOccurs[i].Clan2; createFactionChannel((PVP_CLAN::TPVPClan)i);
}
// create dynamic channel for faction war if not already exist for( CPlayerManager::TMapPlayers::const_iterator it = PlayerManager.getPlayers().begin(); it != PlayerManager.getPlayers().end(); ++it )
createFactionChannel(clan1); {
createFactionChannel(clan2); CPlayerManager::SCPlayer scPlayer=(*it).second;
// send start of faction war to all clients, and add faction channel to character with concerned allegiance if (scPlayer.Player)
for( CPlayerManager::TMapPlayers::const_iterator it = PlayerManager.getPlayers().begin(); it != PlayerManager.getPlayers().end(); ++it )
{ {
CPlayerManager::SCPlayer scPlayer=(*it).second; CCharacter *activePlayer=scPlayer.Player->getActiveCharacter();
if (activePlayer)
if (scPlayer.Player)
{ {
CCharacter *activePlayer=scPlayer.Player->getActiveCharacter(); updateFactionChannel(activePlayer);
if (activePlayer)
{
CMessage msgout( "IMPULSION_ID" );
CEntityId id = activePlayer->getId();
msgout.serial( id );
CBitMemStream bms;
nlverify ( GenericMsgManager.pushNameToStream( "PVP_FACTION:PUSH_FACTION_WAR", bms) );
bms.serialEnum( clan1 );
bms.serialEnum( clan2 );
msgout.serialBufferWithSize((uint8*)bms.buffer(), bms.length());
sendMessageViaMirror( NLNET::TServiceId(id.getDynamicId()), msgout );
// add faction channel to character if needed
addFactionChannelToCharacter( activePlayer );
addRemoveFactionChannelToUserWithPriviledge( activePlayer );
}
} }
} }
} }
@ -796,43 +971,6 @@ void CPVPManager2::onIOSMirrorUp()
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
bool CPVPManager2::stopFactionWar( PVP_CLAN::TPVPClan clan1, PVP_CLAN::TPVPClan clan2 ) bool CPVPManager2::stopFactionWar( PVP_CLAN::TPVPClan clan1, PVP_CLAN::TPVPClan clan2 )
{ {
vector< PVP_CLAN::CFactionWar >::iterator it;
for( it=_FactionWarOccurs.begin(); it!=_FactionWarOccurs.end(); ++it )
{
if( (*it).inPvPFaction( clan1, clan2 ) )
{
// send end of faction war to all clients, and remove faction channel if needed
for( CPlayerManager::TMapPlayers::const_iterator it2 = PlayerManager.getPlayers().begin(); it2 != PlayerManager.getPlayers().end(); ++it2 )
{
CPlayerManager::SCPlayer scPlayer=(*it2).second;
if (scPlayer.Player)
{
CCharacter *activePlayer=scPlayer.Player->getActiveCharacter();
if (activePlayer)
{
CMessage msgout( "IMPULSION_ID" );
CEntityId id = activePlayer->getId();
msgout.serial( id );
CBitMemStream bms;
nlverify ( GenericMsgManager.pushNameToStream( "PVP_FACTION:POP_FACTION_WAR", bms) );
bms.serialEnum( clan1 );
bms.serialEnum( clan2 );
msgout.serialBufferWithSize((uint8*)bms.buffer(), bms.length());
sendMessageViaMirror( NLNET::TServiceId(id.getDynamicId()), msgout );
removeFactionChannelForCharacter(activePlayer);
}
}
}
// erase war
_FactionWarOccurs.erase(it);
removeFactionChannel(clan1);
removeFactionChannel(clan2);
return true;
}
}
return false; return false;
} }
@ -842,10 +980,7 @@ void CPVPManager2::createFactionChannel(PVP_CLAN::TPVPClan clan)
TMAPFactionChannel::iterator it = _FactionChannel.find(clan); TMAPFactionChannel::iterator it = _FactionChannel.find(clan);
if( it == _FactionChannel.end() ) if( it == _FactionChannel.end() )
{ {
ucstring title;
string name = NLMISC::strupr( string("Faction_") + PVP_CLAN::toString(clan) ); string name = NLMISC::strupr( string("Faction_") + PVP_CLAN::toString(clan) );
// title.fromUtf8(name);
// TChanID factionChannelId = DynChatEGS.addChan(name, title );
TChanID factionChannelId = DynChatEGS.addLocalizedChan(name); TChanID factionChannelId = DynChatEGS.addLocalizedChan(name);
// set historic size of the newly created channel // set historic size of the newly created channel
DynChatEGS.setHistoricSize( factionChannelId, FactionChannelHistoricSize ); DynChatEGS.setHistoricSize( factionChannelId, FactionChannelHistoricSize );
@ -854,15 +989,60 @@ void CPVPManager2::createFactionChannel(PVP_CLAN::TPVPClan clan)
} }
} }
void CPVPManager2::createExtraFactionChannel(const std::string & channelName)
{
TMAPExtraFactionChannel::iterator it = _ExtraFactionChannel.find(channelName);
if( it == _ExtraFactionChannel.end() )
{
string name = NLMISC::strupr( string("Faction_") + channelName );
TChanID factionChannelId = DynChatEGS.addLocalizedChan(name);
// set historic size of the newly created channel
DynChatEGS.setHistoricSize( factionChannelId, FactionChannelHistoricSize );
_ExtraFactionChannel.insert( make_pair(channelName, factionChannelId) );
}
}
TChanID CPVPManager2::createUserChannel(const std::string & channelName, const std::string & pass)
{
TMAPExtraFactionChannel::iterator it = _UserChannel.find(channelName);
if( it == _UserChannel.end() )
{
string channelTitle;
if (channelName.substr(0, 1) == "#")
channelTitle = channelName.substr(5);
else
channelTitle = channelName;
TChanID factionChannelId = DynChatEGS.addChan(channelName, channelTitle);
DynChatEGS.setHistoricSize( factionChannelId, FactionChannelHistoricSize );
_UserChannel.insert( make_pair(channelName, factionChannelId) );
_PassChannels.insert( make_pair(factionChannelId, pass) );
return factionChannelId;
}
return DYN_CHAT_INVALID_CHAN;
}
void CPVPManager2::deleteUserChannel(const std::string & channelName)
{
TMAPExtraFactionChannel::iterator it = _UserChannel.find(channelName);
if( it != _UserChannel.end() )
{
DynChatEGS.removeChan( (*it).second );
TMAPPassChannel::iterator it2 = _PassChannels.find((*it).second);
if( it2 != _PassChannels.end() )
_PassChannels.erase(it2);
_UserChannel.erase(it);
}
}
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
void CPVPManager2::removeFactionChannel(PVP_CLAN::TPVPClan clan) void CPVPManager2::removeFactionChannel(PVP_CLAN::TPVPClan clan)
{ {
for( uint32 i = 0; i < _FactionWarOccurs.size(); ++i )
{
if( _FactionWarOccurs[ i ].Clan1 == clan || _FactionWarOccurs[ i ].Clan2 == clan)
return;
}
TMAPFactionChannel::iterator it = _FactionChannel.find( clan ); TMAPFactionChannel::iterator it = _FactionChannel.find( clan );
if( it != _FactionChannel.end() ) if( it != _FactionChannel.end() )
{ {
@ -874,48 +1054,18 @@ void CPVPManager2::removeFactionChannel(PVP_CLAN::TPVPClan clan)
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
bool CPVPManager2::factionWarOccurs( PVP_CLAN::TPVPClan clan1, PVP_CLAN::TPVPClan clan2 ) const bool CPVPManager2::factionWarOccurs( PVP_CLAN::TPVPClan clan1, PVP_CLAN::TPVPClan clan2 ) const
{ {
if( clan1 != PVP_CLAN::Neutral && clan2 != PVP_CLAN::Neutral )
{
uint32 factionWarOccursSize = (uint32)_FactionWarOccurs.size();
for( uint32 i = 0; i < factionWarOccursSize; ++i )
{
if( _FactionWarOccurs[ i ].inPvPFaction( clan1, clan2 ) )
return true;
}
}
return false; return false;
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
bool CPVPManager2::factionWarOccurs( pair<PVP_CLAN::TPVPClan, PVP_CLAN::TPVPClan> allegiance1, pair<PVP_CLAN::TPVPClan, PVP_CLAN::TPVPClan> allegiance2 ) const bool CPVPManager2::factionWarOccurs( pair<PVP_CLAN::TPVPClan, PVP_CLAN::TPVPClan> allegiance1, pair<PVP_CLAN::TPVPClan, PVP_CLAN::TPVPClan> allegiance2 ) const
{ {
bool warOccurs = false; return false;
if( allegiance1.first != PVP_CLAN::Neutral )
{
if( allegiance2.first != PVP_CLAN::Neutral && allegiance1.first != allegiance2. first )
warOccurs |= factionWarOccurs( allegiance1.first, allegiance2.first );
if( allegiance2.second != PVP_CLAN::Neutral && allegiance1.first != allegiance2.second )
warOccurs |= factionWarOccurs( allegiance1.first, allegiance2.second );
}
if( allegiance1.second != PVP_CLAN::Neutral )
{
if( allegiance2.first != PVP_CLAN::Neutral && allegiance1.second != allegiance2.first )
warOccurs |= factionWarOccurs( allegiance1.second, allegiance2.first );
if( allegiance2.second != PVP_CLAN::Neutral && allegiance1.second != allegiance2.second )
warOccurs |= factionWarOccurs( allegiance1.second, allegiance2.second );
}
return warOccurs;
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
bool CPVPManager2::isFactionInWar( PVP_CLAN::TPVPClan clan ) bool CPVPManager2::isFactionInWar( PVP_CLAN::TPVPClan clan )
{ {
uint32 factionWarOccursSize = (uint32)_FactionWarOccurs.size();
for( uint32 i = 0; i < factionWarOccursSize; ++i )
{
if( _FactionWarOccurs[ i ].Clan1 == clan || _FactionWarOccurs[ i ].Clan2 == clan )
return true;
}
return false; return false;
} }
@ -925,6 +1075,7 @@ bool CPVPManager2::isFactionInWar( PVP_CLAN::TPVPClan clan )
//----------------------------------------------- //-----------------------------------------------
void CPVPManager2::sendFactionWarsToClient( CCharacter * user ) void CPVPManager2::sendFactionWarsToClient( CCharacter * user )
{ {
/** Old Pvp
nlassert(user); nlassert(user);
CMessage msgout( "IMPULSION_ID" ); CMessage msgout( "IMPULSION_ID" );
@ -947,6 +1098,7 @@ void CPVPManager2::sendFactionWarsToClient( CCharacter * user )
msgout.serialBufferWithSize( (uint8*)bms.buffer(), bms.length() ); msgout.serialBufferWithSize( (uint8*)bms.buffer(), bms.length() );
CUnifiedNetwork::getInstance()->send( NLNET::TServiceId(id.getDynamicId()), msgout ); CUnifiedNetwork::getInstance()->send( NLNET::TServiceId(id.getDynamicId()), msgout );
*/
} }
@ -1264,7 +1416,8 @@ NLMISC_COMMAND(setFactionWar, "Start/stop current wars between faction", "<Facti
PVP_CLAN::TPVPClan faction1 = PVP_CLAN::fromString( args[ 0 ] ); PVP_CLAN::TPVPClan faction1 = PVP_CLAN::fromString( args[ 0 ] );
PVP_CLAN::TPVPClan faction2 = PVP_CLAN::fromString( args[ 1 ] ); PVP_CLAN::TPVPClan faction2 = PVP_CLAN::fromString( args[ 1 ] );
uint32 war = (uint32)atoi(args[ 2 ].c_str()); uint32 war;
NLMISC::fromString(args[ 2 ], war);
if( faction1 < PVP_CLAN::BeginClans || faction1 > PVP_CLAN::EndClans ) if( faction1 < PVP_CLAN::BeginClans || faction1 > PVP_CLAN::EndClans )
{ {

View file

@ -41,6 +41,8 @@ class CPVPManager2
NL_INSTANCE_COUNTER_DECL(CPVPManager2); NL_INSTANCE_COUNTER_DECL(CPVPManager2);
public: public:
typedef std::map< PVP_CLAN::TPVPClan, TChanID > TMAPFactionChannel; typedef std::map< PVP_CLAN::TPVPClan, TChanID > TMAPFactionChannel;
typedef std::map< std::string, TChanID > TMAPExtraFactionChannel;
typedef std::map< TChanID, std::string > TMAPPassChannel;
///\name LOW LEVEL MANAGEMENT ///\name LOW LEVEL MANAGEMENT
//@{ //@{
@ -55,21 +57,27 @@ public:
/// callback called at each tick /// callback called at each tick
void tickUpdate(); void tickUpdate();
/// return dynamic channel TChanID attribued to a faction /// return dynamic channel TChanID attribued to a faction
TChanID getFactionDynChannel( PVP_CLAN::TPVPClan faction); TChanID getFactionDynChannel( const std::string& channelName );
/// return dynamic channel TChanID attribued to an user
TChanID getUserDynChannel( const std::string& channelName);
/// return dynamic channel TChanID attribued to a faction
const std::string &getPassUserChannel( TChanID channelId);
/// return dynamic channel TChanID character must have, DYN_CHAT_INVALID_CHAN if he must don't have faction channel /// return dynamic channel TChanID character must have, DYN_CHAT_INVALID_CHAN if he must don't have faction channel
TChanID getCharacterChannel(CCharacter * user); std::vector<TChanID> getCharacterChannels(CCharacter * user);
/// return dynamic channel TChanId subscribed by character, DYN_CHAT_INVALID_CHAN if character have no faction channel /// return dynamic channel TChanId subscribed by character, DYN_CHAT_INVALID_CHAN if character have no faction channel
TChanID getCharacterRegisteredChannel(CCharacter * user); std::vector<TChanID> getCharacterRegisteredChannels(CCharacter * user);
/// return dynamic user channel TChanId subscribed by character, DYN_CHAT_INVALID_CHAN if character have no user channel
std::vector<TChanID> getCharacterUserChannels(CCharacter * user);
// add faction channel to character if needed // add faction channel to character if needed
void addFactionChannelToCharacter(CCharacter * user); void addFactionChannelToCharacter(TChanID channel, CCharacter * user, bool writeRight = true, bool userChannel = false);
// remove faction channel for character // remove faction channel for character
void removeFactionChannelForCharacter(CCharacter * user); void removeFactionChannelForCharacter(TChanID channel, CCharacter * user, bool userChannel = false);
// add/remove faction channel to this character with privilege // add/remove faction channel to this character with privilege
void addRemoveFactionChannelToUserWithPriviledge(CCharacter * user ); void addRemoveFactionChannelToUserWithPriviledge(TChanID channel, CCharacter * user, bool s = true );
/// handle player disconnection /// handle player disconnection
void playerDisconnects(CCharacter * user); void playerDisconnects(CCharacter * user);
/// handle to add or remove faction channel to player of needed /// handle to add or remove faction channel to player of needed
void addOrRemoveFactionChannel(CCharacter * user, bool b = true ); void updateFactionChannel(CCharacter * user, bool b = true );
/// handle player death /// handle player death
void playerDies(CCharacter * user); void playerDies(CCharacter * user);
/// handle player teleportation /// handle player teleportation
@ -113,6 +121,12 @@ public:
bool stopFactionWar( PVP_CLAN::TPVPClan clan1, PVP_CLAN::TPVPClan clan2 ); bool stopFactionWar( PVP_CLAN::TPVPClan clan1, PVP_CLAN::TPVPClan clan2 );
// create a faction channel if not already exist // create a faction channel if not already exist
void createFactionChannel(PVP_CLAN::TPVPClan clan); void createFactionChannel(PVP_CLAN::TPVPClan clan);
// create an extra faction channel if not already exist (for marauders, agnos, urasiens and hominits)
void createExtraFactionChannel(const std::string & channelName);
// create an user channel if not already exist
TChanID createUserChannel(const std::string & channelName, const std::string & pass);
// remove a user channel
void deleteUserChannel(const std::string & channelName);
// remove a fation channel if faction is no more involved in a war // remove a fation channel if faction is no more involved in a war
void removeFactionChannel(PVP_CLAN::TPVPClan clan); void removeFactionChannel(PVP_CLAN::TPVPClan clan);
// return true if faction war occurs between the 2 factions // return true if faction war occurs between the 2 factions
@ -165,8 +179,13 @@ private:
TFactionWars _FactionWarOccurs; TFactionWars _FactionWarOccurs;
/// channel for faction in war /// channel for faction in war
TMAPFactionChannel _FactionChannel; TMAPFactionChannel _FactionChannel;
TMAPExtraFactionChannel _ExtraFactionChannel;
TMAPExtraFactionChannel _UserChannel;
TMAPPassChannel _PassChannels;
/// character registered channel /// character registered channel
std::map< NLMISC::CEntityId, TChanID > _CharacterChannel; typedef std::map< NLMISC::CEntityId, std::vector<TChanID> > TCharacterChannels;
TCharacterChannels _CharacterChannels;
TCharacterChannels _CharacterUserChannels;
/// if a player does an offensive(curative) action on a faction pvp enemy(ally) we must update flag /// if a player does an offensive(curative) action on a faction pvp enemy(ally) we must update flag
bool _PVPFactionAllyReminder; bool _PVPFactionAllyReminder;
bool _PVPFactionEnemyReminder; bool _PVPFactionEnemyReminder;

View file

@ -253,6 +253,7 @@ bool CCharacterShoppingList::passThruFilter(TItemTradePtr itemTrade, bool dynnam
case ITEMFAMILY::HARVEST_TOOL: case ITEMFAMILY::HARVEST_TOOL:
case ITEMFAMILY::CRAFTING_TOOL: case ITEMFAMILY::CRAFTING_TOOL:
case ITEMFAMILY::COSMETIC: case ITEMFAMILY::COSMETIC:
case ITEMFAMILY::CONSUMABLE:
if( form->Type != _Character->getItemTypeFilter() ) if( form->Type != _Character->getItemTypeFilter() )
return false; return false;
break; break;
@ -269,7 +270,8 @@ bool CCharacterShoppingList::passThruFilter(TItemTradePtr itemTrade, bool dynnam
form->Family != ITEMFAMILY::COSMETIC && form->Family != ITEMFAMILY::COSMETIC &&
form->Family != ITEMFAMILY::TELEPORT && form->Family != ITEMFAMILY::TELEPORT &&
form->Family != ITEMFAMILY::SERVICE && form->Family != ITEMFAMILY::SERVICE &&
form->Family != ITEMFAMILY::GENERIC_ITEM form->Family != ITEMFAMILY::GENERIC_ITEM &&
form->Family != ITEMFAMILY::CONSUMABLE
) )
{ {
if( _Character->getMinClassItemFilter() != RM_CLASS_TYPE::Unknown && itemEnergy != ~0u ) if( _Character->getMinClassItemFilter() != RM_CLASS_TYPE::Unknown && itemEnergy != ~0u )
@ -387,6 +389,7 @@ uint32 CCharacterShoppingList::getSellPrice( const TItemTradePtr itemTrade, bool
case ITEMFAMILY::SHIELD: case ITEMFAMILY::SHIELD:
case ITEMFAMILY::JEWELRY: case ITEMFAMILY::JEWELRY:
case ITEMFAMILY::RAW_MATERIAL: case ITEMFAMILY::RAW_MATERIAL:
case ITEMFAMILY::CONSUMABLE:
priceFactor *= 4.0f; priceFactor *= 4.0f;
break; break;
case ITEMFAMILY::COSMETIC: case ITEMFAMILY::COSMETIC:

View file

@ -580,6 +580,7 @@ IShopUnit * CShopTypeManager::getDynamicShopUnit( const TItemTradePtr& item, uin
case ITEMFAMILY::JEWELRY: case ITEMFAMILY::JEWELRY:
case ITEMFAMILY::CRYSTALLIZED_SPELL: case ITEMFAMILY::CRYSTALLIZED_SPELL:
case ITEMFAMILY::ITEM_SAP_RECHARGE: case ITEMFAMILY::ITEM_SAP_RECHARGE:
case ITEMFAMILY::CONSUMABLE:
{ {
uint32 itemType = itemForm->Type; uint32 itemType = itemForm->Type;
uint32 itemOrigin = itemForm->Origin; uint32 itemOrigin = itemForm->Origin;

View file

@ -863,7 +863,12 @@ void CTeam::removeMission( uint idx, TMissionResult result)
result = mr_fail; result = mr_fail;
} }
const CMissionTemplate *tpl = CMissionManager::getInstance()->getTemplate(_Missions[idx]->getTemplateId()); CMissionTemplate *tpl = CMissionManager::getInstance()->getTemplate(_Missions[idx]->getTemplateId());
if ( tpl && !tpl->Tags.NoList )
{
_Missions[idx]->clearUsersJournalEntry();
}
/*Bsi.append( StatPath, NLMISC::toString("[MIT%s] %u %s", /*Bsi.append( StatPath, NLMISC::toString("[MIT%s] %u %s",
MissionResultStatLogTag[result], MissionResultStatLogTag[result],
@ -877,7 +882,6 @@ void CTeam::removeMission( uint idx, TMissionResult result)
tpl->getMissionName().c_str()); tpl->getMissionName().c_str());
*/ */
// EGSPD::missionTeamLog(MissionResultStatLogTag[result], this->_TeamId, tpl->getMissionName()); // EGSPD::missionTeamLog(MissionResultStatLogTag[result], this->_TeamId, tpl->getMissionName());
_Missions[idx]->clearUsersJournalEntry();
CMissionManager::getInstance()->deInstanciateMission(_Missions[idx]); CMissionManager::getInstance()->deInstanciateMission(_Missions[idx]);
delete _Missions[idx]; delete _Missions[idx];
_Missions.erase(_Missions.begin() + idx) ; _Missions.erase(_Missions.begin() + idx) ;

View file

@ -90,6 +90,14 @@ void cbSetZoneState( NLNET::CMessage& msgin, const std::string &serviceName, NLN
CZoneManager *pZM = &CZoneManager::getInstance(); CZoneManager *pZM = &CZoneManager::getInstance();
// get the places
CPlace *place = pZM->getPlaceFromName(sZoneName);
if (place != NULL)
if (place->isGooPath())
place->setGooActive(nState != 0);
// get the deposit zone (linear search) // get the deposit zone (linear search)
const vector<CDeposit*> &rDeps = pZM->getDeposits(); const vector<CDeposit*> &rDeps = pZM->getDeposits();
for (uint32 i = 0; i < rDeps.size(); ++i) for (uint32 i = 0; i < rDeps.size(); ++i)
@ -267,6 +275,7 @@ bool CPlace::build(const NLLIGO::CPrimPath * path, uint16 id)
_CenterX = sint32 ( ( minX + maxX ) *1000.0f / 2.0f ); _CenterX = sint32 ( ( minX + maxX ) *1000.0f / 2.0f );
_CenterY = sint32 ( ( minY + maxY ) *1000.0f / 2.0f ); _CenterY = sint32 ( ( minY + maxY ) *1000.0f / 2.0f );
_GooPath = true; _GooPath = true;
_GooActive = true;
_Reported = false; _Reported = false;
return true; return true;
@ -331,6 +340,7 @@ bool CPlace::build(const NLLIGO::CPrimZone * zone,uint16 id, bool reportAutorise
_CenterX = sint32 ( ( minX + maxX ) *1000.0f / 2.0f ); _CenterX = sint32 ( ( minX + maxX ) *1000.0f / 2.0f );
_CenterY = sint32 ( ( minY + maxY ) *1000.0f / 2.0f ); _CenterY = sint32 ( ( minY + maxY ) *1000.0f / 2.0f );
_GooPath = false; _GooPath = false;
_GooActive = false;
// get place_type of re-spawn point // get place_type of re-spawn point
PLACE_TYPE::TPlaceType placeType; PLACE_TYPE::TPlaceType placeType;

View file

@ -148,9 +148,11 @@ public:
///\return center coords ///\return center coords
inline sint32 getCenterX(){ return _CenterX;} inline sint32 getCenterX(){ return _CenterX;}
inline sint32 getCenterY(){ return _CenterY;} inline sint32 getCenterY(){ return _CenterY;}
inline void setGooActive(bool state) { _GooActive = state; }
bool getReported() const { return _Reported; } bool getReported() const { return _Reported; }
bool isGooPath() const { return _GooPath; } bool isGooPath() const { return _GooPath; }
bool isGooActive() const { return _GooActive; }
bool isMainPlace() const { return _MainPlace; } bool isMainPlace() const { return _MainPlace; }
TAIAlias getAlias()const{ return _Alias; } TAIAlias getAlias()const{ return _Alias; }
@ -169,6 +171,7 @@ private:
bool _Reported; bool _Reported;
/// Flag indicate this place is a goo path /// Flag indicate this place is a goo path
bool _GooPath; bool _GooPath;
bool _GooActive;
/// true if the place is the main place where a user can be /// true if the place is the main place where a user can be
bool _MainPlace; bool _MainPlace;
/// respawn points validated when a user enters the place /// respawn points validated when a user enters the place

View file

@ -1417,8 +1417,15 @@ void CChatManager::sendChat( CChatGroup::TGroupType senderChatMode, const TDataS
{ {
if (itCl->second->getId().getType() == RYZOMID::player) if (itCl->second->getId().getType() == RYZOMID::player)
{ {
if (itCl->second->isInIgnoreList(sender)) bool havePriv = false;
if (charInfos && charInfos->HavePrivilege)
{
havePriv = true;
}
if ( ! havePriv && itCl->second->isInIgnoreList(sender))
{
return; return;
}
uint32 senderNameIndex; uint32 senderNameIndex;
// if the sender exists // if the sender exists
@ -1605,8 +1612,15 @@ void CChatManager::sendChat2Ex( CChatGroup::TGroupType senderChatMode, const TDa
{ {
if (itCl->second->getId().getType() == RYZOMID::player) if (itCl->second->getId().getType() == RYZOMID::player)
{ {
if (itCl->second->isInIgnoreList(sender)) bool havePriv = false;
if (charInfos && charInfos->HavePrivilege)
{
havePriv = true;
}
if ( ! havePriv && itCl->second->isInIgnoreList(sender))
{
return; return;
}
// send the chat phrase to the client // send the chat phrase to the client
// send the string to FE // send the string to FE
@ -1655,6 +1669,7 @@ void CChatManager::sendChatCustomEmote( const TDataSetRow &sender, const TDataSe
TDataSetRow senderFake = TDataSetRow::createFromRawIndex( INVALID_DATASET_ROW ); TDataSetRow senderFake = TDataSetRow::createFromRawIndex( INVALID_DATASET_ROW );
CCharacterInfos * receiverInfos = IOS->getCharInfos( TheDataset.getEntityId(receiver) ); CCharacterInfos * receiverInfos = IOS->getCharInfos( TheDataset.getEntityId(receiver) );
CCharacterInfos * senderInfos = IOS->getCharInfos( TheDataset.getEntityId(sender) );
if( receiverInfos ) if( receiverInfos )
{ {
TClientInfoCont::iterator itCl = _Clients.find( receiver ); TClientInfoCont::iterator itCl = _Clients.find( receiver );
@ -1662,8 +1677,15 @@ void CChatManager::sendChatCustomEmote( const TDataSetRow &sender, const TDataSe
{ {
if (itCl->second->getId().getType() == RYZOMID::player) if (itCl->second->getId().getType() == RYZOMID::player)
{ {
if (itCl->second->isInIgnoreList(sender)) bool havePriv = false;
if (senderInfos && senderInfos->HavePrivilege)
{
havePriv = true;
}
if ( ! havePriv && itCl->second->isInIgnoreList(sender))
{
return; return;
}
// send the string to FE // send the string to FE
CMessage msgout( "IMPULS_CH_ID" ); CMessage msgout( "IMPULS_CH_ID" );
@ -1752,8 +1774,8 @@ void CChatManager::tell2( const TDataSetRow& sender, const TDataSetRow& receiver
return; return;
} }
// check if the sender is not in the ignore list of the receiver // check if the sender is CSR or is not in the ignore list of the receiver
if( !itCl->second->isInIgnoreList(sender) ) if(senderInfos->HavePrivilege || !itCl->second->isInIgnoreList(sender) )
{ {
// send the chat phrase to the client // send the chat phrase to the client
TVectorParamCheck params; TVectorParamCheck params;
@ -1850,7 +1872,7 @@ void CChatManager::tell( const TDataSetRow& sender, const string& receiverIn, co
} }
// check if the sender is not in the ignore list of the receiver // check if the sender is not in the ignore list of the receiver
if( !itCl->second->isInIgnoreList(sender) ) if(senderInfos->HavePrivilege || !itCl->second->isInIgnoreList(sender) )
{ {
// check if user is afk // check if user is afk
if ( receiverInfos->DataSetIndex.isValid() && TheDataset.isDataSetRowStillValid( receiverInfos->DataSetIndex ) ) if ( receiverInfos->DataSetIndex.isValid() && TheDataset.isDataSetRowStillValid( receiverInfos->DataSetIndex ) )
@ -2018,8 +2040,9 @@ void CChatManager::farTell( const NLMISC::CEntityId &senderCharId, const ucstrin
return; return;
} }
// check if the sender is not in the ignore list of the receiver CCharacterInfos * senderInfos = IOS->getCharInfos(senderName);
if( !itCl->second->isInIgnoreList(senderCharId) ) // check if the sender is CSR is not in the ignore list of the receiver
if((senderInfos && senderInfos->HavePrivilege) || !itCl->second->isInIgnoreList(senderCharId) )
{ {
// check if user is afk // check if user is afk
// if ( receiverInfos->DataSetIndex.isValid() && TheDataset.isDataSetRowStillValid( receiverInfos->DataSetIndex ) ) // if ( receiverInfos->DataSetIndex.isValid() && TheDataset.isDataSetRowStillValid( receiverInfos->DataSetIndex ) )
@ -2311,8 +2334,25 @@ ucstring CChatManager::filterClientInput(ucstring &text)
// any double white skipped // any double white skipped
if (text[pos] == '&') if (text[pos] == '&')
{ {
// filter out '&' to remove system color code (like '&SYS&' ) // Special case if there is <NEW> or <CHG> at the beginning
result += '.'; bool hasBrackets = false;
if (pos >= 5)
{
hasBrackets = (text[pos-1] == '>') &&
(text[pos-5] == '<');
}
// Filter out '&' at the first non-whitespace position to remove
// system color code (like '&SYS&' )
bool disallowAmpersand = (result.size() == 0) || hasBrackets;
if (disallowAmpersand)
{
result += '.';
}
else
{
// authorized ampersand
result += '&';
}
} }
else if (text[pos] == '@' && pos < text.size()-1 && text[pos+1] == '{') else if (text[pos] == '@' && pos < text.size()-1 && text[pos+1] == '{')
{ {