//----------------------------------------------------------------------------------------------
bool AttackEntityAction::Execute(RtsGame& game, const WorldClock& p_clock)
{
EntityClassType attackerType = (EntityClassType)_params[PARAM_EntityClassId];
EntityClassType targetType = (EntityClassType)_params[PARAM_TargetEntityClassId];
AbstractAdapter *pAdapter = g_OnlineCaseBasedPlanner->Reasoner()->Adapter();
bool executed = false;
// Adapt attacker
m_attackerId = pAdapter->GetEntityObjectId(attackerType,AdapterEx::AttackerStatesRank);
if (m_attackerId != INVALID_TID)
{
m_targetId = pAdapter->AdaptTargetEntity(targetType, Parameters());
if (m_targetId != INVALID_TID)
{
GameEntity* pAttacker = game.Self()->GetEntity(m_attackerId);
_ASSERTE(pAttacker);
pAttacker->Lock(this);
executed = pAttacker->AttackEntity(m_targetId);
}
}
return executed;
}
//----------------------------------------------------------------------------------------------
bool MoveAction::ExecuteAux(RtsGame& game, const WorldClock& p_clock)
{
AbstractAdapter *pAdapter = g_OnlineCaseBasedPlanner->Reasoner()->Adapter();
EntityClassType entityType = (EntityClassType)_params[PARAM_EntityClassId];
//Adapt Entity
_entityId = pAdapter->GetEntityObjectId(entityType, AdapterEx::EntityToMoveStatesRank);
bool executed = false;
if(_entityId != INVALID_TID)
{
//Adapt position
_position = pAdapter->AdaptPosition(Parameters());
_pEntity = game.Self()->GetEntity(_entityId);
_pEntity->Lock(this);
_ASSERTE(_pEntity);
executed = _pEntity->Move(_position);
}
return executed;
}
bool BuildActionEx::ExecuteAux(RtsGame& game, const WorldClock& p_clock)
{
EntityClassType buildingType;
GameEntity *pGameBuilder;
AbstractAdapter *pAdapter = g_OnlineCaseBasedPlanner->Reasoner()->Adapter();
bool bOk = false;
// Adapt builder
_builderId = pAdapter->GetEntityObjectId(game.Self()->GetWorkerType(),AdapterEx::WorkerStatesRankVector);
if (_builderId != INVALID_TID)
{
buildingType = (EntityClassType)_params[PARAM_EntityClassId];
// Initialize build state
_buildStarted = false;
// Adapt build position
assert(pAdapter);
_buildArea = pAdapter->AdaptPositionForBuilding(buildingType);
// Issue build order
pGameBuilder = game.Self()->GetEntity(_builderId);
assert(pGameBuilder);
bOk = pGameBuilder->Build(buildingType, _buildArea.Pos());
if (bOk)
{
_buildIssued = true;
pGameBuilder->Lock(this);
assert(!_buildArea.IsNull());
_buildArea.Lock(this);
assert(!_requiredResources.IsNull());
_requiredResources.Lock(this);
}
}
return bOk;
}
//----------------------------------------------------------------------------------------------
bool AttackGroundAction::Execute(RtsGame& game, const WorldClock& p_clock)
{
EntityClassType attackerType = (EntityClassType)_params[PARAM_EntityClassId];
AbstractAdapter *pAdapter = g_OnlineCaseBasedPlanner->Reasoner()->Adapter();
bool executed = false;
// Adapt attacker
_attackerId = pAdapter->GetEntityObjectId(attackerType,AdapterEx::AttackerStatesRank);
if (_attackerId != INVALID_TID)
{
GameEntity* pGameAttacker = game.Self()->GetEntity(_attackerId);
_ASSERTE(pGameAttacker);
pGameAttacker->Lock(this);
// Adapt attack position
_position = pAdapter->AdaptEnemyBorder();
executed = pGameAttacker->AttackGround(_position);
}
return executed;
}
bool IStrategizer::GatherResourceAction::ExecuteAux(RtsGame* pRtsGame, const WorldClock& p_clock )
{
EntityClassType gathererType = (EntityClassType)_params[PARAM_EntityClassId];
ResourceType resourceType;
AbstractAdapter* pAdapter = g_OnlineCaseBasedPlanner->Reasoner()->Adapter();
bool bOK = false;
// Adapt gatherer
_gathererId = pAdapter->GetEntityObjectId(gathererType, AdapterEx::WorkerStatesRankVector);
if(_gathererId != INVALID_TID)
{
resourceType = (ResourceType)_params[PARAM_ResourceId];
// Initialize gather state
_gatherStarted = false;
// Adapt resource id
assert(pAdapter);
_resourceId = pAdapter->AdaptResourceForGathering(resourceType, Parameters());
if(_resourceId != INVALID_TID)
{
GameEntity* pGameGatherer = g_Game->Self()->GetEntity(_gathererId);
GameEntity* pGameResource = g_Game->GetPlayer(PLAYER_Neutral)->GetEntity(_resourceId);
assert(pGameGatherer);
assert(pGameResource);
bOK = pGameGatherer->GatherResourceEntity(_resourceId);
if (bOK)
{
_gatherIssued = true;
pGameGatherer->Lock(this);
}
}
}
return bOK;
}