1186 lines
37 KiB
C++
1186 lines
37 KiB
C++
// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
|
|
// Copyright (C) 2010 Winch Gate Property Limited
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Affero General Public License as
|
|
// published by the Free Software Foundation, either version 3 of the
|
|
// License, or (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Affero General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Affero General Public License
|
|
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
|
|
|
|
// include files
|
|
#include "stdpch.h"
|
|
|
|
#include "npc_description_msg.h"
|
|
#include "ai.h"
|
|
#include "ai_mgr_pet.h"
|
|
#include "ai_share/ai_actions.h"
|
|
#include "aids_interface.h"
|
|
#include "ai_player.h"
|
|
#include "ai_grp_pet.h"
|
|
#include "ai_bot_npc.h"
|
|
#include "ai_mgr_npc.h"
|
|
#include "ai_grp_npc.h"
|
|
#include "ai_bot_fauna.h"
|
|
#include "ai_mgr_fauna.h"
|
|
#include "ai_grp_fauna.h"
|
|
#include "ai_profile_fauna.h" // for CCorpseFaunaProfile
|
|
#include "dyn_mission.h"
|
|
#include "mirrors.h"
|
|
|
|
|
|
#include "game_share/tick_event_handler.h"
|
|
#include "messages.h"
|
|
#include "server_share/msg_brick_service.h"
|
|
#include "server_share/msg_ai_service.h"
|
|
#include "server_share/effect_message.h"
|
|
// ai_share
|
|
#include "ai_share/ai_actions_dr.h"
|
|
|
|
|
|
#include "egs_interface.h"
|
|
|
|
|
|
#include "dyn_grp_inline.h"
|
|
|
|
using namespace NLMISC;
|
|
using namespace NLNET;
|
|
using namespace AITYPES;
|
|
|
|
//--------------------------------------------------------------------------
|
|
// CTransportClass message receivers
|
|
//--------------------------------------------------------------------------
|
|
|
|
class CCharacterBotChatBeginEndReceiver: public CCharacterBotChatBeginEnd
|
|
{
|
|
virtual void callback (const std::string &name, NLNET::TServiceId id)
|
|
{
|
|
// make sure bot chat start vector size is even
|
|
if (BotChatStart.size()&1)
|
|
{
|
|
nlwarning("CCharacterBotChatBeginEndReceiver::callback(): Invalid BotChatStart vector length");
|
|
return;
|
|
}
|
|
|
|
// make sure bot chat end vector size is even
|
|
if (BotChatEnd.size()&1)
|
|
{
|
|
nlwarning("CCharacterBotChatBeginEndReceiver::callback(): Invalid BotChatEnd vector length");
|
|
return;
|
|
}
|
|
|
|
// nlwarning("Cannot initiate Chat between Bot, will be correct in next AI integration");
|
|
|
|
// start new bot chats
|
|
{
|
|
for (uint i=0;i<BotChatStart.size();i+=2)
|
|
CAIS::instance().beginBotChat(BotChatStart[i+1],BotChatStart[i]);
|
|
}
|
|
|
|
// terminate ended bot chats
|
|
{
|
|
for (uint i=0;i<BotChatEnd.size();i+=2)
|
|
CAIS::instance().endBotChat(BotChatEnd[i+1],BotChatEnd[i]);
|
|
}
|
|
|
|
}
|
|
};
|
|
|
|
class CCharacterDynChatBeginEndReceiver: public CCharacterDynChatBeginEnd
|
|
{
|
|
virtual void callback (const std::string &name, NLNET::TServiceId id)
|
|
{
|
|
// report to the npcs
|
|
for ( uint i=0; i!=DynChatStart.size(); ++i )
|
|
CAIS::instance().beginDynChat( DynChatStart[i]);
|
|
for ( uint i=0; i!=DynChatEnd.size(); ++i )
|
|
CAIS::instance().endDynChat( DynChatEnd[i] );
|
|
}
|
|
|
|
};
|
|
|
|
|
|
//-------------------------------------------------------------------------
|
|
// callback for AIDS seviceUp() event
|
|
//--------------------------------------------------------------------------
|
|
/*
|
|
static void cbAIDSServiceUp( const std::string &serviceName, uint16 serviceId, void *arg )
|
|
{
|
|
CMsgAIServiceUp(100.0f,100.0f).send(uint8(serviceId));
|
|
}
|
|
*/
|
|
|
|
//-------------------------------------------------------------------------
|
|
// the callback table
|
|
//--------------------------------------------------------------------------
|
|
|
|
static void cbAddEntities( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId );
|
|
static void cbR2GoLive( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId );
|
|
static void cbR2StopLive( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId );
|
|
static void cbR2StartInstance( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId );
|
|
extern void cbR2NpcBotScriptById( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId );
|
|
extern void cbR2NpcGroupScriptByName( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId );
|
|
static void cbValidateSourceSpawn( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId );
|
|
static void cbValidateSimpleSourceSpawn( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId );
|
|
extern void cbOutpostCreateSquad( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId );
|
|
extern void cbOutpostSpawnSquad( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId );
|
|
extern void cbOutpostDespawnSquad( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId );
|
|
extern void cbOutpostDeleteSquad( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId );
|
|
extern void cbOutpostDespawnAllSquads( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId );
|
|
extern void cbOutpostSetOwner( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId );
|
|
extern void cbOutpostSetAttacker( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId );
|
|
extern void cbOutpostSetState( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId );
|
|
extern void cbOutpostEvent( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId );
|
|
extern void cbOutpostSetBuildingBotSheet( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId );
|
|
extern void cbEventCreateNpcGroup( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId );
|
|
extern void cbEventNpcGroupScript( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId );
|
|
extern void cbEventFaunaBotSetRadii( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId );
|
|
extern void cbEventFaunaBotResetRadii( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId );
|
|
extern void cbEventBotCanAggro( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId );
|
|
extern void cbEventBotSheet( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId );
|
|
extern void cbAskBotDespawnNotification( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId );
|
|
extern void cbSpawnEasterEgg( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId );
|
|
extern void cbDespawnEasterEgg( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId );
|
|
|
|
|
|
TUnifiedCallbackItem CbArray[] =
|
|
{
|
|
{ "ADDED_ENTITIES", cbAddEntities, },
|
|
{ "SRC_SPWN_VLD", cbValidateSourceSpawn },
|
|
{ "S_SRC_SPWN_VLD", cbValidateSimpleSourceSpawn },
|
|
{ "R2_GOLIVE", cbR2GoLive },
|
|
{ "R2_STOPLIVE", cbR2StopLive },
|
|
{ "R2_STARTINSTANCE", cbR2StartInstance },
|
|
{ "R2_NPC_BOT_SCRIPT_BY_ID", cbR2NpcBotScriptById },
|
|
{ "R2_NPC_GROUP_SCRIPT_BY_NAME", cbR2NpcGroupScriptByName },
|
|
{ "OUTPOST_CREATE_SQUAD", cbOutpostCreateSquad },
|
|
{ "OUTPOST_SPAWN_SQUAD", cbOutpostSpawnSquad },
|
|
{ "OUTPOST_DESPAWN_SQUAD", cbOutpostDespawnSquad },
|
|
{ "OUTPOST_DELETE_SQUAD", cbOutpostDeleteSquad },
|
|
{ "OUTPOST_DESPAWN_ALL_SQUADS", cbOutpostDespawnAllSquads },
|
|
{ "OUTPOST_OWNER", cbOutpostSetOwner },
|
|
{ "OUTPOST_ATTACKER", cbOutpostSetAttacker },
|
|
{ "OUTPOST_STATE", cbOutpostSetState },
|
|
{ "OUTPOST_EVENT", cbOutpostEvent },
|
|
{ "OUTPOST_SET_BUILDING_BOT_SHEET", cbOutpostSetBuildingBotSheet },
|
|
{ "EVENT_CREATE_NPC_GROUP", cbEventCreateNpcGroup },
|
|
{ "EVENT_NPC_GROUP_SCRIPT", cbEventNpcGroupScript },
|
|
{ "EVENT_FAUNA_BOT_SET_RADII", cbEventFaunaBotSetRadii },
|
|
{ "EVENT_FAUNA_BOT_RESET_RADII", cbEventFaunaBotResetRadii },
|
|
{ "EVENT_BOT_CAN_AGGRO", cbEventBotCanAggro },
|
|
{ "EVENT_BOT_SHEET", cbEventBotSheet },
|
|
{ "ASK_BOT_DESPAWN_NOTIFICATION", cbAskBotDespawnNotification },
|
|
{ "SPAWN_EASTER_EGG", cbSpawnEasterEgg },
|
|
{ "DESPAWN_EASTER_EGG", cbDespawnEasterEgg },
|
|
};
|
|
|
|
|
|
|
|
void CMessages::release()
|
|
{
|
|
}
|
|
|
|
void CMessages::notifyBotDespawn(NLNET::TServiceId serviceId, uint32 botAlias, const NLMISC::CEntityId& botId)
|
|
{
|
|
CMessage msgout("BOT_DESPAWN_NOTIFICATION");
|
|
msgout.serial(botAlias);
|
|
msgout.serial(const_cast<NLMISC::CEntityId&>(botId));
|
|
CUnifiedNetwork::getInstance()->send(serviceId, msgout);
|
|
}
|
|
|
|
|
|
void CMessages::notifyBotDeath(NLNET::TServiceId serviceId, uint32 botAlias, const NLMISC::CEntityId& botId)
|
|
{
|
|
CMessage msgout("BOT_DEATH_NOTIFICATION");
|
|
msgout.serial(botAlias);
|
|
msgout.serial(const_cast<NLMISC::CEntityId&>(botId));
|
|
CUnifiedNetwork::getInstance()->send(serviceId, msgout);
|
|
}
|
|
|
|
void CMessages::notifyBotStopNpcControl(NLNET::TServiceId serviceId, uint32 botAlias, const NLMISC::CEntityId& botId)
|
|
{
|
|
CMessage msgout("BOT_STOPCCONTROL_NOTIFICATION");
|
|
msgout.serial(botAlias);
|
|
msgout.serial(const_cast<NLMISC::CEntityId&>(botId));
|
|
CUnifiedNetwork::getInstance()->send(serviceId, msgout);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// Messages from the DSS
|
|
//--------------------------------------------------------------------------
|
|
|
|
#include "nel/ligo/primitive.h"
|
|
#include "nel/ligo/primitive_utils.h"
|
|
|
|
#include "ai_share/ai_share.h"
|
|
#include "ai_share/ai_actions.h"
|
|
|
|
#include "game_share/task_list.h"
|
|
|
|
|
|
|
|
|
|
|
|
// Load Scenarip phase 1 (remove old entities)
|
|
class CTaskRingGoLive1 : public CTask<uint32>
|
|
{
|
|
public:
|
|
CTaskRingGoLive1(uint32 aiInstance, bool isBase)
|
|
:_AiInstance(aiInstance), _IsBase(isBase){}
|
|
|
|
virtual void doOperation()
|
|
{
|
|
nldebug("Tick %u CTaskRingGoLive1 (Despawn) %u %u", getTime(), _AiInstance, _IsBase);
|
|
std::string actFilename = toString("r2.%04d.act.primitive", _AiInstance);
|
|
std::string baseFilename= toString("r2.%04d.base.primitive", _AiInstance);
|
|
|
|
ICommand::execute(toString("createDynamicAIInstance %d", _AiInstance), *InfoLog);
|
|
ICommand::execute(toString("unloadPrimitiveFile \"%s\"", actFilename.c_str()), *InfoLog);
|
|
|
|
if (_IsBase)
|
|
{
|
|
ICommand::execute(toString("unloadPrimitiveFile \"%s\"", baseFilename.c_str()), *InfoLog);
|
|
}
|
|
|
|
}
|
|
private:
|
|
uint32 _AiInstance;
|
|
bool _IsBase;
|
|
};
|
|
|
|
|
|
|
|
|
|
// Load Scenarip phase 2 (insert new entities)
|
|
class CTaskRingGoLive2 : public CTask<uint32>
|
|
{
|
|
|
|
public:
|
|
CTaskRingGoLive2(TSessionId sessionId, uint32 aiInstance, bool isBase)
|
|
:_SessionId(sessionId), _AiInstance(aiInstance), _IsBase(isBase){}
|
|
|
|
virtual void doOperation()
|
|
{
|
|
|
|
nldebug("Tick %u, CTaskRingGoLive2 (Spawn) session %u instance %u %u", getTime(), _SessionId.asInt(), _AiInstance, _IsBase);
|
|
CAIActions::IExecutor* executer;
|
|
executer = CAIActions::getExecuter();
|
|
|
|
ICommand::execute(toString("createDynamicAIInstance %d", _AiInstance), *InfoLog);
|
|
|
|
AI_SHARE::CAIActionsDataRecordPtr dataRec;
|
|
dataRec.init(&Pdr);
|
|
|
|
dataRec.applyToExecutor(*executer);
|
|
{
|
|
std::string cmd = toString("spawnManagers r2.%04d.%s", _SessionId.asInt(), _IsBase?"base":"act");
|
|
ICommand::execute(cmd, *InfoLog);
|
|
}
|
|
{
|
|
std::string cmd = toString("spawnManagers r2.%04d.%s", _SessionId.asInt(), _IsBase?"base.zone_trigger":"act.zone_trigger");
|
|
ICommand::execute(cmd, *InfoLog);
|
|
}
|
|
}
|
|
|
|
public:
|
|
CPersistentDataRecord Pdr;
|
|
|
|
private:
|
|
uint32 _AiInstance;
|
|
TSessionId _SessionId;
|
|
bool _IsBase;
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
static void cbR2GoLive( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
|
|
{
|
|
|
|
TSessionId sessionId;
|
|
uint32 aiInstance;
|
|
bool isBase;
|
|
uint32 size;
|
|
|
|
msgin.serial(sessionId);
|
|
msgin.serial(aiInstance);
|
|
msgin.serial(isBase);
|
|
msgin.serial(size);
|
|
if (size != 0)
|
|
{
|
|
// case where we want to start an instance but (at start of an edition session) but animation not started
|
|
|
|
uint32 tick = CTimeInterface::gameCycle();
|
|
CTaskRingGoLive1* task1 = new CTaskRingGoLive1( aiInstance, isBase);
|
|
CTaskRingGoLive2* task2 = new CTaskRingGoLive2( sessionId, aiInstance, isBase);
|
|
task2->Pdr.clear();
|
|
|
|
|
|
uint8* buffer = new uint8[size];
|
|
msgin.serialBuffer(buffer, size);
|
|
task2->Pdr.fromBuffer((const char*)buffer, size);
|
|
delete [] buffer;
|
|
|
|
|
|
CAIS::instance().addTickedTask(tick + 1,task1);
|
|
CAIS::instance().addTickedTask(tick + 2, task2);
|
|
|
|
|
|
}
|
|
|
|
if( isBase )
|
|
{
|
|
// ack to unblock DSS session queue
|
|
CMessage msgout("SESSION_ACK");
|
|
msgout.fastWrite( aiInstance );
|
|
CUnifiedNetwork::getInstance()->send("DSS",msgout);
|
|
nlinfo( "R2An: ack sent to DSS for anim session %u", aiInstance );
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
|
|
|
|
class CTaskR2StopLive : public CTask<uint32>
|
|
{
|
|
|
|
public:
|
|
CTaskR2StopLive(uint32 aiInstance, bool isBase)
|
|
:_AiInstance(aiInstance), _IsBase(isBase){}
|
|
|
|
virtual void doOperation()
|
|
{
|
|
ICommand::execute(toString("createDynamicAIInstance %d", _AiInstance), *InfoLog);
|
|
|
|
|
|
// load a primitiv.binprim from DSS
|
|
//ICommand::execute(toString("despawnManagers %s", isBase?"base":"act"), *InfoLog);
|
|
ICommand::execute(toString("unloadPrimitiveFile \"r2.%04d.act.primitive\"", _AiInstance), *InfoLog);
|
|
|
|
//isBase == false <=> stop act
|
|
// isBase == true <=> stop Live
|
|
if (_IsBase)
|
|
{
|
|
ICommand::execute(toString("unloadPrimitiveFile \"r2.%04d.base.primitive\"", _AiInstance), *InfoLog);
|
|
CAIS::instance().destroyAIInstance(_AiInstance, true);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
private:
|
|
uint32 _AiInstance;
|
|
bool _IsBase;
|
|
};
|
|
|
|
static void cbR2StopLive( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
|
|
{
|
|
|
|
bool isBase;
|
|
uint32 aiInstance;
|
|
msgin.serial(aiInstance);
|
|
msgin.serial(isBase);
|
|
|
|
uint32 tick = CTimeInterface::gameCycle();
|
|
CTask<uint32>* task1 = new CTaskR2StopLive( aiInstance, isBase);
|
|
CAIS::instance().addTickedTask(tick ,task1);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
class CTaskR2StartInstance: public CTask<uint32>
|
|
{
|
|
|
|
public:
|
|
CTaskR2StartInstance(uint32 aiInstance)
|
|
:_AiInstance(aiInstance){}
|
|
|
|
virtual void doOperation()
|
|
{
|
|
// destroy the instance before exist
|
|
CAIS::instance().destroyAIInstance(_AiInstance, false);
|
|
ICommand::execute(toString("createDynamicAIInstance %d", _AiInstance), *InfoLog);
|
|
}
|
|
|
|
|
|
private:
|
|
uint32 _AiInstance;
|
|
};
|
|
|
|
static void cbR2StartInstance( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
|
|
{
|
|
uint32 aiInstance;
|
|
msgin.serial(aiInstance);
|
|
|
|
uint32 tick = CTimeInterface::gameCycle();
|
|
CTask<uint32>* task1 = new CTaskR2StartInstance( aiInstance);
|
|
CAIS::instance().addTickedTask(tick ,task1);
|
|
|
|
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// Messages from the GPMS
|
|
//--------------------------------------------------------------------------
|
|
|
|
//
|
|
static void cbAddEntities( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
|
|
{
|
|
// This is where we should deal with player record creation
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------------------
|
|
// Messages from the EGS
|
|
//--------------------------------------------------------------------------
|
|
void cbValidateSourceSpawn( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
|
|
{
|
|
H_AUTO(ValidateSourceSpawn);
|
|
|
|
// Read/write header
|
|
CMessage msgout( "SRC_SPWN_VLD_R" );
|
|
uint32 nbSources;
|
|
//CVector prospectingPos;
|
|
//msgin.fastRead( prospectingPos );
|
|
|
|
// Get world position of prospector
|
|
const RYAI_MAP_CRUNCH::CWorldMap& worldMap = CWorldContainer::getWorldMap();
|
|
//RYAI_MAP_CRUNCH::CWorldPosition prospectorWorldPos;
|
|
//CAIVector prospectingAiPos( (double)prospectingPos.x, (double)prospectingPos.y );
|
|
//bool isProspectingPosValid = worldMap.setWorldPosition( (double)prospectingPos.z, prospectorWorldPos, prospectingAiPos );
|
|
|
|
msgin.fastRead( nbSources );
|
|
msgout.fastWrite( nbSources );
|
|
|
|
for ( uint i=0; i!=nbSources; ++i )
|
|
{
|
|
// Read request
|
|
CVector2f pos2f;
|
|
TDataSetRow sourceDataSetRow;
|
|
msgin.serial( pos2f );
|
|
msgin.serial( sourceDataSetRow );
|
|
msgout.serial( sourceDataSetRow );
|
|
|
|
// Check position
|
|
RYAI_MAP_CRUNCH::CWorldPosition wPos;
|
|
CAIVector aiPos( (double)pos2f.x, (double)pos2f.y );
|
|
std::vector<RYAI_MAP_CRUNCH::CWorldPosition> wPosList;
|
|
|
|
bool canSpawnHere = worldMap.setWorldPosition( AITYPES::vp_auto, wPos, aiPos );
|
|
|
|
//worldMap.getWorldPositions( wPosList, aiPos );
|
|
//for ( std::vector<RYAI_MAP_CRUNCH::CWorldPosition>::const_iterator it=wPosList.begin(); it!=wPosList.end(); ++it )
|
|
{
|
|
// Discard if the position is in water or in interiors
|
|
if ( canSpawnHere && (wPos.getFlags() & (RYAI_MAP_CRUNCH::Water | RYAI_MAP_CRUNCH::Interior)) )
|
|
canSpawnHere = false;
|
|
//continue;
|
|
|
|
msgout.fastWrite( canSpawnHere );
|
|
|
|
// TODO: Browse the possible surfaces for the position (x,y), then keep only the one(s)
|
|
// for which a pathfinding from the prospector to the source limited to 5 surfaces succeeds
|
|
}
|
|
}
|
|
|
|
// Send reply
|
|
sendMessageViaMirror( serviceId, msgout ); // via mirror because receiver will access mirror
|
|
//nldebug( "Processed %u forage source pos validations", nbSources );
|
|
}
|
|
|
|
|
|
void cbValidateSimpleSourceSpawn( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
|
|
{
|
|
H_AUTO(ValidateSourceSpawn);
|
|
|
|
// Read/write header
|
|
CMessage msgout( "SRC_SPWN_VLD_R" );
|
|
|
|
// Read request
|
|
uint32 nbSources = 1;
|
|
msgout.fastWrite( nbSources );
|
|
CVector2f pos2f;
|
|
TDataSetRow sourceDataSetRow;
|
|
msgin.serial( pos2f );
|
|
msgin.serial( sourceDataSetRow );
|
|
msgout.serial( sourceDataSetRow );
|
|
|
|
// Check position
|
|
const RYAI_MAP_CRUNCH::CWorldMap& worldMap = CWorldContainer::getWorldMap();
|
|
RYAI_MAP_CRUNCH::CWorldPosition wPos;
|
|
CAIVector aiPos( (double)pos2f.x, (double)pos2f.y );
|
|
bool canSpawnHere = worldMap.setWorldPosition( AITYPES::vp_auto, wPos, aiPos );
|
|
|
|
// Discard if the position is in water or in interiors
|
|
if ( canSpawnHere && (wPos.getFlags() & (RYAI_MAP_CRUNCH::Water | RYAI_MAP_CRUNCH::Interior)) )
|
|
canSpawnHere = false;
|
|
|
|
msgout.fastWrite( canSpawnHere );
|
|
|
|
// Send reply
|
|
sendMessageViaMirror( serviceId, msgout ); // via mirror because receiver will access mirror
|
|
//nldebug( "Processed a simple forage source pos validation" );
|
|
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------------------
|
|
// CTransportClass callbacks
|
|
//--------------------------------------------------------------------------
|
|
/*
|
|
void CMsgAIOpenMgrs::callback (const std::string &serviceName, uint8 sid)
|
|
{
|
|
if (Name.size()!=Type.size() || Name.size()!=MgrId.size())
|
|
{
|
|
nlwarning("Size missmatch in vectors in CMsgAIOpenMgrs message - message ignored");
|
|
return;
|
|
}
|
|
|
|
// iterate through the entries in the message opening new managers
|
|
for (uint i=0;i<Name.size();++i)
|
|
{
|
|
// look for a type that matches the type name given
|
|
EMgrType type=mgrType(Type[i].c_str());
|
|
|
|
if (type!=MgrTypeBadType)
|
|
{
|
|
// open the manger as requested
|
|
CAIS::newMgr(type,MgrId[i],Name[i],std::string());
|
|
}
|
|
else
|
|
{
|
|
// failed to identify type so give up
|
|
nlwarning("Failed to translate '%s' into a known type - request to open manager %04d (%s) ignored",
|
|
Type[i].c_str(),MgrId[i],Name[i].c_str());
|
|
std::string msgStr("Failed to open "+Name[i]+" due to bad type: '"+Type[i]+"'");
|
|
CMsgAIFeedback(msgStr).send("AIDS");
|
|
}
|
|
}
|
|
}
|
|
*/
|
|
|
|
class CAITauntImp : public CAITauntMsg
|
|
{
|
|
public:
|
|
void callback (const std::string &name, NLNET::TServiceId id);
|
|
protected:
|
|
private:
|
|
};
|
|
|
|
class CAIPlayerRespawnMsgImp : public CAIPlayerRespawnMsg
|
|
{
|
|
public:
|
|
virtual void callback (const std::string &name, NLNET::TServiceId id);
|
|
};
|
|
|
|
class CAIAskForInfosOnEntityImp
|
|
:public CAIAskForInfosOnEntityMsg
|
|
{
|
|
public:
|
|
void callback (const std::string &name, NLNET::TServiceId id);
|
|
};
|
|
|
|
|
|
class CEnableAggroOnPlayerImp
|
|
:public CEnableAggroOnPlayerMsg
|
|
{
|
|
public:
|
|
void callback (const std::string &name, NLNET::TServiceId id);
|
|
};
|
|
|
|
class CSetBotHeadingImp : public CSetBotHeadingMsg
|
|
{
|
|
public:
|
|
void callback(const std::string &name, NLNET::TServiceId id);
|
|
};
|
|
|
|
class CChangeActionFlagMsgImp
|
|
:public CChangeActionFlagMsg
|
|
{
|
|
public:
|
|
void callback (const std::string &name, NLNET::TServiceId id);
|
|
};
|
|
|
|
class CChangeCreatureModeMsgImp
|
|
:public CChangeCreatureModeMsg
|
|
{
|
|
public:
|
|
void callback (const std::string &name, NLNET::TServiceId id);
|
|
};
|
|
|
|
//-------------------------------------------------------------------------
|
|
// singleton initialisation and release
|
|
//--------------------------------------------------------------------------
|
|
|
|
void CMessages::init()
|
|
{
|
|
// incoming from AIDS
|
|
TRANSPORT_CLASS_REGISTER( CMsgAICloseMgrs );
|
|
TRANSPORT_CLASS_REGISTER( CMsgAIBackupMgrs );
|
|
TRANSPORT_CLASS_REGISTER( CMsgAIUploadActions );
|
|
TRANSPORT_CLASS_REGISTER( CMsgAISpawnMgrs );
|
|
TRANSPORT_CLASS_REGISTER( CMsgAIDespawnMgrs );
|
|
|
|
// outgoing to AIDS
|
|
TRANSPORT_CLASS_REGISTER( CMsgAIServiceUp );
|
|
TRANSPORT_CLASS_REGISTER( CMsgAIManagerUp );
|
|
TRANSPORT_CLASS_REGISTER( CMsgAIFeedback );
|
|
|
|
// Classes used for comms with EGS (outgoing)
|
|
// TRANSPORT_CLASS_REGISTER( CNpcBotDescription );
|
|
TRANSPORT_CLASS_REGISTER( CCharacterBotChatBeginEndReceiver );
|
|
TRANSPORT_CLASS_REGISTER( CCharacterDynChatBeginEndReceiver );
|
|
TRANSPORT_CLASS_REGISTER( CFaunaBotDescription );
|
|
TRANSPORT_CLASS_REGISTER( CUserEventMsgImp );
|
|
TRANSPORT_CLASS_REGISTER( CSetEscortTeamIdImp );
|
|
TRANSPORT_CLASS_REGISTER( CCreatureDespawnImp );
|
|
TRANSPORT_CLASS_REGISTER( CDelHandledAIGroupImp );
|
|
TRANSPORT_CLASS_REGISTER( CAddHandledAIGroupImp );
|
|
TRANSPORT_CLASS_REGISTER( CHandledAIGroupSpawnedMsg );
|
|
TRANSPORT_CLASS_REGISTER( CHandledAIGroupDespawnedMsg );
|
|
TRANSPORT_CLASS_REGISTER( CGiveItemRequestMsg );
|
|
TRANSPORT_CLASS_REGISTER( CReceiveItemRequestMsg );
|
|
|
|
// Classes used for comms between AI and EGS
|
|
TRANSPORT_CLASS_REGISTER (CPetSpawnMsgImp);
|
|
TRANSPORT_CLASS_REGISTER (CPetSpawnConfirmationMsg);
|
|
|
|
TRANSPORT_CLASS_REGISTER (CPetCommandMsgImp);
|
|
TRANSPORT_CLASS_REGISTER (CPetCommandConfirmationMsg);
|
|
|
|
TRANSPORT_CLASS_REGISTER (CBSAIDeathReport);
|
|
TRANSPORT_CLASS_REGISTER (CCAisActionMsg);
|
|
|
|
TRANSPORT_CLASS_REGISTER (CEGSExecutePhraseMsg);
|
|
TRANSPORT_CLASS_REGISTER (CEGSExecuteAiActionMsg);
|
|
|
|
TRANSPORT_CLASS_REGISTER (CAddEffectsMessage);
|
|
TRANSPORT_CLASS_REGISTER (CRemoveEffectsMessage);
|
|
|
|
// TRANSPORT_CLASS_REGISTER (COutpostList);
|
|
// TRANSPORT_CLASS_REGISTER (COutpostDescription);
|
|
TRANSPORT_CLASS_REGISTER (CDutyDescription);
|
|
// TRANSPORT_CLASS_REGISTER (COutpostStateImp);
|
|
// TRANSPORT_CLASS_REGISTER (COutpostWarEnd);
|
|
|
|
TRANSPORT_CLASS_REGISTER (CAITauntImp);
|
|
|
|
TRANSPORT_CLASS_REGISTER (CAILostAggroMsg);
|
|
TRANSPORT_CLASS_REGISTER (CAIGainAggroMsg);
|
|
|
|
TRANSPORT_CLASS_REGISTER (CAIPlayerRespawnMsgImp);
|
|
|
|
TRANSPORT_CLASS_REGISTER (CAIAskForInfosOnEntityImp);
|
|
TRANSPORT_CLASS_REGISTER (CAIInfosOnEntityMsg);
|
|
TRANSPORT_CLASS_REGISTER (CEnableAggroOnPlayerImp);
|
|
TRANSPORT_CLASS_REGISTER (CChangeActionFlagMsgImp);
|
|
|
|
TRANSPORT_CLASS_REGISTER (CPetSetOwnerImp);
|
|
|
|
TRANSPORT_CLASS_REGISTER (CSetBotHeadingImp);
|
|
|
|
// messages related to instance management
|
|
TRANSPORT_CLASS_REGISTER (CReportAICollisionAvailableMsg);
|
|
TRANSPORT_CLASS_REGISTER (CReportStaticAIInstanceMsg);
|
|
TRANSPORT_CLASS_REGISTER (CReportAIInstanceDespawnMsg);
|
|
TRANSPORT_CLASS_REGISTER (CWarnBadInstanceMsgImp);
|
|
TRANSPORT_CLASS_REGISTER (CCreatureSetUrlMsg);
|
|
TRANSPORT_CLASS_REGISTER (CChangeCreatureMaxHPMsg)
|
|
TRANSPORT_CLASS_REGISTER (CChangeCreatureHPMsg);
|
|
TRANSPORT_CLASS_REGISTER (CChangeCreatureModeMsgImp);
|
|
TRANSPORT_CLASS_REGISTER (CQueryEgs);
|
|
|
|
// setup the callback array
|
|
CUnifiedNetwork::getInstance()->addCallbackArray( CbArray, sizeof(CbArray)/sizeof(CbArray[0]) );
|
|
|
|
// hook up callback to service up of data service
|
|
// CUnifiedNetwork::getInstance()->setServiceUpCallback( std::string("AIDS"), cbAIDSServiceUp, 0);
|
|
}
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// CallBack part
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
void CEnableAggroOnPlayerImp::callback (const std::string &name, NLNET::TServiceId id)
|
|
{
|
|
CAIEntityPhysical *phys=CAIS::instance().getEntityPhysical(EntityRowId);
|
|
if (!phys)
|
|
{
|
|
// When go from test to edition the ai instance is destroyed
|
|
if (!IsRingShard)
|
|
{
|
|
nlwarning("CEnableAggroOnPlayerImp::callback: unknow entity %s on this AIS !", EntityRowId.toString().c_str());
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
switch(phys->getRyzomType())
|
|
{
|
|
case RYZOMID::player:
|
|
{
|
|
CBotPlayer *const bot=safe_cast<CBotPlayer*>(phys);
|
|
bot->setAggroable(EnableAggro);
|
|
if (!EnableAggro)
|
|
bot->forgotAggroForAggroer();
|
|
}
|
|
break;
|
|
default:
|
|
nlwarning("CEnableAggroOnPlayerImp::callback: non player entity ! %s(%u) on this AIS !", phys->getEntityId().toString().c_str(), EntityRowId.toString().c_str());
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
void CAIAskForInfosOnEntityImp::callback (const std::string &name, NLNET::TServiceId id)
|
|
{
|
|
CAIInfosOnEntityMsg msg;
|
|
msg.AskerRowID=AskerRowID;
|
|
msg.EntityRowId=EntityRowId;
|
|
|
|
CArrayStringWriter stringWriter(msg.Infos);
|
|
|
|
CAIEntityPhysical *phys=CAIS::instance().getEntityPhysical(EntityRowId);
|
|
if (phys)
|
|
{
|
|
switch(phys->getRyzomType())
|
|
{
|
|
case RYZOMID::creature:
|
|
case RYZOMID::npc:
|
|
case RYZOMID::pack_animal:
|
|
{
|
|
const CBot *const bot=safe_cast<const CBot*>(&phys->getPersistent());
|
|
std::vector<std::string> strings = bot->getMultiLineInfoString();
|
|
msg.Infos.insert(msg.Infos.end(), strings.begin(), strings.end());
|
|
}
|
|
break;
|
|
default:
|
|
std::vector<std::string> strings = phys->getMultiLineInfoString();
|
|
msg.Infos.insert(msg.Infos.end(), strings.begin(), strings.end());
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
nlwarning("CAIAskForInfosOnEntityImp::callback: entity %s is unknow on this AIS.", EntityRowId.toString().c_str());
|
|
stringWriter.append(toString("%s : unknow entity index %s", IService::getInstance()->getServiceShortName().c_str(), EntityRowId.toString().c_str()));
|
|
}
|
|
msg.send("EGS");
|
|
}
|
|
|
|
void CChangeActionFlagMsgImp::callback (const std::string &name, NLNET::TServiceId id)
|
|
{
|
|
const uint32 size = (uint32)Entities.size();
|
|
nlassert( size == ActionFlags.size() && size == Values.size());
|
|
|
|
for (uint32 i = 0 ; i < size ; ++i)
|
|
{
|
|
CAIEntityPhysical *const phys=CAIS::instance().getEntityPhysical(Entities[i]);
|
|
if (!phys)
|
|
continue;
|
|
|
|
if (Values[i])
|
|
phys->setActionFlags((RYZOMACTIONFLAGS::TActionFlag)ActionFlags[i]);
|
|
else
|
|
phys->removeActionFlags((RYZOMACTIONFLAGS::TActionFlag)ActionFlags[i]);
|
|
}
|
|
}
|
|
|
|
void CChangeCreatureModeMsgImp::callback (const std::string &name, NLNET::TServiceId id)
|
|
{
|
|
CAIEntityPhysical *phys=CAIS::instance().getEntityPhysical(CreatureId);
|
|
if (!phys)
|
|
return;
|
|
|
|
static_cast<CModEntityPhysical*>(phys)->setMode( MBEHAV::EMode(NewMode) );
|
|
}
|
|
|
|
//
|
|
////----------------------------------------------------------------
|
|
//// EGS -> AIS ask infos on entity
|
|
////----------------------------------------------------------------
|
|
//class CAIAskForInfosOnEntityMsg : public NLNET::CTransportClass
|
|
//{
|
|
//public:
|
|
// TDataSetRow EntityRowId;
|
|
//
|
|
// virtual void description ()
|
|
// {
|
|
// className ("CAIAskForInfosOnEntityMsg");
|
|
// property ("EntityRowId", PropDataSetRow, TDataSetRow(), EntityRowId);
|
|
// }
|
|
// virtual void callback (const std::string &name, uint8 id) {}
|
|
//};
|
|
//
|
|
////----------------------------------------------------------------
|
|
//// AIS -> EGS returns infos on entity as a vector of strings
|
|
////----------------------------------------------------------------
|
|
//class CAIInfosOnEntityMsg : public NLNET::CTransportClass
|
|
//{
|
|
//public:
|
|
// TDataSetRow EntityRowId;
|
|
// std::vector<std::string> Infos;
|
|
//
|
|
// virtual void description ()
|
|
// {
|
|
// className ("CAIInfosOnEntityMsg");
|
|
// property ("EntityRowId", PropDataSetRow, TDataSetRow(), EntityRowId);
|
|
// propertyCont ("Infos", PropString, Infos);
|
|
// }
|
|
// virtual void callback (const std::string &name, uint8 id) {}
|
|
//};
|
|
|
|
|
|
void CMsgAIUploadActions::callback(const std::string &serviceName, NLNET::TServiceId sid)
|
|
{
|
|
for(uint i=0;i<Data.size();)
|
|
{
|
|
uint argCount;
|
|
char action[9];
|
|
std::vector<CAIActions::CArg> args;
|
|
|
|
if (Data.size()-i<sizeof(char)+sizeof(uint64))
|
|
{
|
|
nlwarning("Unexpected end of input data in CMsgAIUploadActions message");
|
|
CAIDSInterface::warning("Unexpected end of input data in CMsgAIUploadActions()");
|
|
return;
|
|
}
|
|
argCount=Data[i]; i++;
|
|
uint k;
|
|
for (k=0;k<8;++i,++k)
|
|
action[k]=Data[i];
|
|
action[k]=0;
|
|
for (uint j=0;j<argCount;++j)
|
|
{
|
|
args.push_back(CAIActions::CArg::serialFromString(Data,i));
|
|
if (i<=Data.size())
|
|
continue;
|
|
|
|
nlwarning("Unexpected end of input data in CMsgAIUploadActions message");
|
|
CAIDSInterface::warning("Unexpected end of input data in CMsgAIUploadActions()");
|
|
return;
|
|
}
|
|
CAIActions::execute(action,args);
|
|
}
|
|
}
|
|
|
|
void CMsgAISpawnMgrs::callback(const std::string &serviceName, NLNET::TServiceId sid)
|
|
{
|
|
nlwarning("*** CMsgAISpawnMgrs message received from AIDS but not treated ***");
|
|
CMsgAIFeedback("*** CMsgAISpawnMgrs message received from AIDS but not treated ***").send("AIDS");
|
|
}
|
|
|
|
void CMsgAIDespawnMgrs::callback(const std::string &serviceName, NLNET::TServiceId sid)
|
|
{
|
|
nlwarning("*** CMsgAIDespawnMgrs message received from AIDS but not treated ***");
|
|
CMsgAIFeedback("*** CMsgAIDespawnMgrs message received from AIDS but not treated ***").send("AIDS");
|
|
}
|
|
|
|
void CMsgAICloseMgrs::callback (const std::string &serviceName, NLNET::TServiceId sid)
|
|
{
|
|
nlassert(false); // AIDataService.
|
|
// for (uint i=0;i<MgrId.size();++i)
|
|
// CAIS::instance().AIList()[0]->deleteMgr(MgrId[i]);
|
|
}
|
|
|
|
void CMsgAIBackupMgrs::callback (const std::string &serviceName, NLNET::TServiceId sid)
|
|
{
|
|
nlassert(false); // AIDataService.
|
|
|
|
nlwarning("*** Backup message received from AIDS but not treated ***");
|
|
CMsgAIFeedback("*** Backup message received from AIDS but not treated ***").send("AIDS");
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------------------
|
|
// CTransportClass stub callbacks for outgoing messages
|
|
//--------------------------------------------------------------------------
|
|
|
|
void CMsgAIServiceUp::callback (const std::string &serviceName, NLNET::TServiceId sid)
|
|
{
|
|
}
|
|
|
|
void CMsgAIManagerUp::callback (const std::string &serviceName, NLNET::TServiceId sid)
|
|
{
|
|
}
|
|
|
|
void CMsgAIFeedback::callback (const std::string &serviceName, NLNET::TServiceId sid)
|
|
{
|
|
}
|
|
|
|
|
|
void CBSAIDeathReport::callback(const std::string &name, NLNET::TServiceId id)
|
|
{
|
|
for (uint i=0; i<Bots.size(); ++i)
|
|
{
|
|
CAIEntityPhysical* phys=CAIS::instance().getEntityPhysical(Bots[i]);
|
|
if (!phys)
|
|
{
|
|
if (Zombies[i])
|
|
{
|
|
nldebug("CBSAIDeathReport::callback: ZombyUnKnown entity %s not handled here", Bots[i].toString().c_str());
|
|
}
|
|
// removed because of multi AIS
|
|
//nldebug("CBSAIDeathReport::callback: entity %s not handled here", Bots[i].toString().c_str());
|
|
continue;
|
|
}
|
|
|
|
#if !FINAL_VERSION
|
|
nlassert(phys->getRyzomType()!=RYZOMID::player);
|
|
#else
|
|
if (phys->getRyzomType()==RYZOMID::player)
|
|
{
|
|
if (Zombies[i])
|
|
{
|
|
nldebug("CBSAIDeathReport::callback: ZombyPlayer entity %s !!", Bots[i].toString().c_str());
|
|
}
|
|
continue;
|
|
}
|
|
#endif
|
|
static_cast<CModEntityPhysical*>(phys)->setMode(MBEHAV::DEATH);
|
|
if (Zombies[i])
|
|
{
|
|
if (dynamic_cast<CModEntityPhysical*>(phys)==NULL)
|
|
{
|
|
nldebug("CBSAIDeathReport::callback: ZombyCastError entity %s !!", Bots[i].toString().c_str());
|
|
}
|
|
else
|
|
{
|
|
nldebug("CBSAIDeathReport::callback: ZombyDEATHSet entity %s !!", Bots[i].toString().c_str());
|
|
}
|
|
|
|
}
|
|
|
|
switch(phys->getRyzomType())
|
|
{
|
|
case RYZOMID::npc:
|
|
{
|
|
const CSpawnBotNpc *const sb = static_cast<CSpawnBotNpc*>(phys);
|
|
CSpawnGroupNpc &spawnGrp = sb->spawnGrp();
|
|
const CMgrNpc &mgr = spawnGrp.getPersistent().mgr();
|
|
|
|
spawnGrp.addBotToDespawnAndRespawnTime (&(sb->getPersistent()), spawnGrp.getPersistent().despawnTime(), spawnGrp.getPersistent().respawnTime());
|
|
|
|
if (spawnGrp.getPersistent().getSquadLeader(false)==&sb->getPersistent())
|
|
spawnGrp.getPersistent().processStateEvent(mgr.EventSquadLeaderKilled);
|
|
|
|
|
|
CBotNpc* bot = NLMISC::safe_cast<CBotNpc*>(&(sb->getPersistent()));
|
|
spawnGrp.botHaveDied (bot);
|
|
bot->notifyBotDeath();
|
|
|
|
std::string eventBotKilled;
|
|
if (spawnGrp.getProfileParameter("event_bot_killed", eventBotKilled) && !eventBotKilled.empty())
|
|
{
|
|
nlinfo("NPC: TRIGGER EVENT BOT KILLED");
|
|
}
|
|
|
|
spawnGrp.getPersistent().processStateEvent(mgr.EventBotKilled);
|
|
|
|
std::string eventGroupKilled;
|
|
if (!spawnGrp.isGroupAlive(0*1))
|
|
{
|
|
if (spawnGrp.getProfileParameter("event_group_killed", eventGroupKilled) && !eventGroupKilled.empty())
|
|
{
|
|
nlinfo("NPC: TRIGGER EVENT GROUP KILLED");
|
|
}
|
|
spawnGrp.getPersistent().processStateEvent(mgr.EventGrpEliminated);
|
|
}
|
|
|
|
if (!eventBotKilled.empty() || !eventGroupKilled.empty())
|
|
{
|
|
CSpawnBot *const spBot = static_cast<CSpawnBot*>(phys);
|
|
// make a vector of aggroable player
|
|
CBotAggroOwner::TBotAggroList const& aggroList = spBot->getBotAggroList();
|
|
//typedef std::map<TDataSetRow, TAggroEntryPtr> TBotAggroList;
|
|
CBotAggroOwner::TBotAggroList::const_iterator aggroIt(aggroList.begin()), aggroEnd(aggroList.end());
|
|
TDataSetRow foundRow = TDataSetRow();
|
|
|
|
std::vector<TDataSetRow> playerAggroable;
|
|
for (; aggroIt != aggroEnd; ++aggroIt)
|
|
{
|
|
if (CMirrors::getEntityId(aggroIt->first).getType() != RYZOMID::player)
|
|
continue;
|
|
CAIEntityPhysical* ep = CAIS::instance().getEntityPhysical(aggroIt->first);
|
|
if (!ep)
|
|
continue;
|
|
CBotPlayer const* const player = NLMISC::safe_cast<CBotPlayer const*>(ep);
|
|
if (!player)
|
|
continue;
|
|
if (!player->isAggroable())
|
|
continue;
|
|
playerAggroable.push_back(aggroIt->first);
|
|
}
|
|
|
|
NLNET::CMessage msgout("TRIGGER_WEBIG");
|
|
if (!eventBotKilled.empty())
|
|
msgout.serial(eventBotKilled);
|
|
else
|
|
msgout.serial(eventGroupKilled);
|
|
|
|
uint32 nbPlayers = (uint32)playerAggroable.size();
|
|
msgout.serial(nbPlayers);
|
|
for (uint32 i = 0; i < nbPlayers; i++)
|
|
{
|
|
msgout.serial(playerAggroable[i]);
|
|
}
|
|
sendMessageViaMirror("EGS", msgout);
|
|
}
|
|
}
|
|
break;
|
|
case RYZOMID::creature:
|
|
{
|
|
CSpawnBotFauna *const sb = static_cast<CSpawnBotFauna*>(phys);
|
|
CSpawnGroupFauna &spawnGrp = sb->spawnGrp();
|
|
CMgrFauna &mgr = spawnGrp.getPersistent().mgr();
|
|
|
|
sb->setAIProfile(new CCorpseFaunaProfile(sb));
|
|
{
|
|
const sint32 DespawnTime=spawnGrp.getPersistent().timer(CGrpFauna::CORPSE_TIME);
|
|
const sint32 RespawnTime=spawnGrp.getPersistent().timer(CGrpFauna::RESPAWN_TIME);
|
|
// set the _Bot to be despawn and gives the control to its group.
|
|
// despawn the corpse after DespawnTime, and hence respawn after DespawnTime+RespawnTime since now.
|
|
spawnGrp.addBotToDespawnAndRespawnTime(&sb->getPersistent(),(uint32) DespawnTime, (uint32) DespawnTime + (uint32) RespawnTime);
|
|
}
|
|
|
|
spawnGrp.getPersistent().processStateEvent(mgr.EventBotKilled);
|
|
if (spawnGrp.isGroupAlive())
|
|
break;
|
|
|
|
spawnGrp.getPersistent().processStateEvent(mgr.EventGrpEliminated);
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
void CEGSExecutePhraseMsg::callback(const std::string &name, NLNET::TServiceId id)
|
|
{
|
|
}
|
|
|
|
|
|
void CAITauntImp::callback (const std::string &name, NLNET::TServiceId id)
|
|
{
|
|
CAIEntityPhysical *entity=CAIS::instance().getEntityPhysical(TargetRowId);
|
|
|
|
if (!entity)
|
|
return;
|
|
|
|
CBotAggroOwner *aggroOwner=NULL;
|
|
|
|
switch (entity->getRyzomType())
|
|
{
|
|
case RYZOMID::creature:
|
|
case RYZOMID::npc:
|
|
aggroOwner=NLMISC::safe_cast<CSpawnBot*>(entity);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (!aggroOwner)
|
|
return;
|
|
|
|
aggroOwner->maximizeAggroFor(PlayerRowId);
|
|
}
|
|
|
|
void CAIPlayerRespawnMsgImp::callback (const std::string &name, NLNET::TServiceId id)
|
|
{
|
|
CAIEntityPhysical *entity=CAIS::instance().getEntityPhysical(PlayerRowId);
|
|
if (!entity)
|
|
return;
|
|
|
|
CBotPlayer *player=NLMISC::safe_cast<CBotPlayer*>(entity);
|
|
if (!player)
|
|
return;
|
|
|
|
player->forgotAggroForAggroer();
|
|
}
|
|
|
|
|
|
|
|
void sAggroLost(TDataSetRow playerBot, TDataSetRow targetBot)
|
|
{
|
|
CAIEntityPhysical *entity=CAIS::instance().getEntityPhysical(playerBot); // necessary ?
|
|
if ( !entity
|
|
|| CMirrors::getEntityId(playerBot).getType()!=RYZOMID::player)
|
|
return;
|
|
|
|
CAILostAggroMsg msg(targetBot, playerBot);
|
|
msg.send("EGS");
|
|
|
|
CBotPlayer *player=NLMISC::safe_cast<CBotPlayer*>(entity);
|
|
if (!player)
|
|
return;
|
|
player->removeAggroer(targetBot);
|
|
}
|
|
|
|
|
|
void sAggroGain(TDataSetRow playerBot, TDataSetRow targetBot)
|
|
{
|
|
CAIEntityPhysical *entity=CAIS::instance().getEntityPhysical(playerBot); // necessary ?
|
|
if ( !entity
|
|
|| CMirrors::getEntityId(playerBot).getType()!=RYZOMID::player)
|
|
return;
|
|
|
|
CAIGainAggroMsg msg(targetBot, playerBot);
|
|
msg.send("EGS");
|
|
|
|
CBotPlayer *player=NLMISC::safe_cast<CBotPlayer*>(entity);
|
|
if (!player)
|
|
return;
|
|
player->addAggroer(targetBot);
|
|
}
|
|
|
|
|
|
void CSetBotHeadingImp::callback(const std::string &serviceName, NLNET::TServiceId serviceId)
|
|
{
|
|
CAIEntityPhysical *ep =CAIS::instance().getEntityPhysical(BotRowId);
|
|
|
|
if (ep == NULL)
|
|
{
|
|
nlwarning("CSetBotHeadingImp : invalid bot id : %s (%u)", TheDataset.getEntityId(BotRowId).toString().c_str(), BotRowId.getIndex());
|
|
return;
|
|
}
|
|
|
|
// ok, we have an entity physical, try to make it a npc
|
|
CSpawnBotNpc *sb = dynamic_cast<CSpawnBotNpc*>(ep);
|
|
|
|
if (sb == NULL)
|
|
{
|
|
nlwarning("CSetBotHeadingImp : bot id %s (%u) is not an NPC !", TheDataset.getEntityId(BotRowId).toString().c_str(), BotRowId.getIndex());
|
|
return;
|
|
}
|
|
|
|
// set the theta
|
|
sb->setTheta(CAngle(double(Heading)));
|
|
}
|
|
|
|
|
|
void CWarnBadInstanceMsgImp::callback(const std::string &serviceName, NLNET::TServiceId serviceId)
|
|
{
|
|
CAIS::instance().warnBadInstanceMsgImp(serviceName, serviceId, *this);
|
|
}
|
|
|
|
#include "event_reaction_include.h"
|