mirror of
https://port.numenaute.org/aleajactaest/khanat-opennel-code.git
synced 2024-12-05 09:44:47 +00:00
4535 lines
126 KiB
C++
4535 lines
126 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/>.
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// includes
|
|
//-----------------------------------------------------------------------------
|
|
#include "stdpch.h"
|
|
|
|
#include "server_animation_module.h"
|
|
|
|
#include "nel/net/unified_network.h"
|
|
#include "nel/net/module_message.h"
|
|
#include "nel/net/module_socket.h"
|
|
#include "nel/net/module_builder_parts.h"
|
|
#include "nel/net/module_manager.h"
|
|
#include "nel/misc/command.h"
|
|
#include "nel/misc/path.h"
|
|
#include "nel/misc/types_nl.h"
|
|
#include "nel/misc/sstring.h"
|
|
#include "nel/misc/string_conversion.h"
|
|
#include "nel/ligo/primitive.h"
|
|
#include "nel/ligo/ligo_config.h"
|
|
#include "nel/ligo/primitive_utils.h"
|
|
|
|
|
|
#include "game_share/utils.h"
|
|
#include "game_share/persistent_data.h"
|
|
#include "game_share/chat_group.h"
|
|
#include "game_share/misc_const.h"
|
|
#include "game_share/ring_session_manager_itf.h"
|
|
|
|
#include "game_share/object.h"
|
|
#include "game_share/scenario.h"
|
|
#include "game_share/r2_messages.h"
|
|
#include "game_share/r2_ligo_config.h"
|
|
#include "game_share/scenario_entry_points.h"
|
|
#include "game_share/ring_access.h"
|
|
|
|
// TEMP
|
|
//#include "r2_modules/server_edition_module.h"
|
|
//#include "r2_modules/server_admin_module.h"
|
|
|
|
#include "ai_wrapper.h"
|
|
#include "dms.h"
|
|
|
|
|
|
|
|
|
|
|
|
using namespace std;
|
|
using namespace NLMISC;
|
|
using namespace NLLIGO;
|
|
using namespace NLNET;
|
|
using namespace R2;
|
|
|
|
// Debug
|
|
CVariable<bool> WriteScenarioDebugDataToFile( "DSS", "WriteScenarioDebugDataToFile", "Set to true to write scenario rtdata and xml primitive to file", false, 0, true );
|
|
CVariable<uint32> DelayBeforeStartAct ("DSS", "DelayBeforeStartAct", "The delay wait by player/dm between the moment a dm/ai has decided the change of act and the moment of the real change", 30, 0, true );
|
|
CVariable<uint32> DelayBeforeNewLocation ("DSS", "DelayBeforeNewLocation", "The min delay between 2 change of location", 25, 0, true );
|
|
CVariable<bool> UseSheetClientWithLevel( "DSS", "UseSheetClientWithLevel", "use sheet client like basic_fyros_male_f2.creature instead of basic_fyros_male_f2.creature", true, 0, true );
|
|
//std::vector<CPersistentDataRecordRyzomStore> Pdrs;
|
|
static CPersistentDataRecordRyzomStore Pdr;
|
|
|
|
NLNET_REGISTER_MODULE_FACTORY(CServerAnimationModule, "ServerAnimationModule");
|
|
|
|
namespace R2
|
|
{
|
|
|
|
class CRtNpc : public NLMISC::CRefCount
|
|
{
|
|
public:
|
|
CRtNpc(TAIAlias alias, CObject* objectData, TAIAlias grpAlias, uint32 dmProperty)
|
|
{
|
|
Alias = alias;
|
|
ObjectData = objectData;
|
|
GrpAlias = grpAlias;
|
|
NpcAnimationProp = dmProperty;
|
|
NameId = 0;
|
|
Alived = true;
|
|
}
|
|
|
|
NLMISC::CEntityId EntityId;
|
|
TAIAlias Alias;
|
|
TAIAlias GrpAlias;
|
|
TDataSetRow DataSetRow;
|
|
CObject* ObjectData;
|
|
uint32 NpcAnimationProp;
|
|
uint32 NameId;
|
|
bool Alived;
|
|
|
|
};
|
|
|
|
|
|
class CRtGrp: public NLMISC::CRefCount
|
|
{
|
|
public:
|
|
CRtGrp(TAIAlias alias, CObject* objectData, const std::string& fullName)
|
|
{
|
|
Alias = alias;
|
|
ObjectData = objectData;
|
|
FullName = fullName;
|
|
//EntityId = NLMISC::CEntityId::Unknown; (default)
|
|
|
|
}
|
|
|
|
NLMISC::CEntityId EntityId;
|
|
TAIAlias Alias;
|
|
std::string FullName;
|
|
CObject* ObjectData;
|
|
};
|
|
|
|
|
|
class CRtUserTrigger
|
|
{
|
|
public:
|
|
std::string FullName;
|
|
std::string Grp;
|
|
std::string Name;
|
|
};
|
|
|
|
|
|
class CRtAct : public NLMISC::CRefCount
|
|
{
|
|
public:
|
|
typedef std::map<TAIAlias, NLMISC::CSmartPtr<R2::CRtNpc> > TRtNpcs;
|
|
typedef std::map<TAIAlias, NLMISC::CSmartPtr<R2::CRtGrp> > TRtGrps;
|
|
typedef std::vector<CRtUserTrigger> TRtUserTriggers;
|
|
typedef uint32 TEggId;
|
|
typedef std::string TFullGrpName;
|
|
typedef std::map<TEggId, TFullGrpName> TActiveEasterEggs;
|
|
|
|
public:
|
|
R2::CRtGrp* getRtGrpByName(const std::string& name) const;
|
|
void addUserTrigger(const CRtUserTrigger& userTrigger);
|
|
bool activateEasterEgg(uint32 easterEggId, const std::string & grpControler)
|
|
{
|
|
|
|
|
|
TRtGrps::const_iterator first(RtGrps.begin()), last(RtGrps.end());
|
|
for ( ; first != last && first->second->FullName != grpControler ; ++first) { }
|
|
|
|
if ( first == last)
|
|
{
|
|
nlwarning("SAM: Error while activating easter egg. The controler grp is not valid.");
|
|
return false;
|
|
}
|
|
return ActiveEasterEggs.insert(std::make_pair(easterEggId, grpControler)).second;
|
|
}
|
|
bool deactivateEasterEgg(uint32 easterEggId);
|
|
|
|
public:
|
|
TRtNpcs RtNpcs;
|
|
TRtGrps RtGrps;
|
|
uint16 WeatherValue; // 0 for auto weather
|
|
//uint8 Season; // 0 for auto season
|
|
uint32 LocationId;
|
|
std::string Name;
|
|
TRtUserTriggers UserTriggers;
|
|
TActiveEasterEggs ActiveEasterEggs;
|
|
std::string ActDescription;
|
|
std::string PreActDescription;
|
|
|
|
|
|
|
|
};
|
|
|
|
bool CRtAct::deactivateEasterEgg(uint32 easterEggId)
|
|
{
|
|
TActiveEasterEggs::iterator found(ActiveEasterEggs.find(easterEggId));
|
|
if (found == ActiveEasterEggs.end()) return false;
|
|
ActiveEasterEggs.erase(found);
|
|
return true;
|
|
}
|
|
|
|
|
|
R2::CRtGrp* CRtAct::getRtGrpByName(const std::string& name) const
|
|
{
|
|
TRtGrps::const_iterator first(RtGrps.begin()), last(RtGrps.end());
|
|
for ( ; first != last ; ++first)
|
|
{
|
|
CObject* object = first->second->ObjectData;
|
|
if ( object && object->isString("Id") )
|
|
{
|
|
std::string data = object->toString("Id");
|
|
if (data == name) { return first->second; }
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void CRtAct::addUserTrigger(const CRtUserTrigger& userTrigger)
|
|
{
|
|
|
|
CRtGrp * rtGrp = getRtGrpByName(userTrigger.Grp);
|
|
if (rtGrp)
|
|
{
|
|
UserTriggers.push_back(userTrigger);
|
|
UserTriggers.back().FullName = rtGrp->FullName;
|
|
}
|
|
else
|
|
{
|
|
nlwarning("Try to create undef user trigger '%s'", userTrigger.Grp.c_str());
|
|
}
|
|
}
|
|
|
|
class CRtLocation
|
|
{
|
|
public:
|
|
uint8 Season;
|
|
std::string Island;
|
|
std::string EntryPoint;
|
|
};
|
|
|
|
|
|
class CBotControler
|
|
{
|
|
public:
|
|
typedef NLMISC::CTwinMap< uint32, NLMISC::CEntityId > TControlledEntities;
|
|
typedef std::map <uint32, TControlledEntities > TControlledEntitiesList; //
|
|
|
|
public:
|
|
CBotControler(){}
|
|
|
|
bool add(const NLMISC::CEntityId& eid, const NLMISC::CEntityId& creatureId);
|
|
|
|
bool remove(const NLMISC::CEntityId& eid, const NLMISC::CEntityId& creatureId);
|
|
|
|
NLMISC::CEntityId getEntity(const NLMISC::CEntityId& eid, uint32 id) const;
|
|
|
|
void getBots(const NLMISC::CEntityId& eid, std::map<uint32, NLMISC::CEntityId>& bots);
|
|
void getBots(uint32 playerId, std::map<uint32, NLMISC::CEntityId>& bots);
|
|
|
|
void removeChar(const NLMISC::CEntityId& eid);
|
|
|
|
uint32 getBotsCount(uint32 charId) const;
|
|
|
|
|
|
private:
|
|
TControlledEntitiesList _List;
|
|
|
|
};
|
|
|
|
void CBotControler::getBots(const NLMISC::CEntityId& eid, std::map<uint32, NLMISC::CEntityId>& bots)
|
|
{
|
|
TCharId charId = static_cast<TCharId>(eid.getShortId());
|
|
getBots(charId, bots);
|
|
|
|
}
|
|
|
|
|
|
void CBotControler::getBots(uint32 charId, std::map<uint32, NLMISC::CEntityId>& bots)
|
|
{
|
|
TControlledEntitiesList::iterator found(_List.find(charId));
|
|
if ( found == _List.end()) { return; }
|
|
const std::map<uint32, NLMISC::CEntityId>& entities =found->second.getAToBMap();
|
|
bots = entities;
|
|
|
|
|
|
}
|
|
|
|
uint32 CBotControler::getBotsCount(uint32 charId) const
|
|
{
|
|
TControlledEntitiesList::const_iterator found(_List.find(charId));
|
|
if ( found == _List.end()) { return 0; }
|
|
const std::map<uint32, NLMISC::CEntityId>& entities =found->second.getAToBMap();
|
|
return (uint32)entities.size();
|
|
}
|
|
|
|
|
|
void CBotControler::removeChar(const NLMISC::CEntityId& eid)
|
|
{
|
|
TCharId charId = static_cast<TCharId>(eid.getShortId());
|
|
TControlledEntitiesList::iterator found(_List.find(charId));
|
|
if ( found != _List.end()) { _List.erase(found); }
|
|
}
|
|
|
|
|
|
bool CBotControler::add(const NLMISC::CEntityId& eid, const NLMISC::CEntityId& creatureId)
|
|
{
|
|
|
|
TCharId charId = static_cast<TCharId>(eid.getShortId());
|
|
TControlledEntitiesList::iterator found = _List.find(charId);
|
|
if (found == _List.end())
|
|
{
|
|
found = _List.insert( std::make_pair(charId, CTwinMap<uint32,NLMISC::CEntityId >() ) ).first;
|
|
}
|
|
TControlledEntities & twin = found->second;
|
|
const uint32* id = twin.getA(creatureId);
|
|
if ( id ) { return false; }
|
|
const std::map<uint32, NLMISC::CEntityId> & entities = twin.getAToBMap();
|
|
uint32 last = 1;
|
|
if (!entities.empty())
|
|
{
|
|
uint32 f = entities.rbegin()->first;
|
|
last += f;
|
|
}
|
|
twin.add(last, creatureId);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
bool CBotControler::remove(const NLMISC::CEntityId& eid, const NLMISC::CEntityId& creatureId)
|
|
{
|
|
TCharId charId = static_cast<TCharId>(eid.getShortId());
|
|
TControlledEntitiesList::iterator found = _List.find(charId);
|
|
if (found == _List.end())
|
|
{
|
|
return false;
|
|
}
|
|
TControlledEntities & twin = found->second;
|
|
const uint32* id = twin.getA(creatureId);
|
|
if ( !id ) { return false; }
|
|
twin.removeWithB(creatureId);
|
|
if (twin.getAToBMap().empty()){ _List.erase(found); }
|
|
return true;
|
|
|
|
}
|
|
|
|
NLMISC::CEntityId CBotControler::getEntity(const NLMISC::CEntityId& eid, uint32 id) const
|
|
{
|
|
TCharId charId = static_cast<TCharId>(eid.getShortId());
|
|
TControlledEntitiesList::const_iterator found = _List.find(charId);
|
|
// As the player disconnected?
|
|
if (found == _List.end()) { return NLMISC::CEntityId(); }
|
|
const NLMISC::CTwinMap<uint32, NLMISC::CEntityId> & twin = found->second;
|
|
const NLMISC::CEntityId * entity = twin.getB(id);
|
|
if (!entity) { return NLMISC::CEntityId(); }
|
|
return *entity;
|
|
}
|
|
|
|
|
|
|
|
struct TCharacterInfo
|
|
{
|
|
public:
|
|
NLMISC::CEntityId TargetId;
|
|
};
|
|
|
|
class CAnimationSession
|
|
{
|
|
public:
|
|
typedef std::vector< NLMISC::CSmartPtr<CRtAct> > TActs;
|
|
typedef std::vector<CRtLocation> TLocations;
|
|
typedef uint32 TActId;
|
|
typedef uint32 TEasterEggId;
|
|
typedef std::map<TEasterEggId, TActId> TActiveEasterEggs;
|
|
typedef uint32 TAiInstance;
|
|
typedef std::map<uint32, TCharacterInfo> TCharacterInfos;
|
|
|
|
public:
|
|
std::auto_ptr<CObject> RtData;
|
|
TScenarioHeaderSerializer ScenarioHeader;
|
|
TSessionId SessionId;
|
|
//vector<userId>
|
|
std::vector<uint32> ConnectedChars;
|
|
std::vector<CPersistentDataRecordRyzomStore> Pdrs;
|
|
TActs Acts;
|
|
|
|
uint32 CurrentAct; //if 0 <=> no act
|
|
uint16 WeatherValue; // current weather in the [1, 1023] range, or 0 for auto weather
|
|
// weather value can come from the scenario description, or may have been changed by an animator
|
|
uint8 CurrSeason; // current season or ~0 for no season set yet
|
|
bool StartingAct; // 1 if a player/ia has schedule a startAct
|
|
uint32 InitialAct; //act at which begin the scenario (1) for animation currentAct for test
|
|
|
|
uint32 ScenarioScore;
|
|
NLMISC::TTime ScenarioTime;
|
|
bool TimingIsFinished;
|
|
|
|
|
|
std::vector<TMissionItem> MissionItems;
|
|
|
|
TLocations Locations;
|
|
TActiveEasterEggs ActiveEasterEggs;
|
|
|
|
CBotControler IncarningBots;
|
|
CBotControler TalkingAsBots;
|
|
TAiInstance AiInstance;
|
|
NLMISC::TTime DateOfLastNewLocation;
|
|
sint32 InitialX;
|
|
sint32 InitialY;
|
|
uint8 InitialSeason;
|
|
std::set<uint32> CharacternValidePosition;
|
|
bool InitialTp;
|
|
TCharacterInfos CharacterInfos;
|
|
|
|
public:
|
|
CAnimationSession()
|
|
{
|
|
WeatherValue = 0; // auto weather
|
|
CurrSeason = std::numeric_limits<uint8>::max();
|
|
StartingAct = false;
|
|
InitialAct = 1;
|
|
AiInstance = std::numeric_limits<uint32>::max(); //wrong value
|
|
DateOfLastNewLocation = 0;
|
|
|
|
InitialX = 0;
|
|
InitialY = 0;
|
|
InitialSeason = 0;
|
|
InitialTp = false;
|
|
|
|
TimingIsFinished = false;
|
|
ScenarioScore = 0;
|
|
}
|
|
|
|
void setStartParams(sint32 x, sint32 y, uint8 season) { InitialX = x; InitialY = y; InitialSeason = season; }
|
|
|
|
void setWeatherValue(uint16 value);
|
|
void setSeason(uint8 value);
|
|
|
|
void sendWeatherValueToChar(uint32 charId, uint16 weatherValue) const;
|
|
|
|
void sendSeasonToChar(uint32 charId, uint8 season) const;
|
|
|
|
uint32 getActCount() const { return (uint32)Pdrs.size(); }
|
|
|
|
void updateUserTriggerDescriptions(TUserTriggerDescriptions& userTriggerDescriptions);
|
|
|
|
void updateActPositionDescriptions(TActPositionDescriptions& actPositionDescriptions);
|
|
|
|
void easterEggLooted(uint32 easterEggId, TSessionId scenarioId);
|
|
|
|
|
|
|
|
};
|
|
|
|
void CAnimationSession::easterEggLooted(uint32 easterEggId, TSessionId /* scenarioId */)
|
|
{
|
|
|
|
TActiveEasterEggs::const_iterator found = ActiveEasterEggs.find(easterEggId);
|
|
DROP_IF(found == ActiveEasterEggs.end(), "Error try to loot an unactive easter egg" ,return);
|
|
uint32 actId = found->second;
|
|
DROP_IF(actId >= Acts.size(), "Error try to loot an unactive easter egg", return);
|
|
CRtAct* rtAct = Acts[actId];
|
|
|
|
CRtAct::TActiveEasterEggs::const_iterator found2 = rtAct->ActiveEasterEggs.find(easterEggId);
|
|
DROP_IF(found2 == rtAct->ActiveEasterEggs.end(), "Error try to loot an unactive easter egg", return);
|
|
std::string fullname = found2->second;
|
|
|
|
CAiWrapper::getInstance().triggerUserTrigger(fullname, 2);
|
|
|
|
|
|
}
|
|
|
|
|
|
void CAnimationSession::setWeatherValue(uint16 weatherValue)
|
|
{
|
|
WeatherValue = weatherValue;
|
|
// update weather on EGS for all players connected to that map
|
|
for (uint k = 0; k < ConnectedChars.size(); ++k)
|
|
{
|
|
sendWeatherValueToChar(ConnectedChars[k], weatherValue);
|
|
}
|
|
}
|
|
|
|
void CAnimationSession::setSeason(uint8 season)
|
|
{
|
|
if (season == CurrSeason) return;
|
|
CurrSeason = season;
|
|
// update season on EGS for all players connected to that map
|
|
for (uint k = 0; k < ConnectedChars.size(); ++k)
|
|
{
|
|
sendSeasonToChar(ConnectedChars[k], season);
|
|
}
|
|
}
|
|
|
|
void CAnimationSession::sendWeatherValueToChar(uint32 charId, uint16 weatherValue) const
|
|
{
|
|
|
|
CMessage msgout("SET_PLAYER_WEATHER");
|
|
msgout.serial(charId);
|
|
uint16 weatherValue16 = (uint16) weatherValue;
|
|
msgout.serial(weatherValue16);
|
|
CUnifiedNetwork::getInstance()->send("EGS", msgout);
|
|
}
|
|
|
|
void CAnimationSession::sendSeasonToChar(uint32 charId, uint8 season) const
|
|
{
|
|
|
|
CMessage msgout("SET_PLAYER_SEASON");
|
|
msgout.serial(charId);
|
|
msgout.serial(season);
|
|
CUnifiedNetwork::getInstance()->send("EGS", msgout);
|
|
}
|
|
|
|
void CAnimationSession::updateUserTriggerDescriptions(TUserTriggerDescriptions& userTriggerDescriptions)
|
|
{
|
|
userTriggerDescriptions.clear();
|
|
|
|
//Act0 trigger
|
|
uint32 actIndex = 0;
|
|
uint32 actCount = (uint32)Acts.size();
|
|
for ( ; actIndex != actCount; ++actIndex)
|
|
{
|
|
CRtAct* act = Acts[actIndex];
|
|
uint32 userTriggerCount = (uint32)act->UserTriggers.size();
|
|
uint32 index = 0;
|
|
for ( ; index != userTriggerCount; ++index)
|
|
{
|
|
TUserTriggerDescription userTriggerDescription;
|
|
userTriggerDescription.Name = act->UserTriggers[index].Name;
|
|
userTriggerDescription.Act = actIndex;
|
|
userTriggerDescription.Id = index;
|
|
userTriggerDescriptions.push_back(userTriggerDescription);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void CAnimationSession::updateActPositionDescriptions(TActPositionDescriptions& actPositionDescriptions)
|
|
{
|
|
actPositionDescriptions.clear();
|
|
|
|
uint32 actIndex = 0;
|
|
uint32 actCount = (uint32)Acts.size();
|
|
for ( ; actIndex != actCount; ++actIndex)
|
|
{
|
|
CRtAct* act = Acts[actIndex];
|
|
TActPositionDescription actPositionDescription;
|
|
if ( act->LocationId <= this->Locations.size())
|
|
{
|
|
actPositionDescription.Name = act->Name;
|
|
actPositionDescription.Season = this->Locations[act->LocationId ].Season;
|
|
actPositionDescription.Island = this->Locations[ act->LocationId].Island;
|
|
actPositionDescription.LocationId = act->LocationId;
|
|
}
|
|
else
|
|
{
|
|
actPositionDescription.Name = act->Name;
|
|
actPositionDescription.Season = 0;
|
|
actPositionDescription.Island = "";
|
|
actPositionDescription.LocationId = 0;
|
|
}
|
|
actPositionDescriptions.push_back(actPositionDescription);
|
|
}
|
|
}
|
|
|
|
|
|
class CAttributeToProperty
|
|
{
|
|
public:
|
|
CAttributeToProperty(CObject* object, IPrimitive* prim)
|
|
{
|
|
_Object = object;
|
|
_Primitive = prim;
|
|
}
|
|
|
|
void setAttributeAsString(const std::string & attrName, const std::string& propName)
|
|
{
|
|
CObject* attr = _Object->getAttr(attrName);
|
|
if (attr && attr->isString())
|
|
{
|
|
std::string str = attr->toString();
|
|
_Primitive->addPropertyByName(propName.c_str(), new CPropertyString(str));
|
|
}
|
|
}
|
|
|
|
void setAttributeAsStringWithPrefix(const std::string & attrName, const std::string& propName, const std::string& prefix)
|
|
{
|
|
CObject* attr = _Object->getAttr(attrName);
|
|
if (attr && attr->isString())
|
|
{
|
|
std::string str = attr->toString();
|
|
_Primitive->addPropertyByName(propName.c_str(), new CPropertyString(prefix+str));
|
|
}
|
|
}
|
|
|
|
|
|
void setAiStateName( const std::string& prefix);
|
|
|
|
void setAttributeAsStringArray(const std::string & attrName, const std::string& propName);
|
|
|
|
void setAttributeAsStringArrayWithPrefix(const std::string & attrName, const std::string& propName, const std::string& prefix)
|
|
{
|
|
CObject* attr = _Object->getAttr(attrName);
|
|
if (attr && attr->isString())
|
|
{
|
|
string str = attr->toString();
|
|
vector<string> result;
|
|
NLMISC::splitString(str, "\n", result);
|
|
|
|
uint32 first = 0, last = (uint32)result.size();
|
|
for ( ; first != last ; ++first)
|
|
{
|
|
result[first] = prefix + result[first] ;
|
|
}
|
|
|
|
_Primitive->addPropertyByName(propName.c_str(), new CPropertyStringArray(result));
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void setAttributeAsBool(const std::string & attrName, const std::string& propName)
|
|
{
|
|
CObject* attr = _Object->getAttr(attrName);
|
|
if (attr && attr->isNumber())
|
|
{
|
|
sint value = static_cast<sint>(attr->toNumber());
|
|
_Primitive->addPropertyByName(propName.c_str(), new CPropertyString(value?"true":"false"));
|
|
}
|
|
}
|
|
|
|
void setPrimPoint()
|
|
{
|
|
CObject* attr = 0;
|
|
CPrimPoint* point = dynamic_cast<CPrimPoint*>(_Primitive);
|
|
|
|
nlassert(point);
|
|
CObject* pt = _Object->getAttr("Pt");
|
|
if (pt)
|
|
{
|
|
attr = pt->getAttr("x");
|
|
if (attr && attr->isNumber()) { point->Point.x = static_cast<float>(attr->toNumber()); }
|
|
|
|
attr = pt->getAttr("y");
|
|
if (attr && attr->isNumber()) { point->Point.y = static_cast<float>(attr->toNumber()); }
|
|
|
|
attr = pt->getAttr("z");
|
|
if (attr && attr->isNumber()) { point->Point.z = static_cast<float>(0.0); }
|
|
}
|
|
|
|
attr = _Object->getAttr("Angle");
|
|
if (attr && attr->isNumber()) { point->Angle = static_cast<float>(attr->toNumber()); }
|
|
}
|
|
|
|
void setPrimPath();
|
|
void setPrimZone();
|
|
|
|
private:
|
|
CObject* _Object;
|
|
IPrimitive* _Primitive;
|
|
};
|
|
|
|
|
|
void CAttributeToProperty::setAttributeAsStringArray(const std::string & attrName, const std::string& propName)
|
|
{
|
|
CObject* attr = _Object->getAttr(attrName);
|
|
if (attr && attr->isString())
|
|
{
|
|
string str = attr->toString();
|
|
vector<string> result;
|
|
NLMISC::splitString(str, "\n", result);
|
|
_Primitive->addPropertyByName(propName.c_str(), new CPropertyStringArray(result));
|
|
}
|
|
}
|
|
|
|
|
|
void CAttributeToProperty::setAiStateName(const std::string& prefix)
|
|
{
|
|
std::string ai_movement, ai_activity;
|
|
std::string name;
|
|
|
|
CObject* tmp=_Object->getAttr("Id");
|
|
if( !(tmp&&tmp->isString())&&((name = tmp->toString()).length()!=0))
|
|
{
|
|
nlwarning("R2Ani: invalide rtData");
|
|
return;
|
|
}
|
|
|
|
_Primitive->addPropertyByName("name", new CPropertyString(prefix + name));
|
|
|
|
}
|
|
|
|
|
|
void CAttributeToProperty::setPrimPath()
|
|
{
|
|
CObject* attr = 0;
|
|
CPrimPath* points = dynamic_cast<CPrimPath*>(_Primitive);
|
|
nlassert(points);
|
|
CObject* pts = _Object->getAttr("Pts");
|
|
if (pts)
|
|
{
|
|
|
|
uint32 first(0), last( pts->getSize() );
|
|
points->VPoints.resize(last);
|
|
for ( ; first != last ; ++first )
|
|
{
|
|
CObject* pt = pts->getValue(first);
|
|
|
|
attr = pt->getAttr("x");
|
|
if (attr && attr->isNumber()) { points->VPoints[first].x = static_cast<float>(attr->toNumber()); }
|
|
|
|
attr = pt->getAttr("y");
|
|
if (attr && attr->isNumber()) { points->VPoints[first].y = static_cast<float>(attr->toNumber()); }
|
|
|
|
attr = pt->getAttr("z");
|
|
if (attr && attr->isNumber()) { points->VPoints[first].z = static_cast<float>(attr->toNumber()); }
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
|
|
void CAttributeToProperty::setPrimZone()
|
|
{
|
|
CObject* attr = 0;
|
|
CPrimZone* points = dynamic_cast<CPrimZone*>(_Primitive);
|
|
nlassert(points);
|
|
CObject* pts = _Object->getAttr("Pts");
|
|
if (pts)
|
|
{
|
|
|
|
uint32 first(0), last( pts->getSize() );
|
|
points->VPoints.resize(last);
|
|
for ( ; first != last ; ++first )
|
|
{
|
|
CObject* pt = pts->getValue(first);
|
|
|
|
attr = pt->getAttr("x");
|
|
if (attr && attr->isNumber()) { points->VPoints[first].x = static_cast<float>(attr->toNumber()); }
|
|
|
|
attr = pt->getAttr("y");
|
|
if (attr && attr->isNumber()) { points->VPoints[first].y = static_cast<float>(attr->toNumber()); }
|
|
|
|
attr = pt->getAttr("z");
|
|
if (attr && attr->isNumber()) { points->VPoints[first].z = static_cast<float>(attr->toNumber()); }
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------
|
|
|
|
class CTaskStopTest : public CTask<NLMISC::TTime>
|
|
{
|
|
public:
|
|
CTaskStopTest(CServerAnimationModule* animationModule, TSessionId sessionId)
|
|
:_AnimationModule(animationModule), _SessionId(sessionId) { }
|
|
|
|
void doOperation()
|
|
{
|
|
uint32 unused;
|
|
_AnimationModule->stopTestImpl(_SessionId, unused);
|
|
}
|
|
|
|
private:
|
|
CServerAnimationModule* _AnimationModule;
|
|
TSessionId _SessionId;
|
|
|
|
};
|
|
|
|
class CTaskBroadcast : public CTask<NLMISC::TTime>
|
|
{
|
|
public:
|
|
// Take ownership of the message
|
|
CTaskBroadcast(CServerAnimationModule* animationModule, TSessionId sessionId, CMessage& msg)
|
|
:_AnimationModule(animationModule), _SessionId(sessionId) { _Msg.swap(msg); }
|
|
|
|
void doOperation()
|
|
{
|
|
_AnimationModule->broadcastMsg(_SessionId, _Msg);
|
|
|
|
}
|
|
|
|
private:
|
|
CServerAnimationModule* _AnimationModule;
|
|
TSessionId _SessionId;
|
|
CMessage _Msg;
|
|
|
|
};
|
|
|
|
|
|
class CTaskStartAct : public CTask<NLMISC::TTime>
|
|
{
|
|
public:
|
|
CTaskStartAct(NLMISC::TTime t, CServerAnimationModule* animationModule, TSessionId sessionId, uint32 actId, bool mustTp)
|
|
: CTask<NLMISC::TTime>(t),
|
|
_AnimationModule(animationModule),
|
|
_SessionId(sessionId),_ActId(actId), _MustTp(mustTp){}
|
|
void doOperation()
|
|
{
|
|
CAnimationSession* session = _AnimationModule->getSession(_SessionId);
|
|
if (session && session->StartingAct)
|
|
{
|
|
session->StartingAct = false;
|
|
_AnimationModule->startAct(_SessionId, _ActId);
|
|
if (_MustTp)
|
|
{
|
|
session->DateOfLastNewLocation = NLMISC::CTime::getLocalTime ();
|
|
session->CharacternValidePosition.clear(); // we invalidate all player;
|
|
std::vector<uint32>::const_iterator first(session->ConnectedChars.begin()), last(session->ConnectedChars.end());
|
|
for ( ; first != last ; ++first)
|
|
{
|
|
session->CharacternValidePosition.insert(*first);
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
private:
|
|
CServerAnimationModule* _AnimationModule;
|
|
TSessionId _SessionId;
|
|
uint32 _ActId;
|
|
bool _MustTp;
|
|
|
|
};
|
|
|
|
|
|
class CTaskScheduleStartSession: public CTask<NLMISC::TTime>
|
|
{
|
|
public:
|
|
CTaskScheduleStartSession( CServerAnimationModule* animationModule, const CAnimationMessageAnimationStart& msg)
|
|
:_AnimationModule(animationModule), _Msg(msg)
|
|
{}
|
|
|
|
void doOperation()
|
|
{
|
|
_AnimationModule->scheduleStartSessionImpl(_Msg);
|
|
}
|
|
private:
|
|
CServerAnimationModule* _AnimationModule;
|
|
CAnimationMessageAnimationStart _Msg;
|
|
|
|
};
|
|
|
|
//--------------------------------------------------------------------------------------------
|
|
|
|
|
|
void CServerAnimationModule::broadcastMessage(CAnimationSession* session, const NLNET::CMessage& msg)
|
|
{
|
|
if (!session->ConnectedChars.empty())
|
|
{
|
|
std::vector<uint32>::const_iterator first(session->ConnectedChars.begin()), last(session->ConnectedChars.end());
|
|
for ( ; first != last ; ++first)
|
|
{
|
|
const NLNET::TModuleProxyPtr* ptr = getEditionModule()->getClientProxyPtr(*first);
|
|
if (ptr)
|
|
{
|
|
(*ptr)->sendModuleMessage(this, msg);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void CServerAnimationModule::scheduleStartAct(TSessionId sessionId, uint32 actId)
|
|
{
|
|
CAnimationSession* session = getSession(sessionId);
|
|
if (session)
|
|
{
|
|
CMessage msg;
|
|
if (!session->StartingAct)
|
|
{
|
|
|
|
if (0<actId && actId < session->getActCount() )
|
|
{
|
|
session->StartingAct = true;
|
|
|
|
uint32 currentAct = session->CurrentAct;
|
|
uint32 nextLocationId = session->Acts[actId]->LocationId;
|
|
uint32 currentLoctionId = session->Acts[currentAct]->LocationId;
|
|
|
|
DROP_IF( nextLocationId >= session->Locations.size(), "Invalid Location", return);
|
|
DROP_IF( currentLoctionId >= session->Locations.size(), "Invalid Location", return);
|
|
|
|
|
|
|
|
bool mustTp = nextLocationId != currentLoctionId;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
NLMISC::TTime delay = mustTp
|
|
? 3000 // Tp with jump
|
|
: 1000; // Normal TP
|
|
|
|
if (!session->Acts[actId]->PreActDescription.empty())
|
|
{
|
|
delay = 3000;
|
|
}
|
|
|
|
if (session->InitialTp )
|
|
{
|
|
session->InitialTp = false;
|
|
mustTp = true;
|
|
delay = 0;
|
|
}
|
|
|
|
// if act change in the last 20 second add a wait effect.
|
|
if (session->DateOfLastNewLocation != 0)
|
|
{
|
|
NLMISC::TTime now = CTime::getLocalTime();
|
|
NLMISC::TTime wait = now - session->DateOfLastNewLocation;
|
|
if ( wait < NLMISC::TTime(DelayBeforeNewLocation)*1000)
|
|
{
|
|
delay += NLMISC::TTime(DelayBeforeNewLocation)*1000 - wait;
|
|
}
|
|
|
|
}
|
|
_Tasks.addTask( new CTaskStartAct( NLMISC::CTime::getLocalTime () + delay, this, sessionId, actId, mustTp));
|
|
if (mustTp)
|
|
{
|
|
broadcastMessage(session, CShareClientEditionItfProxy::buildMessageFor_scheduleStartAct(msg, 0, actId, uint32(delay/1000)) );
|
|
}
|
|
|
|
if (!session->Acts[actId]->PreActDescription.empty())
|
|
{
|
|
NLNET::CMessage msg;
|
|
CShareClientEditionItfProxy::buildMessageFor_systemMsg(msg, "BC_ML", "", session->Acts[actId]->PreActDescription);
|
|
_Tasks.addTaskAt(NLMISC::CTime::getLocalTime () + delay - 3000 , new CTaskBroadcast(this, sessionId, msg));
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
broadcastMessage(session, CShareClientEditionItfProxy::buildMessageFor_scheduleStartAct(msg, 2, actId, DelayBeforeStartAct) );
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
broadcastMessage(session, CShareClientEditionItfProxy::buildMessageFor_scheduleStartAct(msg, 1, actId, DelayBeforeStartAct) );
|
|
}
|
|
}
|
|
}
|
|
|
|
void CServerAnimationModule::init(NLNET::IModuleSocket* gateway, CDynamicMapService* server)
|
|
{
|
|
_Server = server;
|
|
|
|
CAiWrapper::getInstance().init( CPrimitiveContext::instance().CurrentLigoConfig);
|
|
this->plugModule(gateway);
|
|
_Emotes.get("");//force lazy initialization
|
|
|
|
// check if the AI service is up
|
|
const std::vector<TServiceId> &connectionList = CUnifiedNetwork::getInstance()->getConnectionList();
|
|
for( uint i = (uint)connectionList.size(); i > 0; --i )
|
|
{
|
|
nldebug( "R2An: %s is already up", CUnifiedNetwork::getInstance()->getServiceName(connectionList[i-1]).c_str() );
|
|
if( "AIS" == CUnifiedNetwork::getInstance()->getServiceName(connectionList[i-1]) )
|
|
{
|
|
_ReadyForNextSession = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
CServerAnimationModule::CServerAnimationModule() :
|
|
_ReadyForNextSession( false )
|
|
{
|
|
CServerAnimationItfSkel::init(this);
|
|
CShareServerAnimationItfSkel::init(this);
|
|
_Server = 0;
|
|
}
|
|
|
|
CServerAnimationModule::~CServerAnimationModule()
|
|
{
|
|
while( !_QueuedSessions.empty() )
|
|
{
|
|
CAnimationSession *animSession = _QueuedSessions.front();
|
|
_QueuedSessions.pop_front();
|
|
delete animSession;
|
|
}
|
|
}
|
|
|
|
|
|
IPrimitive* CServerAnimationModule::getAction(CObject* action, const std::string& prefix,TSessionId scenarioId)
|
|
{
|
|
if (!action)
|
|
{
|
|
nlwarning("Error while generating primitives in scenario '%u'", scenarioId.asInt());
|
|
return 0;
|
|
}
|
|
IPrimitive* pAction= dynamic_cast<IPrimitive *> (CClassRegistry::create ("CPrimNode"));
|
|
pAction->addPropertyByName("class", new CPropertyString("npc_event_handler_action"));
|
|
pAction->addPropertyByName("ai_type", new CPropertyString("NPC_EVENT_ACTION")); // AJM
|
|
pAction->addPropertyByName("weight", new CPropertyString("1")); // AJM
|
|
CAttributeToProperty a2pAction(action, pAction);
|
|
a2pAction.setAttributeAsString("Action","action");
|
|
a2pAction.setAttributeAsString("Action","name"); // AJM: default value for name <- action
|
|
CObject* tmp=action->getAttr("Action");
|
|
if(tmp&&tmp->isString()&&tmp->toString()=="npc_say")
|
|
{
|
|
CObject* tmp2 = action->getAttr("Parameters");
|
|
if(tmp2&&tmp2->isString())
|
|
{
|
|
NLMISC::CSString param (tmp2->toString());
|
|
NLMISC::CVectorSString result;
|
|
|
|
if(param.splitLines(result) )
|
|
{
|
|
if (result.size() == 0)
|
|
{
|
|
nlwarning("ERROR: npc_say but no parameters !!! %d in session ", scenarioId.asInt());
|
|
}
|
|
|
|
if(result.size()>=1)
|
|
{
|
|
NLMISC::CSString name(result[0]);
|
|
if(name.find(":",0)!=string::npos)
|
|
{
|
|
result[0] = prefix+result[0];
|
|
}
|
|
}
|
|
|
|
if(result.size()>=2)
|
|
result[1] = "DSS_"+toString(scenarioId)+" "+result[1];
|
|
if(result.size()>=3)
|
|
{
|
|
for(uint32 i=2;i<result.size();++i)
|
|
{
|
|
result[i] = prefix + result[i];
|
|
}
|
|
}
|
|
pAction->addPropertyByName("parameters", new CPropertyStringArray( (std::vector<std::string> &)result ));
|
|
}
|
|
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (!action->isString("Action") )
|
|
{
|
|
nlwarning("Invalid rtData: no action found");
|
|
return 0;
|
|
}
|
|
CSString caction(action->toString("Action"));
|
|
if (caction == "begin_state" || caction.left(14)=="trigger_event_" || caction == "facing")
|
|
{
|
|
a2pAction.setAttributeAsStringArrayWithPrefix("Parameters","parameters", prefix);
|
|
}
|
|
else if (caction == "emot")
|
|
{
|
|
std::string attrName("Parameters"), propName("parameters");
|
|
|
|
CObject* attr = action->getAttr(attrName);
|
|
if (attr && attr->isString())
|
|
{
|
|
string str = attr->toString();
|
|
vector<string> result;
|
|
NLMISC::splitString(str, "\n", result);
|
|
|
|
uint32 first = 0, last = (uint32)result.size();
|
|
for ( ; first != last ; ++first)
|
|
{
|
|
if (first == 0)
|
|
{
|
|
result[first] = _Emotes.get(result[first]);
|
|
}
|
|
else
|
|
{
|
|
result[first] = prefix + result[first] ;
|
|
}
|
|
}
|
|
|
|
pAction->addPropertyByName(propName.c_str(), new CPropertyStringArray(result));
|
|
}
|
|
|
|
}
|
|
else if(caction == "modify_variable" || caction=="condition_if" || caction=="condition_if_else" || caction == "dynamic_if")
|
|
{
|
|
CSString str = action->toString("Parameters");
|
|
if(str.find(":")!=string::npos)
|
|
{
|
|
a2pAction.setAttributeAsStringArrayWithPrefix("Parameters","parameters", prefix);
|
|
}
|
|
else
|
|
{
|
|
|
|
a2pAction.setAttributeAsStringArray("Parameters","parameters");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
a2pAction.setAttributeAsStringArray("Parameters","parameters");
|
|
}
|
|
}
|
|
|
|
|
|
CObject* weight = action->getAttr("Weight");
|
|
if(weight)
|
|
{
|
|
uint32 w = (int)weight->toNumber();
|
|
std::string weightStr = toString(w);
|
|
pAction->addPropertyByName("Weight", new CPropertyString(weightStr));
|
|
}
|
|
|
|
|
|
CObject* children= action->getAttr("Children");
|
|
uint32 nb =children->getSize();
|
|
for(uint32 i=0;i<nb;++i)
|
|
{
|
|
IPrimitive* tmp=getAction(children->getValue(i), prefix,scenarioId);
|
|
if (!tmp)
|
|
{
|
|
nlwarning("Error in action %s nb: %u", action->toString("Name").c_str(), i);
|
|
return 0;
|
|
}
|
|
pAction->insertChild(tmp);
|
|
}
|
|
|
|
return pAction;
|
|
}
|
|
|
|
bool CServerAnimationModule::queueSession(CAnimationSession* session, bool /* runTest */)
|
|
{
|
|
// write scenario rtdata to a file for debugging
|
|
try
|
|
{
|
|
if( WriteScenarioDebugDataToFile )
|
|
{
|
|
// binary
|
|
COFile output;
|
|
output.open("outpout.rt.bin");
|
|
CObjectSerializerServer serializer( session->RtData.get());
|
|
serializer.serial(output);
|
|
output.flush();
|
|
output.close();
|
|
}
|
|
|
|
if( WriteScenarioDebugDataToFile )
|
|
{
|
|
// text
|
|
COFile output;
|
|
//std::stringstream ss;
|
|
std::string ss;
|
|
output.open("outpout.rt");
|
|
session->RtData->serialize(ss);
|
|
output.serialBuffer((uint8*)ss.c_str(), (uint)ss.size());
|
|
output.flush();
|
|
output.close();
|
|
}
|
|
}
|
|
catch (const std::exception& e )
|
|
{
|
|
nlwarning("Exception while writing debug files %s", e.what() );
|
|
}
|
|
catch(...)
|
|
{
|
|
nlwarning("Undefined Exception while writing debug files");
|
|
}
|
|
|
|
|
|
{
|
|
requestLoadTable(session);
|
|
}
|
|
//std::vector<CPersistentDataRecord> pdrs;
|
|
session->Pdrs.clear();
|
|
|
|
|
|
if (!makeAnimationSession(session, true))
|
|
{
|
|
|
|
nlwarning("R2An: Invalid Session");
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
void CServerAnimationModule::startTest(TSessionId sessionId, CPersistentDataRecord& pdr)
|
|
{
|
|
|
|
CAnimationSession* session = getSession(sessionId);
|
|
if (!session) { return ; }
|
|
uint32 aiInstance = session->AiInstance;
|
|
|
|
nlinfo( "R2An: startTest for sessionId %u in ai instance %u", sessionId.asInt(), aiInstance );
|
|
|
|
|
|
if (! _CharacterControlProxy.isNull() )
|
|
{
|
|
CCharacterControlItfProxy proxy(_CharacterControlProxy);
|
|
proxy.sendItemDescription(this, sessionId, session->MissionItems);
|
|
}
|
|
if (_IOSRingProxy != NULL)
|
|
{
|
|
CIOSRingItfProxy proxy(_IOSRingProxy);
|
|
vector<TCharMappedInfo> itemInfos;
|
|
for (uint i=0; i<session->MissionItems.size(); ++i)
|
|
{
|
|
R2::TCharMappedInfo itemInfo;
|
|
itemInfo.setItemSheet(session->MissionItems[i].SheetId);
|
|
itemInfo.setName(session->MissionItems[i].Name);
|
|
itemInfos.push_back(itemInfo);
|
|
}
|
|
proxy.storeItemNamesForAIInstance(this, aiInstance, itemInfos);
|
|
}
|
|
//Use initial sessionId in case of linked session
|
|
CAiWrapper::getInstance().startTest(session->SessionId, aiInstance, pdr);
|
|
}
|
|
|
|
|
|
void CServerAnimationModule::startAct(TSessionId sessionId, uint32 actId)
|
|
{
|
|
nlinfo( "R2An: startAct for sessionId %u", sessionId.asInt() );
|
|
bool isLocal = !_Server->useNetwork();
|
|
|
|
|
|
CAnimationSession* animSession = getSession(sessionId);
|
|
DROP_IF(!animSession, "Invalid Session", return);
|
|
uint32 aiInstance = animSession->AiInstance;
|
|
DROP_IF(actId < 1 || animSession->Pdrs.size() <= actId, "Invalid Act", return);
|
|
|
|
|
|
if ( !isLocal )
|
|
{
|
|
deactivateEasterEggsFromAct(sessionId, actId);
|
|
}
|
|
|
|
|
|
uint32 currentAct = animSession->CurrentAct;
|
|
uint32 nextLocationId = animSession->Acts[actId]->LocationId;
|
|
uint32 currentLoctionId = animSession->Acts[currentAct]->LocationId;
|
|
bool mustTp = nextLocationId != currentLoctionId;
|
|
if (animSession->InitialTp )
|
|
{
|
|
animSession->InitialTp = false;
|
|
mustTp = true;
|
|
}
|
|
animSession->CurrentAct = actId;
|
|
// update entry point
|
|
IServerEditionModule *svEditionModule = _Server->getEditionModule(); // note: in the future the modules could be in two distinct process, thus they would need an interface/proxy communication
|
|
BOMB_IF(!svEditionModule, "Server edition module not found", return); // Can not happend
|
|
|
|
CScenario *scenarioSession = svEditionModule->getScenarioById( sessionId );
|
|
BOMB_IF(!scenarioSession, NLMISC::toString("Scenario Session not found for session %u", sessionId.asInt()) , return);
|
|
CObject* scenario = scenarioSession->getHighLevel();
|
|
|
|
if (!scenario)
|
|
{
|
|
nlwarning("ERROR that previously lead to crash");
|
|
CAnimationSession* session = getSession(sessionId);
|
|
if (session)
|
|
{
|
|
for(uint32 i = 0; i < session->ConnectedChars.size(); ++i)
|
|
{
|
|
nlwarning("Error: connected user %u", session->ConnectedChars[i]);
|
|
}
|
|
}
|
|
|
|
|
|
if ( scenarioSession->getRtData())
|
|
{
|
|
nlwarning("ERROR: The corrupted scenario has RTDATA but no HL.");
|
|
}
|
|
|
|
nlwarning("ERROR: you must check the backup : session_%d_?.r2", sessionId.asInt());
|
|
BOMB( NLMISC::toString("BIG ERROR: Scenario was not found for session %u, it previously lead to dss crash", sessionId.asInt()), return);
|
|
return;
|
|
}
|
|
|
|
|
|
double x, y, orient;
|
|
uint8 season;
|
|
_Server->getAnimationModule()->getPosition( sessionId, x, y, orient, season );
|
|
|
|
CFarPosition entryPoint;
|
|
entryPoint.SessionId = sessionId;
|
|
entryPoint.PosState.X = (sint32)(x*1000.0);
|
|
entryPoint.PosState.Y = (sint32)(y*1000.0);
|
|
entryPoint.PosState.Z = 0; // ??
|
|
entryPoint.PosState.Heading = 0; // ??
|
|
|
|
if (!isLocal)
|
|
{
|
|
if (animSession->WeatherValue != animSession->Acts[actId]->WeatherValue)
|
|
{
|
|
animSession->setWeatherValue(animSession->Acts[actId]->WeatherValue);
|
|
}
|
|
uint32 location = animSession->Acts[actId]->LocationId;
|
|
season = animSession->Locations[ location ].Season;
|
|
animSession->setSeason(season);
|
|
}
|
|
|
|
{
|
|
|
|
NLNET::CMessage msg;
|
|
CShareClientEditionItfProxy::buildMessageFor_scheduleStartAct(msg, 0, actId, 0) ;
|
|
_Tasks.addTaskAt(NLMISC::CTime::getLocalTime () + 3000 , new CTaskBroadcast(this, sessionId, msg));
|
|
}
|
|
|
|
|
|
if (!animSession->Acts[actId]->ActDescription.empty())
|
|
{
|
|
NLNET::CMessage msg;
|
|
CShareClientEditionItfProxy::buildMessageFor_systemMsg(msg, "BC_ML", "", animSession->Acts[actId]->ActDescription);
|
|
_Tasks.addTaskAt(NLMISC::CTime::getLocalTime () + 3000 , new CTaskBroadcast(this, sessionId, msg));
|
|
}
|
|
|
|
// send position to connected users
|
|
CAnimationSession* session = getSession(sessionId);
|
|
BOMB_IF(!session, NLMISC::toString( "Session not found for session %u", sessionId.asInt() ), return);
|
|
for(uint32 i = 0; i < session->ConnectedChars.size(); ++i)
|
|
{
|
|
uint32 charId = session->ConnectedChars[i];
|
|
|
|
const NLNET::TModuleProxyPtr * pUserModuleProxy = getEditionModule()->getClientProxyPtr(charId);
|
|
if (pUserModuleProxy)
|
|
{
|
|
if ( !_CharacterControlProxy.isNull())
|
|
{
|
|
CCharacterControlItfProxy ccip( _CharacterControlProxy );
|
|
ccip.setUserCharActPosition(this, charId, entryPoint, season);
|
|
}
|
|
addPioneer(sessionId, charId);
|
|
if (mustTp)
|
|
{
|
|
getEditionModule()->tpToEntryPoint(*pUserModuleProxy, actId);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
nlinfo("The user %u has quit the animation session %u before its start", charId, sessionId.asInt());
|
|
}
|
|
|
|
|
|
}
|
|
// Use Initial session in case of linked act
|
|
CAiWrapper::getInstance().startAct(session->SessionId, aiInstance, animSession->Pdrs[actId]);
|
|
}
|
|
|
|
void CServerAnimationModule::setWeatherValue(TSessionId sessionId, uint16 weatherValue)
|
|
{
|
|
if (!_Server->useNetwork())
|
|
{
|
|
nlwarning("simulate setWeatherValue : %d", (int) weatherValue);
|
|
return;
|
|
}
|
|
|
|
CAnimationSession *session = getSession(sessionId);
|
|
if (!session)
|
|
{
|
|
nlwarning("R2An: Invalid session %d", sessionId.asInt());
|
|
return;
|
|
}
|
|
if (weatherValue == session->WeatherValue) return;
|
|
session->setWeatherValue(weatherValue);
|
|
}
|
|
|
|
void CServerAnimationModule::setSeasonValue(TSessionId sessionId, uint8 seasonValue)
|
|
{
|
|
if (!_Server->useNetwork())
|
|
{
|
|
nlwarning("simulate setWeatherValue : %d", (int) seasonValue);
|
|
return;
|
|
}
|
|
|
|
CAnimationSession *session = getSession(sessionId);
|
|
if (!session)
|
|
{
|
|
nlwarning("R2An: Invalid session %d", sessionId.asInt());
|
|
return;
|
|
}
|
|
if (seasonValue == session->CurrSeason) return;
|
|
session->setSeason(seasonValue);
|
|
}
|
|
|
|
|
|
|
|
bool CServerAnimationModule::translateActToPrimitive(CInstanceMap& components, CAnimationSession* animSession, CObject* act,
|
|
uint32 actId, NLLIGO::CPrimitives& primDoc)
|
|
{
|
|
H_AUTO( translateActToPrimitive );
|
|
CRtAct* rtAct = new CRtAct();
|
|
|
|
|
|
animSession->Acts[actId] = rtAct;
|
|
|
|
if ( act->isNumber("LocationId")
|
|
&& act->isString("Name")
|
|
&& act->isString("ActDescription")
|
|
&& act->isString("PreActDescription")
|
|
)
|
|
{
|
|
rtAct->Name = act->toString("Name");
|
|
rtAct->ActDescription = act->toString("ActDescription");
|
|
rtAct->PreActDescription = act->toString("PreActDescription");
|
|
rtAct->LocationId = static_cast<uint32>(act->toNumber("LocationId"));
|
|
}
|
|
else
|
|
{
|
|
nlwarning("Error in session '%u' data Corrupted", animSession->SessionId.asInt());
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
nlassert(primDoc.RootNode != NULL);
|
|
primDoc.RootNode->addPropertyByName("class", new CPropertyString("root")); // AJM
|
|
primDoc.RootNode->addPropertyByName("name", new CPropertyString("")); // AJM
|
|
primDoc.RootNode->addPropertyByName("path", new CPropertyString("")); // AJM
|
|
CPrimitiveContext::instance().CurrentPrimitive = &primDoc;
|
|
CLigoConfig* cfg = CPrimitiveContext::instance().CurrentLigoConfig;
|
|
if (cfg)
|
|
{
|
|
CR2LigoConfig * r2Cfg = dynamic_cast<R2::CR2LigoConfig*>(cfg);
|
|
if (r2Cfg)
|
|
{
|
|
CR2LigoConfig::TScenarioType type;
|
|
if (actId == 0) { type = CR2LigoConfig::Base; }
|
|
else { type = CR2LigoConfig::Act; }
|
|
primDoc.setAliasStaticPart( r2Cfg->getStaticAliasMapping(animSession->AiInstance, type));
|
|
}
|
|
}
|
|
|
|
CObject* aiStates = act->getAttr("AiStates");
|
|
uint32 firstAiState = 0;
|
|
uint32 lastAiState = aiStates->getSize();
|
|
std::string managerPrefix = toString("r2.%04d.", animSession->SessionId.asInt());
|
|
std::string prefix = toString("r2_%04d_", animSession->SessionId.asInt());
|
|
|
|
|
|
|
|
|
|
// Content Manager
|
|
IPrimitive *npcManager = 0;
|
|
|
|
{
|
|
IPrimitive *npc_manager = dynamic_cast<IPrimitive *> (CClassRegistry::create ("CPrimZone"));
|
|
npc_manager->addPropertyByName("class", new CPropertyString("npc_manager"));
|
|
std::string managerName = managerPrefix + (actId==0? "base": "act");
|
|
npc_manager->addPropertyByName("name", new CPropertyString(managerName));
|
|
npc_manager->addPropertyByName("ai_type", new CPropertyString("MANAGER")); // AJM
|
|
npc_manager->addPropertyByName("ai_manager_type", new CPropertyString("NPC")); // AJM
|
|
npc_manager->addPropertyByName("trigger_type", new CPropertyString("npc_zone")); // AJM
|
|
primDoc.RootNode->insertChild(npc_manager);
|
|
CPrimAlias *npc_manager_alias = dynamic_cast<CPrimAlias *> (CClassRegistry::create ("CPrimAlias"));
|
|
npc_manager_alias->addPropertyByName("class", new CPropertyString("alias"));
|
|
npc_manager_alias->addPropertyByName("name", new CPropertyString("alias"));
|
|
npc_manager->insertChild(npc_manager_alias);
|
|
npcManager = npc_manager;
|
|
}
|
|
|
|
IPrimitive *zoneTriggerManager = 0;
|
|
// Trigger Manager
|
|
{
|
|
IPrimitive *npc_manager = dynamic_cast<IPrimitive *> (CClassRegistry::create ("CPrimZone"));
|
|
npc_manager->addPropertyByName("class", new CPropertyString("npc_manager"));
|
|
std::string managerName = managerPrefix + (actId==0? "base.zone_trigger": "act.zone_trigger");
|
|
npc_manager->addPropertyByName("name", new CPropertyString(managerName));
|
|
npc_manager->addPropertyByName("ai_type", new CPropertyString("MANAGER")); // AJM
|
|
npc_manager->addPropertyByName("ai_manager_type", new CPropertyString("NPC")); // AJM
|
|
npc_manager->addPropertyByName("trigger_type", new CPropertyString("npc_zone")); // AJM
|
|
primDoc.RootNode->insertChild(npc_manager);
|
|
CPrimAlias *npc_manager_alias = dynamic_cast<CPrimAlias *> (CClassRegistry::create ("CPrimAlias"));
|
|
npc_manager_alias->addPropertyByName("class", new CPropertyString("alias"));
|
|
npc_manager_alias->addPropertyByName("name", new CPropertyString("alias"));
|
|
npc_manager->insertChild(npc_manager_alias);
|
|
zoneTriggerManager = npc_manager;
|
|
}
|
|
|
|
for ( ; firstAiState != lastAiState ; ++firstAiState)
|
|
{
|
|
CObject* aiState = aiStates->getValue(firstAiState);
|
|
|
|
std::string aiMovement = aiState->toString("AiMovement");
|
|
|
|
IPrimitive *state = 0;
|
|
|
|
if (aiMovement == "follow_route")
|
|
{
|
|
state = dynamic_cast<IPrimitive *> (CClassRegistry::create ("CPrimPath"));
|
|
state->addPropertyByName("class", new CPropertyString("npc_route"));
|
|
state->addPropertyByName("ai_type", new CPropertyString("NPC_STATE_ROUTE")); // AJM
|
|
state->addPropertyByName("ai_profile_params", new CPropertyStringArray()); // AJM
|
|
state->addPropertyByName("vertical_pos", new CPropertyString("auto")); // AJM
|
|
}
|
|
else
|
|
{
|
|
state = dynamic_cast<IPrimitive *> (CClassRegistry::create ("CPrimZone"));
|
|
state->addPropertyByName("class", new CPropertyString("npc_zone"));
|
|
state->addPropertyByName("ai_type", new CPropertyString("NPC_STATE_ZONE")); // AJM
|
|
state->addPropertyByName("ai_profile_params", new CPropertyStringArray()); // AJM
|
|
state->addPropertyByName("vertical_pos", new CPropertyString("auto")); // AJM
|
|
state->addPropertyByName("keywords", new CPropertyStringArray()); // AJM
|
|
}
|
|
|
|
CAttributeToProperty a2pAiState(aiState, state);
|
|
|
|
if (aiMovement == "follow_route")
|
|
{
|
|
a2pAiState.setPrimPath();
|
|
}
|
|
else
|
|
{
|
|
a2pAiState.setPrimZone();
|
|
}
|
|
|
|
a2pAiState.setAttributeAsStringWithPrefix("Id", "name", prefix);
|
|
a2pAiState.setAttributeAsString("AiActivity", "ai_activity");
|
|
a2pAiState.setAttributeAsString("AiMovement", "ai_movement");
|
|
a2pAiState.setAttributeAsStringArray("AiProfilesParams", "ai_profiles_params");
|
|
a2pAiState.setAttributeAsStringArray("Keywords", "keywords");
|
|
|
|
bool isTriggerZone = false;
|
|
if ( aiState->isNumber("IsTriggerZone") )
|
|
{
|
|
isTriggerZone = static_cast<uint32>(aiState->toNumber("IsTriggerZone")) == 1;
|
|
}
|
|
if (isTriggerZone)
|
|
{
|
|
zoneTriggerManager->insertChild(state);
|
|
}
|
|
else
|
|
{
|
|
npcManager->insertChild(state);
|
|
|
|
}
|
|
|
|
|
|
CPrimAlias *state_alias = dynamic_cast<CPrimAlias *> (CClassRegistry::create ("CPrimAlias"));
|
|
state_alias->addPropertyByName("class", new CPropertyString("alias"));
|
|
state_alias->addPropertyByName("name", new CPropertyString("alias"));
|
|
state->insertChild(state_alias);
|
|
|
|
CObject* children = aiState->getAttr("Children");
|
|
uint32 firstChild(0), lastChild(children->getSize());
|
|
for ( ; firstChild != lastChild ; ++firstChild)
|
|
{
|
|
CObject* childName = children->getValue(firstChild);
|
|
CObject* component = components.find(childName->toString());
|
|
|
|
|
|
CObject* oName = component->getAttr("Id");
|
|
if (!oName || !oName->isString())
|
|
{
|
|
nlwarning("Error data corrupt: Invalid group");
|
|
return false;
|
|
}
|
|
|
|
std::string fullName = prefix+component->toString("Id");
|
|
|
|
IPrimitive *npc_group = dynamic_cast<IPrimitive *> (CClassRegistry::create ("CPrimNode"));
|
|
npc_group->addPropertyByName("class", new CPropertyString("npc_group"));
|
|
|
|
npc_group->addPropertyByName("name", new CPropertyString(prefix+component->toString("Id")));
|
|
npc_group->addPropertyByName("ai_type", new CPropertyString("GROUP_NPC")); // AJM
|
|
if (component->isNumber("AutoSpawn") && component->toNumber("AutoSpawn")==0)
|
|
{
|
|
npc_group->addPropertyByName("autoSpawn", new CPropertyString("false"));
|
|
}
|
|
else
|
|
{
|
|
npc_group->addPropertyByName("autoSpawn", new CPropertyString("true")); // AJM
|
|
}
|
|
|
|
npc_group->addPropertyByName("grp_keywords", new CPropertyStringArray()); // AJM
|
|
npc_group->addPropertyByName("count", new CPropertyString("0")); // AJM
|
|
npc_group->addPropertyByName("bot_keywords", new CPropertyStringArray()); // AJM
|
|
npc_group->addPropertyByName("bot_equipment", new CPropertyStringArray()); // AJM
|
|
npc_group->addPropertyByName("bot_chat_parameters", new CPropertyStringArray()); // AJM
|
|
npc_group->addPropertyByName("bot_sheet_client", new CPropertyString("")); // AJM
|
|
npc_group->addPropertyByName("bot_vertical_pos", new CPropertyString("auto")); // AJM
|
|
state->insertChild(npc_group);
|
|
|
|
IPrimitive *npc_group_parameters = 0;
|
|
{
|
|
|
|
npc_group_parameters = dynamic_cast<IPrimitive *> (CClassRegistry::create ("CPrimNode"));
|
|
CAttributeToProperty a2p(component, npc_group_parameters);
|
|
|
|
|
|
|
|
npc_group_parameters->addPropertyByName("class", new CPropertyString("npc_group_parameters"));
|
|
npc_group_parameters->addPropertyByName("name", new CPropertyString("parameters"));
|
|
npc_group_parameters->addPropertyByName("ai_type", new CPropertyString("GRP_PARAMETERS")); // AJM
|
|
a2p.setAttributeAsStringArray("AiProfilParams", "ai_profile_params");
|
|
a2p.setAttributeAsStringArray("GrpParameters", "grp_parameters");
|
|
}
|
|
|
|
npc_group->insertChild(npc_group_parameters);
|
|
|
|
CPrimAlias *npc_group_alias = dynamic_cast<CPrimAlias *> (CClassRegistry::create ("CPrimAlias"));
|
|
npc_group_alias->addPropertyByName("class", new CPropertyString("alias"));
|
|
npc_group_alias->addPropertyByName("name", new CPropertyString("alias"));
|
|
npc_group->insertChild(npc_group_alias);
|
|
// nlinfo("R2Anim: Group %u %s", npc_group_alias->getFullAlias(), std::string(prefix+component->toString("Id")).c_str());
|
|
CRtGrp* rtGrp = new CRtGrp(npc_group_alias->getFullAlias(), component, fullName);
|
|
animSession->Acts[actId]->RtGrps[rtGrp->Alias] = rtGrp;
|
|
|
|
CObject* npcChild = component->getAttr("Children");
|
|
uint32 firstNpc(0), lastNpc(npcChild->getSize());
|
|
for ( ; firstNpc != lastNpc ; ++firstNpc)
|
|
{
|
|
CObject* objectNpcId = npcChild->getValue(firstNpc);
|
|
std::string npcId ( objectNpcId->toString() );
|
|
CObject* objectNpc = components.find(npcId);
|
|
|
|
|
|
if (!objectNpc
|
|
|| !objectNpc->isString("Name")
|
|
|| !objectNpc->isString("ChatParameters")
|
|
|| !objectNpc->isString("Keywords")
|
|
|| !objectNpc->isString("SheetClient")
|
|
|| !objectNpc->isString("Sheet")
|
|
)
|
|
{
|
|
nlwarning("Error in session '%u' data Corrupted", animSession->SessionId.asInt());
|
|
return false;
|
|
}
|
|
|
|
CPrimPoint *npc_bot = dynamic_cast<CPrimPoint *> (CClassRegistry::create ("CPrimPoint"));
|
|
|
|
CAttributeToProperty a2p(objectNpc, npc_bot);
|
|
|
|
a2p.setPrimPoint();
|
|
npc_bot->addPropertyByName("class", new CPropertyString("npc_bot"));
|
|
npc_bot->addPropertyByName("ai_type", new CPropertyString("BOT_NPC")); // AJM
|
|
npc_bot->addPropertyByName("vertical_pos", new CPropertyString("auto")); // AJM
|
|
std::string botname = objectNpc->toString("Name");
|
|
if (botname.length()==0)
|
|
{
|
|
//npc_bot->addPropertyByName("name",new CPropertyString(npcId));
|
|
a2p.setAttributeAsStringWithPrefix("Id", "name", prefix);
|
|
}
|
|
else
|
|
{
|
|
a2p.setAttributeAsString("Name", "name");
|
|
}
|
|
a2p.setAttributeAsStringArray("ChatParameters", "chat_parameters");
|
|
a2p.setAttributeAsStringArray("Keywords", "keywords");
|
|
|
|
|
|
std::string sheet_client = objectNpc->toString("SheetClient");
|
|
{
|
|
uint32 len = (uint32)sheet_client.length();
|
|
//9=".creature".length()
|
|
if(len>9)
|
|
{
|
|
std::string right = sheet_client.substr(len-9, 9);
|
|
if(right == ".creature")
|
|
sheet_client = sheet_client.substr(0,len-9);
|
|
}
|
|
}
|
|
|
|
std::string sheet = objectNpc->toString("Sheet");
|
|
{
|
|
|
|
uint32 len = (uint32)sheet.length();
|
|
//9=".creature".length()
|
|
if(len>9)
|
|
{
|
|
std::string right = sheet.substr(len-9, 9);
|
|
if(right == ".creature")
|
|
sheet = sheet.substr(0,len-9);
|
|
}
|
|
}
|
|
|
|
if (UseSheetClientWithLevel)
|
|
{
|
|
static std::string basic="basic_";
|
|
static uint32 basicSize = (uint32)basic.size();
|
|
static std::string female = "_female";
|
|
static uint32 femaleSize = (uint32)female.size();
|
|
static std::string male = "_male";
|
|
static uint32 maleSize = (uint32)male.size();
|
|
|
|
uint32 sheetClientSize = (uint32)sheet_client.size();
|
|
|
|
// Special case of basic_*_female or basic_*_female
|
|
if ( (sheetClientSize > basicSize && sheet_client.substr(0, basicSize) == basic) && !sheet.empty() &&
|
|
(
|
|
(sheetClientSize > femaleSize && sheet_client.substr(sheetClientSize - femaleSize) == female) ||
|
|
(sheetClientSize > maleSize && sheet_client.substr(sheetClientSize - maleSize) == male)
|
|
)
|
|
)
|
|
{
|
|
|
|
std::string::size_type pos = sheet.rfind('_');
|
|
if (pos != std::string::npos)
|
|
{
|
|
|
|
std::string level = sheet.substr(pos);
|
|
if (level.size() == 3
|
|
&& 'a' <= level[1] && level[1] <= 'f'
|
|
&& '1' <= level[2] && level[2] <= '4')
|
|
{
|
|
sheet_client += level;
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
add an SHEET_CLIENT:SheetClient into the equipment if a alterantiv sheet_client is given
|
|
*/
|
|
|
|
if (sheet.empty())
|
|
{
|
|
|
|
a2p.setAttributeAsStringArray("Equipment", "equipment");
|
|
npc_bot->addPropertyByName("sheet_client", new CPropertyString(sheet_client));
|
|
}
|
|
|
|
else
|
|
{
|
|
|
|
|
|
|
|
CObject* attr = objectNpc->getAttr("Equipment");
|
|
if (attr && attr->isString())
|
|
{
|
|
string str = attr->toString();
|
|
vector<string> result;
|
|
NLMISC::splitString(str, "\n", result);
|
|
result.push_back(NLMISC::toString("CLIENT_SHEET:%s", sheet_client.c_str()));
|
|
npc_bot->addPropertyByName("equipment", new CPropertyStringArray(result));
|
|
}
|
|
|
|
npc_bot->addPropertyByName("sheet_client", new CPropertyString(sheet));
|
|
|
|
}
|
|
|
|
a2p.setAttributeAsBool("IsStuck", "is_stuck");
|
|
npc_group->insertChild(npc_bot);
|
|
|
|
CPrimAlias *npc_bot_alias = dynamic_cast<CPrimAlias *> (CClassRegistry::create ("CPrimAlias"));
|
|
npc_bot_alias->addPropertyByName("class", new CPropertyString("alias"));
|
|
npc_bot_alias->addPropertyByName("name", new CPropertyString("alias"));
|
|
npc_bot->insertChild(npc_bot_alias);
|
|
// nlinfo("R2Anim: Bot %u %s", npc_bot_alias->getFullAlias(), std::string(prefix+objectNpc->toString("Id")).c_str());
|
|
uint32 dmProperty = 0;
|
|
if (objectNpc->isNumber("DmProperty"))
|
|
{
|
|
dmProperty = static_cast< uint32 > (objectNpc->toNumber("DmProperty"));
|
|
}
|
|
CRtNpc* rtNpc = new CRtNpc(npc_bot_alias->getFullAlias(), objectNpc, npc_group_alias->getFullAlias(), dmProperty);
|
|
|
|
animSession->Acts[actId]->RtNpcs[rtNpc->Alias] = rtNpc;
|
|
|
|
|
|
}
|
|
}
|
|
}
|
|
CObject* events = act->getAttr("Events");
|
|
uint32 firstEvent=0,lastEvent=0;
|
|
if(events)lastEvent=events->getSize();
|
|
|
|
//for each event
|
|
for(;firstEvent!=lastEvent;++firstEvent)
|
|
{
|
|
//create the primitive event and its associated actions
|
|
IPrimitive* pEvent = getEvent(events->getValue(firstEvent), components, prefix, animSession->SessionId);
|
|
if (!pEvent)
|
|
{
|
|
nlwarning("Error while generating primitive");
|
|
return false;
|
|
}
|
|
//insert the primitive event
|
|
CObject* eventObject = events->getValue(firstEvent);
|
|
|
|
bool isTriggerZone = false;
|
|
if ( eventObject->isNumber("IsTriggerZone") )
|
|
{
|
|
isTriggerZone = static_cast<uint32>(eventObject->toNumber("IsTriggerZone")) == 1;
|
|
}
|
|
if (isTriggerZone)
|
|
{
|
|
zoneTriggerManager->insertChild(pEvent);
|
|
}
|
|
else
|
|
{
|
|
npcManager->insertChild(pEvent);
|
|
}
|
|
|
|
}
|
|
animSession->Acts[actId]->WeatherValue = 0;
|
|
CObject *weatherValue = act->getAttr("WeatherValue");
|
|
if (weatherValue)
|
|
{
|
|
animSession->Acts[actId]->WeatherValue = (uint16) weatherValue->toNumber();
|
|
}
|
|
|
|
|
|
|
|
// nodeId
|
|
{
|
|
|
|
CObject* tree = act->getAttr("UserTriggers");
|
|
if (!tree || !tree->isTable())
|
|
{
|
|
nlwarning("R2An: Data corrupted");
|
|
return false;
|
|
}
|
|
uint32 lastnode = tree->getSize();
|
|
uint32 firstnode = 0;
|
|
for (; firstnode != lastnode; ++firstnode)
|
|
{
|
|
CObject* node = tree->getValue(firstnode);
|
|
if (!node
|
|
|| !node->isTable()
|
|
|| !node->isString("Name")
|
|
|| !node->isString("Grp") )
|
|
{
|
|
nlwarning("R2An: Data corrupted");
|
|
return false;
|
|
}
|
|
|
|
CRtUserTrigger userTrigger;
|
|
userTrigger.Grp = node->toString("Grp");
|
|
userTrigger.Name = node->toString("Name");
|
|
animSession->Acts[actId]->addUserTrigger(userTrigger);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CServerAnimationModule::makeAnimationSession(CAnimationSession* animSession, bool /* runTest */)
|
|
{
|
|
if( !animSession )
|
|
{
|
|
nlwarning("R2An: Null animation session received!");
|
|
return false;
|
|
}
|
|
|
|
// add session to queue
|
|
_QueuedSessions.push_back( animSession );
|
|
if (!_Server->useNetwork())
|
|
{
|
|
_ReadyForNextSession = true;
|
|
}
|
|
|
|
nldebug( "R2An: animation session %u received, %u in queue", animSession->SessionId.asInt(), _QueuedSessions.size() );
|
|
return true;
|
|
}
|
|
|
|
bool CServerAnimationModule::doMakeAnimationSession(CAnimationSession* animSession)
|
|
{
|
|
H_AUTO( makeAnimationSession );
|
|
if (!animSession)
|
|
{
|
|
nlwarning("R2An: No animation session to make");
|
|
return false;
|
|
}
|
|
|
|
|
|
TSessionId sessionId = animSession->SessionId;
|
|
|
|
|
|
bool sessionOk =_Sessions.insert(std::make_pair(sessionId, animSession)).second;
|
|
if (!sessionOk)
|
|
{
|
|
nlwarning("R2An: Can't start test, previous session (%u) not closed and trying to start another one", sessionId.asInt());
|
|
return false;
|
|
}
|
|
|
|
nlinfo("R2An: makeAnimationSession %u", sessionId.asInt());
|
|
std::vector<CPrimitives> primDocs;
|
|
|
|
|
|
CObject* rtScenario = animSession->RtData.get();
|
|
|
|
uint32 aiInstance = animSession->AiInstance;
|
|
|
|
if (!rtScenario)
|
|
{
|
|
nlwarning("R2An: Can't make animation session, no RtScenario");
|
|
return false;
|
|
}
|
|
|
|
// build instance map
|
|
CInstanceMap components("Id");
|
|
components.set(animSession->RtData.get());//default + act courant
|
|
|
|
//Create Plot items
|
|
|
|
CObject* plotItems = rtScenario->getAttr("PlotItems");
|
|
if (!plotItems || !plotItems->isTable())
|
|
{
|
|
nlwarning("R2An: Data corrupted:session '%u'",sessionId.asInt());
|
|
return false;
|
|
}
|
|
|
|
uint32 lastPlotItem = plotItems->getSize();
|
|
uint32 firstPlotItem = 0;
|
|
for (; firstPlotItem != lastPlotItem; ++firstPlotItem)
|
|
{
|
|
CObject* plotItem = plotItems->getValue(firstPlotItem);
|
|
if (!plotItem
|
|
|| !plotItem->isTable()
|
|
|| !plotItem->isNumber("SheetId")
|
|
|| !plotItem->isString("Name")
|
|
|| !plotItem->isString("Description")
|
|
|| !plotItem->isString("Comment")
|
|
)
|
|
{
|
|
nlwarning("R2An: Data corrupted:session '%u'",sessionId.asInt());
|
|
return false;
|
|
}
|
|
|
|
uint32 sheetIdAsInt = static_cast<uint32>(plotItem->toNumber("SheetId"));
|
|
CSheetId plotItemSheetId( sheetIdAsInt );
|
|
|
|
|
|
if ( !CRingAccess::getInstance().isPlotItemSheetId(plotItemSheetId) )
|
|
{
|
|
nlwarning("!!!!!!!!!!!!");
|
|
nlwarning("!!!!!!!!!!!! Someone is trying to hack us?");
|
|
nlwarning("!!!!!!!!!!!!");
|
|
nlwarning("ERROR: a session %u has faked a Plot item sheetId, or new plot items have been added. SheetId='%s' sheetIdAsInt=%u", sessionId.asInt(), plotItemSheetId.toString().c_str(), sheetIdAsInt);
|
|
std::vector<uint32>::const_iterator first(animSession->ConnectedChars.begin()), last(animSession->ConnectedChars.end());
|
|
nlwarning("There is %u connected Chars:", animSession->ConnectedChars.size());
|
|
for ( ; first != last ; ++first)
|
|
{
|
|
nlwarning("CharId = %u UserId(%u)", *first, *first >> 4);
|
|
}
|
|
|
|
nlwarning("!!!!!!!!!!!!");
|
|
nlwarning("!!!!!!!!!!!!");
|
|
return false;
|
|
}
|
|
TMissionItem missionItem;
|
|
missionItem.SheetId = plotItemSheetId;
|
|
missionItem.Name = ucstring::makeFromUtf8( plotItem->toString("Name") );
|
|
missionItem.Description = ucstring::makeFromUtf8( plotItem->toString("Description") );
|
|
missionItem.Comment = ucstring::makeFromUtf8( plotItem->toString("Comment") );
|
|
|
|
animSession->MissionItems.push_back(missionItem);
|
|
}
|
|
|
|
|
|
// LocationId
|
|
{
|
|
|
|
CObject* locations = rtScenario->getAttr("Locations");
|
|
if (!locations || !locations->isTable())
|
|
{
|
|
nlwarning("R2An: Data corrupted");
|
|
return false;
|
|
}
|
|
uint32 lastLocation = locations->getSize();
|
|
uint32 firstLocation = 0;
|
|
for (; firstLocation != lastLocation; ++firstLocation)
|
|
{
|
|
CObject* location = locations->getValue(firstLocation);
|
|
if (!location
|
|
|| !location->isTable()
|
|
|| !location->isNumber("Season")
|
|
|| !location->isString("Island")
|
|
|| !location->isString("EntryPoint")
|
|
|
|
)
|
|
{
|
|
nlwarning("R2An: Data corrupted:session '%u'",sessionId.asInt());
|
|
return false;
|
|
}
|
|
|
|
CRtLocation locationItem;
|
|
locationItem.Season = static_cast<uint8>(location->toNumber("Season"));
|
|
locationItem.Island = location->toString("Island");
|
|
locationItem.EntryPoint = location->toString("EntryPoint");
|
|
animSession->Locations.push_back(locationItem);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//Translate Act to Primitive
|
|
CObject* acts = rtScenario->getAttr("Acts");
|
|
|
|
|
|
uint32 firstAct = 0;
|
|
uint32 lastAct = acts->getSize();
|
|
primDocs.resize(lastAct);
|
|
animSession->Acts.resize(lastAct);
|
|
for (; firstAct != lastAct ; ++firstAct)
|
|
{
|
|
//std::string key = acts->getKey(firstAct);
|
|
CObject* act= acts->getValue(firstAct);
|
|
if (!act)
|
|
{
|
|
nlwarning("R2An: Can't make animation session, invalid RtAct");
|
|
return false;
|
|
}
|
|
|
|
bool ok = translateActToPrimitive(components, animSession, act, firstAct, primDocs[firstAct] ); //TODO
|
|
if (!ok)
|
|
{
|
|
nlwarning("R2An: Data corrupted:session '%u'",sessionId.asInt());
|
|
return false;
|
|
}
|
|
}
|
|
|
|
uint32 first = 0, last = (uint32)primDocs.size();
|
|
animSession->Pdrs.resize(last);
|
|
|
|
|
|
for ( ; first != last; ++first)
|
|
{
|
|
H_AUTO( translatePrimitivesToPdr );
|
|
// translatePrimitivesToPdr;
|
|
//first <=> actId
|
|
CPrimitives *primDoc = &primDocs[first];
|
|
|
|
std::string streamFileName;
|
|
if (first==0)
|
|
{
|
|
streamFileName= toString("r2.%04d.base.primitive", aiInstance);
|
|
}
|
|
else
|
|
{
|
|
streamFileName= toString("r2.%04d.act.primitive", aiInstance);
|
|
}
|
|
|
|
if (WriteScenarioDebugDataToFile) // Debug
|
|
{
|
|
nldebug("writing xml primitive file %s", toString("r2.%04u.act%u.primitive", sessionId.asInt(), first).c_str());
|
|
saveXmlPrimitiveFile(*primDoc, toString("r2.%04u.act%u.primitive", sessionId.asInt(), first)); // save for debug use
|
|
}
|
|
|
|
CAiWrapper::getInstance().primsToPdr(primDoc, streamFileName, animSession->Pdrs[first]);
|
|
|
|
if (WriteScenarioDebugDataToFile) // Debug
|
|
{
|
|
string tmp = toString("r2.%04u.act%u.pdr.xml", sessionId.asInt(), first);
|
|
nldebug( "writing xml pdr file %s", tmp.c_str() );
|
|
animSession->Pdrs[first].writeToTxtFile( tmp.c_str() );
|
|
}
|
|
}
|
|
|
|
// send start_test to the AI service
|
|
startTest(sessionId, animSession->Pdrs.front());
|
|
|
|
|
|
|
|
// Update animator session info
|
|
{
|
|
std::vector<uint32>::const_iterator first(animSession->ConnectedChars.begin()), last(animSession->ConnectedChars.end());
|
|
for ( ; first != last ; ++first)
|
|
{
|
|
|
|
bool inserted = _CharSessions.insert(std::make_pair(*first, sessionId)).second;
|
|
if (!inserted)
|
|
{
|
|
if (_CharSessions[*first] != sessionId)
|
|
{
|
|
TSessionId previousCharSessionId = _CharSessions[*first];
|
|
CAnimationSession* previousSession = getSession( previousCharSessionId );
|
|
BOMB_IF(!previousSession ,"BUG: Failed to get animation session object with id "+NLMISC::toString(previousCharSessionId.asInt()), return false);
|
|
std::vector<uint32> & chars = previousSession->ConnectedChars;
|
|
chars.erase(std::remove(chars.begin(), chars.end(), *first ), chars.end());
|
|
}
|
|
_CharSessions[*first] = sessionId;
|
|
}
|
|
nlinfo("R2An: Char %u is connected to session %u as animator / tester(edition)", *first, sessionId.asInt());
|
|
}
|
|
}
|
|
|
|
// Not linked session. so we need to tp at first start (in order to avoid to be stuck at the
|
|
// entry point of the scenario if the player has not enought ring point
|
|
if (_Server->getEditionModule()->getLinkedSessionId(sessionId) == TSessionId(0)
|
|
&& !_Server->getEditionModule()->isEditingSession(sessionId) )
|
|
{
|
|
animSession->InitialTp = true;
|
|
}
|
|
|
|
animSession->StartingAct = true;
|
|
// start the first act 0.5 second after the creation of AINSTANCE to be sure that setPionerRight is done after the creation of the instance
|
|
_Tasks.addTask( new CTaskStartAct( NLMISC::CTime::getLocalTime () + 500, this, sessionId, animSession->InitialAct, false));
|
|
//startAct(sessionId, animSession->InitialAct);
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool CServerAnimationModule::getConnectedChars(TSessionId sessionId, std::vector<TCharId>& chars) const
|
|
{
|
|
CAnimationSession* previousSession = getSession( sessionId );
|
|
if (!previousSession) { return false;}
|
|
|
|
|
|
chars = previousSession->ConnectedChars;
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
bool CServerAnimationModule::stopTestImpl(TSessionId sessionId, uint32 & lastAct)
|
|
{
|
|
bool useNetwork = _Server->useNetwork();
|
|
|
|
CAnimationSession* session = getSession( sessionId );
|
|
if (!session)
|
|
{
|
|
nlwarning("R2An: Error can not stop a nonexistent animation %u", sessionId.asInt());
|
|
return false;
|
|
}
|
|
uint32 aiInstance = session->AiInstance;
|
|
requestUnloadTable(sessionId);
|
|
requestReleaseChannels(sessionId);
|
|
|
|
if ( !_CharacterControlProxy.isNull())
|
|
{
|
|
CCharacterControlItfProxy proxy(_CharacterControlProxy);
|
|
proxy.scenarioEnded(this, sessionId);
|
|
}
|
|
|
|
if (useNetwork)
|
|
{
|
|
session->setWeatherValue(0); // back to auto-weather
|
|
}
|
|
|
|
// Use initial session id in case of linked act
|
|
CAiWrapper::getInstance().stopTest(session->SessionId, aiInstance);
|
|
|
|
|
|
std::vector<uint32> chars = session->ConnectedChars;
|
|
std::vector<uint32>::iterator first(chars.begin()), last(chars.end());
|
|
for ( ; first != last ; ++first)
|
|
{
|
|
TCharSessions::iterator erased(_CharSessions.find(*first));
|
|
if (erased != _CharSessions.end())
|
|
{
|
|
_CharSessions.erase(erased);
|
|
}
|
|
}
|
|
chars.clear();
|
|
|
|
|
|
TSessions::iterator found = _Sessions.find(sessionId);
|
|
if (found == _Sessions.end())
|
|
{
|
|
TSessionId remappedSession = _Server->getEditionModule()->getLinkedSessionId(sessionId);
|
|
found = _Sessions.find(remappedSession);
|
|
}
|
|
_Sessions.erase( found );
|
|
|
|
lastAct = session->CurrentAct;
|
|
delete session;
|
|
return true;
|
|
}
|
|
|
|
bool CServerAnimationModule::stopTest(TSessionId sessionId, uint32 & lastAct)
|
|
{
|
|
CAnimationSession* session = getSession( sessionId );
|
|
if (!session)
|
|
{
|
|
nlinfo("R2An: trying to stop a nonexistent animation %u (will try later)", sessionId.asInt());
|
|
_Tasks.addTaskAt( NLMISC::CTime::getLocalTime() + 1000, new CTaskStopTest(this, sessionId));
|
|
return false;
|
|
}
|
|
return stopTestImpl(sessionId, lastAct);
|
|
}
|
|
|
|
void CServerAnimationModule::onModuleUpdate()
|
|
{
|
|
H_AUTO(CServerAnimationModule_onModuleUpdate);
|
|
|
|
bool queuedSession = _ReadyForNextSession && !_QueuedSessions.empty();
|
|
|
|
if (queuedSession)
|
|
{
|
|
CAnimationSession *animSession = _QueuedSessions.front();
|
|
_QueuedSessions.pop_front();
|
|
doMakeAnimationSession( animSession );
|
|
nldebug( "R2An: animation session %u processed, %u in queue", animSession->SessionId.asInt(), _QueuedSessions.size() );
|
|
}
|
|
|
|
NLMISC::TTime now = NLMISC::CTime::getLocalTime();
|
|
|
|
_Tasks.execute(now);
|
|
|
|
}
|
|
|
|
void CServerAnimationModule::onModuleUp(NLNET::IModuleProxy *senderModuleProxy)
|
|
{
|
|
std::string moduleName = senderModuleProxy->getModuleClassName();
|
|
// send back a message to the client to open the firewall
|
|
|
|
if ( moduleName == "StringManagerModule")
|
|
{
|
|
_StringManagerProxy = senderModuleProxy;
|
|
nlinfo("StringManagerModule identified!!");
|
|
}
|
|
else if ( moduleName == "CharacterControl")
|
|
{
|
|
_CharacterControlProxy = senderModuleProxy;
|
|
}
|
|
else if ( moduleName == "IOSRingModule")
|
|
{
|
|
_IOSRingProxy= senderModuleProxy;
|
|
}
|
|
}
|
|
|
|
|
|
void CServerAnimationModule::onModuleDown(NLNET::IModuleProxy *senderModuleProxy)
|
|
{
|
|
std::string moduleName = senderModuleProxy->getModuleClassName();
|
|
|
|
if ( moduleName == "StringManagerModule")
|
|
{
|
|
_StringManagerProxy = NULL;
|
|
nlinfo("StringManagerModule disconnected!");
|
|
}
|
|
else if ( moduleName == "CharacterControl")
|
|
{
|
|
_CharacterControlProxy = NULL;
|
|
}
|
|
else if ( moduleName == "ClientEditionModule") // a client has disconnected
|
|
{
|
|
|
|
uint32 charId;
|
|
NLMISC::CEntityId eid;
|
|
std::string userPriv;
|
|
std::string extendedPriv;
|
|
|
|
bool ok = getCharInfo(senderModuleProxy, charId, eid, userPriv, extendedPriv);
|
|
if (!ok) { return ; }
|
|
|
|
TSessionId sessionId = getSessionIdByCharId(charId);
|
|
|
|
{
|
|
CAnimationSession* session = getSession(sessionId);
|
|
if (session)
|
|
{
|
|
std::vector<uint32>& connectChars = session->ConnectedChars;
|
|
std::vector<uint32>::iterator found ( std::find(connectChars.begin(), connectChars.end(), charId) );
|
|
if (found != connectChars.end())
|
|
{
|
|
std::map<uint32, NLMISC::CEntityId> incarningBots;
|
|
std::map<uint32, NLMISC::CEntityId> talkingAsBots;
|
|
|
|
session->IncarningBots.getBots(eid, incarningBots);
|
|
session->TalkingAsBots.getBots(eid, talkingAsBots);
|
|
|
|
{
|
|
std::map<uint32, NLMISC::CEntityId>::const_iterator first(talkingAsBots.begin()), last(talkingAsBots.end());
|
|
for (; first != last; ++first)
|
|
{
|
|
removeTalkingAsPlayer(sessionId, first->second, eid);
|
|
}
|
|
}
|
|
|
|
{
|
|
std::map<uint32, NLMISC::CEntityId>::const_iterator first(incarningBots.begin()), last(incarningBots.end());
|
|
for (; first != last; ++first)
|
|
{
|
|
removeIncarningPlayer(sessionId, first->second, eid);
|
|
}
|
|
}
|
|
connectChars.erase(found);
|
|
|
|
session->IncarningBots.removeChar(eid);
|
|
session->TalkingAsBots.removeChar(eid);
|
|
}
|
|
|
|
{
|
|
TCharSessions::iterator found( _CharSessions.find(charId) );
|
|
if (found != _CharSessions.end()) { sessionId = found->second; _CharSessions.erase(found); }
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (senderModuleProxy == _IOSRingProxy)
|
|
{
|
|
_IOSRingProxy = NULL;
|
|
}
|
|
}
|
|
|
|
|
|
void CServerAnimationModule::stopAct(TSessionId sessionId)
|
|
{
|
|
nlinfo( "R2An: stopAct for sessionId %u", sessionId.asInt() );
|
|
if (!_Server->useNetwork())
|
|
{
|
|
nlwarning("simulate stopAct");
|
|
return;
|
|
}
|
|
|
|
CAnimationSession* session = getSession(sessionId);
|
|
if (!session) return;
|
|
|
|
//nlwarning CurrentAct == 0
|
|
|
|
|
|
deactivateEasterEggsFromAct(sessionId, session->CurrentAct);
|
|
|
|
session->CurrentAct = 0;
|
|
|
|
uint32 aiInstance = session->AiInstance;
|
|
// Use initial session in case of linked act
|
|
CAiWrapper::getInstance().stopAct(session->SessionId, aiInstance);
|
|
|
|
}
|
|
|
|
|
|
bool CServerAnimationModule::getPosition(TSessionId sessionId, double& x, double& y, double& orient, uint8& season, uint32 actIndex)
|
|
{
|
|
CAnimationSession *animSession = getSession( sessionId );
|
|
|
|
if(! animSession) { return false; } // normal case when getStart position while creating scenario
|
|
|
|
uint32 currentAct = animSession->CurrentAct;
|
|
|
|
if (actIndex != 0)
|
|
{
|
|
currentAct = actIndex;
|
|
}
|
|
|
|
if (currentAct == 0) { currentAct = 1; }
|
|
|
|
DROP_IF(currentAct >= animSession->Acts.size(), "Error: invalide act", return false);
|
|
|
|
uint32 locationId = animSession->Acts[currentAct]->LocationId;
|
|
|
|
DROP_IF(locationId >= animSession->Locations.size(), "Error: invalide location", return false);
|
|
|
|
CRtLocation & location = animSession->Locations[locationId];
|
|
|
|
CScenarioEntryPoints& epManager = CScenarioEntryPoints::getInstance();
|
|
|
|
CScenarioEntryPoints::CCompleteIsland * island = epManager.getIslandFromId(location.Island);
|
|
DROP_IF(!island, "No Island.", return false);
|
|
|
|
CScenarioEntryPoints::CShortEntryPoint *entryPoint = epManager.getEntryPointFromIds(location.Island, location.EntryPoint);
|
|
if (!entryPoint)
|
|
{
|
|
entryPoint = epManager.getEntryPointFromIds(location.Island, island->EntryPoints[0].Location); //Evil Hack must be removed
|
|
}
|
|
DROP_IF(!entryPoint, "No EntryPoint.", return false);
|
|
|
|
x = entryPoint->X;
|
|
y = entryPoint->Y;
|
|
orient = 0;
|
|
season = location.Season;
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
void CServerAnimationModule::getStartParams(NLNET::IModuleProxy * /* sender */, uint32 charId, TSessionId lastStoredSessionId)
|
|
{
|
|
_Server->getEditionModule()->getStartParams(charId, lastStoredSessionId);
|
|
}
|
|
|
|
|
|
void CServerAnimationModule::askSetUserCharActPosition( NLNET::IModuleProxy * /* sender */, uint32 charId )
|
|
{
|
|
// get entry point
|
|
double x, y, orient;
|
|
uint8 season;
|
|
|
|
TSessionId sessionId = _Server->getAdminModule()->getSessionIdByCharId(charId );
|
|
bool ok = _Server->getAdminModule()->getPosition( sessionId, x, y, orient, season );
|
|
if (!ok) { return; }
|
|
|
|
CFarPosition entryPoint;
|
|
entryPoint.SessionId = sessionId;
|
|
entryPoint.PosState.X = (sint32)(x*1000.0);
|
|
entryPoint.PosState.Y = (sint32)(y*1000.0);
|
|
entryPoint.PosState.Z = 0; // ??
|
|
entryPoint.PosState.Heading = 0; // ??
|
|
|
|
CCharacterControlItfProxy ccip( _CharacterControlProxy );
|
|
ccip.setUserCharActPosition(this, charId, entryPoint, season);
|
|
}
|
|
|
|
CAnimationSession* CServerAnimationModule::getSession(TSessionId sessionId) const
|
|
{
|
|
if (sessionId.asInt() == 0) { return 0; }
|
|
|
|
TSessions::const_iterator session = _Sessions.find(sessionId);
|
|
if (session == _Sessions.end())
|
|
{
|
|
TSessionId remapped = _Server->getEditionModule()->getLinkedSessionId(sessionId);
|
|
if (remapped.asInt() == 0) { return 0; }
|
|
session = _Sessions.find(remapped);
|
|
}
|
|
|
|
if (session == _Sessions.end()) { return 0; }
|
|
|
|
return session->second;
|
|
}
|
|
|
|
|
|
void CServerAnimationModule::connectAnimationModePlay(NLNET::IModuleProxy* proxy)
|
|
{
|
|
|
|
CShareClientEditionItfProxy client(proxy);
|
|
//getEditionModule()->tpToEntryPoint(proxy, 0);
|
|
client.onAnimationModePlayConnected(this);
|
|
}
|
|
|
|
|
|
|
|
|
|
TSessionId CServerAnimationModule::getSessionIdByCharId(TCharId charId) const
|
|
{
|
|
|
|
TCharSessions::const_iterator charSessionFound( _CharSessions.find(charId) );
|
|
|
|
if (charSessionFound == _CharSessions.end())
|
|
{
|
|
return (TSessionId)0;
|
|
}
|
|
return charSessionFound->second;
|
|
}
|
|
|
|
CAnimationSession* CServerAnimationModule::getSessionByCharId(TCharId charId) const
|
|
{
|
|
if (charId == 0)
|
|
return NULL;
|
|
return getSession(getSessionIdByCharId(charId));
|
|
}
|
|
|
|
void CServerAnimationModule::addPioneer( TSessionId sessionId, TCharId charId)
|
|
{
|
|
CAnimationSession* session = getSession(sessionId);
|
|
if (!session) return;
|
|
bool isLocal = !_Server->useNetwork();
|
|
std::vector<uint32>::const_iterator found(std::find(session->ConnectedChars.begin(), session->ConnectedChars.end(), charId));
|
|
bool added = false;
|
|
if (found == session->ConnectedChars.end())
|
|
{
|
|
session->ConnectedChars.push_back(charId);
|
|
added = true;
|
|
}
|
|
|
|
|
|
// Warning the player can receive an addPioneer Message before it client Module went down
|
|
|
|
{
|
|
bool inserted =_CharSessions.insert(std::make_pair(charId, sessionId)).second;
|
|
if (!inserted)
|
|
{
|
|
// lookup the previous session id and make sure that we have a session for this id
|
|
TSessionId previousCharSessionId = _CharSessions[charId];
|
|
|
|
// disconnect from previous scenario
|
|
if (previousCharSessionId != sessionId)
|
|
{
|
|
|
|
CAnimationSession* previousSession = getSession(previousCharSessionId);
|
|
if (previousSession != session)
|
|
{
|
|
std::vector<uint32> & chars = previousSession->ConnectedChars;
|
|
chars.erase(std::remove(chars.begin(), chars.end(), charId ), chars.end());
|
|
}
|
|
}
|
|
_CharSessions[charId] = sessionId;
|
|
}
|
|
|
|
}
|
|
nlinfo("R2An: Char %u is connected as animator", charId);
|
|
// update weather for that char
|
|
if ( !isLocal )
|
|
{
|
|
session->sendWeatherValueToChar(charId, session->WeatherValue);
|
|
}
|
|
|
|
|
|
const TModuleProxyPtr* clientProxyPtr = getEditionModule()->getClientProxyPtr(charId);
|
|
if (!clientProxyPtr)
|
|
{
|
|
nlwarning("A pioneer has just entered in a session %u but has no proxy %u", sessionId.asInt(), charId);
|
|
return;
|
|
}
|
|
getEditionModule()->updateCharPioneerRight(charId);
|
|
// TODO send this information only if client
|
|
askMissionItemsDescription(*clientProxyPtr);
|
|
askActPositionDescriptions(*clientProxyPtr);
|
|
askUserTriggerDescriptions(*clientProxyPtr);
|
|
askTalkingAsListUpdate(*clientProxyPtr);
|
|
askIncarnatingListUpdate(*clientProxyPtr);
|
|
askUpdateScenarioHeader(*clientProxyPtr);
|
|
|
|
CShareClientEditionItfProxy proxy(*clientProxyPtr);
|
|
proxy.onCurrentActIndexUpdated(this, session->CurrentAct);
|
|
if (session->CharacternValidePosition.find(charId) == session->CharacternValidePosition.end())
|
|
{
|
|
session->CharacternValidePosition.insert(charId);
|
|
}
|
|
|
|
|
|
if (added)
|
|
{
|
|
uint32 actId = session->CurrentAct;
|
|
if (session->Acts.size() > actId && !session->Acts[actId]->ActDescription.empty())
|
|
{
|
|
CShareClientEditionItfProxy proxy(*clientProxyPtr);
|
|
proxy.systemMsg(this, "BC_ML", "", session->Acts[actId]->ActDescription);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void CServerAnimationModule::onDssTarget( IModuleProxy *senderModuleProxy, const std::vector<std::string> & params)
|
|
{
|
|
uint32 charId;
|
|
NLMISC::CEntityId eid;
|
|
std::string userPriv;
|
|
std::string extendedPriv;
|
|
|
|
bool ok = checkSecurityInfo(senderModuleProxy, charId, eid, userPriv, extendedPriv);
|
|
if (!ok) { return ; }
|
|
|
|
DROP_IF(!_CharacterControlProxy, "Try to send message to EGS must he is down", return);
|
|
|
|
CCharacterControlItfProxy proxy(_CharacterControlProxy);
|
|
proxy.sendCharTargetToDss(this, eid, params);
|
|
|
|
}
|
|
|
|
/***
|
|
** Called when the DM stops talking as a NPC or Incarning a NPC.
|
|
**/
|
|
void CServerAnimationModule::stopTalk(const NLMISC::CEntityId &eid, const NLMISC::CEntityId &/* creatureId */,
|
|
TDataSetRow entityRowId)
|
|
{
|
|
TCharId charId = static_cast<TCharId>(eid.getShortId());
|
|
const NLNET::TModuleProxyPtr * foundModule = getEditionModule()->getClientProxyPtr(charId);
|
|
BOMB_IF(foundModule==NULL, "stopTalk failed because getClientProxyPtr() returned NULL for entity "+eid.toString(),return);
|
|
|
|
CAnimationSession* session = getSessionByCharId(charId);
|
|
if (!session) { return; }
|
|
|
|
TModuleId moduleId = (*foundModule)->getModuleProxyId();
|
|
|
|
CMessage msg("stopTalk");
|
|
msg.serial(moduleId);
|
|
msg.serial(entityRowId);
|
|
_StringManagerProxy->sendModuleMessage(this,msg);
|
|
|
|
|
|
}
|
|
|
|
|
|
void CServerAnimationModule::stopIncarn(const NLMISC::CEntityId &eid, const NLMISC::CEntityId &creatureId)
|
|
{
|
|
CAiWrapper::getInstance().stopControlNpc(eid, creatureId);
|
|
}
|
|
|
|
|
|
|
|
CRtNpc* CServerAnimationModule::getNpcByAlias(TSessionId sessionId, TAIAlias alias) const
|
|
{
|
|
CAnimationSession* session = getSession(sessionId);
|
|
if (!session) { return 0; }
|
|
if (session->Acts.empty()) { return 0; }
|
|
|
|
|
|
|
|
{
|
|
CRtAct::TRtNpcs::const_iterator found( session->Acts[0]->RtNpcs.find(alias) );
|
|
if (found != session->Acts[0]->RtNpcs.end())
|
|
{
|
|
return found->second;
|
|
}
|
|
}
|
|
|
|
uint32 currentAct = session->CurrentAct;
|
|
if (currentAct != 0)
|
|
{
|
|
CRtAct::TRtNpcs::const_iterator found( session->Acts[currentAct]->RtNpcs.find(alias) );
|
|
if (found != session->Acts[currentAct]->RtNpcs.end())
|
|
{
|
|
return found->second;
|
|
}
|
|
}
|
|
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
void CServerAnimationModule::stopControlNpcs(TCharId charId)
|
|
{
|
|
const NLNET::TModuleProxyPtr * foundModule = getEditionModule()->getClientProxyPtr(charId);
|
|
if (!foundModule)
|
|
{
|
|
return;
|
|
}
|
|
|
|
NLNET::TModuleProxyPtr clientProxyPtr = *foundModule;
|
|
|
|
NLMISC::CEntityId clientEid;
|
|
std::string userPriv;
|
|
std::string extendedPriv;
|
|
|
|
bool ok = checkSecurityInfo(clientProxyPtr, charId, clientEid, userPriv, extendedPriv);
|
|
if (!ok) { return; }
|
|
|
|
TSessionId sessionId = getSessionIdByCharId(charId);
|
|
CAnimationSession* session = getSession(sessionId);
|
|
if (!session) { return; }
|
|
|
|
|
|
|
|
// Remove Incarn
|
|
{
|
|
|
|
std::map<uint32, NLMISC::CEntityId > entities;
|
|
session->IncarningBots.getBots(charId, entities);
|
|
|
|
|
|
{
|
|
std::map<uint32, NLMISC::CEntityId > ::const_iterator botEid(entities.begin()), last(entities.end());
|
|
for (; botEid != last; ++botEid)
|
|
{
|
|
|
|
if (isIncarnedByPlayer(botEid->second, clientEid))
|
|
{
|
|
removeIncarningPlayer(sessionId, botEid->second, clientEid);
|
|
stopIncarn(clientEid, botEid->second);
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
// Remove Talks as
|
|
{
|
|
|
|
std::map<uint32, NLMISC::CEntityId > entities;
|
|
session->TalkingAsBots.getBots(charId, entities);
|
|
|
|
|
|
{
|
|
std::map<uint32, NLMISC::CEntityId > ::const_iterator botEid(entities.begin()), last(entities.end());
|
|
for (; botEid != last; ++botEid)
|
|
{
|
|
|
|
if (isTalkingAs(botEid->second, clientEid))
|
|
{
|
|
TOwnedEntities::iterator iter = _TalkedAsEntities.find(botEid->second);
|
|
if (iter != _TalkedAsEntities.end())
|
|
{
|
|
stopTalk(clientEid, botEid->second, iter->second.CreatureRowId);
|
|
removeTalkingAsPlayer(sessionId, botEid->second, clientEid);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
void CServerAnimationModule::askUpdateScenarioHeader(NLNET::IModuleProxy *clientProxyPtr)
|
|
{
|
|
|
|
uint32 charId;
|
|
NLMISC::CEntityId clientEid;
|
|
std::string userPriv;
|
|
std::string extendedPriv;
|
|
|
|
bool ok = checkSecurityInfo(clientProxyPtr, charId, clientEid, userPriv, extendedPriv);
|
|
if (!ok) { return; }
|
|
|
|
TSessionId sessionId = getSessionIdByCharId(charId);
|
|
CAnimationSession* session = getSession(sessionId);
|
|
if (!session) { return; }
|
|
|
|
|
|
CShareClientEditionItfProxy proxy(clientProxyPtr);
|
|
proxy.updateScenarioHeader(this, session->ScenarioHeader);
|
|
|
|
}
|
|
|
|
void CServerAnimationModule::askIncarnatingListUpdate(NLNET::IModuleProxy *clientProxyPtr)
|
|
{
|
|
|
|
uint32 charId;
|
|
NLMISC::CEntityId clientEid;
|
|
std::string userPriv;
|
|
std::string extendedPriv;
|
|
|
|
bool ok = checkSecurityInfo(clientProxyPtr, charId, clientEid, userPriv, extendedPriv);
|
|
if (!ok) { return; }
|
|
|
|
TSessionId sessionId = getSessionIdByCharId(charId);
|
|
CAnimationSession* session = getSession(sessionId);
|
|
if (!session) { return; }
|
|
|
|
std::map<uint32, NLMISC::CEntityId > entities;
|
|
session->IncarningBots.getBots(charId, entities);
|
|
std::map<uint32, NLMISC::CEntityId >::const_iterator first(entities.begin()), last(entities.end());
|
|
std::vector<uint32> botsId;
|
|
for (; first!= last ; ++first)
|
|
{
|
|
|
|
TOwnedEntities::iterator found = _IncarnedEntities.find(first->second);
|
|
if (found != _IncarnedEntities.end())
|
|
{
|
|
TAIAlias alias = found->second.CreatatureAlias;
|
|
|
|
CRtNpc* npc = getNpcByAlias(sessionId, alias);
|
|
if (npc)
|
|
{
|
|
botsId.push_back(first->first);
|
|
botsId.push_back(npc->NameId);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
CShareClientEditionItfProxy proxy(clientProxyPtr);
|
|
proxy.updateIncarningList(this, botsId);
|
|
|
|
}
|
|
|
|
void CServerAnimationModule::askTalkingAsListUpdate(NLNET::IModuleProxy *clientProxyPtr)
|
|
{
|
|
uint32 charId;
|
|
NLMISC::CEntityId clientEid;
|
|
std::string userPriv;
|
|
std::string extendedPriv;
|
|
|
|
bool ok = checkSecurityInfo(clientProxyPtr, charId, clientEid, userPriv, extendedPriv);
|
|
if (!ok) { return; }
|
|
|
|
TSessionId sessionId = getSessionIdByCharId(charId);
|
|
CAnimationSession* session = getSession(sessionId);
|
|
if (!session){ return; }
|
|
|
|
std::map<uint32, NLMISC::CEntityId > entities;
|
|
session->TalkingAsBots.getBots(charId, entities);
|
|
std::map<uint32, NLMISC::CEntityId >::const_iterator first(entities.begin()), last(entities.end());
|
|
std::vector<uint32> botsId;
|
|
for (; first!= last ; ++first)
|
|
{
|
|
|
|
TOwnedEntities::iterator found = _TalkedAsEntities.find(first->second);
|
|
if (found != _TalkedAsEntities.end())
|
|
{
|
|
TAIAlias alias = found->second.CreatatureAlias;
|
|
|
|
CRtNpc* npc = getNpcByAlias(sessionId, alias);
|
|
if (npc)
|
|
{
|
|
botsId.push_back(first->first);
|
|
botsId.push_back(npc->NameId);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
CShareClientEditionItfProxy proxy(clientProxyPtr);
|
|
proxy.updateTalkingAsList(this, botsId);
|
|
}
|
|
|
|
void CServerAnimationModule::updateIncarningList(TSessionId /* sessionId */, uint32 charId)
|
|
{
|
|
const NLNET::TModuleProxyPtr * foundModule = getEditionModule()->getClientProxyPtr(charId);
|
|
if (foundModule)
|
|
{
|
|
askIncarnatingListUpdate(*foundModule);
|
|
}
|
|
}
|
|
|
|
|
|
void CServerAnimationModule::updateTalkingAsList(TSessionId /* sessionId */, uint32 charId)
|
|
{
|
|
|
|
const NLNET::TModuleProxyPtr * foundModule = getEditionModule()->getClientProxyPtr(charId);
|
|
if (foundModule)
|
|
{
|
|
askTalkingAsListUpdate(*foundModule);
|
|
}
|
|
}
|
|
|
|
|
|
bool CServerAnimationModule::setIncarningPlayer(TSessionId sessionId, const NLMISC::CEntityId& creatureId, const NLMISC::CEntityId& eid, TDataSetRow entityRowId, TAIAlias alias)
|
|
{
|
|
|
|
bool ok = true;
|
|
CAnimationSession* session = getSession(sessionId);
|
|
if (!session) { return false; }
|
|
ok = session->IncarningBots.add( eid, creatureId);
|
|
if (!ok) { return false; }
|
|
|
|
|
|
TOwnedEntities::iterator iter = _IncarnedEntities.find(creatureId);
|
|
if (iter == _IncarnedEntities.end())
|
|
{
|
|
COwnedCreatureInfo info;
|
|
info.PlayerIds.push_back(eid);
|
|
info.CreatureRowId = entityRowId;
|
|
info.CreatatureAlias = alias;
|
|
_IncarnedEntities[creatureId] = info;
|
|
}
|
|
else
|
|
{
|
|
_IncarnedEntities[creatureId].PlayerIds.push_back(eid);
|
|
}
|
|
|
|
updateIncarningList(sessionId, static_cast<uint32>(eid.getShortId()) );
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
bool CServerAnimationModule::setTalkingAsPlayer(TSessionId sessionId, const NLMISC::CEntityId& creatureId, const NLMISC::CEntityId& eid, TDataSetRow entityRowId, TAIAlias alias)
|
|
{
|
|
bool ok = true;
|
|
CAnimationSession* session = getSession(sessionId);
|
|
if (!session) { return false; }
|
|
ok = session->TalkingAsBots.add( eid, creatureId);
|
|
if (!ok) { return false; }
|
|
|
|
TOwnedEntities::iterator iter = _TalkedAsEntities.find(creatureId);
|
|
if (iter == _TalkedAsEntities.end())
|
|
{
|
|
COwnedCreatureInfo info;
|
|
info.PlayerIds.push_back(eid);
|
|
info.CreatureRowId = entityRowId;
|
|
info.CreatatureAlias = alias;
|
|
_TalkedAsEntities[creatureId] = info;
|
|
}
|
|
else
|
|
{
|
|
_TalkedAsEntities[creatureId].PlayerIds.push_back(eid);
|
|
}
|
|
|
|
|
|
updateTalkingAsList(sessionId, uint32(eid.getShortId())) ;
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
bool CServerAnimationModule::isIncarnedByPlayer(const NLMISC::CEntityId& creatureId, const NLMISC::CEntityId& eid) const
|
|
{
|
|
TOwnedEntities::const_iterator iter = _IncarnedEntities.find(creatureId);
|
|
if (iter == _IncarnedEntities.end())
|
|
{
|
|
return false;
|
|
}
|
|
COwnedCreatureInfo info = (*iter).second;
|
|
std::vector<NLMISC::CEntityId>::const_iterator eidIt(info.PlayerIds.begin()), last(info.PlayerIds.end());
|
|
for (; eidIt != last; ++eidIt)
|
|
{
|
|
if ((*eidIt) == eid)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool CServerAnimationModule::isTalkingAs(const NLMISC::CEntityId& creatureId, const NLMISC::CEntityId& eid) const
|
|
{
|
|
TOwnedEntities::const_iterator iter = _TalkedAsEntities.find(creatureId);
|
|
if (iter == _TalkedAsEntities.end())
|
|
{
|
|
return false;
|
|
}
|
|
COwnedCreatureInfo info = (*iter).second;
|
|
std::vector<NLMISC::CEntityId>::const_iterator eidIt(info.PlayerIds.begin()), last(info.PlayerIds.end());
|
|
for (; eidIt != last; ++eidIt)
|
|
{
|
|
if ((*eidIt) == eid)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
void CServerAnimationModule::removeTalkingAsPlayer(TSessionId sessionId, const NLMISC::CEntityId& creatureId, const NLMISC::CEntityId& eid)
|
|
{
|
|
TOwnedEntities::iterator iter = _TalkedAsEntities.find(creatureId);
|
|
COwnedCreatureInfo info = (*iter).second;
|
|
std::vector<NLMISC::CEntityId>::iterator eidIt(info.PlayerIds.begin()), last(info.PlayerIds.end());
|
|
for (; eidIt != last; ++eidIt)
|
|
{
|
|
if ((*eidIt) == eid)
|
|
{
|
|
info.PlayerIds.erase(eidIt);
|
|
break;
|
|
}
|
|
}
|
|
if (info.PlayerIds.empty())
|
|
{
|
|
_TalkedAsEntities.erase(iter);
|
|
}
|
|
|
|
CAnimationSession* session = getSession(sessionId);
|
|
if (!session) { return ; }
|
|
session->TalkingAsBots.remove( eid, creatureId);
|
|
|
|
updateTalkingAsList(sessionId, uint32( eid.getShortId()));
|
|
|
|
|
|
}
|
|
|
|
void CServerAnimationModule::removeIncarningPlayer(TSessionId sessionId, const NLMISC::CEntityId& creatureId, const NLMISC::CEntityId& eid)
|
|
{
|
|
TOwnedEntities::iterator iter = _IncarnedEntities.find(creatureId);
|
|
COwnedCreatureInfo info = (*iter).second;
|
|
std::vector<NLMISC::CEntityId>::iterator eidIt(info.PlayerIds.begin()), last(info.PlayerIds.end());
|
|
for (; eidIt != last; ++eidIt)
|
|
{
|
|
if ((*eidIt) == eid)
|
|
{
|
|
info.PlayerIds.erase(eidIt);
|
|
break;
|
|
}
|
|
}
|
|
if (info.PlayerIds.empty())
|
|
{
|
|
_IncarnedEntities.erase(iter);
|
|
}
|
|
|
|
CAnimationSession* session = getSession(sessionId);
|
|
if (!session) { return ; }
|
|
session->IncarningBots.remove(eid, creatureId);
|
|
|
|
updateIncarningList(sessionId, uint32(eid.getShortId()) );
|
|
|
|
}
|
|
|
|
void CServerAnimationModule::updateAnimationProperties(NLNET::IModuleProxy *senderModuleProxy, const NLMISC::CEntityId & eid, CRtNpc * rtNpc, CRtGrp* rtGrp)
|
|
{
|
|
|
|
|
|
CMessage msg("NPC_APROP"); //Animation Properties
|
|
|
|
if (eid == NLMISC::CEntityId::Unknown || rtNpc == 0)
|
|
{
|
|
uint32 zero = 0;
|
|
msg.serial(zero);
|
|
senderModuleProxy->sendModuleMessage(this, msg);
|
|
return;
|
|
}
|
|
uint32 animationProp = rtNpc->NpcAnimationProp;
|
|
const NLMISC::CEntityId & creatureId = rtNpc->EntityId;
|
|
|
|
if (animationProp & CAnimationProp::Controlable && rtNpc->Alived)
|
|
{
|
|
if (isIncarnedByPlayer(creatureId, eid))
|
|
{
|
|
animationProp |= CAnimationProp::Controled;
|
|
}
|
|
|
|
}
|
|
|
|
if (animationProp & CAnimationProp::Speaking && rtNpc->Alived)
|
|
{
|
|
if (isTalkingAs(creatureId, eid))
|
|
{
|
|
animationProp |= CAnimationProp::SpeakedAs;
|
|
}
|
|
}
|
|
|
|
if (!rtNpc->Alived)
|
|
{
|
|
animationProp &= ~CAnimationProp::Alive;
|
|
}
|
|
|
|
if (rtGrp)
|
|
{
|
|
CObjectTable* children = rtGrp->ObjectData->toTable("Children");
|
|
if (children->getSize() > 1)
|
|
{
|
|
animationProp |= CAnimationProp::Grouped;
|
|
}
|
|
}
|
|
|
|
msg.serial(animationProp);
|
|
senderModuleProxy->sendModuleMessage(this, msg);
|
|
return;
|
|
}
|
|
|
|
void CServerAnimationModule::onCharTargetReceived( NLNET::IModuleProxy *senderModuleProxy,
|
|
const NLMISC::CEntityId& eid, const NLMISC::CEntityId&creatureId,
|
|
TAIAlias alias, TDataSetRow entityRowId,
|
|
const ucstring& /* ucName */, uint32 nameId,
|
|
const std::vector<std::string> & param,
|
|
bool alived)
|
|
{
|
|
|
|
|
|
std::vector<std::string> args(param);
|
|
TCharId charId = static_cast<TCharId>(eid.getShortId());
|
|
|
|
const NLNET::TModuleProxyPtr * foundModule = getEditionModule()->getClientProxyPtr(charId);
|
|
DROP_IF(!foundModule, NLMISC::toString("Invalid Char %u", charId), return);
|
|
|
|
|
|
if (!alived || entityRowId == TDataSetRow() || alias == 0 || creatureId == CEntityId::Unknown )
|
|
{
|
|
updateAnimationProperties(* foundModule, CEntityId::Unknown, 0, 0);
|
|
return;
|
|
}
|
|
|
|
|
|
|
|
TCharSessions::const_iterator charSessionFound( _CharSessions.find(charId) );
|
|
DROP_IF(charSessionFound == _CharSessions.end(), NLMISC::toString("Invalid Session for Char %u", charId), return);
|
|
|
|
|
|
TSessionId sessionId = charSessionFound->second;
|
|
|
|
CAnimationSession* session = getSession(sessionId);
|
|
DROP_IF(session->Acts.empty() , NLMISC::toString("Invalid Session %u for Char %u (No act available)",charSessionFound->second.asInt(), charId), return);
|
|
|
|
|
|
if ( session->Acts.empty() )
|
|
{
|
|
return;
|
|
}
|
|
|
|
NLMISC::CEntityId oldTargetId = NLMISC::CEntityId::Unknown;
|
|
CAnimationSession::TCharacterInfos::iterator charInfos = session->CharacterInfos.find(charId);
|
|
if (charInfos != session->CharacterInfos.end())
|
|
{
|
|
oldTargetId = charInfos->second.TargetId;
|
|
}
|
|
|
|
session->CharacterInfos[charId].TargetId = creatureId;
|
|
|
|
// Add to targeted entities if necessary
|
|
{
|
|
|
|
COwnedCreatureInfo tmp;
|
|
std::pair < TOwnedEntities::iterator, bool> ret = _TargetedEntities.insert( std::make_pair(creatureId, tmp));
|
|
TOwnedEntities::iterator entity = ret.first;
|
|
bool firstTime = ret.second;
|
|
std::vector<NLMISC::CEntityId>& container = entity->second.PlayerIds;
|
|
std::vector<NLMISC::CEntityId>::iterator it = std::find(container.begin(), container.end(), eid);
|
|
if (it == container.end()){ container.push_back(eid); }
|
|
if (firstTime)
|
|
{
|
|
CAiWrapper::getInstance().askBotDespawnNotification(creatureId, alias);
|
|
}
|
|
}
|
|
|
|
if (oldTargetId != NLMISC::CEntityId::Unknown && oldTargetId != creatureId)
|
|
{
|
|
CAnimationSession::TCharacterInfos::iterator charInfos = session->CharacterInfos.find(charId);
|
|
if (charInfos != session->CharacterInfos.end())
|
|
{
|
|
NLMISC::CEntityId oldTargetId = charInfos->second.TargetId;
|
|
TOwnedEntities::iterator oldTargetIt = _TargetedEntities.find(oldTargetId);
|
|
if (oldTargetIt != _TargetedEntities.end())
|
|
{
|
|
std::vector<NLMISC::CEntityId>& container = oldTargetIt->second.PlayerIds;
|
|
std::vector<NLMISC::CEntityId>::iterator it = std::find(container.begin(), container.end(), eid);
|
|
if (it != container.end())
|
|
{
|
|
container.erase(it);
|
|
}
|
|
if (container.empty())
|
|
{
|
|
_TargetedEntities.erase(oldTargetIt);
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
|
|
uint32 SelectedNpcAct = 0;
|
|
|
|
CRtAct::TRtNpcs::const_iterator npcFound ( session->Acts[0]->RtNpcs.find(alias) );
|
|
CRtNpc * rtNpc = 0;
|
|
std::string name;
|
|
if (npcFound == session->Acts[0]->RtNpcs.end())
|
|
{
|
|
npcFound = session->Acts[ session->CurrentAct ]->RtNpcs.find(alias);
|
|
if (npcFound != session->Acts[ session->CurrentAct ]->RtNpcs.end())
|
|
{
|
|
rtNpc = npcFound->second.getPtr();
|
|
name = rtNpc->ObjectData->getAttr("Name")->toString();
|
|
SelectedNpcAct= session->CurrentAct;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rtNpc = npcFound->second.getPtr();
|
|
name = rtNpc->ObjectData->getAttr("Name")->toString();
|
|
}
|
|
|
|
// Try to target an invalid
|
|
if (!rtNpc) { return; }
|
|
|
|
CRtAct::TRtGrps & rtGrps = session->Acts[ SelectedNpcAct ]->RtGrps;
|
|
CRtAct::TRtGrps::const_iterator grpFound = rtGrps.find(rtNpc->GrpAlias);
|
|
CRtGrp *rtGrp = 0;
|
|
if (grpFound != rtGrps.end())
|
|
{
|
|
rtGrp = grpFound->second.getPtr();
|
|
}
|
|
|
|
//update data
|
|
rtNpc->EntityId = creatureId;
|
|
rtNpc->DataSetRow = entityRowId;
|
|
rtNpc->NameId = nameId;
|
|
rtNpc->Alived = alived;
|
|
|
|
uint32 animationProp = rtNpc->NpcAnimationProp;
|
|
|
|
if (args.empty())
|
|
{
|
|
updateAnimationProperties(*foundModule, eid, rtNpc, rtGrp);
|
|
return;
|
|
}
|
|
|
|
|
|
if ( (animationProp & CAnimationProp::Spawnable) )
|
|
{
|
|
if (args[0] == "DESPAWN_NPC")
|
|
{
|
|
|
|
if (rtNpc->EntityId != NLMISC::CEntityId::Unknown)
|
|
{
|
|
CAiWrapper::getInstance().despawnEntity(rtNpc->EntityId, alias);
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
if ( (animationProp & CAnimationProp::Alive) )
|
|
{
|
|
|
|
if (args[0] == "ADD_HP") { CAiWrapper::getInstance().setHPLevel(rtNpc->EntityId, alias, 1); return; }
|
|
|
|
if (args[0] == "KILL_NPC" && alived) { CAiWrapper::getInstance().setHPLevel(rtNpc->EntityId, alias, 0); return; }
|
|
if (args[0] == "ADD_HP") { CAiWrapper::getInstance().setHPLevel(rtNpc->EntityId, alias, 1); return; }
|
|
|
|
if (args[0] == "GRP_KILL" && alived) { CAiWrapper::getInstance().setGrpHPLevel(rtNpc->EntityId, alias, 0); return; }
|
|
if (args[0] == "GRP_HEAL") { CAiWrapper::getInstance().setGrpHPLevel(rtNpc->EntityId, alias, 1); return; }
|
|
|
|
|
|
|
|
if (args[0] == "AGGRO_RANGE_BIG"
|
|
|| args[0] == "AGGRO_RANGE_NORMAL"
|
|
|| args[0] == "AGGRO_RANGE_SMALL"
|
|
|| args[0] == "AGGRO_RANGE_NONE")
|
|
{
|
|
if (args[0] == "AGGRO_RANGE_BIG") { CAiWrapper::getInstance().setAggroRange(rtNpc->EntityId, 100); return;}
|
|
if (args[0] == "AGGRO_RANGE_NORMAL") { CAiWrapper::getInstance().setAggroRange(rtNpc->EntityId, 30); return;}
|
|
if (args[0] == "AGGRO_RANGE_SMALL") { CAiWrapper::getInstance().setAggroRange(rtNpc->EntityId, 15); return;}
|
|
if (args[0] == "AGGRO_RANGE_NONE") { CAiWrapper::getInstance().setAggroRange(rtNpc->EntityId, 0); return;}
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
if ( (animationProp & CAnimationProp::Controlable) )
|
|
{
|
|
if ( args[0] == "CONTROL" && alived)
|
|
{
|
|
if (!isIncarnedByPlayer(creatureId, eid))
|
|
{
|
|
|
|
if (session->IncarningBots.getBotsCount(charId) == 0) // We can now only incarnate One Npc
|
|
{
|
|
if ( setIncarningPlayer(sessionId, creatureId, eid, entityRowId, alias) )
|
|
{
|
|
CAiWrapper::getInstance().controlNpc(eid, creatureId);
|
|
/*
|
|
if (_CharacterControlProxy)
|
|
{
|
|
CCharacterControlItfProxy proxy(_CharacterControlProxy);
|
|
proxy.teleportCharacterToNpc(this, charId, creatureId, session->CurrSeason );
|
|
}
|
|
*/
|
|
CAiWrapper::getInstance().askBotDespawnNotification(creatureId, alias);
|
|
|
|
updateAnimationProperties(*foundModule, eid, rtNpc, rtGrp);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
CShareClientEditionItfProxy proxy( *foundModule );
|
|
proxy.systemMsg(this, "BC", "", "uiR2EDAlreadyIncarningANpc");
|
|
}
|
|
|
|
}
|
|
args[0] = "TALK_AS";
|
|
}
|
|
|
|
|
|
|
|
|
|
if ( args[0] == "STOP_CONTROL")
|
|
{
|
|
CEntityId bot = creatureId;
|
|
|
|
if (args.size() == 2)
|
|
{
|
|
uint32 id;
|
|
fromString(args[1], id);
|
|
|
|
CAnimationSession* session = getSession(sessionId);
|
|
if (session)
|
|
{
|
|
bot = session->IncarningBots.getEntity( eid, id);
|
|
if ( bot == NLMISC::CEntityId() ) { return; }
|
|
|
|
}
|
|
}
|
|
|
|
if (isIncarnedByPlayer(bot, eid))
|
|
{
|
|
stopIncarn(eid, bot);
|
|
removeIncarningPlayer(sessionId, bot, eid);
|
|
}
|
|
|
|
|
|
if (isTalkingAs(bot, eid))
|
|
{
|
|
stopTalk(eid, bot, entityRowId);
|
|
removeTalkingAsPlayer(sessionId, bot, eid);
|
|
}
|
|
updateAnimationProperties(*foundModule, eid, rtNpc, rtGrp);
|
|
return;
|
|
}
|
|
|
|
}
|
|
|
|
if ( (animationProp & CAnimationProp::Speaking) )
|
|
{
|
|
if (args[0] == "TALK_AS" && alived)
|
|
{
|
|
if (isTalkingAs(creatureId, eid))
|
|
return;
|
|
|
|
|
|
|
|
if (session->TalkingAsBots.getBotsCount(charId) < 8)
|
|
{
|
|
if ( setTalkingAsPlayer(sessionId, creatureId, eid, entityRowId, alias) )
|
|
{
|
|
CMessage msg("TALK_AS");
|
|
TModuleId tmp = (*foundModule)->getModuleProxyId();
|
|
msg.serial(tmp);
|
|
msg.serial(entityRowId);
|
|
msg.serial(name);
|
|
msg.serial(sessionId);
|
|
_StringManagerProxy->sendModuleMessage(this,msg);
|
|
|
|
CAiWrapper::getInstance().askBotDespawnNotification(creatureId, alias);
|
|
updateAnimationProperties(*foundModule, eid, rtNpc, rtGrp);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
CShareClientEditionItfProxy proxy(*foundModule);
|
|
proxy.systemMsg(this, "BC", "", "uiR2EDSpeakingAsTooManyEntities");
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
if (args[0] == "STOP_TALK")
|
|
{
|
|
NLMISC::CEntityId bot = creatureId;
|
|
TDataSetRow botDSR = entityRowId;
|
|
if (args.size() == 2)
|
|
{
|
|
uint32 id;
|
|
fromString(args[1], id);
|
|
|
|
CAnimationSession* session = getSession(sessionId);
|
|
if (session)
|
|
{
|
|
bot = session->TalkingAsBots.getEntity( eid, id);
|
|
if ( bot == NLMISC::CEntityId() ) { return; }
|
|
TOwnedEntities::const_iterator found(_TalkedAsEntities.find(bot));
|
|
if (found == _TalkedAsEntities.end()) { return ;}
|
|
botDSR = found->second.CreatureRowId;
|
|
}
|
|
}
|
|
|
|
if (isTalkingAs(bot, eid))
|
|
{
|
|
stopTalk(eid, bot,botDSR);
|
|
removeTalkingAsPlayer(sessionId, bot, eid);
|
|
updateAnimationProperties(*foundModule, eid, rtNpc, rtGrp);
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
// EGS message to indicates that a character is ready in mirror
|
|
void CServerAnimationModule::characterReady(NLNET::IModuleProxy * /* sender */, const NLMISC::CEntityId &charEid)
|
|
{
|
|
uint32 charId = uint32(charEid.getShortId());
|
|
|
|
nldebug("characterReady : received character ready for char %u", charId);
|
|
// forward the event to the server edition module
|
|
getEditionModule()->characterReady(charId);
|
|
}
|
|
|
|
|
|
|
|
bool CServerAnimationModule::onProcessModuleMessage(IModuleProxy *senderModuleProxy, const CMessage &msgin)
|
|
{
|
|
std::string operationName = msgin.getName();
|
|
|
|
// if (CServerAnimationItfSkel::onDispatchMessage(senderModuleProxy, msgin))
|
|
// {
|
|
// return;
|
|
// }
|
|
//
|
|
// // From Client
|
|
// if (CShareServerAnimationItfSkel::onDispatchMessage(senderModuleProxy, msgin))
|
|
// {
|
|
// return;
|
|
// }
|
|
|
|
|
|
|
|
// from service.cpp
|
|
if (!senderModuleProxy)
|
|
{
|
|
if (operationName == "SESSION_ACK")
|
|
{
|
|
// AIS ack receiving anim session
|
|
uint32 aiInstance;
|
|
nlRead(msgin, serial, aiInstance);
|
|
nlinfo( "R2An: ack received from AIS for anim session %u", aiInstance );
|
|
_ReadyForNextSession = true;
|
|
return true;
|
|
}
|
|
|
|
|
|
if (operationName == "translateAndForwardArg")
|
|
{
|
|
_StringManagerProxy->sendModuleMessage(this,msgin);
|
|
return true;
|
|
}
|
|
nlassert(0);
|
|
return false;
|
|
|
|
}
|
|
else if (senderModuleProxy->getModuleClassName() == "ClientEditionModule")
|
|
{
|
|
uint32 charId;
|
|
NLMISC::CEntityId clientEid;
|
|
std::string userPriv;
|
|
std::string extendedPriv;
|
|
bool ok = checkSecurityInfo(senderModuleProxy, charId, clientEid, userPriv, extendedPriv);
|
|
if (!ok) { return true; }
|
|
|
|
|
|
if (operationName == "requestStartAct")
|
|
{
|
|
// from users
|
|
uint32 actId;
|
|
nlRead(msgin,serial,actId);
|
|
|
|
// check that char session is known
|
|
TCharSessions::const_iterator charFound(_CharSessions.find(charId));
|
|
if ( charFound == _CharSessions.end())
|
|
{
|
|
// if session is queued, then just info msg
|
|
if( !_QueuedSessions.empty() )
|
|
{
|
|
bool bFoundSession = false;
|
|
CAnimationSession *lastSession = _QueuedSessions.back();
|
|
CAnimationSession *animSession = NULL;
|
|
do
|
|
{
|
|
animSession = _QueuedSessions.front();
|
|
_QueuedSessions.pop_front();
|
|
_QueuedSessions.push_back( animSession );
|
|
|
|
if( !bFoundSession )
|
|
{
|
|
// look for this char in the session
|
|
std::vector<uint32>::const_iterator it = animSession->ConnectedChars.begin(),
|
|
itEnd = animSession->ConnectedChars.end();
|
|
while( it != itEnd )
|
|
{
|
|
if( charId == *it++ )
|
|
{
|
|
bFoundSession = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
} while( lastSession != animSession );
|
|
|
|
if( bFoundSession )
|
|
{
|
|
nlinfo("R2An: startAct received from char %u, anim session is in queue.", charId);
|
|
return true;
|
|
}
|
|
}
|
|
nlwarning("R2An: not connected Char(%u) try to start an act.", charId);
|
|
return true;
|
|
}
|
|
|
|
scheduleStartAct(charFound->second, actId);
|
|
return true;
|
|
}
|
|
|
|
if (operationName == "requestSetSeason")
|
|
{
|
|
uint8 seasonValue;
|
|
nlRead(msgin, serial, seasonValue);
|
|
|
|
TCharSessions::const_iterator charFound(_CharSessions.find(charId));
|
|
if ( charFound == _CharSessions.end())
|
|
{
|
|
nlwarning("R2An: not connected char(%d) try to start an act.", charId);
|
|
return true;
|
|
}
|
|
setSeasonValue(charFound->second, seasonValue);
|
|
return true;
|
|
}
|
|
|
|
if (operationName == "requestSetWeather")
|
|
{
|
|
uint16 weatherValue;
|
|
nlRead(msgin, serial, weatherValue);
|
|
|
|
|
|
TCharSessions::const_iterator charFound(_CharSessions.find(charId));
|
|
if ( charFound == _CharSessions.end())
|
|
{
|
|
nlwarning("R2An: not connected char(%d) try to set the weather.", charId);
|
|
return true;
|
|
}
|
|
setWeatherValue(charFound->second, weatherValue);
|
|
return true;
|
|
}
|
|
|
|
if (operationName == "requestStopAct")
|
|
{
|
|
//from chars
|
|
TCharSessions::const_iterator charFound(_CharSessions.find(charId));
|
|
if ( charFound == _CharSessions.end())
|
|
{
|
|
nlwarning("R2An: not connected char(%u) try to start an act.", charId);
|
|
return true;
|
|
}
|
|
stopAct(charFound->second);
|
|
return true;
|
|
}
|
|
|
|
|
|
if(operationName == "requestStringValue")
|
|
{
|
|
TSessionId scenarioId=(TSessionId)1;
|
|
std::string stringId;
|
|
TModuleId id = senderModuleProxy->getModuleProxyId();
|
|
nlRead(msgin,serial,stringId);
|
|
CMessage msg("requestStringValue");
|
|
msg.serial(scenarioId);
|
|
msg.serial(id);
|
|
msg.serial(stringId);
|
|
_StringManagerProxy->sendModuleMessage(this,msg);
|
|
return true;
|
|
}
|
|
|
|
if(operationName == "requestIdList")
|
|
{
|
|
TSessionId scenarioId = (TSessionId)1;
|
|
TModuleId id = senderModuleProxy->getModuleProxyId();
|
|
CMessage msg("requestIdList");
|
|
msg.serial(scenarioId);
|
|
msg.serial(id);
|
|
_StringManagerProxy->sendModuleMessage(this,msg);
|
|
return true;
|
|
}
|
|
|
|
if(operationName =="talk_as")
|
|
{
|
|
std::string name ;
|
|
nlRead(msgin,serial,name);
|
|
CMessage msg("talk_as");
|
|
TModuleId tmp = senderModuleProxy->getModuleProxyId();
|
|
msg.serial(tmp);
|
|
msg.serial(name);
|
|
_StringManagerProxy->sendModuleMessage(this,msg);
|
|
return true;
|
|
}
|
|
|
|
if(operationName == "stopTalk")
|
|
{
|
|
CMessage msg("stopTalk");
|
|
TModuleId id = senderModuleProxy->getModuleProxyId();
|
|
msg.serial(id);
|
|
_StringManagerProxy->sendModuleMessage(this,msg);
|
|
return true;
|
|
}
|
|
|
|
if(operationName == "requestStringTable")
|
|
{
|
|
CMessage msg("requestStringTable");
|
|
TSessionId scenarioId = (TSessionId)1;
|
|
TModuleId id = senderModuleProxy->getModuleProxyId();
|
|
nlwarning("string table requested!!");
|
|
msg.serial(scenarioId);
|
|
msg.serial(id);
|
|
_StringManagerProxy->sendModuleMessage(this,msg);
|
|
return true;
|
|
}
|
|
|
|
if(operationName=="requestSetValue")
|
|
{
|
|
TSessionId scenarioId = (TSessionId)1;
|
|
std::string stringId;
|
|
std::string value;
|
|
nlRead(msgin,serial,stringId);
|
|
nlRead(msgin,serial,value);
|
|
CMessage msg("requestSetValue");
|
|
nlRead(msg,serial,scenarioId);
|
|
nlRead(msg,serial,stringId);
|
|
nlRead(msg,serial,value);
|
|
_StringManagerProxy->sendModuleMessage(this,msg);
|
|
return true;
|
|
}
|
|
|
|
}
|
|
else if (senderModuleProxy->getModuleClassName() == "ServerEditionModule")
|
|
{
|
|
|
|
if (operationName == "DBG_CREATE_PRIMITIVES")
|
|
{
|
|
TSessionId sessionId;
|
|
nlRead(msgin,serial,sessionId);
|
|
TSessions::const_iterator found = _Sessions.find(sessionId);
|
|
CObjectSerializerServer obj;
|
|
nlRead(msgin,serial,obj);
|
|
|
|
|
|
CAnimationSession* session = new CAnimationSession();
|
|
session->CurrentAct = 0;
|
|
session->RtData.reset( obj.getData() );
|
|
session->SessionId = sessionId;
|
|
queueSession(session, false);
|
|
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
TSessionId CServerAnimationModule::getScenarioId(uint32 charId)
|
|
{
|
|
TCharSessions::const_iterator found = _CharSessions.find(charId);
|
|
if(found!=_CharSessions.end())
|
|
{
|
|
return found->second;
|
|
}
|
|
return TSessionId(std::numeric_limits<uint16>::max());
|
|
}
|
|
|
|
void CServerAnimationModule::disconnectChar(TCharId charId)
|
|
{
|
|
const NLNET::TModuleProxyPtr* client = getEditionModule()->getClientProxyPtr(charId);
|
|
if (client)
|
|
{
|
|
onModuleDown(*client);
|
|
}
|
|
|
|
}
|
|
|
|
void CServerAnimationModule::scheduleStartSession(const CAnimationMessageAnimationStart &msg)
|
|
{
|
|
_Tasks.addTaskAt( NLMISC::CTime::getLocalTime() + 1000, new CTaskScheduleStartSession( this, msg) );
|
|
}
|
|
|
|
|
|
void CServerAnimationModule::scheduleStartSessionImpl(const CAnimationMessageAnimationStart &msg)
|
|
{
|
|
//create new Session
|
|
nlinfo("R2An: creating new animSession %u", msg.SessionId.asInt());
|
|
CAnimationSession* session = new CAnimationSession();
|
|
session->CurrentAct = msg.StartingAct;
|
|
|
|
std::vector<uint32>::const_iterator first(msg.AnimatorCharId.begin()), last(msg.AnimatorCharId.end());
|
|
for ( ; first != last ; ++first)
|
|
{
|
|
session->ConnectedChars.push_back(*first);
|
|
}
|
|
|
|
session->RtData.reset( msg.RtData.getData() );
|
|
session->SessionId = msg.SessionId;
|
|
session->AiInstance = msg.AiInstance;
|
|
session->InitialAct = msg.StartingAct;
|
|
session->ScenarioHeader = msg.ScenarioHeader;
|
|
|
|
// queue session
|
|
bool ok = queueSession(session);
|
|
if (!ok)
|
|
{
|
|
nlwarning("R2An: can't queue animation session");
|
|
return;
|
|
}
|
|
|
|
|
|
// Update animator session info
|
|
{
|
|
std::vector<uint32>::const_iterator first(msg.AnimatorCharId.begin()), last(msg.AnimatorCharId.end());
|
|
for ( ; first != last ; ++first)
|
|
{
|
|
|
|
bool inserted =_CharSessions.insert(std::make_pair(*first, msg.SessionId)).second;
|
|
if (!inserted)
|
|
{
|
|
// lookup the previous sessin id and make sure that we have a session for thsi id
|
|
TSessionId previousCharSessionId = _CharSessions[*first];
|
|
nlinfo("R2An::scheduleStartSession Moving char (%u) from Session %u to Session %u", *first, previousCharSessionId.asInt(), msg.SessionId.asInt());
|
|
BOMB_IF(_Sessions.find(previousCharSessionId)==_Sessions.end(),"scheduleStartSession giving up because failed to find _Sessions entry for character",return);
|
|
// disconnect from previous scenario
|
|
if (previousCharSessionId != msg.SessionId)
|
|
{
|
|
CAnimationSession* previousSession = getSession( previousCharSessionId );
|
|
BOMB_IF(!previousSession, "BUG: Failed to get pointer to session object with Id: "+NLMISC::toString(previousCharSessionId.asInt()), return);
|
|
std::vector<uint32> & chars = previousSession->ConnectedChars;
|
|
chars.erase(std::remove(chars.begin(), chars.end(), *first ), chars.end());
|
|
}
|
|
_CharSessions[*first] = msg.SessionId;
|
|
}
|
|
nlinfo("R2An: Char %u is connected as animator", *first);
|
|
}
|
|
}
|
|
session->CurrSeason = std::numeric_limits<uint8>::max();
|
|
}
|
|
|
|
|
|
IPrimitive* CServerAnimationModule::getEvent(CObject* event,CInstanceMap& components, const std::string& prefix,TSessionId scenarioId)
|
|
{
|
|
//create the primitive event
|
|
IPrimitive* pEvent = 0;
|
|
pEvent = dynamic_cast<IPrimitive *> (CClassRegistry::create ("CPrimNode"));
|
|
pEvent->addPropertyByName("class", new CPropertyString("npc_event_handler"));
|
|
pEvent->addPropertyByName("ai_type", new CPropertyString("NPC_EVENT")); // AJM
|
|
pEvent->addPropertyByName("state_keyword_filter", new CPropertyStringArray()); // AJM
|
|
pEvent->addPropertyByName("group_keyword_filter", new CPropertyStringArray()); // AJM
|
|
CAttributeToProperty a2pEvent(event, pEvent);
|
|
|
|
a2pEvent.setAttributeAsStringWithPrefix("Id", "name", prefix); //
|
|
a2pEvent.setAttributeAsString("Event", "event");
|
|
a2pEvent.setAttributeAsStringArrayWithPrefix("StatesByName", "states_by_name", prefix);//TODO more verification
|
|
a2pEvent.setAttributeAsStringArrayWithPrefix("GroupsByName", "groups_by_name",prefix); //TODO???
|
|
|
|
CPrimAlias *event_alias = dynamic_cast<CPrimAlias *> (CClassRegistry::create ("CPrimAlias"));
|
|
event_alias->addPropertyByName("class", new CPropertyString("alias"));
|
|
event_alias->addPropertyByName("name", new CPropertyString("alias"));
|
|
pEvent->insertChild(event_alias);
|
|
|
|
CObject* actions_id = event->getAttr("ActionsId");
|
|
uint32 firstAction=0,lastAction=0;
|
|
if(actions_id)lastAction=actions_id->getSize();
|
|
IPrimitive* father;
|
|
if(lastAction>1)
|
|
{
|
|
father = dynamic_cast<IPrimitive *> (CClassRegistry::create ("CPrimNode"));
|
|
father->addPropertyByName("class", new CPropertyString("npc_event_handler_action"));
|
|
father->addPropertyByName("ai_type", new CPropertyString("NPC_EVENT_ACTION")); // AJM
|
|
father->addPropertyByName("weight", new CPropertyString("1")); // AJM
|
|
father->addPropertyByName("action",new CPropertyString("multi_actions"));
|
|
father->addPropertyByName("name", new CPropertyString("multi_actions")); // AJM
|
|
pEvent->insertChild(father);
|
|
}
|
|
else
|
|
{
|
|
father = pEvent;
|
|
}
|
|
//for each action of this event
|
|
for(;firstAction!=lastAction;++firstAction)
|
|
{
|
|
CObject * action_id = actions_id->getValue(firstAction);
|
|
std::string id = action_id->toString();
|
|
CObject* action=components.find(id); // can be null?
|
|
if (!action)
|
|
{
|
|
nlwarning("Error while generating primitives in session '%u' in action '%s'", scenarioId.asInt(), id.c_str());
|
|
return 0;
|
|
}
|
|
//create the primitive action
|
|
IPrimitive* pAction=getAction(action, prefix,scenarioId);
|
|
if (!pAction )
|
|
{
|
|
nlwarning("Error for '%u'th action '%s' in states '%s' with group '%s'", firstAction, event->toString("Name").c_str(), event->toString("StatesByName").c_str(), event->toString("GroupsByName").c_str());
|
|
return 0;
|
|
}
|
|
//add the action to the event
|
|
father->insertChild(pAction);
|
|
}
|
|
return pEvent;
|
|
}
|
|
|
|
void CServerAnimationModule::requestLoadTable(CAnimationSession* session)
|
|
{
|
|
CObject* texts = session->RtData->getAttr("Texts");
|
|
TSessionId scenarioId = session->SessionId;
|
|
|
|
CMessage msg("registerTable");
|
|
//serialize scenarioId
|
|
msg.serial(scenarioId);
|
|
|
|
{
|
|
uint32 size = (uint32)session->ConnectedChars.size();
|
|
std::vector<const TModuleProxyPtr*> connected;
|
|
for(uint32 i=0; i<size; ++i)
|
|
{
|
|
const NLNET::TModuleProxyPtr* ptr = getEditionModule()->getClientProxyPtr(session->ConnectedChars[i]);
|
|
if (ptr){ connected.push_back(ptr); }
|
|
}
|
|
uint32 connectedSize = (uint32)connected.size();
|
|
|
|
msg.serial( connectedSize );
|
|
for(uint32 i=0; i<connectedSize ;++i)
|
|
{
|
|
const TModuleProxyPtr* ptr = connected[i];
|
|
TModuleId id= (*ptr)->getModuleProxyId();
|
|
msg.serial(id);
|
|
|
|
}
|
|
|
|
if (connected.size() != session->ConnectedChars.size())
|
|
{
|
|
nlwarning("SAn: error pioneer deconnection not found.");
|
|
}
|
|
}
|
|
|
|
//create the message to send the local string table to the
|
|
//string manager module
|
|
if((texts==NULL)||(texts->getAttr("Texts")->getSize()==0))
|
|
{
|
|
uint32 tmp=0;
|
|
msg.serial(tmp);
|
|
}
|
|
else
|
|
{
|
|
CObject* textsTable = texts->getAttr("Texts");
|
|
uint32 size;
|
|
if(textsTable && textsTable->isTable() && (size=textsTable->getSize())!=0 )
|
|
{
|
|
|
|
//serialize entry count
|
|
msg.serial(size);
|
|
for(uint32 i=0;i<size;++i)
|
|
{
|
|
CObject* entry = textsTable->getValue(i);
|
|
std::string tmp = entry->getAttr("Id")->toString();
|
|
msg.serial(tmp);
|
|
tmp = entry->getAttr("Text")->toString();
|
|
msg.serial(tmp);
|
|
}
|
|
|
|
}
|
|
}
|
|
_StringManagerProxy->sendModuleMessage(this,msg );
|
|
}
|
|
|
|
void CServerAnimationModule::requestUnloadTable(TSessionId sessionId)
|
|
{
|
|
CMessage msg("unregisterTable");
|
|
msg.serial(sessionId);
|
|
if (_StringManagerProxy != 0)
|
|
{
|
|
_StringManagerProxy->sendModuleMessage(this,msg);
|
|
}
|
|
}
|
|
|
|
void CServerAnimationModule::requestReleaseChannels(TSessionId sessionId)
|
|
{
|
|
CMessage msg("CLEAR_CHANNELS");
|
|
msg.serial(sessionId);
|
|
if (_StringManagerProxy != 0)
|
|
{
|
|
_StringManagerProxy->sendModuleMessage(this,msg);
|
|
}
|
|
}
|
|
|
|
void CServerAnimationModule::onServiceUp(const std::string &serviceName, TServiceId /* serviceId */)
|
|
{
|
|
nlinfo( "R2An: %s onServiceUp", serviceName.c_str() );
|
|
if( serviceName == "AIS" )
|
|
{
|
|
_ReadyForNextSession = true;
|
|
}
|
|
}
|
|
|
|
void CServerAnimationModule::onServiceDown(const std::string &serviceName, TServiceId /* serviceId */)
|
|
{
|
|
nlinfo( "R2An: %s onServiceDown", serviceName.c_str() );
|
|
if( serviceName == "AIS" )
|
|
{
|
|
_ReadyForNextSession = false;
|
|
}
|
|
}
|
|
|
|
|
|
void CServerAnimationModule::askMissionItemsDescription(NLNET::IModuleProxy *senderModuleProxy)
|
|
{
|
|
uint32 charId;
|
|
NLMISC::CEntityId clientEid;
|
|
std::string userPriv;
|
|
std::string extendedPriv;
|
|
|
|
bool ok = checkSecurityInfo(senderModuleProxy, charId, clientEid, userPriv, extendedPriv);
|
|
if (!ok) { return; }
|
|
|
|
TSessionId sessionId = getSessionIdByCharId(charId);
|
|
CAnimationSession* session = getSession(sessionId);
|
|
if (session)
|
|
{
|
|
CShareClientEditionItfProxy clientproxy(senderModuleProxy);
|
|
clientproxy.updateMissionItemsDescription(this, sessionId, session->MissionItems);
|
|
}
|
|
|
|
}
|
|
|
|
void CServerAnimationModule::deactivateEasterEggsFromAct(TSessionId scenarioId, uint32 actId)
|
|
{
|
|
DROP_IF(_CharacterControlProxy.isNull() , "No CharacterControlProxy", return);
|
|
|
|
|
|
CAnimationSession* session = getSession(scenarioId);
|
|
DROP_IF(!session, toString("No Session %d", scenarioId.asInt()), return);
|
|
|
|
|
|
DROP_IF(actId >= session->Acts.size(), "Error in activateEasterEgg ", return );
|
|
|
|
CRtAct* rtAct = session->Acts[actId];
|
|
|
|
DROP_IF(!rtAct, "Error in activateEasterEgg ", return );
|
|
|
|
if (rtAct->ActiveEasterEggs.empty())
|
|
{
|
|
return;
|
|
}
|
|
|
|
|
|
|
|
std::set<uint32> easterEggs;
|
|
|
|
CRtAct::TActiveEasterEggs::const_iterator first(rtAct->ActiveEasterEggs.begin()), last(rtAct->ActiveEasterEggs.end());
|
|
|
|
for (; first != last; ++first)
|
|
{
|
|
easterEggs.insert(first->first);
|
|
CAnimationSession::TActiveEasterEggs::iterator toErase(session->ActiveEasterEggs.find(first->first));
|
|
DROP_IF(toErase == session->ActiveEasterEggs.end(), "Error in activateEasterEgg ", return );
|
|
session->ActiveEasterEggs.erase(toErase);
|
|
}
|
|
|
|
session->Acts[actId]->ActiveEasterEggs.clear();
|
|
|
|
CCharacterControlItfProxy proxy(_CharacterControlProxy);
|
|
proxy.deactivateEasterEggs(this, easterEggs , scenarioId);
|
|
|
|
}
|
|
|
|
void CServerAnimationModule::deactivateEasterEgg(class NLNET::IModuleProxy * /* aisControl */, uint32 easterEggId, TSessionId scenarioId, uint32 actId)
|
|
{
|
|
DROP_IF(_CharacterControlProxy.isNull(), "No CharacterControlProxy", return);
|
|
|
|
|
|
CAnimationSession* session = getSession(scenarioId);
|
|
DROP_IF(!session, toString("No Session %d", scenarioId.asInt()), return);
|
|
|
|
|
|
// TODO Move code to session?
|
|
DROP_IF(actId >= session->Acts.size(), "Error in activateEasterEgg ", return );
|
|
bool ok = session->Acts[actId]->deactivateEasterEgg(easterEggId);
|
|
|
|
if (!ok)
|
|
{
|
|
// already removed
|
|
return;
|
|
}
|
|
|
|
CAnimationSession::TActiveEasterEggs::iterator found(session->ActiveEasterEggs.find(easterEggId));
|
|
if (found != session->ActiveEasterEggs.end())
|
|
{
|
|
session->ActiveEasterEggs.erase(found);
|
|
}
|
|
|
|
CCharacterControlItfProxy proxy(_CharacterControlProxy);
|
|
proxy.deactivateEasterEgg(this, easterEggId, scenarioId);
|
|
}
|
|
|
|
void CServerAnimationModule::activateEasterEgg(class NLNET::IModuleProxy * /* aisControl */, uint32 easterEggId, TSessionId scenarioId, uint32 actId ,const std::string & items, float x, float y, float z, float heading, const std::string& grpControler, const std::string& name, const std::string& look)
|
|
{
|
|
DROP_IF(_CharacterControlProxy.isNull(), "No CharacterControlProxy", return);
|
|
|
|
CAnimationSession* session = getSession(scenarioId);
|
|
DROP_IF(!session, toString("No Session %d", scenarioId.asInt()), return);
|
|
|
|
std::vector<std::string> itemNames;
|
|
NLMISC::splitString(items, ";", itemNames);
|
|
std::vector<R2::TItemAndQuantity> itemsAndQuantities;
|
|
|
|
|
|
uint32 first = 0, last = (uint32)itemNames.size();
|
|
for (; first != last ; ++first)
|
|
{
|
|
std::vector<std::string> itemAndQt;
|
|
std::string itemQt = itemNames[first];
|
|
NLMISC::splitString(itemQt, ":", itemAndQt);
|
|
|
|
DROP_IF( itemAndQt.size() != 2, "Syntax error in activateEasterEgg", return );
|
|
|
|
uint32 item;
|
|
bool ok = NLMISC::fromString(itemAndQt[0], item);
|
|
|
|
DROP_IF( !ok, "Error activateEasterEgg", return);
|
|
|
|
uint32 qt;
|
|
ok = NLMISC::fromString(itemAndQt[1], qt);
|
|
|
|
DROP_IF( !ok, "Error in activateEasterEgg", return);
|
|
DROP_IF( qt > 255, "Error in activateEasterEgg", return);
|
|
DROP_IF( item >= session->MissionItems.size(), "Error activateEasterEgg", return);
|
|
|
|
R2::TItemAndQuantity itemAndQuantity;
|
|
itemAndQuantity.SheetId = session->MissionItems[item].SheetId;
|
|
itemAndQuantity.Quantity = qt;
|
|
itemsAndQuantities.push_back(itemAndQuantity);
|
|
}
|
|
|
|
|
|
DROP_IF(actId >= session->Acts.size(), "Error in activateEasterEgg ", return );
|
|
bool ok = session->Acts[actId]->activateEasterEgg(easterEggId, grpControler);
|
|
|
|
if (!ok)
|
|
{
|
|
// component already activated
|
|
return;
|
|
}
|
|
|
|
ok = session->ActiveEasterEggs.insert(make_pair(easterEggId, actId)).second;
|
|
if (!ok)
|
|
{
|
|
//must never happend
|
|
nlwarning("Error while activating easter egg");
|
|
}
|
|
|
|
CFarPosition pos;
|
|
pos.SessionId = scenarioId;
|
|
pos.PosState.X = static_cast<int>(x*1000);
|
|
pos.PosState.Y = static_cast<int>(y*1000);
|
|
pos.PosState.Z = static_cast<int>(z*1000);
|
|
pos.PosState.Heading = static_cast<float>(heading*1000);
|
|
|
|
CCharacterControlItfProxy proxy(_CharacterControlProxy);
|
|
proxy.activateEasterEgg(this, easterEggId, scenarioId, session->AiInstance, itemsAndQuantities, pos, name, look);
|
|
|
|
}
|
|
|
|
void CServerAnimationModule::onEasterEggLooted(class NLNET::IModuleProxy * /* egs */, uint32 easterEggId, TSessionId scenarioId)
|
|
{
|
|
CAnimationSession* session = getSession(scenarioId);
|
|
DROP_IF(!session, toString("No Session %d", scenarioId.asInt()), return);
|
|
session->easterEggLooted(easterEggId, scenarioId);
|
|
}
|
|
|
|
|
|
void CServerAnimationModule::onUserTriggerTriggered(NLNET::IModuleProxy *senderModuleProxy, uint32 actId, uint32 triggerId)
|
|
{
|
|
uint32 charId;
|
|
NLMISC::CEntityId clientEid;
|
|
std::string userPriv;
|
|
std::string extendedPriv;
|
|
|
|
bool ok = checkSecurityInfo(senderModuleProxy, charId, clientEid, userPriv, extendedPriv);
|
|
if (!ok) { return; }
|
|
|
|
TSessionId sessionId = getSessionIdByCharId(charId);
|
|
CAnimationSession* session = getSession(sessionId);
|
|
if (session)
|
|
{
|
|
triggerUserTrigger(sessionId, actId, triggerId);
|
|
}
|
|
|
|
}
|
|
|
|
void CServerAnimationModule::triggerUserTrigger( TSessionId sessionId, uint32 actId, uint32 triggerId)
|
|
{
|
|
CAnimationSession* animationSession = getSession(sessionId);
|
|
|
|
if (animationSession && actId < animationSession->Acts.size() && triggerId < animationSession->Acts[actId]->UserTriggers.size())
|
|
{
|
|
std::string groupName = animationSession->Acts[actId]->UserTriggers[triggerId].FullName;
|
|
CAiWrapper::getInstance().triggerUserTrigger(groupName, 1);
|
|
}
|
|
else
|
|
{
|
|
nlwarning("error in CServerAnimationModule::triggerUserTrigger(%d, %d, %d)", sessionId.asInt(), actId, triggerId);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void CServerAnimationModule::askActPositionDescriptions(NLNET::IModuleProxy *senderModuleProxy)
|
|
{
|
|
uint32 charId;
|
|
NLMISC::CEntityId clientEid;
|
|
std::string userPriv;
|
|
std::string extendedPriv;
|
|
|
|
bool ok = checkSecurityInfo(senderModuleProxy, charId, clientEid, userPriv, extendedPriv);
|
|
if (!ok) { return; }
|
|
|
|
TSessionId sessionId = getSessionIdByCharId(charId);
|
|
CAnimationSession* session = getSession(sessionId);
|
|
if (session)
|
|
{
|
|
CShareClientEditionItfProxy clientproxy(senderModuleProxy);
|
|
TActPositionDescriptions actPositionDescriptions;
|
|
session->updateActPositionDescriptions(actPositionDescriptions);
|
|
clientproxy.updateActPositionDescriptions(this, actPositionDescriptions);
|
|
}
|
|
|
|
}
|
|
|
|
void CServerAnimationModule::askUserTriggerDescriptions(NLNET::IModuleProxy *senderModuleProxy)
|
|
{
|
|
uint32 charId;
|
|
NLMISC::CEntityId clientEid;
|
|
std::string userPriv;
|
|
std::string extendedPriv;
|
|
|
|
bool ok = checkSecurityInfo(senderModuleProxy, charId, clientEid, userPriv, extendedPriv);
|
|
if (!ok) { return; }
|
|
|
|
TSessionId sessionId = getSessionIdByCharId(charId);
|
|
CAnimationSession* session = getSession(sessionId);
|
|
if (session)
|
|
{
|
|
CShareClientEditionItfProxy clientproxy(senderModuleProxy);
|
|
TUserTriggerDescriptions userTriggerDescriptions;
|
|
session->updateUserTriggerDescriptions(userTriggerDescriptions);
|
|
clientproxy.updateUserTriggerDescriptions(this, userTriggerDescriptions);
|
|
}
|
|
|
|
|
|
}
|
|
|
|
void CServerAnimationModule::onBotDeathNotification(NLMISC::CEntityId& creatureId)
|
|
{
|
|
onBotDespawnNotification(creatureId);
|
|
}
|
|
|
|
|
|
void CServerAnimationModule::onBotDespawnNotification(NLMISC::CEntityId& creatureId)
|
|
{
|
|
TOwnedEntities::iterator itControl = _IncarnedEntities.find(creatureId);
|
|
TOwnedEntities::iterator itTalk = _TalkedAsEntities.find(creatureId);
|
|
TOwnedEntities::iterator itTarget = _TargetedEntities.find(creatureId);
|
|
|
|
if (itControl == _IncarnedEntities.end() && itTalk == _TalkedAsEntities.end() && itTarget == _TargetedEntities.end() )
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (itTarget != _TargetedEntities.end() )
|
|
{
|
|
COwnedCreatureInfo& info = (*itTarget).second;
|
|
std::vector<NLMISC::CEntityId>& playerId = info.PlayerIds;
|
|
std::vector<NLMISC::CEntityId>::iterator first(playerId.begin()), last(playerId.end());
|
|
for (; first != last; ++first)
|
|
{
|
|
CEntityId eid = *first;
|
|
uint32 charId = static_cast<uint32>(first->getShortId());
|
|
const NLNET::TModuleProxyPtr* pClient = getEditionModule()->getClientProxyPtr(charId);
|
|
if (pClient)
|
|
{
|
|
updateAnimationProperties(*pClient, CEntityId::Unknown, 0, 0);
|
|
}
|
|
}
|
|
_TargetedEntities.erase(itTarget);
|
|
|
|
}
|
|
|
|
if (itControl != _IncarnedEntities.end())
|
|
{
|
|
COwnedCreatureInfo& info = (*itControl).second;
|
|
|
|
std::vector<NLMISC::CEntityId> playerId = info.PlayerIds;
|
|
|
|
|
|
std::vector<NLMISC::CEntityId>::iterator first(playerId.begin()), last(playerId.end());
|
|
for (; first != last; ++first)
|
|
{
|
|
CEntityId eid = *first;
|
|
uint32 charId = static_cast<uint32>(first->getShortId());
|
|
TSessionId sessionId = getSessionIdByCharId(charId) ;
|
|
removeIncarningPlayer(sessionId, creatureId, eid);
|
|
stopIncarn(eid, creatureId);
|
|
const NLNET::TModuleProxyPtr* pClient = getEditionModule()->getClientProxyPtr(charId);
|
|
if (pClient)
|
|
{
|
|
updateAnimationProperties(*pClient, CEntityId::Unknown, 0, 0);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
if (itTalk != _TalkedAsEntities.end())
|
|
{
|
|
COwnedCreatureInfo& info = (*itTalk).second;
|
|
|
|
std::vector<NLMISC::CEntityId> playerId = info.PlayerIds;
|
|
|
|
std::vector<NLMISC::CEntityId>::iterator first(playerId.begin()), last(playerId.end());
|
|
for (; first != last; ++first)
|
|
{
|
|
CEntityId eid = *first;
|
|
uint32 charId = static_cast<uint32>( first->getShortId() );
|
|
TSessionId sessionId = getSessionIdByCharId(charId);
|
|
removeTalkingAsPlayer(sessionId, creatureId, eid);
|
|
stopTalk(eid, creatureId, info.CreatureRowId);
|
|
const NLNET::TModuleProxyPtr* pClient = getEditionModule()->getClientProxyPtr(charId);
|
|
if (pClient)
|
|
{
|
|
updateAnimationProperties(*pClient, CEntityId::Unknown, 0, 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
|
|
void CServerAnimationModule::onStopNpcControlNotification(NLMISC::CEntityId& creatureId)
|
|
{
|
|
TOwnedEntities::iterator itControl = _IncarnedEntities.find(creatureId);
|
|
|
|
|
|
if (itControl != _IncarnedEntities.end())
|
|
{
|
|
COwnedCreatureInfo& info = (*itControl).second;
|
|
|
|
std::vector<NLMISC::CEntityId> playerId = info.PlayerIds;
|
|
|
|
|
|
std::vector<NLMISC::CEntityId>::iterator first(playerId.begin()), last(playerId.end());
|
|
for (; first != last; ++first)
|
|
{
|
|
CEntityId eid = *first;
|
|
uint32 charId = static_cast<uint32>(first->getShortId());
|
|
TSessionId sessionId = getSessionIdByCharId(charId) ;
|
|
removeIncarningPlayer(sessionId, creatureId, eid);
|
|
stopIncarn(eid, creatureId);
|
|
const NLNET::TModuleProxyPtr* pClient = getEditionModule()->getClientProxyPtr(charId);
|
|
if (pClient)
|
|
{
|
|
updateAnimationProperties(*pClient, CEntityId::Unknown, 0, 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
NLMISC_CLASS_COMMAND_IMPL(CServerAnimationModule, loadPdrFile)
|
|
{
|
|
if (args.size() != 1)
|
|
return false;
|
|
Pdr.clear();
|
|
CAiWrapper::getInstance().fileToPdr(args[0], Pdr);
|
|
return true;
|
|
}
|
|
|
|
NLMISC_CLASS_COMMAND_IMPL(CServerAnimationModule, savePdrFile)
|
|
{
|
|
|
|
if (args.size() != 1)
|
|
return false;
|
|
|
|
CAiWrapper::getInstance().pdrToFile(Pdr, args[0]);
|
|
return true;
|
|
}
|
|
|
|
|
|
NLMISC_CLASS_COMMAND_IMPL(CServerAnimationModule, displayPdr)
|
|
{
|
|
|
|
if (args.size() != 0)
|
|
return false;
|
|
|
|
CAiWrapper::getInstance().displayPdr(Pdr);
|
|
return true;
|
|
}
|
|
|
|
|
|
NLMISC_CLASS_COMMAND_IMPL(CServerAnimationModule, clearPdr)
|
|
{
|
|
if (args.size() != 0)
|
|
return false;
|
|
|
|
CAiWrapper::getInstance().clearPdr( Pdr);
|
|
return true;
|
|
}
|
|
|
|
|
|
NLMISC_CLASS_COMMAND_IMPL(CServerAnimationModule, loadPrimitiveFile)
|
|
{
|
|
if (args.size() != 1)
|
|
return false;
|
|
CAiWrapper::getInstance().primitiveFileToPdr(args[0], Pdr);
|
|
return true;
|
|
}
|
|
|
|
NLMISC_CLASS_COMMAND_IMPL(CServerAnimationModule, loadRtFile)
|
|
{
|
|
if (args.size() != 1)
|
|
return false;
|
|
|
|
CIFile file;
|
|
if (!file.open(args[0]))
|
|
{
|
|
nlwarning("can't open '%s'", args[0].c_str());
|
|
}
|
|
CObjectSerializerServer obj;
|
|
obj.serial(file);
|
|
Pdr.clear();
|
|
// translateScenarioToPdr(obj.getData(), Pdr);
|
|
|
|
return true;
|
|
}
|
|
|
|
NLMISC_CLASS_COMMAND_IMPL(CServerAnimationModule, startTest)
|
|
{
|
|
if (args.size() != 1)
|
|
return false;
|
|
|
|
uint32 id;
|
|
fromString(args[0], id);
|
|
startTest(TSessionId(id), Pdr);
|
|
return true;
|
|
}
|
|
|
|
NLMISC_CLASS_COMMAND_IMPL(CServerAnimationModule, stopTest)
|
|
{
|
|
if (args.size() != 1)
|
|
return false;
|
|
|
|
uint32 dummyLastAct = 0;
|
|
uint32 id;
|
|
fromString(args[0], id);
|
|
stopTest(TSessionId(id), dummyLastAct );
|
|
return true;
|
|
}
|
|
|
|
|
|
NLMISC_CLASS_COMMAND_IMPL(CServerAnimationModule, displayMissionItems)
|
|
{
|
|
if (args.size() != 1)
|
|
{
|
|
log.displayNL("ServerAnimationModule.displayMissionItems sessionId");
|
|
return false;
|
|
}
|
|
uint32 id;
|
|
fromString(args[0], id);
|
|
TSessionId sessionId = TSessionId(id);
|
|
CAnimationSession* animationSession = getSession(sessionId);
|
|
if (animationSession)
|
|
{
|
|
uint32 first = 0, last = (uint32)animationSession->MissionItems.size();
|
|
log.displayNL("%d Missions Item:", last);
|
|
for ( ;first != last ; ++first)
|
|
{
|
|
log.displayNL("Item %d '%s' '%s' '%s' '%s'",
|
|
first,
|
|
animationSession->MissionItems[first].SheetId.toString().c_str(),
|
|
animationSession->MissionItems[first].Name.toString().c_str(),
|
|
animationSession->MissionItems[first].Description.toString().c_str(),
|
|
animationSession->MissionItems[first].Comment.toString().c_str()
|
|
);
|
|
}
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
|
|
NLMISC_CLASS_COMMAND_IMPL(CServerAnimationModule, displayUserTriggers)
|
|
{
|
|
if (args.size() != 1)
|
|
{
|
|
log.displayNL("ServerAnimationModule.displayUserTriggers sessionId");
|
|
return false;
|
|
}
|
|
|
|
uint32 id;
|
|
fromString(args[0], id);
|
|
TSessionId sessionId = TSessionId(id);
|
|
CAnimationSession* animationSession = getSession(sessionId);
|
|
if (animationSession)
|
|
{
|
|
TUserTriggerDescriptions userTriggerDescriptions;
|
|
animationSession->updateUserTriggerDescriptions(userTriggerDescriptions);
|
|
|
|
|
|
uint32 first = 0, last = (uint32)userTriggerDescriptions.size();
|
|
log.displayNL("%d User Trigger:", last);
|
|
for ( ;first != last ; ++first)
|
|
{
|
|
log.displayNL("Trigger %d: Name='%s' act='%d' id='%d'",
|
|
first,
|
|
userTriggerDescriptions[first].Name.c_str(),
|
|
userTriggerDescriptions[first].Act,
|
|
userTriggerDescriptions[first].Id
|
|
);
|
|
}
|
|
|
|
}
|
|
return true;
|
|
}
|
|
|
|
NLMISC_CLASS_COMMAND_IMPL(CServerAnimationModule, triggerUserTrigger)
|
|
{
|
|
if (args.size() != 3)
|
|
{
|
|
log.displayNL("ServerAnimationModule.triggerUserTrigger sessionId actId triggerId");
|
|
return false;
|
|
}
|
|
|
|
uint32 id;
|
|
fromString(args[0], id);
|
|
TSessionId sessionId = TSessionId(id);
|
|
uint32 actId;
|
|
fromString(args[1], actId);
|
|
uint32 triggerId;
|
|
fromString(args[2], triggerId);
|
|
triggerUserTrigger(sessionId, actId, triggerId);
|
|
return true;
|
|
}
|
|
|
|
} // namespace R2
|
|
|
|
|
|
|
|
IServerEditionModule* CServerAnimationModule::getEditionModule() const
|
|
{
|
|
return _Server->getEditionModule();
|
|
}
|
|
|
|
NLNET::IModule* CServerAnimationModule::getModule() const { return const_cast<R2::CServerAnimationModule*>(this); }
|
|
|
|
|
|
bool CServerAnimationModule::isSessionRunning(TSessionId sessionId) const
|
|
{
|
|
CAnimationSession* session = getSession(sessionId);
|
|
return session != 0;
|
|
}
|
|
|
|
uint32 CServerAnimationModule::getCurrentAct(TSessionId sessionId) const
|
|
{
|
|
CAnimationSession* session = getSession(sessionId);
|
|
if (session)
|
|
{
|
|
return session->CurrentAct;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
void CServerAnimationModule::dssMessage(NLNET::IModuleProxy * /* ais */, TSessionId sessionId, const std::string & msgType, const std::string& who, const std::string& msg)
|
|
{
|
|
CAnimationSession* session = getSession(sessionId);
|
|
if (session)
|
|
{
|
|
CMessage message;
|
|
std::string translatedMessage = _Server->getValue(sessionId, msg);
|
|
CShareClientEditionItfProxy::buildMessageFor_systemMsg(message, msgType, who, translatedMessage);
|
|
|
|
std::vector<uint32>::const_iterator first( session->ConnectedChars.begin()), last(session->ConnectedChars.end());
|
|
for (; first != last; ++first)
|
|
{
|
|
const NLNET::TModuleProxyPtr* ptr = getEditionModule()->getClientProxyPtr(*first);
|
|
if (ptr)
|
|
{
|
|
(*ptr)->sendModuleMessage(this, message);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void CServerAnimationModule::setSessionStartParams(TSessionId sessionId, sint32 x, sint32 y, uint8 season)
|
|
{
|
|
|
|
CAnimationSession* session = getSession(sessionId);
|
|
if (session) { session->setStartParams(x, y, season);}
|
|
}
|
|
|
|
bool CServerAnimationModule::mustReloadPosition(TSessionId sessionId, TCharId charId) const
|
|
{
|
|
CAnimationSession* session = getSession(sessionId);
|
|
if (!session) { return false; }
|
|
bool ok = session->CharacternValidePosition.find(charId) != session->CharacternValidePosition.end();
|
|
return ok;
|
|
}
|
|
|
|
|
|
|
|
|
|
bool CServerAnimationModule::getHeaderInfo(TSessionId sessionId, TScenarioHeaderSerializer::TValueType& values) const
|
|
{
|
|
CAnimationSession* session = getSession(sessionId);
|
|
if (!session) { return false; }
|
|
values = session->ScenarioHeader.Value;
|
|
return true;
|
|
}
|
|
|
|
void CServerAnimationModule::teleportCharacter(NLNET::IModuleProxy * /* ais */, const NLMISC::CEntityId& eid, float x, float y, float z)
|
|
{
|
|
CAnimationSession * session = getSessionByCharId(TCharId(eid.getShortId()));
|
|
if (session)
|
|
{
|
|
const R2::TR2TpInfos tpInfos; //no tp Infos
|
|
|
|
if ( !_CharacterControlProxy.isNull())
|
|
{
|
|
CCharacterControlItfProxy ccip( _CharacterControlProxy );
|
|
ccip.onTpPositionAsked(this, eid, x, y, z, session->CurrSeason, tpInfos);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
void CServerAnimationModule::broadcastMsg(TSessionId sessionId, const NLNET::CMessage& msg)
|
|
{
|
|
CAnimationSession * session = getSession(sessionId);
|
|
if (!session)
|
|
{
|
|
return;
|
|
}
|
|
|
|
broadcastMessage(session, msg);
|
|
}
|
|
|
|
void CServerAnimationModule::setScenarioPoints(NLNET::IModuleProxy * /* ais */, TSessionId sessionId, float scenarioPoints)
|
|
{
|
|
CAnimationSession* session = getSession(sessionId);
|
|
if (!session) { return; }
|
|
session->ScenarioScore = static_cast<uint32>(scenarioPoints);
|
|
//nldebug("Current Scenario points= %f)", scenarioPoints);
|
|
return;
|
|
}
|
|
|
|
void CServerAnimationModule::startScenarioTiming(NLNET::IModuleProxy * /* ais */, TSessionId sessionId)
|
|
{
|
|
CAnimationSession* session = getSession(sessionId);
|
|
if (!session) { return; }
|
|
|
|
if (!session->TimingIsFinished)
|
|
{
|
|
//NLMISC::TTime startTime = NLMISC::CTime::getLocalTime();
|
|
session->ScenarioTime = NLMISC::CTime::getLocalTime();
|
|
}
|
|
|
|
//nlinfo("Scenario Start time= %u)", scenarioPoints);
|
|
return;
|
|
}
|
|
|
|
void CServerAnimationModule::endScenarioTiming(NLNET::IModuleProxy * /* ais */, TSessionId sessionId)
|
|
{
|
|
CAnimationSession* session = getSession(sessionId);
|
|
if (!session) { return; }
|
|
|
|
if (!session->TimingIsFinished)
|
|
{
|
|
//NLMISC::TTime startTime = NLMISC::CTime::getLocalTime();
|
|
session->ScenarioTime = NLMISC::CTime::getLocalTime() - session->ScenarioTime;
|
|
nldebug("Scenario has been completed in: %u ms", session->ScenarioTime);
|
|
session->TimingIsFinished = true;
|
|
}
|
|
|
|
//nlinfo("Scenario Start time= %u)", scenarioPoints);
|
|
return;
|
|
}
|
|
|
|
bool CServerAnimationModule::getScore(TSessionId sessionId, uint32 &score, NLMISC::TTime &timeTaken)
|
|
{
|
|
|
|
CAnimationSession* session = getSession(sessionId);
|
|
if (!session)
|
|
{
|
|
score = 0;
|
|
timeTaken = 0;
|
|
return false;
|
|
}
|
|
score = session->ScenarioScore;
|
|
if (session->TimingIsFinished == true)
|
|
{
|
|
timeTaken = session->ScenarioTime;
|
|
}
|
|
else
|
|
{
|
|
timeTaken = 0;
|
|
}
|
|
return true;
|
|
}
|