void CBuilderCAI::ExecuteFight(Command& c) { assert((c.options & INTERNAL_ORDER) || owner->unitDef->canFight); if (tempOrder) { tempOrder = false; inCommand = true; } if (c.params.size() < 3) { // this shouldnt happen but anyway ... LOG_L(L_ERROR, "Received a Fight command with less than 3 params on %s in BuilderCAI", owner->unitDef->humanName.c_str()); return; } if (c.params.size() >= 6) { if (!inCommand) { commandPos1 = c.GetPos(3); } } 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, owner->pos); if (f3SqDist(owner->pos, commandPos1) > (96 * 96)) { commandPos1 = owner->pos; } } float3 pos = c.GetPos(0); if (!inCommand) { inCommand = true; commandPos2 = pos; } float3 curPosOnLine = ClosestPointOnLine(commandPos1, commandPos2, owner->pos); if (c.params.size() >= 6) { pos = curPosOnLine; } if (pos != goalPos) { SetGoal(pos, owner->pos); } const bool resurrectMode = !!(c.options & ALT_KEY); const bool reclaimEnemyMode = !!(c.options & META_KEY); const bool reclaimEnemyOnlyMode = (c.options & CONTROL_KEY) && (c.options & META_KEY); ReclaimOption recopt; if (resurrectMode) recopt |= REC_NONREZ; if (reclaimEnemyMode) recopt |= REC_ENEMY; if (reclaimEnemyOnlyMode) recopt |= REC_ENEMYONLY; const float searchRadius = (owner->immobile ? 0 : (300 * owner->moveState)) + ownerBuilder->buildDistance; if (!reclaimEnemyOnlyMode && (owner->unitDef->canRepair || owner->unitDef->canAssist) && // Priority 1: Repair FindRepairTargetAndRepair(curPosOnLine, searchRadius, c.options, true, resurrectMode)){ tempOrder = true; inCommand = false; if (lastPC1 != gs->frameNum) { //avoid infinite loops lastPC1 = gs->frameNum; SlowUpdate(); } return; } if (!reclaimEnemyOnlyMode && resurrectMode && owner->unitDef->canResurrect && // Priority 2: Resurrect (optional) FindResurrectableFeatureAndResurrect(curPosOnLine, searchRadius, c.options, false)) { tempOrder = true; inCommand = false; if (lastPC2 != gs->frameNum) { //avoid infinite loops lastPC2 = gs->frameNum; SlowUpdate(); } return; } if (owner->unitDef->canReclaim && // Priority 3: Reclaim / reclaim non resurrectable (optional) / reclaim enemy units (optional) FindReclaimTargetAndReclaim(curPosOnLine, searchRadius, c.options, recopt)) { tempOrder = true; inCommand = false; if (lastPC3 != gs->frameNum) { //avoid infinite loops lastPC3 = gs->frameNum; SlowUpdate(); } return; } if (f3SqDist(owner->pos, pos) < (64*64)) { FinishCommand(); return; } if (owner->haveTarget && owner->moveType->progressState != AMoveType::Done) { StopMove(); } else if (owner->moveType->progressState != AMoveType::Active) { owner->moveType->StartMoving(goalPos, 8); } }
void CAirCAI::SlowUpdate() { if (!commandQue.empty() && commandQue.front().timeOut < gs->frameNum) { FinishCommand(); return; } if (owner->usingScriptMoveType) { return; // avoid the invalid (CAirMoveType*) cast } AAirMoveType* myPlane=(AAirMoveType*) owner->moveType; if(owner->unitDef->maxFuel > 0){ RefuelIfNeeded(); } if(commandQue.empty()){ if(myPlane->aircraftState == AAirMoveType::AIRCRAFT_FLYING && !owner->unitDef->DontLand() && myPlane->autoLand){ StopMove(); // myPlane->SetState(AAirMoveType::AIRCRAFT_LANDING); } if(owner->unitDef->canAttack && owner->fireState>=2 && owner->moveState != 0 && owner->maxRange > 0){ if(myPlane->IsFighter()){ float testRad=1000 * owner->moveState; CUnit* enemy=helper->GetClosestEnemyAircraft( owner->pos + (owner->speed * 10), testRad, owner->allyteam); if(IsValidTarget(enemy)) { Command nc; nc.id = CMD_ATTACK; nc.params.push_back(enemy->id); nc.options = 0; commandQue.push_front(nc); inCommand = false; return; } } float testRad = 500 * owner->moveState; CUnit* enemy = helper->GetClosestEnemyUnit( owner->pos + (owner->speed * 20), testRad, owner->allyteam); if(IsValidTarget(enemy)) { Command nc; nc.id = CMD_ATTACK; nc.params.push_back(enemy->id); nc.options = 0; commandQue.push_front(nc); inCommand = false; return; } } return; } Command& c = commandQue.front(); if (c.id == CMD_WAIT) { if ((myPlane->aircraftState == AAirMoveType::AIRCRAFT_FLYING) && !owner->unitDef->DontLand() && myPlane->autoLand) { StopMove(); // myPlane->SetState(AAirMoveType::AIRCRAFT_LANDING); } return; } if (c.id != CMD_STOP) { myPlane->Takeoff(); } float3 curPos=owner->pos; switch(c.id){ case CMD_AREA_ATTACK:{ ExecuteAreaAttack(c); return; } default:{ CMobileCAI::Execute(); 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; }
void CAirCAI::SlowUpdate() { if (!commandQue.empty() && commandQue.front().timeOut < gs->frameNum) { FinishCommand(); return; } if (owner->usingScriptMoveType) { return; // avoid the invalid (CAirMoveType*) cast } CAirMoveType* myPlane=(CAirMoveType*) owner->moveType; if(owner->unitDef->maxFuel > 0){ if(myPlane->reservedPad){ return; }else{ if(owner->currentFuel <= 0){ owner->userAttackGround=false; owner->userTarget=0; inCommand=false; CAirBaseHandler::LandingPad* lp = airBaseHandler->FindAirBase( owner, owner->unitDef->minAirBasePower); if(lp){ myPlane->AddDeathDependence(lp); myPlane->reservedPad = lp; myPlane->padStatus = 0; myPlane->oldGoalPos = myPlane->goalPos; return; } float3 landingPos = airBaseHandler->FindClosestAirBasePos( owner, owner->unitDef->minAirBasePower); if(landingPos != ZeroVector && owner->pos.distance2D(landingPos) > 300){ if(myPlane->aircraftState == CAirMoveType::AIRCRAFT_LANDED && owner->pos.distance2D(landingPos) > 800) { myPlane->SetState(CAirMoveType::AIRCRAFT_TAKEOFF); } myPlane->goalPos = landingPos; } else { if(myPlane->aircraftState == CAirMoveType::AIRCRAFT_FLYING) myPlane->SetState(CAirMoveType::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, owner->unitDef->minAirBasePower); if(lp){ owner->userAttackGround=false; owner->userTarget=0; inCommand=false; myPlane->AddDeathDependence(lp); myPlane->reservedPad=lp; myPlane->padStatus=0; myPlane->oldGoalPos=myPlane->goalPos; if(myPlane->aircraftState == CAirMoveType::AIRCRAFT_LANDED){ myPlane->SetState(CAirMoveType::AIRCRAFT_TAKEOFF); } return; } } } } } if(commandQue.empty()){ if(myPlane->aircraftState == CAirMoveType::AIRCRAFT_FLYING && !owner->unitDef->DontLand()){ myPlane->SetState(CAirMoveType::AIRCRAFT_LANDING); } if(owner->unitDef->canAttack && owner->fireState==2 && owner->moveState != 0 && owner->maxRange > 0){ if(myPlane->isFighter){ float testRad=1000 * owner->moveState; CUnit* enemy=helper->GetClosestEnemyAircraft( owner->pos + (owner->speed * 10), testRad, owner->allyteam); if(enemy && !enemy->crashing){ Command nc; nc.id = CMD_ATTACK; nc.params.push_back(enemy->id); nc.options = 0; commandQue.push_front(nc); inCommand = false; return; } } float testRad = 500 * owner->moveState; CUnit* enemy = helper->GetClosestEnemyUnit( owner->pos + (owner->speed * 20), testRad, owner->allyteam); if(enemy && (owner->hasUWWeapons || !enemy->isUnderWater) && !enemy->crashing && (myPlane->isFighter || !enemy->unitDef->canfly)){ Command nc; nc.id = CMD_ATTACK; nc.params.push_back(enemy->id); nc.options = 0; commandQue.push_front(nc); inCommand = false; return; } } return; } Command& c = commandQue.front(); if (c.id == CMD_WAIT) { if ((myPlane->aircraftState == CAirMoveType::AIRCRAFT_FLYING) && !owner->unitDef->DontLand()) { myPlane->SetState(CAirMoveType::AIRCRAFT_LANDING); } return; } if (c.id != CMD_STOP) { if (myPlane->aircraftState == CAirMoveType::AIRCRAFT_LANDED) { myPlane->SetState(CAirMoveType::AIRCRAFT_TAKEOFF); } if (myPlane->aircraftState == CAirMoveType::AIRCRAFT_LANDING) { myPlane->SetState(CAirMoveType::AIRCRAFT_FLYING); } } float3 curPos=owner->pos; switch(c.id){ case CMD_AREA_ATTACK:{ ExecuteAreaAttack(c); return; } default:{ CMobileCAI::Execute(); 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; Command& c=commandQue.front(); switch(c.id) { case CMD_STOP: { StopMove(); CCommandAI::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: { if(c.params.size()<3) { //this shouldnt happen but anyway ... info->AddLine("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: { if(tempOrder) { inCommand = true; tempOrder = false; } if(c.params.size()<3) { //this shouldnt happen but anyway ... info->AddLine("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 { 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->fireState==2) { CUnit* enemy=helper->GetClosestEnemyUnit( curPos, owner->maxRange+100*owner->moveState*owner->moveState, owner->allyteam); if(enemy && (owner->hasUWWeapons || !enemy->isUnderWater) && !(owner->unitDef->noChaseCategory & enemy->category) && !owner->weapons.empty()) { //todo: make sure they dont stray to far from path if(owner->moveState!=1 || LinePointDist(commandPos1,commandPos2,enemy->pos) < 300+max(owner->maxRange, (float)owner->losRadius)) { Command c2,c3; c3 = this->GetReturnFight(c); c2.id=CMD_ATTACK; c2.options=c.options|INTERNAL_ORDER; c2.params.push_back(enemy->id); commandQue.push_front(c3); commandQue.push_front(c2); inCommand=false; tempOrder=true; if(lastPC!=gs->frameNum) { //avoid infinite loops lastPC=gs->frameNum; SlowUpdate(); } return; } } } if((curPos-goalPos).SqLength2D()<4096 || 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: 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)) { StopMove(); FinishCommand(); break; } if(targetDied || (c.params.size() == 1 && uh->units[int(c.params[0])] && !(uh->units[int(c.params[0])]->losStatus[owner->allyteam] & LOS_INRADAR))) { 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 > orderTarget->pos.distance(owner->pos)) || dynamic_cast<CTAAirMoveType*>(owner->moveType)) && (owner->pos-orderTarget->pos).Length2D()<owner->maxRange*0.9) || (owner->pos-orderTarget->pos).SqLength2D()<1024) { StopMove(); owner->moveType->KeepPointingTo(orderTarget->pos, min((double)(owner->losRadius*SQUARE_SIZE*2), owner->maxRange*0.9), true); } else if((orderTarget->pos+owner->posErrorVector*128).distance2D(goalPos) > 10+orderTarget->pos.distance2D(owner->pos)*0.2) { 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->pos-pos).SqLength2D()<1024) { StopMove(); owner->moveType->KeepPointingTo(pos, owner->maxRange*0.9, true); } else if(pos.distance2D(goalPos)>10) { SetGoal(pos,curPos); } } break; case CMD_GUARD: if(uh->units[int(c.params[0])]!=0) { CUnit* guarded=uh->units[int(c.params[0])]; if(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; } }
/** * @brief Executes the Fight command c */ void CMobileCAI::ExecuteFight(Command& c) { assert((c.options & INTERNAL_ORDER) || owner->unitDef->canFight); if (c.params.size() == 1 && !owner->weapons.empty()) { CWeapon* w = owner->weapons.front(); if ((orderTarget != NULL) && !w->AttackUnit(orderTarget, false)) { CUnit* newTarget = CGameHelper::GetClosestValidTarget(owner->pos, owner->maxRange, owner->allyteam, this); if ((newTarget != NULL) && w->AttackUnit(newTarget, false)) { c.params[0] = newTarget->id; inCommand = false; } else { w->AttackUnit(orderTarget, false); } } ExecuteAttack(c); return; } if (tempOrder) { inCommand = true; tempOrder = false; } if (c.params.size() < 3) { LOG_L(L_ERROR, "Received a Fight command with less than 3 params on %s in MobileCAI", owner->unitDef->humanName.c_str()); return; } if (c.params.size() >= 6) { if (!inCommand) { commandPos1 = c.GetPos(3); } } 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, owner->pos); if ((owner->pos - commandPos1).SqLength2D() > (96 * 96)) { commandPos1 = owner->pos; } } float3 pos = c.GetPos(0); if (!inCommand) { inCommand = true; commandPos2 = pos; lastUserGoal = commandPos2; } if (c.params.size() >= 6) { pos = ClosestPointOnLine(commandPos1, commandPos2, owner->pos); } if (pos != goalPos) { SetGoal(pos, owner->pos); } if (owner->unitDef->canAttack && owner->fireState >= FIRESTATE_FIREATWILL && !owner->weapons.empty()) { const float3 curPosOnLine = ClosestPointOnLine(commandPos1, commandPos2, owner->pos); const float searchRadius = owner->maxRange + 100 * owner->moveState * owner->moveState; CUnit* enemy = CGameHelper::GetClosestValidTarget(curPosOnLine, searchRadius, owner->allyteam, this); if (enemy != NULL) { PushOrUpdateReturnFight(); // make the attack-command inherit <c>'s options // NOTE: see AirCAI::ExecuteFight why we do not set INTERNAL_ORDER Command c2(CMD_ATTACK, c.options, enemy->id); commandQue.push_front(c2); inCommand = false; tempOrder = true; // avoid infinite loops (?) if (lastPC != gs->frameNum) { lastPC = gs->frameNum; SlowUpdate(); } return; } } if ((owner->pos - goalPos).SqLength2D() < (64 * 64) || (owner->moveType->progressState == AMoveType::Failed)){ FinishCommand(); } }
void CCommandAI::ExecuteRemove(const Command& c) { if ((c.params.size() <= 0) || (commandQue.size() <= 0)) { return; } // disable repeating during the removals const bool prevRepeat = repeatOrders; repeatOrders = false; CCommandQueue* queue = &commandQue; bool facBuildQueue = false; CFactoryCAI* facCAI = dynamic_cast<CFactoryCAI*>(this); if (facCAI) { if (c.options & CONTROL_KEY) { // check the build order facBuildQueue = true; } else { // use the new commands queue = &facCAI->newUnitCommands; } } // erase commands by a list of command types bool active = false; for (int p = 0; p < (int)c.params.size(); p++) { const int removeValue = (int)c.params[p]; // tag or id if (facBuildQueue && (removeValue == 0) && !(c.options & ALT_KEY)) { continue; // don't remove tag=0 commands from build queues, they // are used the same way that CMD_STOP is, to void orders } CCommandQueue::iterator ci; do { for (ci = queue->begin(); ci != queue->end(); ++ci) { const Command& qc = *ci; if (c.options & ALT_KEY) { if (qc.id != removeValue) { continue; } } else { if (qc.tag != removeValue) { continue; } } if (qc.id == CMD_WAIT) { waitCommandsAI.RemoveWaitCommand(owner, qc); } if (facBuildQueue) { facCAI->RemoveBuildCommand(ci); ci = queue->begin(); break; // the removal may have corrupted the iterator } if (!facCAI && (ci == queue->begin())) { if (!active) { active = true; FinishCommand(); ci = queue->begin(); break; } active = true; } queue->erase(ci); ci = queue->begin(); break; // the removal may have corrupted the iterator } } while (ci != queue->end()); } repeatOrders = prevRepeat; return; }
void CCommandAI::ExecuteRemove(const Command& c) { CCommandQueue* queue = &commandQue; CFactoryCAI* facCAI = dynamic_cast<CFactoryCAI*>(this); // if false, remove commands by tag const bool removeByID = (c.options & ALT_KEY); // disable repeating during the removals const bool prevRepeat = repeatOrders; // erase commands by a list of command types bool active = false; bool facBuildQueue = false; if (facCAI) { if (c.options & CONTROL_KEY) { // keep using the build-order queue facBuildQueue = true; } else { // use the command-queue for new units queue = &facCAI->newUnitCommands; } } if ((c.params.size() <= 0) || (queue->size() <= 0)) { return; } repeatOrders = false; for (unsigned int p = 0; p < c.params.size(); p++) { const int removeValue = c.params[p]; // tag or id if (facBuildQueue && !removeByID && (removeValue == 0)) { // don't remove commands with tag 0 from build queues, they // are used the same way that CMD_STOP is (to void orders) continue; } CCommandQueue::iterator ci; do { for (ci = queue->begin(); ci != queue->end(); ++ci) { const Command& qc = *ci; if (removeByID) { if (qc.GetID() != removeValue) { continue; } } else { if (qc.tag != removeValue) { continue; } } if (qc.GetID() == CMD_WAIT) { waitCommandsAI.RemoveWaitCommand(owner, qc); } if (facBuildQueue) { // if ci == queue->begin() and !queue->empty(), this pop_front()'s // via CFAI::ExecuteStop; otherwise only modifies *ci (not <queue>) if (facCAI->RemoveBuildCommand(ci)) { ci = queue->begin(); break; } } if (!facCAI && (ci == queue->begin())) { if (!active) { active = true; FinishCommand(); ci = queue->begin(); break; } active = true; } queue->erase(ci); ci = queue->begin(); // the removal may have corrupted the iterator break; } } while (ci != queue->end()); } repeatOrders = prevRepeat; }
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->unitDef->speed / 30.0f); 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(uh->units[int(c.params[0])]!=0 && 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 CBuilderCAI::ExecuteReclaim(Command& c) { // 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; const bool checkForBetterTarget = ((++randomCounter % 5) == 0); if (checkForBetterTarget && (c.options & INTERNAL_ORDER) && (c.params.size() >= 5)) { // regular check if there is a closer reclaim target CSolidObject* obj; if (uid >= unitHandler->MaxUnits()) { obj = featureHandler->GetFeature(uid - unitHandler->MaxUnits()); } else { obj = unitHandler->GetUnit(uid); } if (obj) { const float3& pos = c.GetPos(1); 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 >= unitHandler->MaxUnits()) { // reclaim feature CFeature* feature = featureHandler->GetFeature(uid - unitHandler->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 = unitHandler->GetUnit(uid); if (unit != NULL && c.params.size() == 5) { const float3& pos = c.GetPos(1); 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) || (ownerBuilder->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); ownerBuilder->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 CFactoryCAI::SlowUpdate() { if (commandQue.empty() || owner->beingBuilt) { return; } CFactory* fac=(CFactory*)owner; unsigned int oldSize; do { Command& c=commandQue.front(); oldSize=commandQue.size(); map<int,BuildOption>::iterator boi; if((boi=buildOptions.find(c.id))!=buildOptions.end()){ const UnitDef *def = unitDefHandler->GetUnitByName(boi->second.name); if(building){ if(!fac->curBuild && !fac->quedBuild){ building=false; if(owner->group) owner->group->CommandFinished(owner->id,commandQue.front().id); if(!repeatOrders || c.options & DONT_REPEAT) boi->second.numQued--; UpdateIconName(c.id,boi->second); FinishCommand(); } // This can only be true if two factories started building // the restricted unit in the same simulation frame else if(uh->unitsByDefs[owner->team][def->id].size() > def->maxThisUnit){ //unit restricted? CFactory* fac=(CFactory*)owner; building = false; fac->StopBuild(); CancelRestrictedUnit(c, boi->second); } } else { const UnitDef *def = unitDefHandler->GetUnitByName(boi->second.name); if(luaRules && !luaRules->AllowUnitCreation(def, owner, NULL)) { if(!repeatOrders || c.options & DONT_REPEAT){ boi->second.numQued--; } UpdateIconName(c.id,boi->second); FinishCommand(); } else if(uh->unitsByDefs[owner->team][def->id].size() >= def->maxThisUnit){ //unit restricted? CancelRestrictedUnit(c, boi->second); } else if(uh->maxUnits>teamHandler->Team(owner->team)->units.size()){ //max unitlimit reached? fac->StartBuild(boi->second.fullName); building=true; } } } else { switch(c.id){ case CMD_STOP: { ExecuteStop(c); break; } default: { CCommandAI::SlowUpdate(); return; } } } } while ((oldSize != commandQue.size()) && !commandQue.empty()); return; }
void CBuilderCAI::ExecuteGuard(Command& c) { if (!owner->unitDef->canGuard) return; CUnit* guardee = unitHandler->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)) { ownerBuilder->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 { ownerBuilder->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, 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, 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, guardee->id); commandQue.push_front(nc); inCommand = false; return; } else { NonMoving(); } } else { StopSlowGuard(); } }
void CBuilderCAI::ExecuteRepair(Command& c) { // not all builders are repair-capable by default if (!owner->unitDef->canRepair) return; if (c.params.size() == 1 || c.params.size() == 5) { // repair unit CUnit* unit = unitHandler->GetUnit(c.params[0]); if (unit == NULL) { FinishCommand(); return; } if (tempOrder && owner->moveState <= MOVESTATE_MANEUVER) { // limit how far away we go when not roaming if (LinePointDist(commandPos1, commandPos2, unit->pos) > std::max(500.0f, GetBuildRange(unit->radius))) { StopMove(); FinishCommand(); return; } } if (c.params.size() == 5) { const float3& pos = c.GetPos(1); 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())) || ownerBuilder->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)) { ownerBuilder->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]; ownerBuilder->StopBuild(); if (FindRepairTargetAndRepair(pos, radius, c.options, false, (c.options & META_KEY))) { inCommand = false; SlowUpdate(); return; } if (!(c.options & ALT_KEY)) { FinishCommand(); } } else { FinishCommand(); } }
void CBuilderCAI::ExecuteBuildCmd(Command& c) { const map<int, string>::const_iterator boi = buildOptions.find(c.GetID()); if (boi == buildOptions.end()) return; if (!inCommand) { BuildInfo bi; bi.pos.x = math::floor(c.params[0] / SQUARE_SIZE + 0.5f) * SQUARE_SIZE; bi.pos.z = math::floor(c.params[2] / SQUARE_SIZE + 0.5f) * SQUARE_SIZE; bi.pos.y = c.params[1]; if (c.params.size() == 4) bi.buildFacing = abs((int)c.params[3]) % NUM_FACINGS; bi.def = unitDefHandler->GetUnitDefByName(boi->second); CFeature* f = NULL; CGameHelper::TestUnitBuildSquare(bi, f, owner->allyteam, true); if (f != NULL) { if (!bi.def->isFeature || bi.def->wreckName != f->def->name) { ReclaimFeature(f); } else { FinishCommand(); } return; } inCommand = true; build.Parse(c); } assert(build.def->id == -c.GetID() && build.def->id != 0); const float buildeeRadius = GetBuildOptionRadius(build.def, c.GetID()); if (building) { // keep moving until 3D distance to buildPos is LEQ our buildDistance MoveInBuildRange(build.pos, 0.0f); if (!ownerBuilder->curBuild && !ownerBuilder->terraforming) { building = false; StopMove(); // cancel the effect of KeepPointingTo FinishCommand(); } // This can only be true if two builders started building // the restricted unit in the same simulation frame else if (unitHandler->unitsByDefs[owner->team][build.def->id].size() > build.def->maxThisUnit) { // unit restricted building = false; ownerBuilder->StopBuild(); CancelRestrictedUnit(boi->second); } } else { if (unitHandler->unitsByDefs[owner->team][build.def->id].size() >= build.def->maxThisUnit) { // unit restricted, don't bother moving all the way // to the construction site first before telling us // (since greyed-out icons can still be clicked etc, // would be better to prevent that but doesn't cover // case where limit reached while builder en-route) CancelRestrictedUnit(boi->second); StopMove(); return; } build.pos = CGameHelper::Pos2BuildPos(build, true); // keep moving until until 3D distance to buildPos is LEQ our buildDistance if (MoveInBuildRange(build.pos, 0.0f, true)) { if (IsBuildPosBlocked(build)) { StopMove(); FinishCommand(); return; } if (!eventHandler.AllowUnitCreation(build.def, owner, &build)) { StopMove(); // cancel KeepPointingTo FinishCommand(); return; } if (teamHandler->Team(owner->team)->AtUnitLimit()) { return; } CFeature* f = NULL; bool waitstance = false; if (ownerBuilder->StartBuild(build, f, waitstance) || (++buildRetries > 30)) { building = true; } else if (f != NULL && (!build.def->isFeature || build.def->wreckName != f->def->name)) { inCommand = false; ReclaimFeature(f); } else if (!waitstance) { const float fpSqRadius = (build.def->xsize * build.def->xsize + build.def->zsize * build.def->zsize); const float fpRadius = (math::sqrt(fpSqRadius) * 0.5f) * SQUARE_SIZE; // tell everything within the radius of the soon-to-be buildee // to get out of the way; using the model radius is not correct // because this can be shorter than half the footprint diagonal CGameHelper::BuggerOff(build.pos, std::max(buildeeRadius, fpRadius), false, true, owner->team, NULL); NonMoving(); } } else { if (owner->moveType->progressState == AMoveType::Failed) { if (++buildRetries > 5) { StopMove(); FinishCommand(); return; } } // we are on the way to the buildpos, meanwhile it can happen // that another builder already finished our buildcmd or blocked // the buildpos with another building (skip our buildcmd then) if ((++randomCounter % 5) == 0) { if (IsBuildPosBlocked(build)) { StopMove(); FinishCommand(); return; } } } } }
/** * @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) { const int targetID = int(c.params[0]); const bool legalTarget = (targetID >= 0 && targetID < MAX_UNITS); CUnit* targetUnit = (legalTarget)? uh->units[targetID]: 0x0; // check if we have valid target parameter and that we aren't attacking ourselves if (legalTarget && targetUnit != 0x0 && targetUnit != owner) { float3 fix = targetUnit->pos + owner->posErrorVector * 128; float3 diff = float3(fix - owner->pos).Normalize(); if (owner->moveState > 0 || !tempOrder) { 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 { // 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); edgeFactor = fabs(w->targetBorder); } double 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 * SQUARE_SIZE * 2), owner->maxRange * 0.9f), true); } } owner->AttackUnit(orderTarget, c.id == CMD_DGUN); } // 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 * SQUARE_SIZE * 2), owner->maxRange * 0.9f), true); } else if(tempOrder && owner->moveState == 0){ SetGoal(lastUserGoal, owner->pos); } // 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 { 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.Length2D() < (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 CBuilderCAI::SlowUpdate() { if(commandQue.empty()){ CMobileCAI::SlowUpdate(); return; } if(owner->stunned){ return; } Command& c=commandQue.front(); CBuilder* fac=(CBuilder*)owner; float3 curPos=owner->pos; map<int,string>::iterator boi; if((boi=buildOptions.find(c.id))!=buildOptions.end()){ const UnitDef* ud = unitDefHandler->GetUnitByName(boi->second); const float radius = GetUnitRadius(ud, c.id); if (inCommand) { if (building) { if (build.pos.distance2D(fac->pos) > fac->buildDistance+radius-8.0f) { owner->moveType->StartMoving(build.pos, fac->buildDistance*0.5f+radius); } else { StopMove(); owner->moveType->KeepPointingTo(build.pos, (fac->buildDistance+radius)*0.6f, false); //needed since above startmoving cancels this } if(!fac->curBuild && !fac->terraforming){ building=false; StopMove(); //cancel the effect of KeepPointingTo FinishCommand(); } } else { build.Parse(c); const float dist = build.pos.distance2D(fac->pos); if ((dist < (fac->buildDistance * 0.6f + radius)) || (!owner->unitDef->canmove && (dist <= (fac->buildDistance+radius-8.0f)))) { StopMove(); if(luaRules && !luaRules->AllowUnitCreation(build.def, owner, &build.pos)) { FinishCommand(); } else if(uh->unitsType[owner->team][build.def->id]>=build.def->maxThisUnit){ //unit restricted ENTER_MIXED; if(owner->team == gu->myTeam){ logOutput.Print("%s: Build failed, unit type limit reached",owner->unitDef->humanName.c_str()); logOutput.SetLastMsgPos(owner->pos); } ENTER_SYNCED; FinishCommand(); } else if(uh->maxUnits>(int)gs->Team(owner->team)->units.size()){ //max unitlimit reached buildRetries++; owner->moveType->KeepPointingTo(build.pos, fac->buildDistance*0.7f+radius, false); if (fac->StartBuild(build) || (buildRetries > 20)) { building=true; } else { ENTER_MIXED; if ((owner->team == gu->myTeam) && !(buildRetries & 7)) { logOutput.Print("%s: Build pos blocked",owner->unitDef->humanName.c_str()); logOutput.SetLastMsgPos(owner->pos); } ENTER_SYNCED; helper->BuggerOff(build.pos,radius); NonMoving(); } } } else { if (owner->moveType->progressState == CMoveType::Failed) { if (++buildRetries > 5) { StopMove(); FinishCommand(); } } SetGoal(build.pos,owner->pos, fac->buildDistance*0.4f+radius); } } } else { //!inCommand BuildInfo bi; bi.pos.x=floor(c.params[0]/SQUARE_SIZE+0.5f)*SQUARE_SIZE; bi.pos.z=floor(c.params[2]/SQUARE_SIZE+0.5f)*SQUARE_SIZE; bi.pos.y=c.params[1]; CFeature* f=0; if (c.params.size()==4) bi.buildFacing = int(c.params[3]); bi.def = unitDefHandler->GetUnitByName(boi->second); uh->TestUnitBuildSquare(bi,f,owner->allyteam); if (f) { if (!owner->unitDef->canReclaim || !f->def->reclaimable) { // FIXME user shouldn't be able to queue buildings on top of features // in the first place (in this case). StopMove(); FinishCommand(); } else { Command c2; c2.id=CMD_RECLAIM; c2.options=0; c2.params.push_back(f->id+MAX_UNITS); commandQue.push_front(c2); SlowUpdate(); //this assumes that the reclaim command can never return directly without having reclaimed the target } } else { inCommand=true; SlowUpdate(); } } return; } switch (c.id) { case CMD_STOP: { ExecuteStop(c); return; } case CMD_REPAIR: { ExecuteRepair(c); return; } case CMD_CAPTURE: { ExecuteCapture(c); return; } case CMD_GUARD: { ExecuteGuard(c); return; } case CMD_RECLAIM: { ExecuteReclaim(c); return; } case CMD_RESURRECT: { ExecuteResurrect(c); return; } case CMD_PATROL: { ExecutePatrol(c); return; } case CMD_FIGHT: { ExecuteFight(c); return; } case CMD_RESTORE: { ExecuteRestore(c); return; } default: { CMobileCAI::SlowUpdate(); return; } } }
void CAirCAI::SlowUpdate() { if(!commandQue.empty() && commandQue.front().timeOut<gs->frameNum){ FinishCommand(); return; } CAirMoveType* myPlane=(CAirMoveType*)owner->moveType; if(owner->unitDef->maxFuel>0){ if(myPlane->reservedPad){ return; }else{ if(owner->currentFuel <= 0){ 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){ if(myPlane->aircraftState == CAirMoveType::AIRCRAFT_LANDED && owner->pos.distance2D(landingPos) > 800) myPlane->SetState(CAirMoveType::AIRCRAFT_TAKEOFF); myPlane->goalPos=landingPos; } else { if(myPlane->aircraftState == CAirMoveType::AIRCRAFT_FLYING) myPlane->SetState(CAirMoveType::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){ owner->userAttackGround=false; owner->userTarget=0; inCommand=false; myPlane->AddDeathDependence(lp); myPlane->reservedPad=lp; myPlane->padStatus=0; myPlane->oldGoalPos=myPlane->goalPos; if(myPlane->aircraftState==CAirMoveType::AIRCRAFT_LANDED){ myPlane->SetState(CAirMoveType::AIRCRAFT_TAKEOFF); } return; } } } } } if(commandQue.empty()){ if(myPlane->aircraftState==CAirMoveType::AIRCRAFT_FLYING && !owner->unitDef->DontLand ()) myPlane->SetState(CAirMoveType::AIRCRAFT_LANDING); if(owner->fireState==2 && owner->moveState!=0 && owner->maxRange>0){ if(myPlane->isFighter){ float testRad=1000*owner->moveState; CUnit* enemy=helper->GetClosestEnemyAircraft(owner->pos+owner->speed*10,testRad,owner->allyteam); if(enemy && !enemy->crashing){ Command nc; nc.id=CMD_ATTACK; nc.params.push_back(enemy->id); nc.options=0; commandQue.push_front(nc); inCommand=false; return; } } if(owner->moveState && owner->fireState==2 && owner->maxRange>0){ float testRad=500*owner->moveState; CUnit* enemy=helper->GetClosestEnemyUnit(owner->pos+owner->speed*20,testRad,owner->allyteam); if(enemy && (owner->hasUWWeapons || !enemy->isUnderWater) && !enemy->crashing && (myPlane->isFighter || !enemy->unitDef->canfly)){ Command nc; nc.id=CMD_ATTACK; nc.params.push_back(enemy->id); nc.options=0; commandQue.push_front(nc); inCommand=false; return; } } } return; } if(myPlane->aircraftState==CAirMoveType::AIRCRAFT_LANDED && commandQue.front().id!=CMD_STOP){ myPlane->SetState(CAirMoveType::AIRCRAFT_TAKEOFF); } if(myPlane->aircraftState==CAirMoveType::AIRCRAFT_LANDING && commandQue.front().id!=CMD_STOP){ myPlane->SetState(CAirMoveType::AIRCRAFT_FLYING); } float3 curPos=owner->pos; Command& c=commandQue.front(); switch(c.id){ case CMD_STOP:{ CCommandAI::SlowUpdate(); break;} case CMD_MOVE:{ if(tempOrder){ tempOrder=false; inCommand=true; } if(!inCommand){ inCommand=true; commandPos1=myPlane->owner->pos; } float3 pos(c.params[0],c.params[1],c.params[2]); commandPos2=pos; myPlane->goalPos=pos; if(!(c.options&CONTROL_KEY)){ if(owner->fireState==2 && owner->moveState!=0 && owner->maxRange>0){ if(myPlane->isFighter){ float testRad=500*owner->moveState; CUnit* enemy=helper->GetClosestEnemyAircraft(owner->pos+owner->speed*20,testRad,owner->allyteam); if(enemy && ((enemy->unitDef->canfly && !enemy->crashing && myPlane->isFighter) || (!enemy->unitDef->canfly && (!myPlane->isFighter || owner->moveState==2)))){ if(owner->moveState!=1 || LinePointDist(commandPos1,commandPos2,enemy->pos) < 1000){ Command nc; nc.id=CMD_ATTACK; nc.params.push_back(enemy->id); nc.options=c.options; commandQue.push_front(nc); tempOrder=true; inCommand=false; SlowUpdate(); return; } } } if((!myPlane->isFighter || owner->moveState==2) && owner->maxRange>0){ float testRad=325*owner->moveState; CUnit* enemy=helper->GetClosestEnemyUnit(owner->pos+owner->speed*30,testRad,owner->allyteam); if(enemy && (owner->hasUWWeapons || !enemy->isUnderWater) && ((enemy->unitDef->canfly && !enemy->crashing && myPlane->isFighter) || (!enemy->unitDef->canfly && (!myPlane->isFighter || owner->moveState==2)))){ if(owner->moveState!=1 || LinePointDist(commandPos1,commandPos2,enemy->pos) < 1000){ Command nc; nc.id=CMD_ATTACK; nc.params.push_back(enemy->id); nc.options=c.options; commandQue.push_front(nc); tempOrder=true; inCommand=false; SlowUpdate(); return; } } } } } if((curPos-pos).SqLength2D()<16000){ FinishCommand(); } break;} case CMD_PATROL:{ float3 curPos=owner->pos; if(c.params.size()<3){ //this shouldnt happen but anyway ... info->AddLine("Error: got patrol cmd with less than 3 params on %s in aircai", 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(); break;} case CMD_FIGHT:{ if(tempOrder){ tempOrder=false; inCommand=true; } goalPos=float3(c.params[0],c.params[1],c.params[2]); if(!inCommand){ commandPos2=goalPos; inCommand=true; } commandPos1=curPos; if(c.params.size()<3){ //this shouldnt happen but anyway ... info->AddLine("Error: got fight cmd with less than 3 params on %s in aircai", owner->unitDef->humanName.c_str()); return; } float testRad=1000*owner->moveState; CUnit* enemy = helper->GetClosestEnemyAircraft(owner->pos+owner->speed*10,testRad,owner->allyteam); if(owner->fireState==2 && owner->moveState!=0 && owner->maxRange>0){ if(myPlane->isFighter && enemy && !enemy->crashing && (owner->moveState!=1 || LinePointDist(commandPos1,commandPos2,enemy->pos) < 1000)) { Command nc,c3; c3.id = CMD_MOVE; //keep it from being pulled too far off the path float3 dir = goalPos-curPos; dir.Normalize(); dir*=sqrtf(1024+owner->xsize*owner->xsize+owner->ysize*owner->ysize); dir+=curPos; c3.params.push_back(dir.x); c3.params.push_back(dir.y); c3.params.push_back(dir.z); c3.options = c.options|INTERNAL_ORDER; nc.id=CMD_ATTACK; nc.params.push_back(enemy->id); nc.options=c.options|INTERNAL_ORDER; commandQue.push_front(nc); tempOrder=true; inCommand=false; if(lastPC1!=gs->frameNum){ //avoid infinite loops lastPC1=gs->frameNum; SlowUpdate(); } return; } else if(owner->maxRange>0){ float testRad=500*owner->moveState; enemy=helper->GetClosestEnemyUnit(owner->pos+owner->speed*20,testRad,owner->allyteam); if(enemy && (owner->hasUWWeapons || !enemy->isUnderWater) && !enemy->crashing && (myPlane->isFighter || !enemy->unitDef->canfly)) { if(owner->moveState!=1 || LinePointDist(commandPos1,commandPos2,enemy->pos) < 1000){ Command nc,c3; c3.id = CMD_MOVE; //keep it from being pulled too far off the path float3 dir = goalPos-curPos; dir.Normalize(); dir*=sqrtf(1024+owner->xsize*owner->xsize+owner->ysize*owner->ysize); dir+=curPos; c3.params.push_back(dir.x); c3.params.push_back(dir.y); c3.params.push_back(dir.z); c3.options = c.options|INTERNAL_ORDER; nc.id=CMD_ATTACK; nc.params.push_back(enemy->id); nc.options=c.options|INTERNAL_ORDER; commandQue.push_front(c3); commandQue.push_front(nc); tempOrder=true; inCommand=false; if(lastPC2!=gs->frameNum){ //avoid infinite loops lastPC2=gs->frameNum; SlowUpdate(); } return; } } } } myPlane->goalPos=goalPos; if((owner->pos-goalPos).SqLength2D()<16000 || (owner->pos+owner->speed*8-goalPos).SqLength2D()<16000){ FinishCommand(); } return;} case CMD_ATTACK: targetAge++; if(tempOrder && owner->moveState==1){ //limit how far away we fly if(orderTarget && LinePointDist(commandPos1,commandPos2,orderTarget->pos) > 1500){ owner->SetUserTarget(0); FinishCommand(); break; } } 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 && uh->units[int(c.params[0])] && !(uh->units[int(c.params[0])]->losStatus[owner->allyteam] & LOS_INRADAR))){ FinishCommand(); break; } if ((c.params.size() == 3) && (owner->commandShotCount > 0) && (commandQue.size() > 1)) { owner->AttackUnit(0,true); FinishCommand(); break; } if(orderTarget && orderTarget->unitDef->canfly && orderTarget->crashing){ owner->SetUserTarget(0); FinishCommand(); break; } if(orderTarget){ // myPlane->goalPos=orderTarget->pos; } else { // float3 pos(c.params[0],c.params[1],c.params[2]); // myPlane->goalPos=pos; } } else { targetAge=0; 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(); break; } } else { float3 pos(c.params[0],c.params[1],c.params[2]); owner->AttackGround(pos,false); inCommand=true; } } break; case CMD_AREA_ATTACK:{ if(targetDied){ targetDied=false; inCommand=false; } float3 pos(c.params[0],c.params[1],c.params[2]); float radius=c.params[3]; if(inCommand){ if(myPlane->aircraftState==CAirMoveType::AIRCRAFT_LANDED) inCommand=false; if(orderTarget && orderTarget->pos.distance2D(pos)>radius){ inCommand=false; DeleteDeathDependence(orderTarget); orderTarget=0; } if ((c.params.size() == 4) && (owner->commandShotCount > 0) && (commandQue.size() > 1)) { owner->AttackUnit(0,true); FinishCommand(); } } else { if(myPlane->aircraftState!=CAirMoveType::AIRCRAFT_LANDED){ inCommand=true; std::vector<int> eu; helper->GetEnemyUnits(pos,radius,owner->allyteam,eu); if(eu.empty()){ float3 attackPos=pos+gs->randVector()*radius; attackPos.y=ground->GetHeight(attackPos.x,attackPos.z); owner->AttackGround(attackPos,false); } else { int num=(int) (gs->randFloat()*eu.size()); orderTarget=uh->units[eu[num]]; owner->AttackUnit(orderTarget,false); AddDeathDependence(orderTarget); } } } break;} case CMD_GUARD: if(uh->units[int(c.params[0])]!=0){ CUnit* guarded=uh->units[int(c.params[0])]; if(guarded->lastAttacker && guarded->lastAttack+40<gs->frameNum && owner->maxRange>0 && (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 { Command c2; c2.id=CMD_MOVE; c2.options=c.options; 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(); } break; default: CCommandAI::SlowUpdate(); break; } }
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 { StopSlowGuard(); SetGoal(b->terraformCenter,fac->pos,fac->buildDistance*0.7f+b->terraformRadius*0.6f); } return; } else if (b->curReclaim && owner->unitDef->canReclaim){ StopSlowGuard(); if(!ReclaimObject(b->curReclaim)){ StopMove(); } return; } else { fac->StopBuild(); } if (b->curBuild && (!b->curBuild->soloBuilder || (b->curBuild->soloBuilder == owner)) && (( b->curBuild->beingBuilt && owner->unitDef->canAssist) || (!b->curBuild->beingBuilt && owner->unitDef->canRepair))) { StopSlowGuard(); 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->soloBuilder || (f->curBuild->soloBuilder == owner)) && (( f->curBuild->beingBuilt && owner->unitDef->canAssist) || (!f->curBuild->beingBuilt && owner->unitDef->canRepair))) { StopSlowGuard(); 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.1f + guarded->radius) *(fac->buildDistance*1.1f + guarded->radius)){ StopSlowGuard(); } if((guarded->pos-curPos).SqLength2D()< (fac->buildDistance*0.9f + guarded->radius) *(fac->buildDistance*0.9f + guarded->radius)){ StartSlowGuard(guarded->maxSpeed); 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->soloBuilder || (guarded->soloBuilder == owner)) && (( guarded->beingBuilt && owner->unitDef->canAssist) || (!guarded->beingBuilt && owner->unitDef->canRepair))) { StopSlowGuard(); Command nc; nc.id=CMD_REPAIR; nc.options=c.options; nc.params.push_back(guarded->id); commandQue.push_front(nc); inCommand=false; return; } 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 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 CBuilderCAI::ExecuteFight(Command &c) { assert((c.options & INTERNAL_ORDER) || owner->unitDef->canFight); CBuilder* fac=(CBuilder*)owner; if(tempOrder){ tempOrder=false; inCommand=true; } if(c.params.size()<3){ //this shouldnt happen but anyway ... logOutput.Print("Error: got fight cmd with less than 3 params on %s in BuilderCAI",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, owner->pos); if ((owner->pos - commandPos1).SqLength2D() > (96 * 96)) { commandPos1 = owner->pos; } } float3 pos(c.params[0],c.params[1],c.params[2]); if(!inCommand){ inCommand = true; commandPos2 = pos; } if(c.params.size() >= 6){ pos = ClosestPointOnLine(commandPos1, commandPos2, owner->pos); } if(pos!=goalPos){ SetGoal(pos, owner->pos); } float3 curPosOnLine = ClosestPointOnLine(commandPos1, commandPos2, owner->pos); if ((owner->unitDef->canRepair || owner->unitDef->canAssist) && FindRepairTargetAndRepair(curPosOnLine, 300*owner->moveState+fac->buildDistance-8,c.options,true)){ CUnit* target=uh->units[(int)commandQue.front().params[0]]; tempOrder=true; inCommand=false; if(lastPC1!=gs->frameNum){ //avoid infinite loops lastPC1=gs->frameNum; SlowUpdate(); } return; } if(owner->unitDef->canReclaim && FindReclaimableFeatureAndReclaim(curPosOnLine,300,c.options,false)){ tempOrder=true; inCommand=false; if(lastPC2!=gs->frameNum){ //avoid infinite loops lastPC2=gs->frameNum; SlowUpdate(); } return; } if((owner->pos - pos).SqLength2D()<(64*64)){ FinishCommand(); return; } if(owner->haveTarget && owner->moveType->progressState!=CMoveType::Done){ StopMove(); } else if(owner->moveType->progressState!=CMoveType::Active){ owner->moveType->StartMoving(goalPos, 8); } return; }
void CAirCAI::SlowUpdate() { if(gs->paused) // Commands issued may invoke SlowUpdate when paused return; if (!commandQue.empty() && commandQue.front().timeOut < gs->frameNum) { FinishCommand(); return; } if (owner->usingScriptMoveType) { return; // avoid the invalid (CAirMoveType*) cast } AAirMoveType* myPlane=(AAirMoveType*) owner->moveType; bool wantToRefuel = LandRepairIfNeeded(); if(!wantToRefuel && owner->unitDef->maxFuel > 0){ wantToRefuel = RefuelIfNeeded(); } if(commandQue.empty()){ if(myPlane->aircraftState == AAirMoveType::AIRCRAFT_FLYING && !owner->unitDef->DontLand() && myPlane->autoLand) { StopMove(); // myPlane->SetState(AAirMoveType::AIRCRAFT_LANDING); } if(owner->unitDef->canAttack && owner->fireState >= FIRESTATE_FIREATWILL && owner->moveState != MOVESTATE_HOLDPOS && owner->maxRange > 0) { if (myPlane->IsFighter()) { float testRad=1000 * owner->moveState; CUnit* enemy=helper->GetClosestEnemyAircraft( owner->pos + (owner->speed * 10), testRad, owner->allyteam); if(IsValidTarget(enemy)) { Command nc; nc.id = CMD_ATTACK; nc.params.push_back(enemy->id); nc.options = 0; commandQue.push_front(nc); inCommand = false; return; } } const float searchRadius = 500 * owner->moveState; CUnit* enemy = helper->GetClosestValidTarget( owner->pos + (owner->speed * 20), searchRadius, owner->allyteam, this); if (enemy != NULL) { Command nc; nc.id = CMD_ATTACK; nc.params.push_back(enemy->id); nc.options = 0; commandQue.push_front(nc); inCommand = false; return; } } return; } Command& c = commandQue.front(); if (c.id == CMD_WAIT) { if ((myPlane->aircraftState == AAirMoveType::AIRCRAFT_FLYING) && !owner->unitDef->DontLand() && myPlane->autoLand) { StopMove(); // myPlane->SetState(AAirMoveType::AIRCRAFT_LANDING); } return; } if (c.id != CMD_STOP && c.id != CMD_AUTOREPAIRLEVEL && c.id != CMD_IDLEMODE && c.id != CMD_SET_WANTED_MAX_SPEED) { myPlane->Takeoff(); } if (wantToRefuel) { switch (c.id) { case CMD_AREA_ATTACK: case CMD_ATTACK: case CMD_FIGHT: return; } } switch(c.id){ case CMD_AREA_ATTACK:{ ExecuteAreaAttack(c); return; } default:{ CMobileCAI::Execute(); return; } } }
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)){ 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.9){ 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; //info->AddLine("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.995){ 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.9){ 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.99){ 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; } }
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 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 CBuilderCAI::SlowUpdate() { if(commandQue.empty()){ CMobileCAI::SlowUpdate(); return; } Command& c=commandQue.front(); CBuilder* fac=(CBuilder*)owner; map<int,string>::iterator boi; if((boi=buildOptions.find(c.id))!=buildOptions.end()){ float radius; if(cachedRadiusId==c.id){ radius=cachedRadius; } else { radius=modelParser->Load3DO(unitDefHandler->GetUnitByName(boi->second)->model.modelpath,1,owner->team)->radius; cachedRadiusId=c.id; cachedRadius=radius; } if(inCommand){ if(building){ if(buildPos.distance2D(fac->pos)>fac->buildDistance+radius-8){ owner->moveType->StartMoving(buildPos, fac->buildDistance*0.5+radius); } else { StopMove(); owner->moveType->KeepPointingTo(buildPos, (fac->buildDistance+radius)*0.6, false); //needed since above startmoving cancels this } if(!fac->curBuild && !fac->terraforming){ building=false; StopMove(); //cancel the effect of KeepPointingTo FinishCommand(); } } else { buildPos.x=c.params[0]; buildPos.y=c.params[1]; buildPos.z=c.params[2]; if(buildPos.distance2D(fac->pos)<fac->buildDistance*0.6+radius){ StopMove(); if(uh->maxUnits>(int)gs->Team(owner->team)->units.size()){ buildRetries++; owner->moveType->KeepPointingTo(buildPos, fac->buildDistance*0.7+radius, false); if(fac->StartBuild(boi->second,buildPos) || buildRetries>20){ building=true; } else { ENTER_MIXED; if(owner->team==gu->myTeam && !(buildRetries&7)){ info->AddLine("%s: Build pos blocked",owner->unitDef->humanName.c_str()); info->SetLastMsgPos(owner->pos); } ENTER_SYNCED; helper->BuggerOff(buildPos,radius); NonMoving(); } } } else { if(owner->moveType->progressState==CMoveType::Failed){ if(++buildRetries>5){ StopMove(); FinishCommand(); } } SetGoal(buildPos,owner->pos, fac->buildDistance*0.4+radius); } } } else { //!inCommand float3 pos; pos.x=floor(c.params[0]/SQUARE_SIZE+0.5)*SQUARE_SIZE; pos.z=floor(c.params[2]/SQUARE_SIZE+0.5)*SQUARE_SIZE; pos.y=c.params[1]; CFeature* f=0; uh->TestUnitBuildSquare(pos,boi->second,f); if(f){ Command c2; c2.id=CMD_RECLAIM; c2.options=0; c2.params.push_back(f->id+MAX_UNITS); commandQue.push_front(c2); SlowUpdate(); //this assumes that the reclaim command can never return directly without having reclaimed the target } else { inCommand=true; SlowUpdate(); } } return; } switch(c.id){ case CMD_STOP: building=false; fac->StopBuild(); break; case CMD_REPAIR:{ if(c.params.size()==1){ //repair unit CUnit* unit=uh->units[(int)c.params[0]]; if(commandFromPatrol && owner->moveState==1){ //limit how far away we go if(unit && LinePointDist(commandPos1,commandPos2,unit->pos) > 500){ StopMove(); FinishCommand(); break; } } if(unit && unit->health<unit->maxHealth && unit!=owner){ if(unit->pos.distance2D(fac->pos)<fac->buildDistance+unit->radius-8){ StopMove(); fac->SetRepairTarget(unit); owner->moveType->KeepPointingTo(unit->pos, fac->buildDistance*0.9+unit->radius, false); } else { if(goalPos.distance2D(unit->pos)>1) SetGoal(unit->pos,owner->pos, fac->buildDistance*0.9+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;} case CMD_CAPTURE:{ if(c.params.size()==1){ //capture unit CUnit* unit=uh->units[(int)c.params[0]]; if(unit && unit->team!=owner->team){ if(unit->pos.distance2D(fac->pos)<fac->buildDistance+unit->radius-8){ StopMove(); fac->SetCaptureTarget(unit); owner->moveType->KeepPointingTo(unit->pos, fac->buildDistance*0.9+unit->radius, false); } else { if(goalPos.distance2D(unit->pos)>1) SetGoal(unit->pos,owner->pos, fac->buildDistance*0.9+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;} case CMD_GUARD:{ CUnit* guarded=uh->units[(int)c.params[0]]; if(guarded && guarded!=owner){ if(CBuilder* b=dynamic_cast<CBuilder*>(guarded)){ if(b->terraforming){ if(fac->pos.distance2D(b->terraformCenter)<fac->buildDistance*0.8+b->terraformRadius*0.7){ StopMove(); owner->moveType->KeepPointingTo(b->terraformCenter, fac->buildDistance*0.9, false); fac->HelpTerraform(b); } else { SetGoal(b->terraformCenter,fac->pos,fac->buildDistance*0.7+b->terraformRadius*0.6); } return; } if(b->curBuild){ 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){ 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*0.9+guarded->radius)*(fac->buildDistance*0.9+guarded->radius)){ StopMove(); // info->AddLine("should point with type 3?"); owner->moveType->KeepPointingTo(guarded->pos, fac->buildDistance*0.9+guarded->radius, false); if(guarded->health<guarded->maxHealth) fac->SetRepairTarget(guarded); else NonMoving(); }else{ if((goalPos-goal).SqLength2D()>4000) SetGoal(goal,curPos); } } else { FinishCommand(); } return;} case CMD_RECLAIM:{ 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.9+feature->radius){ StopMove(); owner->moveType->KeepPointingTo(feature->pos, fac->buildDistance*0.9+feature->radius, false); fac->SetReclaimTarget(feature); } else { if(goalPos.distance2D(feature->pos)>1){ SetGoal(feature->pos,owner->pos, fac->buildDistance*0.8+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){ if(unit->pos.distance2D(fac->pos)<fac->buildDistance-1+unit->radius){ StopMove(); owner->moveType->KeepPointingTo(unit->pos, fac->buildDistance*0.9+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)){ inCommand=false; SlowUpdate(); return; } if(!(c.options & ALT_KEY)){ FinishCommand(); } } else { //wrong number of parameters FinishCommand(); } return;} case CMD_RESURRECT:{ if(c.params.size()==1){ int id=(int)c.params[0]; if(id>=MAX_UNITS){ //resurrect feature CFeature* feature=featureHandler->features[id-MAX_UNITS]; if(feature && feature->createdFromUnit!=""){ if(feature->pos.distance2D(fac->pos)<fac->buildDistance*0.9+feature->radius){ StopMove(); owner->moveType->KeepPointingTo(feature->pos, fac->buildDistance*0.9+feature->radius, false); fac->SetResurrectTarget(feature); } else { if(goalPos.distance2D(feature->pos)>1){ SetGoal(feature->pos,owner->pos, fac->buildDistance*0.8+feature->radius); } else { if(owner->moveType->progressState==CMoveType::Failed){ StopMove(); FinishCommand(); } } } } else { if(fac->lastResurrected && uh->units[fac->lastResurrected]){ //resurrection finished, start repair c.id=CMD_REPAIR; //kind of hackery to overwrite the current order i suppose c.params.clear(); c.params.push_back(fac->lastResurrected); c.options|=INTERNAL_ORDER; fac->lastResurrected=0; inCommand=false; SlowUpdate(); return; } StopMove(); FinishCommand(); } } else { //resurrect unit FinishCommand(); } } else if(c.params.size()==4){//area resurect float3 pos(c.params[0],c.params[1],c.params[2]); float radius=c.params[3]; if(FindResurrectableFeatureAndResurrect(pos,radius,c.options)){ inCommand=false; SlowUpdate(); return; } if(!(c.options & ALT_KEY)){ FinishCommand(); } } else { //wrong number of parameters FinishCommand(); } return;} case CMD_PATROL:{ float3 curPos=owner->pos; if(commandFromPatrol){ commandFromPatrol=false; inCommand=true; --patrolTime; //prevent searching reclaimtargets etc directly if one of those call returned directly (infinite loop) } if(!inCommand){ float3 pos(c.params[0],c.params[1],c.params[2]); inCommand=true; Command co; co.id=CMD_PATROL; co.params.push_back(curPos.x); co.params.push_back(curPos.y); co.params.push_back(curPos.z); commandQue.push_front(co); activeCommand=1; commandPos1=curPos; patrolTime=0; } Command& c=commandQue[activeCommand]; if(c.params.size()<3){ //this shouldnt happen but anyway ... info->AddLine("Error: got patrol cmd with less than 3 params on %s in BuilderCAI",owner->unitDef->humanName.c_str()); return; } patrolGoal=float3(c.params[0],c.params[1],c.params[2]); commandPos2=patrolGoal; if(!(patrolTime&3) && owner->fireState==2){ if(FindRepairTargetAndRepair(owner->pos,300*owner->moveState,c.options,true)){ CUnit* target=uh->units[(int)commandQue.front().params[0]]; if(owner->moveState!=1 || LinePointDist(commandPos1,commandPos2,target->pos) < 300){ commandFromPatrol=true; inCommand=false; SlowUpdate(); return; } else { commandQue.pop_front(); } } if(FindReclaimableFeatureAndReclaim(owner->pos,300*owner->moveState,c.options)){ commandFromPatrol=true; inCommand=false; SlowUpdate(); return; } } patrolTime++; if(!(patrolGoal==goalPos)){ SetGoal(patrolGoal,curPos); } if((curPos-patrolGoal).SqLength2D()<4096){ if(owner->group) owner->group->CommandFinished(owner->id,CMD_PATROL); if((int)commandQue.size()<=activeCommand+1) activeCommand=0; else { if(commandQue[activeCommand+1].id!=CMD_PATROL) activeCommand=0; else activeCommand++; } commandPos1=commandPos2; } if(owner->haveTarget && owner->moveType->progressState!=CMoveType::Done) StopMove(); else if(owner->moveType->progressState!=CMoveType::Active) owner->moveType->StartMoving(goalPos, 8); return;} case CMD_RESTORE:{ if(inCommand){ if(!fac->terraforming){ FinishCommand(); } } else { float3 pos(c.params[0],c.params[1],c.params[2]); float radius(c.params[3]); if(fac->pos.distance2D(pos)<fac->buildDistance-1){ StopMove(); fac->StartRestore(pos,radius); owner->moveType->KeepPointingTo(pos, fac->buildDistance*0.9, false); inCommand=true; } else { SetGoal(pos,owner->pos, fac->buildDistance*0.9); } } return;} default: break; } CMobileCAI::SlowUpdate(); }
void CTransportCAI::UnloadLand(Command& c) { // default unload CTransportUnit* transport = static_cast<CTransportUnit*>(owner); CUnit* transportee = NULL; float3 wantedPos = c.GetPos(0); if (inCommand) { if (!owner->script->IsBusy()) { FinishCommand(); } } else { const std::list<CTransportUnit::TransportedUnit>& transportees = transport->GetTransportedUnits(); if (transportees.empty()) { FinishCommand(); return; } SetGoal(wantedPos, owner->pos); if (c.params.size() < 4) { // unload the first transportee transportee = (transportees.front()).unit; } else { const int unitID = c.params[3]; // unload a specific transportee for (auto it = transportees.begin(); it != transportees.end(); ++it) { CUnit* carried = it->unit; if (unitID == carried->id) { transportee = carried; break; } } if (transportee == NULL) { FinishCommand(); return; } } if (wantedPos.SqDistance2D(owner->pos) < Square(owner->unitDef->loadingRadius * 0.9f)) { CHoverAirMoveType* am = dynamic_cast<CHoverAirMoveType*>(owner->moveType); wantedPos.y = static_cast<CTransportUnit*>(owner)->GetTransporteeWantedHeight(wantedPos, transportee); if (am != NULL) { // handle air transports differently SetGoal(wantedPos, owner->pos); am->SetWantedAltitude(wantedPos.y - CGround::GetHeightAboveWater(wantedPos.x, wantedPos.z)); am->ForceHeading(static_cast<CTransportUnit*>(owner)->GetTransporteeWantedHeading(transportee)); am->maxDrift = 1.0f; // FIXME: kill the hardcoded constants, use the command's radius // NOTE: 2D distance-check would mean units get dropped from air const bool b1 = (owner->pos.SqDistance(wantedPos) < Square(AIRTRANSPORT_DOCKING_RADIUS)); const bool b2 = (std::abs(owner->heading - am->GetForcedHeading()) < AIRTRANSPORT_DOCKING_ANGLE); const bool b3 = (owner->updir.dot(UpVector) > 0.99f); if (b1 && b2 && b3) { wantedPos.y -= transportee->radius; if (!SpotIsClearIgnoreSelf(wantedPos, transportee)) { // chosen spot is no longer clear to land, choose a new one // if a new spot cannot be found, don't unload at all float3 newWantedPos; if (FindEmptySpot(wantedPos, std::max(16.0f * SQUARE_SIZE, transportee->radius * 4.0f), transportee->radius, newWantedPos, transportee)) { c.SetPos(0, newWantedPos); SetGoal(newWantedPos + UpVector * transportee->model->height, owner->pos); return; } } else { transport->DetachUnit(transportee); if (transportees.empty()) { am->SetAllowLanding(true); owner->script->EndTransport(); } } // move the transport away slightly SetGoal(owner->pos + owner->frontdir * 20.0f, owner->pos); FinishCommand(); } } else { inCommand = true; StopMove(); owner->script->TransportDrop(transportee, wantedPos); } } } }
void CAirCAI::ExecuteFight(Command &c) { assert((c.options & INTERNAL_ORDER) || owner->unitDef->canFight); AAirMoveType* myPlane = (AAirMoveType*) owner->moveType; if(tempOrder){ tempOrder=false; inCommand=true; } if(c.params.size()<3){ //this shouldnt happen but anyway ... logOutput.Print("Error: got fight cmd with less than 3 params on %s in AirCAI", 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()<(127*127)){' // 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, owner->pos); if ((owner->pos - commandPos1).SqLength2D() > (150 * 150)) { commandPos1 = owner->pos; } } goalPos = float3(c.params[0], c.params[1], c.params[2]); if(!inCommand){ inCommand = true; commandPos2=goalPos; } if(c.params.size() >= 6){ goalPos = ClosestPointOnLine(commandPos1, commandPos2, owner->pos); } // CMD_FIGHT is pretty useless if !canAttack but we try to honour the modders wishes anyway... if (owner->unitDef->canAttack && owner->fireState >= 2 && owner->moveState != 0 && owner->maxRange > 0) { float3 curPosOnLine = ClosestPointOnLine(commandPos1, commandPos2, owner->pos + owner->speed*10); float testRad = 1000 * owner->moveState; CUnit* enemy = NULL; if(myPlane->IsFighter()) { enemy = helper->GetClosestEnemyAircraft(curPosOnLine, testRad, owner->allyteam); } if(IsValidTarget(enemy) && (owner->moveState!=1 || LinePointDist(commandPos1, commandPos2, enemy->pos) < 1000)) { Command nc; nc.id=CMD_ATTACK; nc.params.push_back(enemy->id); nc.options=c.options|INTERNAL_ORDER; commandQue.push_front(nc); tempOrder=true; inCommand=false; if(lastPC1!=gs->frameNum){ //avoid infinite loops lastPC1=gs->frameNum; SlowUpdate(); } return; } else { float3 curPosOnLine = ClosestPointOnLine( commandPos1, commandPos2, owner->pos + owner->speed * 20); float testRad = 500 * owner->moveState; enemy = helper->GetClosestEnemyUnit(curPosOnLine, testRad, owner->allyteam); if(IsValidTarget(enemy)) { Command nc; nc.id = CMD_ATTACK; nc.params.push_back(enemy->id); nc.options = c.options | INTERNAL_ORDER; PushOrUpdateReturnFight(); commandQue.push_front(nc); tempOrder = true; inCommand = false; if(lastPC2 != gs->frameNum){ //avoid infinite loops lastPC2 = gs->frameNum; SlowUpdate(); } return; } } } myPlane->goalPos = goalPos; if((owner->pos - goalPos).SqLength2D() < (127 * 127) || (owner->pos + owner->speed*8 - goalPos).SqLength2D() < (127 * 127)) { FinishCommand(); } return; }
void CTransportCAI::UnloadLandFlood(Command& c) { //land, then release all units at once CTransportUnit* transport = static_cast<CTransportUnit*>(owner); CUnit* transportee = NULL; if (inCommand) { if (!owner->script->IsBusy()) { FinishCommand(); } } else { const std::list<CTransportUnit::TransportedUnit>& transportees = transport->GetTransportedUnits(); if (transportees.empty()) { FinishCommand(); return; } if (c.params.size() < 4) { transportee = (transportees.front()).unit; } else { const int unitID = c.params[3]; for (auto it = transportees.begin(); it != transportees.end(); ++it) { CUnit* carried = it->unit; if (unitID == carried->id) { transportee = carried; break; } } if (transportee == NULL) { FinishCommand(); return; } } // move to position float3 pos = c.GetPos(0); if (isFirstIteration) { if (goalPos.SqDistance2D(pos) > 400) { SetGoal(startingDropPos, owner->pos); } } if (startingDropPos.SqDistance2D(owner->pos) < Square(owner->unitDef->loadingRadius * 0.9f)) { CHoverAirMoveType* am = dynamic_cast<CHoverAirMoveType*>(owner->moveType); if (am != NULL) { // lower to ground startingDropPos.y = CGround::GetHeightAboveWater(startingDropPos.x, startingDropPos.z); const float3 wantedPos = startingDropPos + UpVector * transportee->model->height; SetGoal(wantedPos, owner->pos); am->SetWantedAltitude(1.0f); am->SetAllowLanding(true); am->maxDrift = 1.0f; // when on our way down start animations for unloading gear if (isFirstIteration) { owner->script->StartUnload(); } isFirstIteration = false; // once at ground if (owner->pos.y - CGround::GetHeightAboveWater(wantedPos.x, wantedPos.z) < SQUARE_SIZE) { // nail it to the ground before it tries jumping up, only to land again... am->SetState(am->AIRCRAFT_LANDED); // call this so that other animations such as opening doors may be started owner->script->TransportDrop((transportees.front()).unit, pos); transport->DetachUnitFromAir(transportee, pos); FinishCommand(); if (transportees.empty()) { am->SetAllowLanding(true); owner->script->EndTransport(); am->UpdateLanded(); } } } else { // land transports inCommand = true; isFirstIteration = false; StopMove(); owner->script->TransportDrop((transportees.front()).unit, pos); transport->DetachUnitFromAir(transportee, pos); FinishCommand(); if (transportees.empty()) { owner->script->EndTransport(); } } } } }
/** * @brief Executes the Fight command c */ void CMobileCAI::ExecuteFight(Command &c) { assert((c.options & INTERNAL_ORDER) || owner->unitDef->canFight); if(c.params.size() == 1) { if(orderTarget && !owner->weapons.empty() && !owner->weapons.front()->AttackUnit(orderTarget, false)) { CUnit* newTarget = helper->GetClosestValidTarget( owner->pos, owner->maxRange, owner->allyteam, this); if ((newTarget != NULL) && owner->weapons.front()->AttackUnit(newTarget, false)) { c.params[0] = newTarget->id; inCommand = false; } else { owner->weapons.front()->AttackUnit(orderTarget, false); } } ExecuteAttack(c); return; } if(tempOrder){ inCommand = true; tempOrder = false; } if (c.params.size() < 3) { 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, owner->pos); if ((owner->pos - commandPos1).SqLength2D() > (96 * 96)) { commandPos1 = owner->pos; } } float3 pos(c.params[0],c.params[1],c.params[2]); if(!inCommand){ inCommand = true; commandPos2 = pos; lastUserGoal = commandPos2; } if(c.params.size() >= 6){ pos = ClosestPointOnLine(commandPos1, commandPos2, owner->pos); } if(pos!=goalPos){ SetGoal(pos, owner->pos); } if (owner->unitDef->canAttack && owner->fireState >= 2 && !owner->weapons.empty()) { const float3 curPosOnLine = ClosestPointOnLine(commandPos1, commandPos2, owner->pos); const float searchRadius = owner->maxRange + 100 * owner->moveState * owner->moveState; CUnit* enemy = helper->GetClosestValidTarget(curPosOnLine, searchRadius, owner->allyteam, this); if (enemy != NULL) { Command c2; c2.id=CMD_FIGHT; 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((owner->pos - goalPos).SqLength2D() < (64 * 64) || (owner->moveType->progressState == AMoveType::Failed)){ FinishCommand(); } return; }
//----------------------------------------------------------------------------- // Purpose: Runs movement commands for the player // Input : *player - // *ucmd - // *moveHelper - // Output : void CPlayerMove::RunCommand //----------------------------------------------------------------------------- void CPlayerMove::RunCommand ( CBasePlayer *player, CUserCmd *ucmd, IMoveHelper *moveHelper ) { StartCommand( player, ucmd ); // Set globals appropriately gpGlobals->curtime = player->m_nTickBase * TICK_INTERVAL; gpGlobals->frametime = player->m_bGamePaused ? 0 : TICK_INTERVAL; // Add and subtract buttons we're forcing on the player ucmd->buttons |= player->m_afButtonForced; ucmd->buttons &= ~player->m_afButtonDisabled; if ( player->m_bGamePaused ) { // If no clipping and cheats enabled and noclipduring game enabled, then leave // forwardmove and angles stuff in usercmd if ( player->GetMoveType() == MOVETYPE_NOCLIP && sv_cheats->GetBool() && sv_noclipduringpause.GetBool() ) { gpGlobals->frametime = TICK_INTERVAL; } } /* // TODO: We can check whether the player is sending more commands than elapsed real time cmdtimeremaining -= ucmd->msec; if ( cmdtimeremaining < 0 ) { // return; } */ g_pGameMovement->StartTrackPredictionErrors( player ); CommentarySystem_PePlayerRunCommand( player, ucmd ); // Do weapon selection if ( ucmd->weaponselect != 0 ) { CBaseCombatWeapon *weapon = dynamic_cast< CBaseCombatWeapon * >( CBaseEntity::Instance( ucmd->weaponselect ) ); if ( weapon ) { VPROF( "player->SelectItem()" ); player->SelectItem( weapon->GetName(), ucmd->weaponsubtype ); } } IServerVehicle *pVehicle = player->GetVehicle(); // Latch in impulse. if ( ucmd->impulse ) { // Discard impulse commands unless the vehicle allows them. // FIXME: UsingStandardWeapons seems like a bad filter for this. The flashlight is an impulse command, for example. if ( !pVehicle || player->UsingStandardWeaponsInVehicle() ) { player->m_nImpulse = ucmd->impulse; } } // Update player input button states VPROF_SCOPE_BEGIN( "player->UpdateButtonState" ); player->UpdateButtonState( ucmd->buttons ); VPROF_SCOPE_END(); CheckMovingGround( player, TICK_INTERVAL ); g_pMoveData->m_vecOldAngles = player->pl.v_angle; // Copy from command to player unless game .dll has set angle using fixangle if ( player->pl.fixangle == FIXANGLE_NONE ) { player->pl.v_angle = ucmd->viewangles; } else if( player->pl.fixangle == FIXANGLE_RELATIVE ) { player->pl.v_angle = ucmd->viewangles + player->pl.anglechange; } // Call standard client pre-think RunPreThink( player ); // Call Think if one is set RunThink( player, TICK_INTERVAL ); // Setup input. SetupMove( player, ucmd, moveHelper, g_pMoveData ); // Let the game do the movement. if ( !pVehicle ) { VPROF( "g_pGameMovement->ProcessMovement()" ); Assert( g_pGameMovement ); g_pGameMovement->ProcessMovement( player, g_pMoveData ); } else { VPROF( "pVehicle->ProcessMovement()" ); pVehicle->ProcessMovement( player, g_pMoveData ); } // Copy output FinishMove( player, ucmd, g_pMoveData ); // Let server invoke any needed impact functions VPROF_SCOPE_BEGIN( "moveHelper->ProcessImpacts" ); moveHelper->ProcessImpacts(); VPROF_SCOPE_END(); RunPostThink( player ); g_pGameMovement->FinishTrackPredictionErrors( player ); FinishCommand( player ); // Let time pass player->m_nTickBase++; }