khanat-opennel-code/code/ryzom/server/src/ai_service/mirrors.cpp

666 lines
21 KiB
C++

// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2010 Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "stdpch.h"
#include "mirrors.h"
#include "game_share/tick_event_handler.h"
#include "nel/net/service.h"
#include "game_share/misc_const.h"
#include "game_share/fame.h"
#include "ai_bot_npc.h"
#include "ai_grp_npc.h"
#include "server_share/r2_variables.h"
#include "server_share/r2_vision.h"
#include "ai.h"
#include "ai_player.h"
using namespace std;
using namespace NLMISC;
using namespace NLNET;
using namespace MBEHAV;
CMirror CMirrors::Mirror;
CMirroredDataSet *CMirrors::DataSet = NULL;
CMirroredDataSet *CMirrors::FameDataSet = NULL;
const uint MAX_NB_ENTITIES_ISOLATED = 25000;
CEntityId *IsolatedEntityId = NULL;
sint32 *IsolatedX = NULL;
sint32 *IsolatedY = NULL;
sint32 *IsolatedZ = NULL;
float *IsolatedTheta = NULL;
uint32 *IsolatedSheet = NULL;
uint32 *IsolatedSheetServer = NULL;
TDataSetRow *IsolatedTarget = NULL; // sint32
uint32 *IsolatedMode = NULL; // only mode enum
uint32 *IsolatedBehaviour = NULL;
uint32 *IsolatedCurrentHitPoints = NULL;
uint32 *IsolatedMaxHitPoints = NULL;
uint32 *IsolatedBestRoleLevel = NULL;
uint8 *IsolatedCombatState = NULL;
extern CVariable<double> RingMaxSelectDist;
/*
* Initialisation 2
*/
void cbMirrorIsReady( CMirror *mirror )
{
CMirrors::initMirror();
}
void cbMirrorReadyForAddEntity( CMirror *mirror )
{
// Init fx manager
const TDeclaredEntityRangeOfType& declERT = TheDataset.getDeclaredEntityRanges();
{
TDeclaredEntityRangeOfType::const_iterator it = declERT.find( RYZOMID::fx_entity );
const TDeclaredEntityRange& range = GET_ENTITY_TYPE_RANGE(it);
CFxEntityManager::getInstance()->init( range.baseIndex(), range.size() );
}
}
#define initIsolatedPropTable( name, thetype, defaultvalue ) \
name = new thetype [MAX_NB_ENTITIES_ISOLATED]; \
for ( i=0; i!=MAX_NB_ENTITIES_ISOLATED; ++i ) \
name[i] = defaultvalue
/*
* Initialisation 1
*/
void CMirrors::init( void (*cbUpdate)(), void (*cbSync)(), void (*cbRelease)() )
{
// Init the mirror system
vector<string> datasetNames;
datasetNames.push_back( "fe_temp" );
datasetNames.push_back( "fame" );
Mirror.init( datasetNames, cbMirrorIsReady, cbUpdate, cbSync, cbRelease, AISTag );
Mirror.addCallbackWhenMirrorReadyForUse( cbMirrorReadyForAddEntity );
}
/*
* Init after the mirror init
*/
void CMirrors::initMirror()
{
//Mirror.declareEntityTypeUser( RYZOMID::player );
Mirror.declareEntityTypeOwner( RYZOMID::npc, TotalMaxNpc.get() );
Mirror.declareEntityTypeOwner( RYZOMID::creature, TotalMaxFauna.get()+TotalMaxPet.get() );
Mirror.declareEntityTypeOwner( RYZOMID::fx_entity, TotalMaxFx );
DataSet = &(Mirror.getDataSet("fe_temp"));
DataSet->declareProperty( "AIInstance", PSOReadWrite | PSONotifyChanges );
DataSet->declareProperty( "X", PSOReadWrite | PSONotifyChanges );
DataSet->declareProperty( "Y", PSOReadWrite | PSONotifyChanges );
DataSet->declareProperty( "Z", PSOReadWrite );
DataSet->declareProperty( "Theta", PSOReadWrite );
DataSet->declareProperty( "Sheet", PSOReadWrite );
DataSet->declareProperty( "SheetServer", PSOReadWrite );
DataSet->declareProperty( "NPCAlias", PSOWriteOnly );
DataSet->declareProperty( "Mode", PSOReadWrite | PSONotifyChanges );
DataSet->declareProperty( "Behaviour", PSOReadWrite | PSONotifyChanges );
DataSet->declareProperty( "Target", PSOReadWrite | PSONotifyChanges );
DataSet->declareProperty( "CurrentHitPoints", PSOReadOnly );
DataSet->declareProperty( "CurrentRunSpeed", PSOReadOnly );
DataSet->declareProperty( "CurrentWalkSpeed", PSOReadOnly );
DataSet->declareProperty( "MaxHitPoints", PSOReadOnly );
DataSet->declareProperty( "BestRoleLevel", PSOReadOnly );
DataSet->declareProperty( "CombatState", PSOReadOnly );
DataSet->declareProperty( "TeamId", PSOReadOnly | PSONotifyChanges );
DataSet->declareProperty( "InOutpostZoneAlias", PSOReadWrite );
DataSet->declareProperty( "InOutpostZoneSide", PSOReadWrite );
DataSet->declareProperty( "VisualPropertyA", PSOReadWrite );
DataSet->declareProperty( "VisualPropertyB", PSOReadWrite );
DataSet->declareProperty( "VisualPropertyC", PSOReadWrite );
DataSet->declareProperty( "ActionFlags", PSOReadWrite );
DataSet->declareProperty( "VisionCounter", PSOReadOnly );
DataSet->declareProperty( "Fuel", PSOReadOnly );
DataSet->declareProperty( "WhoSeesMe", PSOReadWrite );
DataSet->declareProperty( "ContextualProperty", PSOReadWrite );
initRyzomVisualPropertyIndices( *DataSet );
// init fame dataset
FameDataSet = &(Mirror.getDataSet("fame"));
CFameInterface::getInstance().setFameDataSet(FameDataSet);
Mirror.setNotificationCallback( CMirrors::processMirrorUpdates );
}
// a big bad global var !
extern CAIEntityPhysical *TempSpeaker;
extern CBotPlayer *TempPlayer;
void CMirrors::processMirrorUpdates()
{
TDataSetRow entityIndex;
CEntityId *pEntityId;
CFameInterface &fi = CFameInterface::getInstance();
// Process added entities
DataSet->beginAddedEntities();
while ((entityIndex = DataSet->getNextAddedEntity()) != LAST_CHANGED)
{
const CEntityId& entityId = DataSet->getEntityId(entityIndex);
// Create CAIPlayer object and add to maps
if (entityId.getType() != RYZOMID::player)
continue;
{
CMirrorPropValue<uint32> _instanceNumber(*DataSet, entityIndex, DSPropertyAI_INSTANCE);
const uint32 askedInstance=_instanceNumber();
CAIInstance *const aii = CAIS::instance().getAIInstance(askedInstance);
if (!aii)
{
// The player is not in an AIInstance of that ais.
// Floods on player connections, so no warning
// nlwarning("AIInstance %d not found to spawn player %s", askedInstance, entityId.toString().c_str());
// FOREACH(it,CCont<CAIInstance>, CAIS::instance().AIList())
// {
// nlwarning("exist AIInstance %d at index %d", (*it)->getInstanceNumber(), (*it)->getIndex());
// }
continue;
}
// store the player in the correct instance.
aii->getPlayerMgr()->addSpawnedPlayer(entityIndex, entityId);
}
}
DataSet->endAddedEntities();
FameDataSet->beginAddedEntities();
while( (entityIndex = FameDataSet->getNextAddedEntity()) != LAST_CHANGED )
{
fi.createFameOwner(*FameDataSet, entityIndex);
}
FameDataSet->endAddedEntities();
// Process removed entities
DataSet->beginRemovedEntities();
while( (entityIndex = DataSet->getNextRemovedEntity(&pEntityId)) != LAST_CHANGED )
{
CAIEntityPhysical *entityPhysPtr = CAIS::instance().getEntityPhysical(entityIndex);
// just to check if its a player .. and remove it from Manager and Maps ..
if ( entityPhysPtr
&& entityPhysPtr->getRyzomType()==RYZOMID::player)
{
CBotPlayer *botPlayer=NLMISC::safe_cast<CBotPlayer*>(entityPhysPtr);
botPlayer->getOwner()->removeDespawnedPlayer(entityIndex);
}
}
DataSet->endRemovedEntities();
FameDataSet->beginRemovedEntities();
while( (entityIndex = FameDataSet->getNextRemovedEntity(&pEntityId)) != LAST_CHANGED )
{
fi.removeFameOwner(*FameDataSet, entityIndex);
}
FameDataSet->endRemovedEntities();
// Process properties changed and notified in the mirror
TPropertyIndex propIndex;
DataSet->beginChangedValues();
DataSet->getNextChangedValue( entityIndex, propIndex );
while (entityIndex != LAST_CHANGED)
{
if (propIndex == DSPropertyPOSX || propIndex == DSPropertyPOSX )
{
const CEntityId &entityId=DataSet->getEntityId(entityIndex);
if (entityId.getType() == RYZOMID::player)
{
CAIEntityPhysical *entityPhys=CAIS::instance().getEntityPhysical(entityIndex);
if (entityPhys)
{
CBotPlayer *player=NLMISC::safe_cast<CBotPlayer*>(entityPhys);
if (player)
{
CAIInstance* aiInstance = player->getAIInstance();
aiInstance->updateZoneTrigger(player);
}
}
}
}
else if (propIndex == DSPropertyTEAM_ID)
{
const CEntityId &entityId=DataSet->getEntityId(entityIndex);
if (entityId.getType() == RYZOMID::player)
{
CAIEntityPhysical *entityPhys=CAIS::instance().getEntityPhysical(entityIndex);
if (entityPhys)
{
CBotPlayer *player=NLMISC::safe_cast<CBotPlayer*>(entityPhys);
if (player)
player->getOwner()->updatePlayerTeam(entityIndex);
}
}
}
else if (propIndex == DSPropertyAI_INSTANCE)
{
const CEntityId &entityId=DataSet->getEntityId(entityIndex);
if (entityId.getType() == RYZOMID::player)
{
CAIEntityPhysical *entityPhys=CAIS::instance().getEntityPhysical(entityIndex);
if (entityPhys)
{
// this player is already in a manager, despawn it
CBotPlayer *const botPlayer=NLMISC::safe_cast<CBotPlayer*>(entityPhys);
botPlayer->getOwner()->removeDespawnedPlayer(entityIndex);
}
// could be done with mirrored values. (!?).
CMirrorPropValue<uint32> _instanceNumber(*DataSet, entityIndex, DSPropertyAI_INSTANCE);
const uint32 askedInstance=_instanceNumber();
CAIInstance *aii = CAIS::instance().getAIInstance(askedInstance);
if (aii!=NULL)
{
// store the player in the correct instance.
aii->getPlayerMgr()->addSpawnedPlayer(entityIndex, entityId);
}
else
{
if (askedInstance!=std::numeric_limits<uint32>::max())
{
// no need to warn for ai number instance not in this AIS !
// nlwarning("AIInstance %u not found on AIInstance changement for player %s", askedInstance, entityId.toString().c_str());
// FOREACH(it,CCont<CAIInstance>, CAIS::instance().AIList())
// {
// nlwarning("exist AIInstance %d at index %d", (*it)->getInstanceNumber(), (*it)->getIndex());
// }
}
}
}
}
else if (propIndex == DSPropertyTARGET_ID)
{
CAIEntityPhysical *entityPhys=CAIS::instance().getEntityPhysical(entityIndex);
if (entityPhys)
{
const CEntityId &entityId=DataSet->getEntityId(entityIndex);
if (entityId.getType() == RYZOMID::player)
{
CBotPlayer *player=NLMISC::safe_cast<CBotPlayer*>(entityPhys);
// check if target is a local npc bot then handle bot targeted event
CMirrorPropValueRO<TYPE_TARGET_ID> tgt(TheDataset, entityIndex, DSPropertyTARGET_ID);
CAIEntityPhysical *target = CAIS::instance().getEntityPhysical(tgt());
// update the targering list
if (entityIndex==TDataSetRow()) // no target.
{
player->setTarget(NULL);
}
else
{
if (player->isAggressive())
{
CAIEntityPhysical *oldTarget=player->getTarget();
if ( !oldTarget
|| oldTarget!=target )
player->setTarget(target);
}
else
{
CAIEntityPhysical *oldTarget=player->getVisualTarget();
if ( !oldTarget
|| oldTarget!=target )
player->setVisualTarget(target);
}
}
CSpawnBotNpc *bnpc = dynamic_cast<CSpawnBotNpc *>(target);
if (bnpc)
{
TempSpeaker = bnpc;
TempPlayer = player;
CGroupNpc &grpNpc = bnpc->getPersistent().grp();
if (IsRingShard)
{
CAIPos playerPos(player->pos());
CAIPos npcPos(bnpc->pos());
double dist = npcPos.quickDistTo(playerPos);
bool dm = false;
uint64 whoSeesMe = CMirrors::whoSeesMe(player->dataSetRow());
if (!R2_VISION::isEntityVisibleToPlayers(whoSeesMe))
{
// The player is invisible, its a Dm / Gm: no zone event must be triggered
dm = true;
}
if (!dm && dist <= RingMaxSelectDist)
{
grpNpc.processStateEvent(grpNpc.getEventContainer().EventPlayerTargetNpc);
}
}
else
{
// generate en event on this bot group
grpNpc.processStateEvent(grpNpc.getEventContainer().EventPlayerTargetNpc);
}
// grpNpc.processStateEvent(grpNpc.getEventContainer().EventPlayerTargetNpc);
// grpNpc.getEventContainer().EventPlayerTargetNpc.processStateEvent(&grpNpc);
// if player is in follow mode, then generate an suplementary event
if (player->getFollowMode())
grpNpc.processStateEvent(grpNpc.getEventContainer().EventPlayerFollowNpc);
// grpNpc.getEventContainer().EventPlayerFollowNpc.processStateEvent(&grpNpc);
TempPlayer = NULL;
TempSpeaker = NULL;
}
}
}
}
else if (propIndex == DSPropertyMODE)
{
CAIEntityPhysical *entityPhys=CAIS::instance().getEntityPhysical(entityIndex);
if (entityPhys)
{
const CEntityId &entityId=DataSet->getEntityId(entityIndex);
if (entityId.getType() == RYZOMID::player)
{
CBotPlayer *player=NLMISC::safe_cast<CBotPlayer*>(entityPhys);
// if the player have a target, move it to the correct target list.
if (player->isAggressive())
{
CAIEntityPhysical *target=player->getVisualTarget();
if (target)
player->setTarget(target);
}
else
{
CAIEntityPhysical *target=player->getTarget();
if (target)
player->setVisualTarget(target);
}
}
}
}
/* else if (propIndex == DSPropertyBEHAVIOUR)
{
CAIEntityPhysical *entityPhys=CAIS::instance().getEntityPhysical(entityIndex);
if (entityPhys)
{
const CEntityId &entityId=DataSet->getEntityId(entityIndex);
if (entityId.getType() == RYZOMID::player)
{
CBotPlayer *player=NLMISC::safe_cast<CBotPlayer*>(entityPhys);
MBEHAV::EBehaviour const behaviour = player->getBehaviour();
if( behaviour == MBEHAV::CAST_OFF_SUCCESS );
{
CAIEntityPhysical *target=player->getVisualTarget();
if (target)
player->setTarget(target);
}
}
}
}
*/ DataSet->getNextChangedValue( entityIndex, propIndex );
}
DataSet->endChangedValues();
}
void CMirrors::release()
{
Mirror.release();
}
bool CMirrors::mirrorIsReady()
{
return Mirror.mirrorIsReady();
}
//---------------------------------------------------------------------------------
// Methods for retrieving data from mirrors
TDataSetRow CMirrors::createEntity( CEntityId& entityId )
{
// in ais, we always use entityId auto asigment by mirror
if (Mirror.createEntity( entityId , true))
return DataSet->getDataSetRow( entityId );
else
return TDataSetRow();
}
void CMirrors::declareEntity( const TDataSetRow& entityIndex )
{
DataSet->declareEntity( entityIndex ); // only in the main dataset
}
void CMirrors::removeEntity( const CEntityId& entityId )
{
Mirror.removeEntity( entityId );
}
bool CMirrors::exists( const TDataSetRow& entityIndex )
{
/// is that a bug??
return DataSet->getEntityId( entityIndex ).asUint64() == 0;
//return ! ((uint64)(DataSet->getEntityId( entityIndex )) != 0);
}
const NLMISC::CEntityId& CMirrors::getEntityId( const TDataSetRow& entityIndex )
{
return DataSet->getEntityId( entityIndex );
}
TDataSetRow CMirrors::getDataSetRow( const NLMISC::CEntityId& entityId )
{
return DataSet->getDataSetRow( entityId );
}
uint16 CMirrors::getTeamId(const TDataSetRow& entityIndex)
{
CMirrorPropValueRO<TYPE_TEAM_ID> value( *DataSet, entityIndex, DSPropertyTEAM_ID );
// if ( value()==0 )
// return CTEAM::InvalidTeamId;
return value;
}
CAICoord CMirrors::x( const TDataSetRow& entityIndex )
{
CMirrorPropValueRO<TYPE_POSX> value( *DataSet, entityIndex, DSPropertyPOSX );
if ( value()==0 )
return CAICoord();
return CAICoord((double)value()/(double)1000);
}
CAICoord CMirrors::y( const TDataSetRow& entityIndex )
{
CMirrorPropValueRO<TYPE_POSY> value( *DataSet, entityIndex, DSPropertyPOSY );
if ( value()==0 )
return CAICoord();
return CAICoord((double)value()/(double)1000);
}
sint32 CMirrors::z( const TDataSetRow& entityIndex )
{
CMirrorPropValueRO<TYPE_POSZ> value( *DataSet, entityIndex, DSPropertyPOSZ );
return value();
}
float CMirrors::theta( const TDataSetRow& entityIndex )
{
CMirrorPropValueRO<TYPE_ORIENTATION> value( *DataSet, entityIndex, DSPropertyORIENTATION );
return value();
}
void CMirrors::setPosAndTheta( const TDataSetRow& entityIndex, sint32 posX, sint32 posY, sint32 posZ, float angleRad )
{
#ifdef NL_DEBUG
//nldebug( "%d: E%d: Setting pos to %d %d", CTickEventHandler::getGameCycle(), entityIndex, posX, posY );
/*if ( posX == 0 )
nldebug( "E%d: X is zero", entityIndex );
if ( posY == 0 )
nldebug( "E%d: Y is zero", entityIndex );*/
#endif
CMirrorPropValue<TYPE_POSX> valueX( *DataSet, entityIndex, DSPropertyPOSX );
CMirrorPropValue<TYPE_POSY> valueY( *DataSet, entityIndex, DSPropertyPOSY );
CMirrorPropValue<TYPE_POSZ> valueZ( *DataSet, entityIndex, DSPropertyPOSZ );
CMirrorPropValue<TYPE_ORIENTATION> valueT( *DataSet, entityIndex, DSPropertyORIENTATION );
valueX = posX;
valueY = posY;
valueZ = posZ;
valueT = angleRad;
//nldebug( "%u: Pos&theta of E%d set", CTickEventHandler::getGameCycle(), entityIndex );
}
void CMirrors::setTheta( const TDataSetRow& entityIndex, float angleRad )
{
CMirrorPropValue<TYPE_ORIENTATION> valueT( *DataSet, entityIndex, DSPropertyORIENTATION );
valueT = angleRad;
//nldebug( "%u: Theta of E%d set", CTickEventHandler::getGameCycle(), entityIndex );
}
NLMISC::CSheetId CMirrors::sheet( const TDataSetRow& entityIndex )
{
CMirrorPropValueRO<TYPE_SHEET> value( *DataSet, entityIndex, DSPropertySHEET );
return NLMISC::CSheetId(value());
}
void CMirrors::initSheet( const TDataSetRow& entityIndex, const NLMISC::CSheetId& sheetId )
{
CMirrorPropValue<TYPE_SHEET> value( *DataSet, entityIndex, DSPropertySHEET );
value = sheetId.asInt();
}
NLMISC::CSheetId CMirrors::sheetServer( const TDataSetRow& entityIndex )
{
CMirrorPropValueRO<TYPE_SHEET> value( *DataSet, entityIndex, DSPropertySHEET_SERVER );
return NLMISC::CSheetId(value());
}
void CMirrors::initSheetServer( const TDataSetRow& entityIndex, const NLMISC::CSheetId& sheetId )
{
nlassert(sheetId != NLMISC::CSheetId::Unknown);
CMirrorPropValue<TYPE_SHEET> value( *DataSet, entityIndex, DSPropertySHEET_SERVER );
value = sheetId.asInt();
}
void CMirrors::initNPCAlias( const TDataSetRow& entityIndex, TAIAlias alias )
{
CMirrorPropValue<TYPE_ALIAS> value( *DataSet, entityIndex, DSPropertyNPC_ALIAS );
value = alias;
}
TDataSetRow CMirrors::target( const TDataSetRow& entityIndex )
{
CMirrorPropValueRO<TYPE_TARGET_ID> value( *DataSet, entityIndex, DSPropertyTARGET_ID );
return value();
}
void CMirrors::setVPA( const TDataSetRow& entityIndex, const SAltLookProp &prop )
{
CMirrorPropValue<SAltLookProp> value( *DataSet, entityIndex, DSPropertyVPA );
value = prop;
}
void CMirrors::setVisualPropertyA( const TDataSetRow& entityIndex, const SPropVisualA &prop )
{
CMirrorPropValue<SPropVisualA> value( *DataSet, entityIndex, DSPropertyVPA );
value = prop;
}
void CMirrors::setVisualPropertyB( const TDataSetRow& entityIndex, const SPropVisualB &prop )
{
CMirrorPropValue<SPropVisualB> value( *DataSet, entityIndex, DSPropertyVPB );
value = prop;
}
void CMirrors::setVisualPropertyC( const TDataSetRow& entityIndex, const SPropVisualC &prop )
{
CMirrorPropValue<SPropVisualC> value( *DataSet, entityIndex, DSPropertyVPC );
value = prop;
}
void CMirrors::setBehaviour( const TDataSetRow& entityIndex, MBEHAV::EBehaviour b )
{
CMirrorPropValue<MBEHAV::CBehaviour> value( *DataSet, entityIndex, DSPropertyBEHAVIOUR );
value = b;
}
uint32 CMirrors::bestRoleLevel( const TDataSetRow& entityIndex )
{
CMirrorPropValueRO<TYPE_BEST_ROLE_LEVEL> value( *DataSet, entityIndex, DSPropertyBEST_ROLE_LEVEL );
return value();
}
uint64 CMirrors::whoSeesMe( const TDataSetRow& entityIndex )
{
BOMB_IF( !DataSet->isAccessible(entityIndex), "Try to access to the WhoSeesMe property in the mirror but with an invalid ", return 0L);
CMirrorPropValueRO<TYPE_WHO_SEES_ME> value( *DataSet, entityIndex, DSPropertyWHO_SEES_ME );
return value();
}
/*
* Set target (row)
*/
void CMirrors::setTarget(const TDataSetRow& entityIndex, const TDataSetRow& target)
{
CMirrorPropValue<TYPE_TARGET_ID> value( *DataSet, entityIndex, DSPropertyTARGET_ID );
value = target;
}
/// :KLUDGE: This method implementation should be in game_share instead of AIS and EGS. Both me and the other one are lazy bastards.
void MBEHAV::TMode::setModeAndPos( EMode mode, const TDataSetRow& entityIndex )
{
Mode = mode;
CMirrorPropValueRO<TYPE_POSX> propX( TheDataset, entityIndex, DSPropertyPOSX );
Pos.X16 = (uint16)(propX() >> 4);
CMirrorPropValueRO<TYPE_POSY> propY( TheDataset, entityIndex, DSPropertyPOSY );
Pos.Y16 = (uint16)(propY() >> 4);
//nldebug( "Setting MODE %s for E%u with current pos %d, %d", modeToString( mode ).c_str(), entityIndex.getIndex(), propX(), propY() );
}
#include "event_reaction_include.h"