void CBuilderCAI::ExecuteCapture(Command &c)
{
assert(owner->unitDef->canCapture);
CBuilder* fac=(CBuilder*)owner;
if(c.params.size()==1){ //capture unit
CUnit* unit=uh->units[(int)c.params[0]];
if(unit && unit->team!=owner->team && UpdateTargetLostTimer((int)c.params[0])){
if(unit->pos.distance2D(fac->pos)<fac->buildDistance+unit->radius-8){
StopMove();
fac->SetCaptureTarget(unit);
owner->moveType->KeepPointingTo(unit->pos, fac->buildDistance*0.9f+unit->radius, false);
} else {
if(goalPos.distance2D(unit->pos)>1)
SetGoal(unit->pos,owner->pos, fac->buildDistance*0.9f+unit->radius);
}
} else {
StopMove();
FinishCommand();
}
} else { //capture area
float3 pos(c.params[0],c.params[1],c.params[2]);
float radius=c.params[3];
if(FindCaptureTargetAndCapture(pos,radius,c.options)){
inCommand=false;
SlowUpdate();
return;
}
if(!(c.options & ALT_KEY)){
FinishCommand();
}
}
return;
}
void CAirCAI::ExecuteGuard(Command &c)
{
assert(owner->unitDef->canGuard);
if (int(c.params[0]) >= 0 && uh->units[int(c.params[0])] != NULL
&& UpdateTargetLostTimer(int(c.params[0]))) {
CUnit* guarded = uh->units[int(c.params[0])];
if(owner->unitDef->canAttack && guarded->lastAttack + 40 < gs->frameNum
&& owner->maxRange > 0 && IsValidTarget(guarded->lastAttacker))
{
Command nc;
nc.id = CMD_ATTACK;
nc.params.push_back(guarded->lastAttacker->id);
nc.options = c.options | INTERNAL_ORDER;
commandQue.push_front(nc);
SlowUpdate();
return;
} else {
Command c2;
c2.id = CMD_MOVE;
c2.options = c.options | INTERNAL_ORDER;
c2.params.push_back(guarded->pos.x);
c2.params.push_back(guarded->pos.y);
c2.params.push_back(guarded->pos.z);
c2.timeOut = gs->frameNum + 60;
commandQue.push_front(c2);
return;
}
} else {
FinishCommand();
}
}
void CCommandAI::ExecuteAttack(Command& c)
{
assert(owner->unitDef->canAttack);
if (inCommand) {
if (targetDied || (c.params.size() == 1 && UpdateTargetLostTimer(int(c.params[0])) == 0)) {
FinishCommand();
return;
}
if (!(c.options & ALT_KEY) && SkipParalyzeTarget(orderTarget)) {
FinishCommand();
return;
}
} else {
if (c.params.size() == 1) {
CUnit* targetUnit = unitHandler->GetUnit(c.params[0]);
if (targetUnit == NULL) { FinishCommand(); return; }
if (targetUnit == owner) { FinishCommand(); return; }
if (targetUnit->GetTransporter() != NULL && !modInfo.targetableTransportedUnits) {
FinishCommand(); return;
}
SetOrderTarget(targetUnit);
owner->AttackUnit(targetUnit, (c.options & INTERNAL_ORDER) == 0, c.GetID() == CMD_MANUALFIRE);
inCommand = true;
} else {
owner->AttackGround(c.GetPos(0), (c.options & INTERNAL_ORDER) == 0, c.GetID() == CMD_MANUALFIRE);
inCommand = true;
}
}
}
void CBuilderCAI::ExecuteCapture(Command& c)
{
// not all builders are capture-capable by default
if (!owner->unitDef->canCapture)
return;
CBuilder* builder = (CBuilder*) owner;
if (c.params.size() == 1 || c.params.size() == 5) {
// capture unit
CUnit* unit = uh->GetUnit(c.params[0]);
if (unit == NULL) {
FinishCommand();
return;
}
if (c.params.size() == 5) {
const float3 pos(c.params[1], c.params[2], c.params[3]);
const float radius = c.params[4] + 100; // do not walk too far outside capture area
if (((pos - unit->pos).SqLength2D() > (radius * radius) ||
(builder->curCapture == unit && unit->isMoving && !IsInBuildRange(unit)))) {
StopMove();
FinishCommand();
return;
}
}
if (unit->unitDef->capturable && unit->team != owner->team && UpdateTargetLostTimer(unit->id)) {
if (MoveInBuildRange(unit)) {
builder->SetCaptureTarget(unit);
}
} else {
StopMove();
FinishCommand();
}
} else if (c.params.size() == 4) {
// area capture
const float3 pos = c.GetPos(0);
const float radius = c.params[3];
builder->StopBuild();
if (FindCaptureTargetAndCapture(pos, radius, c.options, (c.options & META_KEY))) {
inCommand = false;
SlowUpdate();
return;
}
if (!(c.options & ALT_KEY)) {
FinishCommand();
}
} else {
FinishCommand();
}
return;
}
void CAirCAI::ExecuteAttack(Command& c)
{
assert(owner->unitDef->canAttack);
targetAge++;
if (tempOrder && owner->moveState == MOVESTATE_MANEUVER) {
// limit how far away we fly
if (orderTarget && LinePointDist(commandPos1, commandPos2, orderTarget->pos) > 1500) {
owner->AttackUnit(NULL, false, false);
FinishCommand();
return;
}
}
if (inCommand) {
if (targetDied || (c.params.size() == 1 && UpdateTargetLostTimer(int(c.params[0])) == 0)) {
FinishCommand();
return;
}
if (orderTarget != NULL) {
if (orderTarget->unitDef->canfly && orderTarget->IsCrashing()) {
owner->AttackUnit(NULL, false, false);
FinishCommand();
return;
}
if (!(c.options & ALT_KEY) && SkipParalyzeTarget(orderTarget)) {
owner->AttackUnit(NULL, false, false);
FinishCommand();
return;
}
}
} else {
targetAge = 0;
if (c.params.size() == 1) {
CUnit* targetUnit = unitHandler->GetUnit(c.params[0]);
if (targetUnit == NULL) { FinishCommand(); return; }
if (targetUnit == owner) { FinishCommand(); return; }
if (targetUnit->GetTransporter() != NULL && !modInfo.targetableTransportedUnits) {
FinishCommand(); return;
}
SetGoal(targetUnit->pos, owner->pos, cancelDistance);
SetOrderTarget(targetUnit);
owner->AttackUnit(targetUnit, (c.options & INTERNAL_ORDER) == 0, false);
inCommand = true;
} else {
SetGoal(c.GetPos(0), owner->pos, cancelDistance);
owner->AttackGround(c.GetPos(0), (c.options & INTERNAL_ORDER) == 0, false);
inCommand = true;
}
}
}
void CAirCAI::ExecuteGuard(Command& c)
{
assert(owner->unitDef->canGuard);
const CUnit* guardee = unitHandler->GetUnit(c.params[0]);
if (guardee == NULL) {
FinishCommand();
return;
}
if (UpdateTargetLostTimer(guardee->id) == 0) {
FinishCommand();
return;
}
if (guardee->outOfMapTime > (GAME_SPEED * 5)) {
FinishCommand();
return;
}
const bool pushAttackCommand =
(owner->maxRange > 0.0f) &&
owner->unitDef->canAttack &&
((guardee->lastAttackFrame + 40) < gs->frameNum) &&
IsValidTarget(guardee->lastAttacker);
if (pushAttackCommand) {
Command nc(CMD_ATTACK, c.options | INTERNAL_ORDER, guardee->lastAttacker->id);
commandQue.push_front(nc);
SlowUpdate();
} else {
Command c2(CMD_MOVE, c.options | INTERNAL_ORDER);
c2.timeOut = gs->frameNum + 60;
if (guardee->pos.IsInBounds()) {
c2.PushPos(guardee->pos);
} else {
float3 clampedGuardeePos = guardee->pos;
clampedGuardeePos.ClampInBounds();
c2.PushPos(clampedGuardeePos);
}
commandQue.push_front(c2);
}
}
void CAirCAI::ExecuteGuard(Command& c)
{
assert(owner->unitDef->canGuard);
const CUnit* guardee = uh->GetUnit(c.params[0]);
if (guardee == NULL) { FinishCommand(); return; }
if (UpdateTargetLostTimer(guardee->id) == 0) { FinishCommand(); return; }
if (guardee->outOfMapTime > (GAME_SPEED * 5)) { FinishCommand(); return; }
const bool pushAttackCommand =
owner->maxRange > 0.0f &&
owner->unitDef->canAttack &&
(guardee->lastAttack + 40 < gs->frameNum) &&
IsValidTarget(guardee->lastAttacker);
if (pushAttackCommand) {
Command nc;
nc.id = CMD_ATTACK;
nc.params.push_back(guardee->lastAttacker->id);
nc.options = c.options | INTERNAL_ORDER;
commandQue.push_front(nc);
SlowUpdate();
} else {
Command c2;
c2.id = CMD_MOVE;
c2.options = c.options | INTERNAL_ORDER;
c2.timeOut = gs->frameNum + 60;
if (guardee->pos.IsInBounds()) {
c2.params.push_back(guardee->pos.x);
c2.params.push_back(guardee->pos.y);
c2.params.push_back(guardee->pos.z);
} else {
float3 clampedGuardeePos = guardee->pos;
clampedGuardeePos.CheckInBounds();
c2.params.push_back(clampedGuardeePos.x);
c2.params.push_back(clampedGuardeePos.y);
c2.params.push_back(clampedGuardeePos.z);
}
commandQue.push_front(c2);
}
}
/**
* @brief Causes this CommandAI to execute the attack order c
*/
void CCommandAI::ExecuteAttack(Command &c)
{
assert(owner->unitDef->canAttack);
if (inCommand) {
if (targetDied || (c.params.size() == 1 && UpdateTargetLostTimer(int(c.params[0])) == 0)) {
FinishCommand();
return;
}
if ((c.params.size() == 3) && (owner->commandShotCount > 0) && (commandQue.size() > 1)) {
FinishCommand();
return;
}
if (!(c.options & ALT_KEY) && SkipParalyzeTarget(orderTarget)) {
FinishCommand();
return;
}
}
else {
owner->commandShotCount = -1;
if (c.params.size() == 1) {
const unsigned int targetID = (unsigned int) c.params[0];
const bool legalTarget = (targetID >= 0) && (targetID < uh->MaxUnits());
CUnit* targetUnit = (legalTarget)? uh->units[targetID]: 0x0;
if (legalTarget && targetUnit != 0x0 && targetUnit != owner) {
owner->AttackUnit(targetUnit, c.id == CMD_DGUN);
if (orderTarget)
DeleteDeathDependence(orderTarget);
orderTarget = targetUnit;
AddDeathDependence(orderTarget);
inCommand = true;
} else {
FinishCommand();
return;
}
} else {
float3 pos(c.params[0], c.params[1], c.params[2]);
owner->AttackGround(pos, c.id == CMD_DGUN);
inCommand = true;
}
}
}
/**
* @brief Executes the guard command c
*/
void CMobileCAI::ExecuteGuard(Command &c)
{
assert(owner->unitDef->canGuard);
assert(!c.params.empty());
const CUnit* guardee = unitHandler->GetUnit(c.params[0]);
if (guardee == NULL) { FinishCommand(); return; }
if (UpdateTargetLostTimer(guardee->id) == 0) { FinishCommand(); return; }
if (guardee->outOfMapTime > (GAME_SPEED * 5)) { FinishCommand(); return; }
const bool pushAttackCommand =
owner->unitDef->canAttack &&
(guardee->lastAttackFrame + 40 < gs->frameNum) &&
IsValidTarget(guardee->lastAttacker);
if (pushAttackCommand) {
Command nc(CMD_ATTACK, c.options, guardee->lastAttacker->id);
commandQue.push_front(nc);
StopSlowGuard();
SlowUpdate();
} else {
const float3 dif = (guardee->pos - owner->pos).SafeNormalize();
const float3 goal = guardee->pos - dif * (guardee->radius + owner->radius + 64.0f);
const bool resetGoal =
((goalPos - goal).SqLength2D() > 1600.0f) ||
(goalPos - owner->pos).SqLength2D() < Square(owner->moveType->GetMaxSpeed() * GAME_SPEED + 1 + SQUARE_SIZE * 2);
if (resetGoal) {
SetGoal(goal, owner->pos);
}
if ((goal - owner->pos).SqLength2D() < 6400.0f) {
StartSlowGuard(guardee->moveType->GetMaxSpeed());
if ((goal - owner->pos).SqLength2D() < 1800.0f) {
StopMove();
NonMoving();
}
} else {
StopSlowGuard();
}
}
}
/**
* @brief Executes the guard command c
*/
void CMobileCAI::ExecuteGuard(Command &c)
{
assert(owner->unitDef->canGuard);
assert(!c.params.empty());
CUnit* guarded = uh->GetUnit(c.params[0]);
if (guarded != NULL && UpdateTargetLostTimer(guarded->id)) {
if (owner->unitDef->canAttack && guarded->lastAttack + 40 < gs->frameNum
&& IsValidTarget(guarded->lastAttacker))
{
StopSlowGuard();
Command nc;
nc.id = CMD_ATTACK;
nc.params.push_back(guarded->lastAttacker->id);
nc.options = c.options;
commandQue.push_front(nc);
SlowUpdate();
return;
} else {
//float3 dif = guarded->speed * guarded->frontdir;
float3 dif = guarded->pos - owner->pos;
dif.Normalize();
float3 goal = guarded->pos - dif * (guarded->radius + owner->radius + 64);
if((goalPos - goal).SqLength2D() > 1600
|| (goalPos - owner->pos).SqLength2D()
< (owner->maxSpeed*30 + 1 + SQUARE_SIZE*2)
* (owner->maxSpeed*30 + 1 + SQUARE_SIZE*2)){
SetGoal(goal, owner->pos);
}
if((goal - owner->pos).SqLength2D() < 6400) {
StartSlowGuard(guarded->maxSpeed);
if((goal-owner->pos).SqLength2D() < 1800){
StopMove();
NonMoving();
}
} else {
StopSlowGuard();
}
}
} else {
FinishCommand();
}
return;
}
void CBuilderCAI::ExecuteReclaim(Command &c)
{
assert(owner->unitDef->canReclaim);
CBuilder* fac=(CBuilder*)owner;
if(c.params.size()==1){
int id=(int) c.params[0];
if(id>=MAX_UNITS){ //reclaim feature
CFeature* feature=featureHandler->features[id-MAX_UNITS];
if(feature){
if(!ReclaimObject(feature)){
StopMove();
FinishCommand();
}
} else {
StopMove();
FinishCommand();
}
} else { //reclaim unit
CUnit* unit=uh->units[id];
if(unit && unit!=owner && unit->unitDef->reclaimable && UpdateTargetLostTimer(id)){
if(!ReclaimObject(unit)){
StopMove();
FinishCommand();
}
} else {
FinishCommand();
}
}
} else if(c.params.size()==4){//area reclaim
float3 pos(c.params[0],c.params[1],c.params[2]);
float radius=c.params[3];
if(FindReclaimableFeatureAndReclaim(pos,radius,c.options,true)){
inCommand=false;
SlowUpdate();
return;
}
if(!(c.options & ALT_KEY)){
FinishCommand();
}
} else { //wrong number of parameters
FinishCommand();
}
return;
}
void CBuilderCAI::ExecuteRepair(Command& c)
{
CBuilder* fac=(CBuilder*)owner;
assert(owner->unitDef->canRepair || owner->unitDef->canAssist);
if (c.params.size() == 1) { //repair unit
CUnit* unit = uh->units[(int)c.params[0]];
if (tempOrder && owner->moveState == 1) { //limit how far away we go
if (unit && LinePointDist(commandPos1, commandPos2, unit->pos) > 500) {
StopMove();
FinishCommand();
return;
}
}
if (unit && (unit->health < unit->maxHealth) &&
((unit != owner) || owner->unitDef->canSelfRepair) &&
(!unit->soloBuilder || (unit->soloBuilder == owner)) &&
UpdateTargetLostTimer((int)c.params[0])) {
if (f3SqDist(unit->pos, fac->pos) < Square(fac->buildDistance+unit->radius-8)) {
StopMove();
fac->SetRepairTarget(unit);
owner->moveType->KeepPointingTo(unit->pos, fac->buildDistance*0.9f+unit->radius, false);
} else {
if (f3SqDist(goalPos, unit->pos) > 1) {
SetGoal(unit->pos,owner->pos, fac->buildDistance*0.9f+unit->radius);
}
}
} else {
StopMove();
FinishCommand();
}
}
else { // repair area
float3 pos(c.params[0], c.params[1], c.params[2]);
float radius=c.params[3];
if (FindRepairTargetAndRepair(pos, radius, c.options, false)) {
inCommand=false;
SlowUpdate();
return;
}
if (!(c.options & ALT_KEY)) {
FinishCommand();
}
}
return;
}
/**
* @brief Causes this CommandAI to execute the attack order c
*/
void CCommandAI::ExecuteAttack(Command &c)
{
assert(owner->unitDef->canAttack);
if (inCommand) {
if (targetDied || (c.params.size() == 1 && UpdateTargetLostTimer(int(c.params[0])) == 0)) {
FinishCommand();
return;
}
if ((c.params.size() == 3) && (owner->commandShotCount > 0) && (commandQue.size() > 1)) {
FinishCommand();
return;
}
if (!(c.options & ALT_KEY) && SkipParalyzeTarget(orderTarget)) {
FinishCommand();
return;
}
}
else {
owner->commandShotCount = -1;
if (c.params.size() == 1) {
CUnit* targetUnit = uh->GetUnit(c.params[0]);
if (targetUnit != NULL && targetUnit != owner) {
owner->AttackUnit(targetUnit, c.id == CMD_DGUN);
if (orderTarget)
DeleteDeathDependence(orderTarget);
orderTarget = targetUnit;
AddDeathDependence(orderTarget);
inCommand = true;
} else {
FinishCommand();
return;
}
} else {
float3 pos(c.params[0], c.params[1], c.params[2]);
owner->AttackGround(pos, c.id == CMD_DGUN);
inCommand = true;
}
}
}
void CCommandAI::ExecuteAttack(Command& c)
{
assert(owner->unitDef->canAttack);
if (inCommand) {
if (targetDied || (c.params.size() == 1 && UpdateTargetLostTimer(int(c.params[0])) == 0)) {
FinishCommand();
return;
}
if ((c.params.size() == 3) && (owner->commandShotCount > 0) && (commandQue.size() > 1)) {
FinishCommand();
return;
}
if (!(c.options & ALT_KEY) && SkipParalyzeTarget(orderTarget)) {
FinishCommand();
return;
}
} else {
owner->commandShotCount = -1;
if (c.params.size() == 1) {
CUnit* targetUnit = uh->GetUnit(c.params[0]);
if (targetUnit == NULL) { FinishCommand(); return; }
if (targetUnit == owner) { FinishCommand(); return; }
if (targetUnit->GetTransporter() != NULL) { FinishCommand(); return; }
SetOrderTarget(targetUnit);
owner->AttackUnit(targetUnit, c.GetID() == CMD_MANUALFIRE);
inCommand = true;
} else {
float3 pos(c.params[0], c.params[1], c.params[2]);
owner->AttackGround(pos, c.GetID() == CMD_MANUALFIRE);
inCommand = true;
}
}
}
void CAirCAI::ExecuteAttack(Command &c)
{
assert(owner->unitDef->canAttack);
targetAge++;
if(tempOrder && owner->moveState == 1){ //limit how far away we fly
if(orderTarget && LinePointDist(commandPos1, commandPos2, orderTarget->pos) > 1500){
owner->SetUserTarget(0);
FinishCommand();
return;
}
}/* why was this block here? - ILMTitan
if(tempOrder && myPlane->isFighter && orderTarget){
if(owner->fireState == 2 && owner->moveState != 0){
CUnit* enemy = helper->GetClosestEnemyAircraft(
owner->pos + (owner->speed * 50), 800, owner->allyteam);
if(enemy && (!orderTarget->unitDef->canfly
|| (orderTarget->pos-owner->pos + owner->speed * 50).
Length() + (100 * gs->randFloat() * 40) - targetAge
< (enemy->pos-owner->pos + owner->speed * 50).Length())){
c.params.clear();
c.params.push_back(enemy->id);
inCommand=false;
}
}
}*/
if(inCommand){
if(targetDied || (c.params.size() == 1 && UpdateTargetLostTimer(int(c.params[0])) == 0)){
FinishCommand();
return;
}
if ((c.params.size() == 3) && (owner->commandShotCount > 0) && (commandQue.size() > 1)) {
owner->AttackUnit(0,true);
FinishCommand();
return;
}
if (orderTarget) {
if (orderTarget->unitDef->canfly && orderTarget->crashing) {
owner->SetUserTarget(0);
FinishCommand();
return;
}
if (!(c.options & ALT_KEY) && SkipParalyzeTarget(orderTarget)) {
owner->SetUserTarget(0);
FinishCommand();
return;
}
}
if(orderTarget){
// myPlane->goalPos=orderTarget->pos;
} else {
// float3 pos(c.params[0],c.params[1],c.params[2]);
// myPlane->goalPos=pos;
}
} else {
targetAge=0;
owner->commandShotCount = -1;
if(c.params.size() == 1){
if(uh->units[int(c.params[0])] != 0 && uh->units[int(c.params[0])] != owner){
orderTarget = uh->units[int(c.params[0])];
owner->AttackUnit(orderTarget, false);
AddDeathDependence(orderTarget);
inCommand = true;
} else {
FinishCommand();
return;
}
} else {
float3 pos(c.params[0],c.params[1],c.params[2]);
owner->AttackGround(pos,false);
inCommand = true;
}
}
return;
}
void CBuilderCAI::ExecuteReclaim(Command& c)
{
CBuilder* builder = (CBuilder*) owner;
// not all builders are reclaim-capable by default
if (!owner->unitDef->canReclaim)
return;
if (c.params.size() == 1 || c.params.size() == 5) {
const int signedId = (int) c.params[0];
if (signedId < 0) {
LOG_L(L_WARNING, "Trying to reclaim unit or feature with id < 0 (%i), aborting.", signedId);
return;
}
const unsigned int uid = signedId;
//FIXME add a per-unit solution to better balance the load?
const bool checkForBetterTarget = (gs->frameNum % (5 * UNIT_SLOWUPDATE_RATE)) < UNIT_SLOWUPDATE_RATE;
if (checkForBetterTarget && (c.options & INTERNAL_ORDER) && (c.params.size() >= 5)) {
// regular check if there is a closer reclaim target
CSolidObject* obj;
if (uid >= uh->MaxUnits()) {
obj = featureHandler->GetFeature(uid - uh->MaxUnits());
} else {
obj = uh->GetUnit(uid);
}
if (obj) {
const float3 pos(c.params[1], c.params[2], c.params[3]);
const float radius = c.params[4];
const float curdist = pos.SqDistance2D(obj->pos);
const bool recUnits = !!(c.options & META_KEY);
const bool recEnemyOnly = (c.options & META_KEY) && (c.options & CONTROL_KEY);
const bool recSpecial = !!(c.options & CONTROL_KEY);
ReclaimOption recopt = REC_NORESCHECK;
if (recUnits) recopt |= REC_UNITS;
if (recEnemyOnly) recopt |= REC_ENEMYONLY;
if (recSpecial) recopt |= REC_SPECIAL;
const int rid = FindReclaimTarget(pos, radius, c.options, recopt, curdist);
if ((rid > 0) && (rid != uid)) {
FinishCommand();
RemoveUnitFromReclaimers(owner);
RemoveUnitFromFeatureReclaimers(owner);
return;
}
}
}
if (uid >= uh->MaxUnits()) { // reclaim feature
CFeature* feature = featureHandler->GetFeature(uid - uh->MaxUnits());
if (feature != NULL) {
bool featureBeingResurrected = IsFeatureBeingResurrected(feature->id, owner);
featureBeingResurrected &= (c.options & INTERNAL_ORDER) && !(c.options & CONTROL_KEY);
if (featureBeingResurrected || !ReclaimObject(feature)) {
StopMove();
FinishCommand();
RemoveUnitFromFeatureReclaimers(owner);
} else {
AddUnitToFeatureReclaimers(owner);
}
} else {
StopMove();
FinishCommand();
RemoveUnitFromFeatureReclaimers(owner);
}
RemoveUnitFromReclaimers(owner);
} else { // reclaim unit
CUnit* unit = uh->GetUnit(uid);
if (unit != NULL && c.params.size() == 5) {
const float3 pos(c.params[1], c.params[2], c.params[3]);
const float radius = c.params[4] + 100.0f; // do not walk too far outside reclaim area
const bool outOfReclaimRange =
(pos.SqDistance2D(unit->pos) > radius * radius) ||
(builder->curReclaim == unit && unit->isMoving && !IsInBuildRange(unit));
const bool busyAlliedBuilder =
unit->unitDef->builder &&
!unit->commandAI->commandQue.empty() &&
teamHandler->Ally(owner->allyteam, unit->allyteam);
if (outOfReclaimRange || busyAlliedBuilder) {
StopMove();
RemoveUnitFromReclaimers(owner);
FinishCommand();
RemoveUnitFromFeatureReclaimers(owner);
return;
}
}
if (unit != NULL && unit != owner && unit->unitDef->reclaimable && UpdateTargetLostTimer(unit->id) && unit->AllowedReclaim(owner)) {
if (!ReclaimObject(unit)) {
StopMove();
FinishCommand();
} else {
AddUnitToReclaimers(owner);
}
} else {
RemoveUnitFromReclaimers(owner);
FinishCommand();
}
RemoveUnitFromFeatureReclaimers(owner);
}
} else if (c.params.size() == 4) {
// area reclaim
const float3 pos = c.GetPos(0);
const float radius = c.params[3];
const bool recUnits = !!(c.options & META_KEY);
const bool recEnemyOnly = (c.options & META_KEY) && (c.options & CONTROL_KEY);
const bool recSpecial = !!(c.options & CONTROL_KEY);
RemoveUnitFromReclaimers(owner);
RemoveUnitFromFeatureReclaimers(owner);
builder->StopBuild();
ReclaimOption recopt = REC_NORESCHECK;
if (recUnits) recopt |= REC_UNITS;
if (recEnemyOnly) recopt |= REC_ENEMYONLY;
if (recSpecial) recopt |= REC_SPECIAL;
if (FindReclaimTargetAndReclaim(pos, radius, c.options, recopt)) {
inCommand = false;
SlowUpdate();
return;
}
if(!(c.options & ALT_KEY)){
FinishCommand();
}
} else {
// wrong number of parameters
RemoveUnitFromReclaimers(owner);
RemoveUnitFromFeatureReclaimers(owner);
FinishCommand();
}
}
void CBuilderCAI::ExecuteGuard(Command& c)
{
if (!owner->unitDef->canGuard)
return;
CBuilder* builder = (CBuilder*) owner;
CUnit* guardee = uh->GetUnit(c.params[0]);
if (guardee == NULL) { FinishCommand(); return; }
if (guardee == owner) { FinishCommand(); return; }
if (UpdateTargetLostTimer(guardee->id) == 0) { FinishCommand(); return; }
if (guardee->outOfMapTime > (GAME_SPEED * 5)) { FinishCommand(); return; }
if (CBuilder* b = dynamic_cast<CBuilder*>(guardee)) {
if (b->terraforming) {
if (MoveInBuildRange(b->terraformCenter, b->terraformRadius * 0.7f)) {
builder->HelpTerraform(b);
} else {
StopSlowGuard();
}
return;
} else if (b->curReclaim && owner->unitDef->canReclaim) {
StopSlowGuard();
if (!ReclaimObject(b->curReclaim)) {
StopMove();
}
return;
} else if (b->curResurrect && owner->unitDef->canResurrect) {
StopSlowGuard();
if (!ResurrectObject(b->curResurrect)) {
StopMove();
}
return;
} else {
builder->StopBuild();
}
const bool pushRepairCommand =
( b->curBuild != NULL) &&
( b->curBuild->soloBuilder == NULL || b->curBuild->soloBuilder == owner) &&
(( b->curBuild->beingBuilt && owner->unitDef->canAssist) ||
( !b->curBuild->beingBuilt && owner->unitDef->canRepair));
if (pushRepairCommand) {
StopSlowGuard();
Command nc(CMD_REPAIR, c.options);
nc.params.push_back(b->curBuild->id);
commandQue.push_front(nc);
inCommand = false;
SlowUpdate();
return;
}
}
if (CFactory* fac = dynamic_cast<CFactory*>(guardee)) {
const bool pushRepairCommand =
( fac->curBuild != NULL) &&
( fac->curBuild->soloBuilder == NULL || fac->curBuild->soloBuilder == owner) &&
(( fac->curBuild->beingBuilt && owner->unitDef->canAssist) ||
(!fac->curBuild->beingBuilt && owner->unitDef->canRepair));
if (pushRepairCommand) {
StopSlowGuard();
Command nc(CMD_REPAIR, c.options);
nc.params.push_back(fac->curBuild->id);
commandQue.push_front(nc);
inCommand = false;
// SlowUpdate();
return;
}
}
if (!(c.options & CONTROL_KEY) && IsUnitBeingReclaimed(guardee, owner))
return;
const float3 pos = guardee->pos;
const float radius = (guardee->immobile) ? guardee->radius : guardee->radius * 0.8f; // in case of mobile units reduce radius a bit
if (MoveInBuildRange(pos, radius)) {
StartSlowGuard(guardee->moveType->GetMaxSpeed());
const bool pushRepairCommand =
( guardee->health < guardee->maxHealth) &&
( guardee->soloBuilder == NULL || guardee->soloBuilder == owner) &&
(( guardee->beingBuilt && owner->unitDef->canAssist) ||
(!guardee->beingBuilt && owner->unitDef->canRepair));
if (pushRepairCommand) {
StopSlowGuard();
Command nc(CMD_REPAIR, c.options);
nc.params.push_back(guardee->id);
commandQue.push_front(nc);
inCommand = false;
return;
} else {
NonMoving();
}
} else {
StopSlowGuard();
}
}
void CBuilderCAI::ExecuteReclaim(Command& c)
{
assert(owner->unitDef->canReclaim);
if(c.params.size()==1){
int id=(int) c.params[0];
if (id >= MAX_UNITS) { //reclaim feature
const CFeatureSet& fset = featureHandler->GetActiveFeatures();
CFeatureSet::const_iterator it = fset.find(id - MAX_UNITS);
if (it != fset.end()) {
CFeature* feature = *it;
if(!ReclaimObject(feature)){
StopMove();
FinishCommand();
RemoveUnitFromFeatureReclaimers(owner);
} else {
AddUnitToFeatureReclaimers(owner);
}
} else {
StopMove();
FinishCommand();
RemoveUnitFromFeatureReclaimers(owner);
}
RemoveUnitFromReclaimers(owner);
} else { //reclaim unit
CUnit* unit=uh->units[id];
if(unit && unit!=owner && unit->unitDef->reclaimable && UpdateTargetLostTimer(id) && unit->AllowedReclaim(owner) ){
if(!ReclaimObject(unit)){
StopMove();
FinishCommand();
} else {
AddUnitToReclaimers(owner);
}
} else {
RemoveUnitFromReclaimers(owner);
FinishCommand();
}
RemoveUnitFromFeatureReclaimers(owner);
}
} else if(c.params.size()==4){//area reclaim
float3 pos(c.params[0],c.params[1],c.params[2]);
float radius=c.params[3];
const bool recAnyTeam = ((c.options & CONTROL_KEY) != 0);
RemoveUnitFromReclaimers(owner);
RemoveUnitFromFeatureReclaimers(owner);
if (FindReclaimableFeatureAndReclaim(pos, radius, c.options, true, recAnyTeam)) {
inCommand=false;
SlowUpdate();
return;
}
if(!(c.options & ALT_KEY)){
FinishCommand();
}
} else { //wrong number of parameters
RemoveUnitFromReclaimers(owner);
RemoveUnitFromFeatureReclaimers(owner);
FinishCommand();
}
return;
}
void CBuilderCAI::ExecuteRepair(Command& c)
{
// not all builders are repair-capable by default
if (!owner->unitDef->canRepair)
return;
CBuilder* builder = (CBuilder*) owner;
if (c.params.size() == 1 || c.params.size() == 5) {
// repair unit
CUnit* unit = uh->GetUnit(c.params[0]);
if (unit == NULL) {
FinishCommand();
return;
}
if (tempOrder && owner->moveState == MOVESTATE_MANEUVER) {
// limit how far away we go
if (LinePointDist(commandPos1, commandPos2, unit->pos) > 500) {
StopMove();
FinishCommand();
return;
}
}
if (c.params.size() == 5) {
const float3 pos(c.params[1], c.params[2], c.params[3]);
const float radius = c.params[4] + 100.0f; // do not walk too far outside repair area
if ((pos - unit->pos).SqLength2D() > radius * radius ||
(unit->isMoving && (((c.options & INTERNAL_ORDER) && !TargetInterceptable(unit, unit->speed.Length2D())) || builder->curBuild == unit)
&& !IsInBuildRange(unit))) {
StopMove();
FinishCommand();
return;
}
}
// do not consider units under construction irreparable
// even if they can be repaired
bool canRepairUnit = true;
canRepairUnit &= ((unit->beingBuilt) || (unit->unitDef->repairable && (unit->health < unit->maxHealth)));
canRepairUnit &= ((unit != owner) || owner->unitDef->canSelfRepair);
canRepairUnit &= (!unit->soloBuilder || (unit->soloBuilder == owner));
canRepairUnit &= (!(c.options & INTERNAL_ORDER) || (c.options & CONTROL_KEY) || !IsUnitBeingReclaimed(unit, owner));
canRepairUnit &= (UpdateTargetLostTimer(unit->id) != 0);
if (canRepairUnit) {
if (MoveInBuildRange(unit)) {
builder->SetRepairTarget(unit);
}
} else {
StopMove();
FinishCommand();
}
} else if (c.params.size() == 4) {
// area repair
const float3 pos = c.GetPos(0);
const float radius = c.params[3];
builder->StopBuild();
if (FindRepairTargetAndRepair(pos, radius, c.options, false, (c.options & META_KEY))) {
inCommand = false;
SlowUpdate();
return;
}
if (!(c.options & ALT_KEY)) {
FinishCommand();
}
} else {
FinishCommand();
}
return;
}
void CMobileCAI::SlowUpdate()
{
if(owner->unitDef->maxFuel>0 && dynamic_cast<CTAAirMoveType*>(owner->moveType)){
CTAAirMoveType* myPlane=(CTAAirMoveType*)owner->moveType;
if(myPlane->reservedPad){
return;
} else {
if(owner->currentFuel <= 0){
StopMove();
owner->userAttackGround=false;
owner->userTarget=0;
inCommand=false;
CAirBaseHandler::LandingPad* lp=airBaseHandler->FindAirBase(owner,8000,owner->unitDef->minAirBasePower);
if(lp){
myPlane->AddDeathDependence(lp);
myPlane->reservedPad=lp;
myPlane->padStatus=0;
myPlane->oldGoalPos=myPlane->goalPos;
return;
}
float3 landingPos = airBaseHandler->FindClosestAirBasePos(owner,8000,owner->unitDef->minAirBasePower);
if(landingPos != ZeroVector && owner->pos.distance2D(landingPos) > 300){
inCommand=false;
StopMove();
SetGoal(landingPos,owner->pos);
} else {
if(myPlane->aircraftState == CTAAirMoveType::AIRCRAFT_FLYING)
myPlane->SetState(CTAAirMoveType::AIRCRAFT_LANDING);
}
return;
}
if(owner->currentFuel < myPlane->repairBelowHealth*owner->unitDef->maxFuel){
if(commandQue.empty() || commandQue.front().id==CMD_PATROL){
CAirBaseHandler::LandingPad* lp=airBaseHandler->FindAirBase(owner,8000,owner->unitDef->minAirBasePower);
if(lp){
StopMove();
owner->userAttackGround=false;
owner->userTarget=0;
inCommand=false;
myPlane->AddDeathDependence(lp);
myPlane->reservedPad=lp;
myPlane->padStatus=0;
myPlane->oldGoalPos=myPlane->goalPos;
if(myPlane->aircraftState==CTAAirMoveType::AIRCRAFT_LANDED){
myPlane->SetState(CTAAirMoveType::AIRCRAFT_TAKEOFF);
}
return;
}
}
}
}
}
if(!commandQue.empty() && commandQue.front().timeOut<gs->frameNum){
StopMove();
FinishCommand();
return;
}
if(commandQue.empty()) {
// if(!owner->ai || owner->ai->State() != CHasState::Active) {
IdleCheck();
// }
if(commandQue.empty() || commandQue.front().id==CMD_ATTACK) //the attack order could terminate directly and thus cause a loop
return;
}
float3 curPos=owner->pos;
// treat any following CMD_SET_WANTED_MAX_SPEED commands as options
// to the current command (and ignore them when it's their turn)
if (commandQue.size() >= 2) {
deque<Command>::iterator it = commandQue.begin();
it++;
const Command& c = *it;
if ((c.id == CMD_SET_WANTED_MAX_SPEED) && (c.params.size() >= 1)) {
const float defMaxSpeed = owner->maxSpeed;
const float newMaxSpeed = min(c.params[0], defMaxSpeed);
owner->moveType->SetMaxSpeed(newMaxSpeed);
}
}
Command& c=commandQue.front();
switch(c.id){
case CMD_WAIT:{
break;
}
case CMD_STOP:{
StopMove();
CCommandAI::SlowUpdate();
break;
}
case CMD_SET_WANTED_MAX_SPEED:{
if (repeatOrders && (commandQue.size() >= 2) &&
(commandQue.back().id != CMD_SET_WANTED_MAX_SPEED)) {
commandQue.push_back(commandQue.front());
}
commandQue.pop_front();
SlowUpdate();
break;
}
case CMD_MOVE:{
float3 pos(c.params[0],c.params[1],c.params[2]);
if(!(pos==goalPos)){
SetGoal(pos,curPos);
}
if((curPos-goalPos).SqLength2D()<1024 || owner->moveType->progressState==CMoveType::Failed){
FinishCommand();
}
break;
}
case CMD_PATROL:{
assert(owner->unitDef->canPatrol);
if(c.params.size()<3){ //this shouldnt happen but anyway ...
logOutput.Print("Error: got patrol cmd with less than 3 params on %s in mobilecai",
owner->unitDef->humanName.c_str());
return;
}
Command temp;
temp.id = CMD_FIGHT;
temp.params.push_back(c.params[0]);
temp.params.push_back(c.params[1]);
temp.params.push_back(c.params[2]);
temp.options = c.options|INTERNAL_ORDER;
commandQue.push_back(c);
commandQue.pop_front();
commandQue.push_front(temp);
if(owner->group){
owner->group->CommandFinished(owner->id,CMD_PATROL);
}
SlowUpdate();
return;
}
case CMD_FIGHT:{
assert((c.options & INTERNAL_ORDER) || owner->unitDef->canFight);
if(tempOrder){
inCommand = true;
tempOrder = false;
}
if(c.params.size()<3){ //this shouldnt happen but anyway ...
logOutput.Print("Error: got fight cmd with less than 3 params on %s in mobilecai",
owner->unitDef->humanName.c_str());
return;
}
if(c.params.size() >= 6){
if(!inCommand){
commandPos1 = float3(c.params[3],c.params[4],c.params[5]);
}
} else {
// Some hackery to make sure the line (commandPos1,commandPos2) is NOT
// rotated (only shortened) if we reach this because the previous return
// fight command finished by the 'if((curPos-pos).SqLength2D()<(64*64)){'
// condition, but is actually updated correctly if you click somewhere
// outside the area close to the line (for a new command).
commandPos1 = ClosestPointOnLine(commandPos1, commandPos2, curPos);
if ((curPos-commandPos1).SqLength2D()>(96*96)) {
commandPos1 = curPos;
}
}
float3 pos(c.params[0],c.params[1],c.params[2]);
if(!inCommand){
inCommand = true;
commandPos2 = pos;
}
if(pos!=goalPos){
SetGoal(pos,curPos);
}
if(owner->unitDef->canAttack && owner->fireState==2){
float3 curPosOnLine = ClosestPointOnLine(commandPos1, commandPos2, curPos);
CUnit* enemy=helper->GetClosestEnemyUnit(
curPosOnLine, owner->maxRange+100*owner->moveState*owner->moveState, owner->allyteam);
if(enemy && (owner->hasUWWeapons || !enemy->isUnderWater)
&& !(owner->unitDef->noChaseCategory & enemy->category) && !owner->weapons.empty()){
Command c2;
c2.id=CMD_ATTACK;
c2.options=c.options|INTERNAL_ORDER;
c2.params.push_back(enemy->id);
PushOrUpdateReturnFight();
commandQue.push_front(c2);
inCommand=false;
tempOrder=true;
if(lastPC!=gs->frameNum){ //avoid infinite loops
lastPC=gs->frameNum;
SlowUpdate();
}
return;
}
}
if((curPos-goalPos).SqLength2D()<(64*64) || owner->moveType->progressState==CMoveType::Failed){
FinishCommand();
}
return;
}
case CMD_DGUN:
if(uh->limitDgun && owner->unitDef->isCommander
&& owner->pos.distance(gs->Team(owner->team)->startPos)>uh->dgunRadius){
StopMove();
FinishCommand();
return;
}
//no break
case CMD_ATTACK:
assert(owner->unitDef->canAttack);
if(tempOrder && owner->moveState<2){ //limit how far away we fly
if(orderTarget && LinePointDist(commandPos1,commandPos2,orderTarget->pos) > 500+owner->maxRange){
StopMove();
FinishCommand();
break;
}
}
if(!inCommand){
if(c.params.size()==1){
if(uh->units[int(c.params[0])]!=0 && uh->units[int(c.params[0])]!=owner){
float3 fix=uh->units[int(c.params[0])]->pos+owner->posErrorVector*128;
SetGoal(fix,curPos);
orderTarget=uh->units[int(c.params[0])];
AddDeathDependence(orderTarget);
inCommand=true;
} else {
StopMove(); //cancel keeppointingto
FinishCommand();
break;
}
} else {
float3 pos(c.params[0],c.params[1],c.params[2]);
SetGoal(pos,curPos);
inCommand=true;
}
}
else if ((c.params.size() == 3) && (owner->commandShotCount > 0) && (commandQue.size() > 1)) {
// the trailing CMD_SET_WANTED_MAX_SPEED in a command pair does not count
if ((commandQue.size() != 2) || (commandQue.back().id != CMD_SET_WANTED_MAX_SPEED)) {
StopMove();
FinishCommand();
break;
}
}
if(targetDied || (c.params.size() == 1 && UpdateTargetLostTimer(int(c.params[0])) == 0)){
StopMove(); //cancel keeppointingto
FinishCommand();
break;
}
if(orderTarget){
//note that we handle aircrafts slightly differently
if((((owner->AttackUnit(orderTarget, c.id==CMD_DGUN)
&& owner->weapons.size() > 0
&& owner->weapons.front()->range -
owner->weapons.front()->relWeaponPos.Length() >
orderTarget->pos.distance(owner->pos))
|| dynamic_cast<CTAAirMoveType*>(owner->moveType))
&& (owner->pos-orderTarget->pos).Length2D() <
owner->maxRange*0.9f)
|| (owner->pos-orderTarget->pos).SqLength2D()<1024){
StopMove();
owner->moveType->KeepPointingTo(orderTarget,
min((float)(owner->losRadius*SQUARE_SIZE*2),
owner->maxRange*0.9f), true);
} else if((orderTarget->pos+owner->posErrorVector*128).distance2D(goalPos) > 10+orderTarget->pos.distance2D(owner->pos)*0.2f){
float3 fix=orderTarget->pos+owner->posErrorVector*128;
SetGoal(fix,curPos);
}
} else {
float3 pos(c.params[0],c.params[1],c.params[2]);
if((owner->AttackGround(pos,c.id==CMD_DGUN) && owner->weapons.size() > 0
&& (owner->pos-pos).Length() <
owner->weapons.front()->range -
owner->weapons.front()->relWeaponPos.Length())
|| (owner->pos-pos).SqLength2D()<1024){
StopMove();
owner->moveType->KeepPointingTo(pos, owner->maxRange*0.9f, true);
} else if(pos.distance2D(goalPos)>10){
SetGoal(pos,curPos);
}
}
break;
case CMD_GUARD:
assert(owner->unitDef->canGuard);
if(int(c.params[0]) >= 0 && uh->units[int(c.params[0])] != NULL && UpdateTargetLostTimer(int(c.params[0]))){
CUnit* guarded=uh->units[int(c.params[0])];
if(owner->unitDef->canAttack && guarded->lastAttacker && guarded->lastAttack+40<gs->frameNum
&& (owner->hasUWWeapons || !guarded->lastAttacker->isUnderWater)){
Command nc;
nc.id=CMD_ATTACK;
nc.params.push_back(guarded->lastAttacker->id);
nc.options=c.options;
commandQue.push_front(nc);
SlowUpdate();
return;
} else {
float3 dif=guarded->pos-curPos;
dif.Normalize();
float3 goal=guarded->pos-dif*(guarded->radius+owner->radius+64);
if((goal-curPos).SqLength2D()<8000){
StopMove();
NonMoving();
}else{
if((goalPos-goal).SqLength2D()>3600)
SetGoal(goal,curPos);
}
}
} else {
FinishCommand();
}
break;
default:
CCommandAI::SlowUpdate();
break;
}
}
void CTransportCAI::SlowUpdate(void)
{
if(commandQue.empty()){
CMobileCAI::SlowUpdate();
return;
}
CTransportUnit* transport=(CTransportUnit*)owner;
Command& c=commandQue.front();
switch(c.id){
case CMD_LOAD_UNITS:
if(c.params.size()==1){ //load single unit
if(transport->transportCapacityUsed >= owner->unitDef->transportCapacity){
FinishCommand();
return;
}
if(inCommand){
if(!owner->cob->busy)
FinishCommand();
return;
}
CUnit* unit=uh->units[(int)c.params[0]];
if(unit && CanTransport(unit) && UpdateTargetLostTimer(int(c.params[0]))){
toBeTransportedUnitId=unit->id;
unit->toBeTransported=true;
if(unit->mass+transport->transportMassUsed > owner->unitDef->transportMass){
FinishCommand();
return;
}
if(goalPos.distance2D(unit->pos)>10){
float3 fix = unit->pos;
SetGoal(fix,owner->pos,64);
}
if(unit->pos.distance2D(owner->pos)<owner->unitDef->loadingRadius*0.9f){
if(CTAAirMoveType* am=dynamic_cast<CTAAirMoveType*>(owner->moveType)){ //handle air transports differently
float3 wantedPos=unit->pos+UpVector*unit->model->height;
SetGoal(wantedPos,owner->pos);
am->dontCheckCol=true;
am->ForceHeading(unit->heading);
am->SetWantedAltitude(unit->model->height);
am->maxDrift=1;
//logOutput.Print("cai dist %f %f %f",owner->pos.distance(wantedPos),owner->pos.distance2D(wantedPos),owner->pos.y-wantedPos.y);
if(owner->pos.distance(wantedPos)<4 && abs(owner->heading-unit->heading)<50 && owner->updir.dot(UpVector)>0.995f){
am->dontCheckCol=false;
am->dontLand=true;
std::vector<int> args;
args.push_back((int)(unit->model->height*65536));
owner->cob->Call("BeginTransport",args);
std::vector<int> args2;
args2.push_back(0);
args2.push_back((int)(unit->model->height*65536));
owner->cob->Call("QueryTransport",args2);
((CTransportUnit*)owner)->AttachUnit(unit,args2[0]);
am->SetWantedAltitude(0);
FinishCommand();
return;
}
} else {
inCommand=true;
scriptReady=false;
StopMove();
std::vector<int> args;
args.push_back(unit->id);
owner->cob->Call("TransportPickup",args,ScriptCallback,this,0);
}
}
} else {
FinishCommand();
}
} else if(c.params.size()==4){ //load in radius
if(lastCall==gs->frameNum) //avoid infinite loops
return;
lastCall=gs->frameNum;
float3 pos(c.params[0],c.params[1],c.params[2]);
float radius=c.params[3];
CUnit* unit=FindUnitToTransport(pos,radius);
if(unit && ((CTransportUnit*)owner)->transportCapacityUsed < owner->unitDef->transportCapacity){
Command c2;
c2.id=CMD_LOAD_UNITS;
c2.params.push_back(unit->id);
c2.options=c.options | INTERNAL_ORDER;
commandQue.push_front(c2);
inCommand=false;
SlowUpdate();
return;
} else {
FinishCommand();
return;
}
}
break;
case CMD_UNLOAD_UNITS:{
if(lastCall==gs->frameNum) //avoid infinite loops
return;
lastCall=gs->frameNum;
if(((CTransportUnit*)owner)->transported.empty()){
FinishCommand();
return;
}
float3 pos(c.params[0],c.params[1],c.params[2]);
float radius=c.params[3];
float3 found;
bool canUnload=FindEmptySpot(pos,max(16.0f,radius),((CTransportUnit*)owner)->transported.front().unit->radius,found);
if(canUnload){
Command c2;
c2.id=CMD_UNLOAD_UNIT;
c2.params.push_back(found.x);
c2.params.push_back(found.y);
c2.params.push_back(found.z);
c2.options=c.options | INTERNAL_ORDER;
commandQue.push_front(c2);
SlowUpdate();
return;
} else {
FinishCommand();
}
break;}
case CMD_UNLOAD_UNIT:
if(inCommand){
if(!owner->cob->busy)
// if(scriptReady)
FinishCommand();
} else {
if(((CTransportUnit*)owner)->transported.empty()){
FinishCommand();
return;
}
float3 pos(c.params[0],c.params[1],c.params[2]);
if(goalPos.distance2D(pos)>20){
SetGoal(pos,owner->pos);
}
if(pos.distance2D(owner->pos)<owner->unitDef->loadingRadius*0.9f){
if(CTAAirMoveType* am=dynamic_cast<CTAAirMoveType*>(owner->moveType)){ //handle air transports differently
pos.y=ground->GetHeight(pos.x,pos.z);
CUnit* unit=((CTransportUnit*)owner)->transported.front().unit;
float3 wantedPos=pos+UpVector*unit->model->height;
SetGoal(wantedPos,owner->pos);
am->SetWantedAltitude(unit->model->height);
am->maxDrift=1;
if(owner->pos.distance(wantedPos)<8 && owner->updir.dot(UpVector)>0.99f){
am->dontLand=false;
owner->cob->Call("EndTransport");
((CTransportUnit*)owner)->DetachUnit(unit);
float3 fix = owner->pos+owner->frontdir*20;
SetGoal(fix,owner->pos); //move the transport away slightly
FinishCommand();
}
} else {
inCommand=true;
scriptReady=false;
StopMove();
std::vector<int> args;
args.push_back(((CTransportUnit*)owner)->transported.front().unit->id);
args.push_back(PACKXZ(pos.x, pos.z));
owner->cob->Call("TransportDrop",args,ScriptCallback,this,0);
}
}
}
break;
default:
CMobileCAI::SlowUpdate();
break;
}
}
/**
* @brief Causes this CMobileCAI to execute the attack order c
*/
void CMobileCAI::ExecuteAttack(Command &c)
{
assert(owner->unitDef->canAttack);
// limit how far away we fly
if (tempOrder && (owner->moveState < 2) && orderTarget
&& LinePointDist(ClosestPointOnLine(commandPos1, commandPos2, owner->pos),
commandPos2, orderTarget->pos)
> (500 * owner->moveState + owner->maxRange)) {
StopMove();
FinishCommand();
return;
}
// check if we are in direct command of attacker
if (!inCommand) {
// don't start counting until the owner->AttackGround() order is given
owner->commandShotCount = -1;
if (c.params.size() == 1) {
CUnit* targetUnit = uh->GetUnit(c.params[0]);
// check if we have valid target parameter and that we aren't attacking ourselves
if (targetUnit != NULL && targetUnit != owner) {
float3 fix = targetUnit->pos + owner->posErrorVector * 128;
float3 diff = float3(fix - owner->pos).Normalize();
SetGoal(fix - diff * targetUnit->radius, owner->pos);
orderTarget = targetUnit;
AddDeathDependence(orderTarget);
inCommand = true;
} else {
// unit may not fire on itself, cancel order
StopMove();
FinishCommand();
return;
}
}
else if (c.params.size() >= 3) {
// user gave force-fire attack command
float3 pos(c.params[0], c.params[1], c.params[2]);
SetGoal(pos, owner->pos);
inCommand = true;
}
}
else if ((c.params.size() == 3) && (owner->commandShotCount > 0) && (commandQue.size() > 1)) {
// the trailing CMD_SET_WANTED_MAX_SPEED in a command pair does not count
if ((commandQue.size() > 2) || (commandQue.back().id != CMD_SET_WANTED_MAX_SPEED)) {
StopMove();
FinishCommand();
return;
}
}
// if our target is dead or we lost it then stop attacking
// NOTE: unit should actually just continue to target area!
if (targetDied || (c.params.size() == 1 && UpdateTargetLostTimer(int(c.params[0])) == 0)) {
// cancel keeppointingto
StopMove();
FinishCommand();
return;
}
// user clicked on enemy unit (note that we handle aircrafts slightly differently)
if (orderTarget) {
//bool b1 = owner->AttackUnit(orderTarget, c.id == CMD_DGUN);
bool b2 = false;
bool b3 = false;
bool b4 = false;
float edgeFactor = 0.f; // percent offset to target center
float3 diff = owner->pos - orderTarget->midPos;
if (owner->weapons.size() > 0) {
if (!(c.options & ALT_KEY) && SkipParalyzeTarget(orderTarget)) {
StopMove();
FinishCommand();
return;
}
CWeapon* w = owner->weapons.front();
// if we have at least one weapon then check if we
// can hit target with our first (meanest) one
b2 = w->TryTargetRotate(orderTarget, c.id == CMD_DGUN);
b3 = Square(w->range - (w->relWeaponPos).Length())
> (orderTarget->pos.SqDistance(owner->pos));
b4 = w->TryTargetHeading(GetHeadingFromVector(-diff.x, -diff.z),
orderTarget->pos, orderTarget != NULL, orderTarget);
edgeFactor = fabs(w->targetBorder);
}
float diffLength2d = diff.Length2D();
// if w->AttackUnit() returned true then we are already
// in range with our biggest weapon so stop moving
// also make sure that we're not locked in close-in/in-range state loop
// due to rotates invoked by in-range or out-of-range states
if (b2) {
if (!(tempOrder && owner->moveState == 0)
&& (diffLength2d * 1.4f > owner->maxRange
- orderTarget->speed.SqLength()
/ owner->unitDef->maxAcc)
&& b4 && diff.dot(orderTarget->speed) < 0)
{
SetGoal(owner->pos + (orderTarget->speed * 80), owner->pos,
SQUARE_SIZE, orderTarget->speed.Length() * 1.1f);
} else {
StopMove();
// FIXME kill magic frame number
if (gs->frameNum > lastCloseInTry + MAX_CLOSE_IN_RETRY_TICKS) {
owner->moveType->KeepPointingTo(orderTarget->midPos,
std::min((float) owner->losRadius * loshandler->losDiv,
owner->maxRange * 0.9f), true);
}
}
owner->AttackUnit(orderTarget, c.id == CMD_DGUN);
}
// if we're on hold pos in a temporary order, then none of the close-in
// code below should run, and the attack command is cancelled.
else if (tempOrder && owner->moveState == 0) {
StopMove();
FinishCommand();
return;
}
// if ((our movetype has type TAAirMoveType and length of 2D vector from us to target
// less than 90% of our maximum range) OR squared length of 2D vector from us to target
// less than 1024) then we are close enough
else if(diffLength2d < (owner->maxRange * 0.9f)){
if (dynamic_cast<CTAAirMoveType*>(owner->moveType)
|| (diff.SqLength2D() < 1024))
{
StopMove();
owner->moveType->KeepPointingTo(orderTarget->midPos,
std::min((float) owner->losRadius * loshandler->losDiv,
owner->maxRange * 0.9f), true);
}
// if (((first weapon range minus first weapon length greater than distance to target)
// and length of 2D vector from us to target less than 90% of our maximum range)
// then we are close enough, but need to move sideways to get a shot.
//assumption is flawed: The unit may be aiming or otherwise unable to shoot
else if (owner->unitDef->strafeToAttack && b3 && diffLength2d < (owner->maxRange * 0.9f))
{
moveDir ^= (owner->moveType->progressState == AMoveType::Failed);
float sin = moveDir ? 3.0/5 : -3.0/5;
float cos = 4.0/5;
float3 goalDiff(0, 0, 0);
goalDiff.x = diff.dot(float3(cos, 0, -sin));
goalDiff.z = diff.dot(float3(sin, 0, cos));
goalDiff *= (diffLength2d < (owner->maxRange * 0.3f)) ? 1/cos : cos;
goalDiff += orderTarget->pos;
SetGoal(goalDiff, owner->pos);
}
}
// if 2D distance of (target position plus attacker error vector times 128)
// to goal position greater than
// (10 plus 20% of 2D distance between attacker and target) then we need to close
// in on target more
else if ((orderTarget->pos + owner->posErrorVector * 128).SqDistance2D(goalPos)
> Square(10 + orderTarget->pos.distance2D(owner->pos) * 0.2f)) {
// if the target isn't in LOS, go to its approximate position
// otherwise try to go precisely to the target
// this should fix issues with low range weapons (mainly melee)
float3 fix = orderTarget->pos +
(orderTarget->losStatus[owner->allyteam] & LOS_INLOS ?
float3(0.f,0.f,0.f) :
owner->posErrorVector * 128);
float3 norm = float3(fix - owner->pos).Normalize();
float3 goal = fix - norm*(orderTarget->radius*edgeFactor*0.8f);
SetGoal(goal, owner->pos);
if (lastCloseInTry < gs->frameNum + MAX_CLOSE_IN_RETRY_TICKS)
lastCloseInTry = gs->frameNum;
}
}
// user is attacking ground
else if (c.params.size() >= 3) {
const float3 pos(c.params[0], c.params[1], c.params[2]);
const float3 diff = owner->pos - pos;
if (owner->weapons.size() > 0) {
// if we have at least one weapon then check if
// we can hit position with our first (assumed
// to be meanest) one
CWeapon* w = owner->weapons.front();
// XXX hack - dgun overrides any checks
if (c.id == CMD_DGUN) {
float rr = owner->maxRange * owner->maxRange;
for (vector<CWeapon*>::iterator it = owner->weapons.begin();
it != owner->weapons.end(); ++it) {
if (dynamic_cast<CDGunWeapon*>(*it))
rr = (*it)->range * (*it)->range;
}
if (diff.SqLength() < rr) {
StopMove();
owner->AttackGround(pos, c.id == CMD_DGUN);
owner->moveType->KeepPointingTo(pos, owner->maxRange * 0.9f, true);
}
} else {
const bool inAngle = w->TryTargetRotate(pos, c.id == CMD_DGUN);
const bool inRange = diff.SqLength2D() < Square(w->range - (w->relWeaponPos).Length2D());
if (inAngle || inRange) {
StopMove();
owner->AttackGround(pos, c.id == CMD_DGUN);
owner->moveType->KeepPointingTo(pos, owner->maxRange * 0.9f, true);
}
}
}
else if (diff.SqLength2D() < 1024) {
StopMove();
owner->moveType->KeepPointingTo(pos, owner->maxRange * 0.9f, true);
}
// if we are more than 10 units distant from target position then keeping moving closer
else if (pos.SqDistance2D(goalPos) > 100) {
SetGoal(pos, owner->pos);
}
}
}
void CTransportCAI::ExecuteLoadUnits(Command& c)
{
CTransportUnit* transport = reinterpret_cast<CTransportUnit*>(owner);
if (c.params.size() == 1) {
// load single unit
CUnit* unit = unitHandler->GetUnit(c.params[0]);
if (unit == NULL) {
FinishCommand();
return;
}
if (c.options & INTERNAL_ORDER) {
if (unit->commandAI->commandQue.empty()) {
if (!LoadStillValid(unit)) {
FinishCommand();
return;
}
} else {
Command& currentUnitCommand = unit->commandAI->commandQue[0];
if ((currentUnitCommand.GetID() == CMD_LOAD_ONTO) && (currentUnitCommand.params.size() == 1) && (int(currentUnitCommand.params[0]) == owner->id)) {
if ((unit->moveType->progressState == AMoveType::Failed) && (owner->moveType->progressState == AMoveType::Failed)) {
unit->commandAI->FinishCommand();
FinishCommand();
return;
}
} else if (!LoadStillValid(unit)) {
FinishCommand();
return;
}
}
}
if (inCommand) {
if (!owner->script->IsBusy()) {
FinishCommand();
}
return;
}
if (unit != NULL && CanTransport(unit) && UpdateTargetLostTimer(int(c.params[0]))) {
SetTransportee(unit);
const float sqDist = unit->pos.SqDistance2D(owner->pos);
const bool inLoadingRadius = (sqDist <= Square(owner->unitDef->loadingRadius));
CTransportUnit* trans = static_cast<CTransportUnit*>(owner);
CHoverAirMoveType* am = dynamic_cast<CHoverAirMoveType*>(owner->moveType);
// subtract 1 square to account for PFS/GMT inaccuracy
const bool outOfRange = (goalPos.SqDistance2D(unit->pos) > Square(owner->unitDef->loadingRadius - SQUARE_SIZE));
const bool moveCloser = (!inLoadingRadius && (!owner->IsMoving() || (am != NULL && am->aircraftState != AAirMoveType::AIRCRAFT_FLYING)));
if (outOfRange || moveCloser) {
SetGoal(unit->pos, owner->pos, std::min(64.0f, owner->unitDef->loadingRadius));
}
if (inLoadingRadius) {
if (am != NULL) {
// handle air transports differently
float3 wantedPos = unit->pos;
wantedPos.y = trans->GetTransporteeWantedHeight(wantedPos, unit);
// calls am->StartMoving() which sets forceHeading to false (and also
// changes aircraftState, possibly in mid-pickup) --> must check that
// wantedPos == goalPos using some epsilon tolerance
// we do not want the forceHeading change at point of pickup because
// am->UpdateHeading() will suddenly notice a large deltaHeading and
// break the DOCKING_ANGLE constraint so call am->ForceHeading() next
SetGoal(wantedPos, owner->pos, 1.0f);
am->ForceHeading(trans->GetTransporteeWantedHeading(unit));
am->SetWantedAltitude(wantedPos.y - CGround::GetHeightAboveWater(wantedPos.x, wantedPos.z));
am->maxDrift = 1.0f;
// FIXME: kill the hardcoded constants, use the command's radius
const bool b1 = (owner->pos.SqDistance(wantedPos) < Square(AIRTRANSPORT_DOCKING_RADIUS));
const bool b2 = (std::abs(owner->heading - unit->heading) < AIRTRANSPORT_DOCKING_ANGLE);
const bool b3 = (owner->updir.dot(UpVector) > 0.995f);
if (b1 && b2 && b3) {
am->SetAllowLanding(false);
am->SetWantedAltitude(0.0f);
owner->script->BeginTransport(unit);
SetTransportee(NULL);
transport->AttachUnit(unit, owner->script->QueryTransport(unit));
FinishCommand();
return;
}
} else {
inCommand = true;
StopMove();
owner->script->TransportPickup(unit);
}
} else if (owner->moveType->progressState == AMoveType::Failed && sqDist < (200 * 200)) {
// if we're pretty close already but CGroundMoveType fails because it considers
// the goal clogged (with the future passenger...), just try to move to the
// point halfway between the transport and the passenger.
SetGoal((unit->pos + owner->pos) * 0.5f, owner->pos);
}
} else {
FinishCommand();
}
} else if (c.params.size() == 4) { // area-load
if (lastCall == gs->frameNum) { // avoid infinite loops
return;
}
lastCall = gs->frameNum;
const float3 pos = c.GetPos(0);
const float radius = c.params[3];
CUnit* unit = FindUnitToTransport(pos, radius);
if (unit && CanTransport(unit)) {
Command c2(CMD_LOAD_UNITS, c.options|INTERNAL_ORDER, unit->id);
commandQue.push_front(c2);
inCommand = false;
SlowUpdate();
return;
} else {
FinishCommand();
return;
}
}
isFirstIteration = true;
startingDropPos = -OnesVector;
}
void CMobileCAI::ExecuteAttack(Command &c)
{
assert(owner->unitDef->canAttack);
// limit how far away we fly based on our movestate
if (tempOrder && orderTarget) {
const float3& closestPos = ClosestPointOnLine(commandPos1, commandPos2, owner->pos);
const float curTargetDist = LinePointDist(closestPos, commandPos2, orderTarget->pos);
const float maxTargetDist = (500 * owner->moveState + owner->maxRange);
if (owner->moveState < MOVESTATE_ROAM && curTargetDist > maxTargetDist) {
StopMove();
FinishCommand();
return;
}
}
// check if we are in direct command of attacker
if (!inCommand) {
if (c.params.size() == 1) {
CUnit* targetUnit = unitHandler->GetUnit(c.params[0]);
// check if we have valid target parameter and that we aren't attacking ourselves
if (targetUnit == NULL) { StopMove(); FinishCommand(); return; }
if (targetUnit == owner) { StopMove(); FinishCommand(); return; }
if (targetUnit->GetTransporter() != NULL && !modInfo.targetableTransportedUnits) {
StopMove(); FinishCommand(); return;
}
const float3 tgtErrPos = targetUnit->pos + owner->posErrorVector * 128;
const float3 tgtPosDir = (tgtErrPos - owner->pos).Normalize();
SetGoal(tgtErrPos - tgtPosDir * targetUnit->radius, owner->pos);
SetOrderTarget(targetUnit);
owner->AttackUnit(targetUnit, (c.options & INTERNAL_ORDER) == 0, c.GetID() == CMD_MANUALFIRE);
inCommand = true;
}
else if (c.params.size() >= 3) {
// user gave force-fire attack command
SetGoal(c.GetPos(0), owner->pos);
inCommand = true;
}
}
// if our target is dead or we lost it then stop attacking
// NOTE: unit should actually just continue to target area!
if (targetDied || (c.params.size() == 1 && UpdateTargetLostTimer(int(c.params[0])) == 0)) {
// cancel keeppointingto
StopMove();
FinishCommand();
return;
}
// user clicked on enemy unit (note that we handle aircrafts slightly differently)
if (orderTarget != NULL) {
bool tryTargetRotate = false;
bool tryTargetHeading = false;
float edgeFactor = 0.0f; // percent offset to target center
const float3 targetMidPosVec = owner->midPos - orderTarget->midPos;
const float targetGoalDist = (orderTarget->pos + owner->posErrorVector * 128.0f).SqDistance2D(goalPos);
const float targetPosDist = Square(10.0f + orderTarget->pos.distance2D(owner->pos) * 0.2f);
const float minPointingDist = std::min(1.0f * owner->losRadius * loshandler->losDiv, owner->maxRange * 0.9f);
// FIXME? targetMidPosMaxDist is 3D, but compared with a 2D value
const float targetMidPosDist2D = targetMidPosVec.Length2D();
//const float targetMidPosMaxDist = owner->maxRange - (orderTarget->speed.SqLength() / owner->unitDef->maxAcc);
if (!owner->weapons.empty()) {
if (!(c.options & ALT_KEY) && SkipParalyzeTarget(orderTarget)) {
StopMove();
FinishCommand();
return;
}
}
for (unsigned int wNum = 0; wNum < owner->weapons.size(); wNum++) {
CWeapon* w = owner->weapons[wNum];
if (c.GetID() == CMD_MANUALFIRE) {
assert(owner->unitDef->canManualFire);
if (!w->weaponDef->manualfire) {
continue;
}
}
tryTargetRotate = w->TryTargetRotate(orderTarget, (c.options & INTERNAL_ORDER) == 0);
tryTargetHeading = w->TryTargetHeading(GetHeadingFromVector(-targetMidPosVec.x, -targetMidPosVec.z), orderTarget->pos, orderTarget != NULL, orderTarget);
if (tryTargetRotate || tryTargetHeading)
break;
edgeFactor = math::fabs(w->targetBorder);
}
// if w->AttackUnit() returned true then we are already
// in range with our biggest (?) weapon, so stop moving
// also make sure that we're not locked in close-in/in-range state loop
// due to rotates invoked by in-range or out-of-range states
if (tryTargetRotate) {
const bool canChaseTarget = (!tempOrder || owner->moveState != MOVESTATE_HOLDPOS);
const bool targetBehind = (targetMidPosVec.dot(orderTarget->speed) < 0.0f);
if (canChaseTarget && tryTargetHeading && targetBehind) {
SetGoal(owner->pos + (orderTarget->speed * 80), owner->pos, SQUARE_SIZE, orderTarget->speed.Length() * 1.1f);
} else {
StopMove();
if (gs->frameNum > lastCloseInTry + MAX_CLOSE_IN_RETRY_TICKS) {
owner->moveType->KeepPointingTo(orderTarget->midPos, minPointingDist, true);
}
}
owner->AttackUnit(orderTarget, (c.options & INTERNAL_ORDER) == 0, c.GetID() == CMD_MANUALFIRE);
}
// if we're on hold pos in a temporary order, then none of the close-in
// code below should run, and the attack command is cancelled.
else if (tempOrder && owner->moveState == MOVESTATE_HOLDPOS) {
StopMove();
FinishCommand();
return;
}
// if ((our movetype has type HoverAirMoveType and length of 2D vector from us to target
// less than 90% of our maximum range) OR squared length of 2D vector from us to target
// less than 1024) then we are close enough
else if (targetMidPosDist2D < (owner->maxRange * 0.9f)) {
if (dynamic_cast<CHoverAirMoveType*>(owner->moveType) != NULL || (targetMidPosVec.SqLength2D() < 1024)) {
StopMove();
owner->moveType->KeepPointingTo(orderTarget->midPos, minPointingDist, true);
}
// if (((first weapon range minus first weapon length greater than distance to target)
// and length of 2D vector from us to target less than 90% of our maximum range)
// then we are close enough, but need to move sideways to get a shot.
//assumption is flawed: The unit may be aiming or otherwise unable to shoot
else if (owner->unitDef->strafeToAttack && targetMidPosDist2D < (owner->maxRange * 0.9f)) {
moveDir ^= (owner->moveType->progressState == AMoveType::Failed);
const float sin = moveDir ? 3.0/5 : -3.0/5;
const float cos = 4.0 / 5;
float3 goalDiff;
goalDiff.x = targetMidPosVec.dot(float3(cos, 0, -sin));
goalDiff.z = targetMidPosVec.dot(float3(sin, 0, cos));
goalDiff *= (targetMidPosDist2D < (owner->maxRange * 0.3f)) ? 1/cos : cos;
goalDiff += orderTarget->pos;
SetGoal(goalDiff, owner->pos);
}
}
// if 2D distance of (target position plus attacker error vector times 128)
// to goal position greater than
// (10 plus 20% of 2D distance between attacker and target) then we need to close
// in on target more
else if (targetGoalDist > targetPosDist) {
// if the target isn't in LOS, go to its approximate position
// otherwise try to go precisely to the target
// this should fix issues with low range weapons (mainly melee)
const float3 errPos = ((orderTarget->losStatus[owner->allyteam] & LOS_INLOS)? ZeroVector: owner->posErrorVector * 128.0f);
const float3 tgtPos = orderTarget->pos + errPos;
const float3 norm = (tgtPos - owner->pos).Normalize();
const float3 goal = tgtPos - norm * (orderTarget->radius * edgeFactor * 0.8f);
SetGoal(goal, owner->pos);
if (lastCloseInTry < gs->frameNum + MAX_CLOSE_IN_RETRY_TICKS)
lastCloseInTry = gs->frameNum;
}
}
// user wants to attack the ground; cycle through our
// weapons until we find one that can accomodate him
else if (c.params.size() >= 3) {
const float3 attackPos = c.GetPos(0);
const float3 attackVec = attackPos - owner->pos;
bool foundWeapon = false;
for (unsigned int wNum = 0; wNum < owner->weapons.size(); wNum++) {
CWeapon* w = owner->weapons[wNum];
if (foundWeapon)
break;
// XXX HACK - special weapon overrides any checks
if (c.GetID() == CMD_MANUALFIRE) {
assert(owner->unitDef->canManualFire);
if (!w->weaponDef->manualfire)
continue;
if (attackVec.SqLength() >= (w->range * w->range))
continue;
StopMove();
owner->AttackGround(attackPos, (c.options & INTERNAL_ORDER) == 0, c.GetID() == CMD_MANUALFIRE);
owner->moveType->KeepPointingTo(attackPos, owner->maxRange * 0.9f, true);
foundWeapon = true;
} else {
// NOTE:
// we call TryTargetHeading which is less restrictive than TryTarget
// (eg. the former succeeds even if the unit has not already aligned
// itself with <attackVec>)
if (w->TryTargetHeading(GetHeadingFromVector(attackVec.x, attackVec.z), attackPos, (c.options & INTERNAL_ORDER) == 0, NULL)) {
if (w->TryTargetRotate(attackPos, (c.options & INTERNAL_ORDER) == 0)) {
StopMove();
owner->AttackGround(attackPos, (c.options & INTERNAL_ORDER) == 0, c.GetID() == CMD_MANUALFIRE);
foundWeapon = true;
}
// for gunships, this pitches the nose down such that
// TryTargetRotate (which also checks range for itself)
// has a bigger chance of succeeding
//
// hence it must be called as soon as we get in range
// and may not depend on what TryTargetRotate returns
// (otherwise we might never get a firing solution)
owner->moveType->KeepPointingTo(attackPos, owner->maxRange * 0.9f, true);
}
}
}
#if 0
// no weapons --> no need to stop at an arbitrary distance?
else if (diff.SqLength2D() < 1024) {
StopMove();
owner->moveType->KeepPointingTo(attackPos, owner->maxRange * 0.9f, true);
}
#endif
// if we are unarmed and more than 10 elmos distant
// from target position, then keeping moving closer
if (owner->weapons.empty() && attackPos.SqDistance2D(goalPos) > 100) {
SetGoal(attackPos, owner->pos);
}
}
void CTransportCAI::ExecuteLoadUnits(Command &c)
{
CTransportUnit* transport=(CTransportUnit*)owner;
if(c.params.size()==1){ //load single unit
if(transport->transportCapacityUsed >= owner->unitDef->transportCapacity){
FinishCommand();
return;
}
CUnit* unit=uh->units[(int)c.params[0]];
if (!unit) {
FinishCommand();
return;
}
if(c.options & INTERNAL_ORDER) {
if(unit->commandAI->commandQue.empty()){
if(!LoadStillValid(unit)){
FinishCommand();
return;
}
} else {
Command & currentUnitCommand = unit->commandAI->commandQue[0];
if(currentUnitCommand.id == CMD_LOAD_ONTO && currentUnitCommand.params.size() == 1 && int(currentUnitCommand.params[0]) == owner->id){
if((unit->moveType->progressState == CMoveType::Failed) && (owner->moveType->progressState == CMoveType::Failed)){
unit->commandAI->FinishCommand();
FinishCommand();
return;
}
} else if(!LoadStillValid(unit)) {
FinishCommand();
return;
}
}
}
if(inCommand){
if(!owner->cob->busy)
FinishCommand();
return;
}
if(unit && CanTransport(unit) && UpdateTargetLostTimer(int(c.params[0]))){
toBeTransportedUnitId=unit->id;
unit->toBeTransported=true;
if(unit->mass+transport->transportMassUsed > owner->unitDef->transportMass){
FinishCommand();
return;
}
if(goalPos.distance2D(unit->pos)>10){
float3 fix = unit->pos;
SetGoal(fix,owner->pos,64);
}
if(unit->pos.distance2D(owner->pos)<owner->unitDef->loadingRadius*0.9f){
if(CTAAirMoveType* am=dynamic_cast<CTAAirMoveType*>(owner->moveType)){ //handle air transports differently
float3 wantedPos=unit->pos+UpVector*unit->model->height;
SetGoal(wantedPos,owner->pos);
am->dontCheckCol=true;
am->ForceHeading(unit->heading);
am->SetWantedAltitude(unit->model->height);
am->maxDrift=1;
//logOutput.Print("cai dist %f %f %f",owner->pos.distance(wantedPos),owner->pos.distance2D(wantedPos),owner->pos.y-wantedPos.y);
if(owner->pos.distance(wantedPos)<4 && abs(owner->heading-unit->heading)<50 && owner->updir.dot(UpVector)>0.995f){
am->dontCheckCol=false;
am->dontLand=true;
std::vector<int> args;
args.push_back((int)(unit->model->height*65536));
owner->cob->Call("BeginTransport",args);
std::vector<int> args2;
args2.push_back(0);
args2.push_back((int)(unit->model->height*65536));
owner->cob->Call("QueryTransport",args2);
((CTransportUnit*)owner)->AttachUnit(unit,args2[0]);
am->SetWantedAltitude(0);
FinishCommand();
return;
}
} else {
inCommand=true;
scriptReady=false;
StopMove();
std::vector<int> args;
args.push_back(unit->id);
owner->cob->Call("TransportPickup",args,ScriptCallback,this,0);
}
}
} else {
FinishCommand();
}
} else if(c.params.size()==4){ //load in radius
if(lastCall==gs->frameNum) //avoid infinite loops
return;
lastCall=gs->frameNum;
float3 pos(c.params[0],c.params[1],c.params[2]);
float radius=c.params[3];
CUnit* unit=FindUnitToTransport(pos,radius);
if(unit && ((CTransportUnit*)owner)->transportCapacityUsed < owner->unitDef->transportCapacity){
Command c2;
c2.id=CMD_LOAD_UNITS;
c2.params.push_back(unit->id);
c2.options=c.options | INTERNAL_ORDER;
commandQue.push_front(c2);
inCommand=false;
SlowUpdate();
return;
} else {
FinishCommand();
return;
}
}
return;
}
void CBuilderCAI::ExecuteGuard(Command &c)
{
assert(owner->unitDef->canGuard);
CBuilder* fac=(CBuilder*)owner;
CUnit* guarded=uh->units[(int)c.params[0]];
if(guarded && guarded!=owner && UpdateTargetLostTimer((int)c.params[0])){
if(CBuilder* b=dynamic_cast<CBuilder*>(guarded)){
if(b->terraforming){
if(fac->pos.distance2D(b->terraformCenter)<fac->buildDistance*0.8f+b->terraformRadius*0.7f){
StopMove();
owner->moveType->KeepPointingTo(b->terraformCenter, fac->buildDistance*0.9f, false);
fac->HelpTerraform(b);
} else {
SetGoal(b->terraformCenter,fac->pos,fac->buildDistance*0.7f+b->terraformRadius*0.6f);
}
return;
}
if (b->curBuild &&
(( b->curBuild->beingBuilt && owner->unitDef->canAssist) ||
(!b->curBuild->beingBuilt && owner->unitDef->canRepair))) {
Command nc;
nc.id=CMD_REPAIR;
nc.options=c.options;
nc.params.push_back(b->curBuild->id);
commandQue.push_front(nc);
inCommand=false;
// SlowUpdate();
return;
}
}
if(CFactory* f=dynamic_cast<CFactory*>(guarded)){
if (f->curBuild &&
(( f->curBuild->beingBuilt && owner->unitDef->canAssist) ||
(!f->curBuild->beingBuilt && owner->unitDef->canRepair))) {
Command nc;
nc.id=CMD_REPAIR;
nc.options=c.options;
nc.params.push_back(f->curBuild->id);
commandQue.push_front(nc);
inCommand=false;
// SlowUpdate();
return;
}
}
float3 curPos=owner->pos;
float3 dif=guarded->pos-curPos;
dif.Normalize();
float3 goal=guarded->pos-dif*(fac->buildDistance*.5);
if((guarded->pos-curPos).SqLength2D()<
(fac->buildDistance*1.9f + guarded->radius)
*(fac->buildDistance*1.9f + guarded->radius)){
StartSlowGuard(guarded->maxSpeed);
} else {
StopSlowGuard();
}
if((guarded->pos-curPos).SqLength2D()<
(fac->buildDistance*0.9f + guarded->radius)
*(fac->buildDistance*0.9f + guarded->radius)){
StopMove();
// logOutput.Print("should point with type 3?");
owner->moveType->KeepPointingTo(guarded->pos,
fac->buildDistance*0.9f+guarded->radius, false);
if(guarded->health<guarded->maxHealth
&& ((guarded->beingBuilt && owner->unitDef->canAssist)
|| (!guarded->beingBuilt && owner->unitDef->canRepair)))
fac->SetRepairTarget(guarded);
else
NonMoving();
}else{
if((goalPos-goal).SqLength2D()>4000
|| (goalPos - owner->pos).SqLength2D() <
(owner->maxSpeed*30 + 1 + SQUARE_SIZE*2)
* (owner->maxSpeed*30 + 1 + SQUARE_SIZE*2)){
SetGoal(goal,curPos);
}
}
} else {
FinishCommand();
}
return;
}
void CBuilderCAI::ExecuteReclaim(Command &c)
{
assert(owner->unitDef->canReclaim);
CBuilder* fac=(CBuilder*)owner;
if(c.params.size()==1){
int id=(int) c.params[0];
if(id>=MAX_UNITS){ //reclaim feature
CFeature* feature=featureHandler->features[id-MAX_UNITS];
if(feature){
if(feature->pos.distance2D(fac->pos)<fac->buildDistance*0.9f+feature->radius){
StopMove();
owner->moveType->KeepPointingTo(feature->pos, fac->buildDistance*0.9f+feature->radius, false);
fac->SetReclaimTarget(feature);
} else {
if(goalPos.distance2D(feature->pos)>1){
SetGoal(feature->pos,owner->pos, fac->buildDistance*0.8f+feature->radius);
} else {
if(owner->moveType->progressState==CMoveType::Failed){
StopMove();
FinishCommand();
}
}
}
} else {
StopMove();
FinishCommand();
}
} else { //reclaim unit
CUnit* unit=uh->units[id];
if(unit && unit!=owner && unit->unitDef->reclaimable && UpdateTargetLostTimer(id)){
if(unit->pos.distance2D(fac->pos)<fac->buildDistance-1+unit->radius){
StopMove();
owner->moveType->KeepPointingTo(unit->pos, fac->buildDistance*0.9f+unit->radius, false);
fac->SetReclaimTarget(unit);
} else {
if(goalPos.distance2D(unit->pos)>1){
SetGoal(unit->pos,owner->pos);
}else{
if(owner->moveType->progressState==CMoveType::Failed){
StopMove();
FinishCommand();
}
}
}
} else {
FinishCommand();
}
}
} else if(c.params.size()==4){//area reclaim
float3 pos(c.params[0],c.params[1],c.params[2]);
float radius=c.params[3];
if(FindReclaimableFeatureAndReclaim(pos,radius,c.options,true)){
inCommand=false;
SlowUpdate();
return;
}
if(!(c.options & ALT_KEY)){
FinishCommand();
}
} else { //wrong number of parameters
FinishCommand();
}
return;
}
void CAirCAI::ExecuteAttack(Command &c)
{
assert(owner->unitDef->canAttack);
targetAge++;
if (tempOrder && owner->moveState == 1) {
// limit how far away we fly
if (orderTarget && LinePointDist(commandPos1, commandPos2, orderTarget->pos) > 1500) {
owner->SetUserTarget(0);
FinishCommand();
return;
}
}
if (inCommand) {
if (targetDied || (c.params.size() == 1 && UpdateTargetLostTimer(int(c.params[0])) == 0)) {
FinishCommand();
return;
}
if ((c.params.size() == 3) && (owner->commandShotCount < 0) && (commandQue.size() > 1)) {
owner->AttackGround(float3(c.params[0], c.params[1], c.params[2]), true);
FinishCommand();
return;
}
if (orderTarget) {
if (orderTarget->unitDef->canfly && orderTarget->crashing) {
owner->SetUserTarget(0);
FinishCommand();
return;
}
if (!(c.options & ALT_KEY) && SkipParalyzeTarget(orderTarget)) {
owner->SetUserTarget(0);
FinishCommand();
return;
}
}
} else {
targetAge = 0;
owner->commandShotCount = -1;
if (c.params.size() == 1) {
const int targetID = int(c.params[0]);
const bool legalTarget = (targetID >= 0 && targetID < MAX_UNITS);
CUnit* targetUnit = (legalTarget)? uh->units[targetID]: 0x0;
if (legalTarget && targetUnit != 0x0 && targetUnit != owner) {
orderTarget = targetUnit;
owner->AttackUnit(orderTarget, false);
AddDeathDependence(orderTarget);
inCommand = true;
SetGoal(orderTarget->pos, owner->pos, cancelDistance);
} else {
FinishCommand();
return;
}
} else {
float3 pos(c.params[0], c.params[1], c.params[2]);
owner->AttackGround(pos, false);
inCommand = true;
}
}
return;
}
/**
* @breif Causes this CMoblieCAI to execute the attack order c
*/
void CMobileCAI::ExecuteAttack(Command &c){
assert(owner->unitDef->canAttack);
if(tempOrder && owner->moveState < 2){ //limit how far away we fly
if(orderTarget && LinePointDist(commandPos1,commandPos2,orderTarget->pos) > 500 + owner->maxRange){
StopMove();
return FinishCommand();
}
}
if(!inCommand){
if(c.params.size()==1){
if(uh->units[int(c.params[0])] != 0 && uh->units[int(c.params[0])] != owner){
float3 fix=uh->units[int(c.params[0])]->pos+owner->posErrorVector*128;
SetGoal(fix, owner->pos);
orderTarget=uh->units[int(c.params[0])];
AddDeathDependence(orderTarget);
inCommand=true;
} else {
StopMove(); //cancel keeppointingto
return FinishCommand();
}
} else {
float3 pos(c.params[0],c.params[1],c.params[2]);
SetGoal(pos, owner->pos);
inCommand=true;
}
return;
}
if(targetDied || (c.params.size() == 1 && UpdateTargetLostTimer(int(c.params[0])) == 0)){
StopMove(); //cancel keeppointingto
return FinishCommand();
}
if(orderTarget){
//note that we handle aircrafts slightly differently
if((((owner->AttackUnit(orderTarget, c.id==CMD_DGUN)
&& owner->weapons.size() > 0
&& owner->weapons.front()->range -
owner->weapons.front()->relWeaponPos.Length() >
orderTarget->pos.distance(owner->pos))
|| dynamic_cast<CTAAirMoveType*>(owner->moveType))
&& (owner->pos-orderTarget->pos).Length2D() <
owner->maxRange*0.9f)
|| (owner->pos-orderTarget->pos).SqLength2D()<1024){
StopMove();
owner->moveType->KeepPointingTo(orderTarget,
min((float)(owner->losRadius*SQUARE_SIZE*2),
owner->maxRange*0.9f), true);
} else if((orderTarget->pos+owner->posErrorVector*128).distance2D(goalPos) > 10+orderTarget->pos.distance2D(owner->pos)*0.2f){
float3 fix=orderTarget->pos+owner->posErrorVector*128;
SetGoal(fix, owner->pos);
}
} else {
float3 pos(c.params[0],c.params[1],c.params[2]);
if((owner->AttackGround(pos,c.id==CMD_DGUN) && owner->weapons.size() > 0
&& (owner->pos-pos).Length() <
owner->weapons.front()->range -
owner->weapons.front()->relWeaponPos.Length())
|| (owner->pos-pos).SqLength2D()<1024){
StopMove();
owner->moveType->KeepPointingTo(pos, owner->maxRange*0.9f, true);
} else if(pos.distance2D(goalPos)>10){
SetGoal(pos, owner->pos);
}
}
}
void CTransportCAI::ExecuteLoadUnits(Command& c)
{
CTransportUnit* transport = reinterpret_cast<CTransportUnit*>(owner);
if (c.params.size() == 1) {
// load single unit
CUnit* unit = unitHandler->GetUnit(c.params[0]);
if (!unit) {
FinishCommand();
return;
}
if (c.options & INTERNAL_ORDER) {
if (unit->commandAI->commandQue.empty()) {
if (!LoadStillValid(unit)) {
FinishCommand();
return;
}
} else {
Command& currentUnitCommand = unit->commandAI->commandQue[0];
if ((currentUnitCommand.GetID() == CMD_LOAD_ONTO) && (currentUnitCommand.params.size() == 1) && (int(currentUnitCommand.params[0]) == owner->id)) {
if ((unit->moveType->progressState == AMoveType::Failed) && (owner->moveType->progressState == AMoveType::Failed)) {
unit->commandAI->FinishCommand();
FinishCommand();
return;
}
} else if (!LoadStillValid(unit)) {
FinishCommand();
return;
}
}
}
if (inCommand) {
if (!owner->script->IsBusy()) {
FinishCommand();
}
return;
}
if (unit && CanTransport(unit) && UpdateTargetLostTimer(int(c.params[0]))) {
SetTransportee(unit);
const float sqDist = unit->pos.SqDistance2D(owner->pos);
const bool inLoadingRadius = (sqDist <= Square(owner->unitDef->loadingRadius));
CHoverAirMoveType* am = dynamic_cast<CHoverAirMoveType*>(owner->moveType);
// subtracting 1 square to account for pathfinder/groundmovetype inaccuracy
if (goalPos.SqDistance2D(unit->pos) > Square(owner->unitDef->loadingRadius - SQUARE_SIZE) ||
(!inLoadingRadius && (!owner->isMoving || (am && am->aircraftState != AAirMoveType::AIRCRAFT_FLYING)))) {
SetGoal(unit->pos, owner->pos, std::min(64.0f, owner->unitDef->loadingRadius));
}
if (inLoadingRadius) {
if (am) { // handle air transports differently
float3 wantedPos = unit->pos;
wantedPos.y = static_cast<CTransportUnit*>(owner)->GetLoadUnloadHeight(wantedPos, unit);
SetGoal(wantedPos, owner->pos);
am->loadingUnits = true;
am->ForceHeading(static_cast<CTransportUnit*>(owner)->GetLoadUnloadHeading(unit));
am->SetWantedAltitude(wantedPos.y - ground->GetHeightAboveWater(wantedPos.x, wantedPos.z));
am->maxDrift = 1;
if ((owner->pos.SqDistance(wantedPos) < Square(AIRTRANSPORT_DOCKING_RADIUS)) &&
(abs(owner->heading-unit->heading) < AIRTRANSPORT_DOCKING_ANGLE) &&
(owner->updir.dot(UpVector) > 0.995f))
{
am->loadingUnits = false;
am->dontLand = true;
owner->script->BeginTransport(unit);
SetTransportee(NULL);
transport->AttachUnit(unit, owner->script->QueryTransport(unit));
am->SetWantedAltitude(0);
FinishCommand();
return;
}
} else {
inCommand = true;
StopMove();
owner->script->TransportPickup(unit);
}
} else if (owner->moveType->progressState == AMoveType::Failed && sqDist < (200 * 200)) {
// if we're pretty close already but CGroundMoveType fails because it considers
// the goal clogged (with the future passenger...), just try to move to the
// point halfway between the transport and the passenger.
SetGoal((unit->pos + owner->pos) * 0.5f, owner->pos);
}
} else {
FinishCommand();
}
} else if (c.params.size() == 4) { // area-load
if (lastCall == gs->frameNum) { // avoid infinite loops
return;
}
lastCall = gs->frameNum;
const float3 pos = c.GetPos(0);
const float radius = c.params[3];
CUnit* unit = FindUnitToTransport(pos, radius);
if (unit && CanTransport(unit)) {
Command c2(CMD_LOAD_UNITS, c.options|INTERNAL_ORDER, unit->id);
commandQue.push_front(c2);
inCommand = false;
SlowUpdate();
return;
} else {
FinishCommand();
return;
}
}
isFirstIteration = true;
startingDropPos = float3(-1.0f, -1.0f, -1.0f);
}