void CTransportCAI::UnloadDrop(Command& c) { // fly over and drop unit if (inCommand) { if (!owner->script->IsBusy()) { FinishCommand(); } } else { auto transport = static_cast<CTransportUnit*>(owner); const auto& transportees = transport->GetTransportedUnits(); if (transportees.empty() || dropSpots.empty()) { FinishCommand(); return; } float3 pos = c.GetPos(0); // head towards goal // note that HoverAirMoveType must be modified to allow // non-stop movement through goals for this to work well if (goalPos.SqDistance2D(pos) > Square(20.0f)) { SetGoal(lastDropPos = pos, owner->pos); } CHoverAirMoveType* am = dynamic_cast<CHoverAirMoveType*>(owner->moveType); CUnit* transportee = (transportees.front()).unit; if (am != NULL) { pos.y = CGround::GetHeightAboveWater(pos.x, pos.z); am->maxDrift = 1.0f; // if near target or passed it accidentally, drop unit if (owner->pos.SqDistance2D(pos) < Square(40.0f) || (((pos - owner->pos).Normalize()).SqDistance(owner->frontdir) > 0.25 && owner->pos.SqDistance2D(pos)< (205*205))) { am->SetAllowLanding(false); owner->script->EndTransport(); transport->DetachUnitFromAir(transportee, pos); dropSpots.pop_back(); if (dropSpots.empty()) { // move the transport away after last drop SetGoal(owner->pos + owner->frontdir * 200, owner->pos); } FinishCommand(); } } else { inCommand = true; StopMove(); owner->script->TransportDrop(transportee, pos); } } }
void CTransportCAI::FinishCommand() { SetTransportee(NULL); CMobileCAI::FinishCommand(); CHoverAirMoveType* am = dynamic_cast<CHoverAirMoveType*>(owner->moveType); if (am == NULL || !commandQue.empty()) return; am->SetWantedAltitude(0.0f); am->wantToStop = true; }
void CTransportCAI::FinishCommand() { CHoverAirMoveType* am = dynamic_cast<CHoverAirMoveType*>(owner->moveType); if (am) { am->loadingUnits = false; } SetTransportee(NULL); CMobileCAI::FinishCommand(); if (am && commandQue.empty()) { am->SetWantedAltitude(0); am->wantToStop = true; } }
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(); } } } } }
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 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 CTransportCAI::UnloadLand(Command& c) { //default unload CTransportUnit* transport = static_cast<CTransportUnit*>(owner); if (inCommand) { if (!owner->script->IsBusy()) { FinishCommand(); } } else { const std::list<CTransportUnit::TransportedUnit>& transList = transport->GetTransportedUnits(); if (transList.empty()) { FinishCommand(); return; } float3 pos = c.GetPos(0); if (goalPos.SqDistance2D(pos) > 400) { SetGoal(pos, owner->pos); } CUnit* unit = NULL; if (c.params.size() < 4) { unit = transList.front().unit; } else { const int unitID = (int)c.params[3]; std::list<CTransportUnit::TransportedUnit>::const_iterator it; for (it = transList.begin(); it != transList.end(); ++it) { CUnit* carried = it->unit; if (unitID == carried->id) { unit = carried; break; } } if (unit == NULL) { FinishCommand(); return; } } if (pos.SqDistance2D(owner->pos) < Square(owner->unitDef->loadingRadius * 0.9f)) { CHoverAirMoveType* am = dynamic_cast<CHoverAirMoveType*>(owner->moveType); pos.y = static_cast<CTransportUnit*>(owner)->GetLoadUnloadHeight(pos, unit); if (am != NULL) { // handle air transports differently SetGoal(pos, owner->pos); am->SetWantedAltitude(pos.y - ground->GetHeightAboveWater(pos.x, pos.z)); float unloadHeading = static_cast<CTransportUnit*>(owner)->GetLoadUnloadHeading(unit); am->ForceHeading(unloadHeading); am->maxDrift = 1; if ((owner->pos.SqDistance(pos) < 64) && (owner->updir.dot(UpVector) > 0.99f) && math::fabs(owner->heading - unloadHeading) < AIRTRANSPORT_DOCKING_ANGLE) { pos.y -= unit->radius; if (!SpotIsClearIgnoreSelf(pos, unit)) { // 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 newpos; if (FindEmptySpot(pos, std::max(16.0f * SQUARE_SIZE, unit->radius * 4.0f), unit->radius, newpos, unit)) { c.SetPos(0, newpos); SetGoal(newpos + UpVector * unit->model->height, owner->pos); return; } } else { transport->DetachUnit(unit); if (transport->GetTransportedUnits().empty()) { am->dontLand = false; owner->script->EndTransport(); } } const float3 fix = owner->pos + owner->frontdir * 20; SetGoal(fix, owner->pos); // move the transport away slightly FinishCommand(); } } else { inCommand = true; StopMove(); owner->script->TransportDrop(unit, pos); } } } }
void CTransportCAI::ExecuteLoadUnits(Command& c) { CTransportUnit* transport = reinterpret_cast<CTransportUnit*>(owner); if (c.params.size() == 1) { // load single unit CUnit* unit = unitHandler->GetUnit(c.params[0]); if (!unit) { FinishCommand(); return; } if (c.options & INTERNAL_ORDER) { if (unit->commandAI->commandQue.empty()) { if (!LoadStillValid(unit)) { FinishCommand(); return; } } else { Command& currentUnitCommand = unit->commandAI->commandQue[0]; if ((currentUnitCommand.GetID() == CMD_LOAD_ONTO) && (currentUnitCommand.params.size() == 1) && (int(currentUnitCommand.params[0]) == owner->id)) { if ((unit->moveType->progressState == AMoveType::Failed) && (owner->moveType->progressState == AMoveType::Failed)) { unit->commandAI->FinishCommand(); FinishCommand(); return; } } else if (!LoadStillValid(unit)) { FinishCommand(); return; } } } if (inCommand) { if (!owner->script->IsBusy()) { FinishCommand(); } return; } if (unit && CanTransport(unit) && UpdateTargetLostTimer(int(c.params[0]))) { SetTransportee(unit); const float sqDist = unit->pos.SqDistance2D(owner->pos); const bool inLoadingRadius = (sqDist <= Square(owner->unitDef->loadingRadius)); CHoverAirMoveType* am = dynamic_cast<CHoverAirMoveType*>(owner->moveType); // subtracting 1 square to account for pathfinder/groundmovetype inaccuracy if (goalPos.SqDistance2D(unit->pos) > Square(owner->unitDef->loadingRadius - SQUARE_SIZE) || (!inLoadingRadius && (!owner->isMoving || (am && am->aircraftState != AAirMoveType::AIRCRAFT_FLYING)))) { SetGoal(unit->pos, owner->pos, std::min(64.0f, owner->unitDef->loadingRadius)); } if (inLoadingRadius) { if (am) { // handle air transports differently float3 wantedPos = unit->pos; wantedPos.y = static_cast<CTransportUnit*>(owner)->GetLoadUnloadHeight(wantedPos, unit); SetGoal(wantedPos, owner->pos); am->loadingUnits = true; am->ForceHeading(static_cast<CTransportUnit*>(owner)->GetLoadUnloadHeading(unit)); am->SetWantedAltitude(wantedPos.y - ground->GetHeightAboveWater(wantedPos.x, wantedPos.z)); am->maxDrift = 1; if ((owner->pos.SqDistance(wantedPos) < Square(AIRTRANSPORT_DOCKING_RADIUS)) && (abs(owner->heading-unit->heading) < AIRTRANSPORT_DOCKING_ANGLE) && (owner->updir.dot(UpVector) > 0.995f)) { am->loadingUnits = false; am->dontLand = true; owner->script->BeginTransport(unit); SetTransportee(NULL); transport->AttachUnit(unit, owner->script->QueryTransport(unit)); am->SetWantedAltitude(0); FinishCommand(); return; } } else { inCommand = true; StopMove(); owner->script->TransportPickup(unit); } } else if (owner->moveType->progressState == AMoveType::Failed && sqDist < (200 * 200)) { // if we're pretty close already but CGroundMoveType fails because it considers // the goal clogged (with the future passenger...), just try to move to the // point halfway between the transport and the passenger. SetGoal((unit->pos + owner->pos) * 0.5f, owner->pos); } } else { FinishCommand(); } } else if (c.params.size() == 4) { // area-load if (lastCall == gs->frameNum) { // avoid infinite loops return; } lastCall = gs->frameNum; const float3 pos = c.GetPos(0); const float radius = c.params[3]; CUnit* unit = FindUnitToTransport(pos, radius); if (unit && CanTransport(unit)) { Command c2(CMD_LOAD_UNITS, c.options|INTERNAL_ORDER, unit->id); commandQue.push_front(c2); inCommand = false; SlowUpdate(); return; } else { FinishCommand(); return; } } isFirstIteration = true; startingDropPos = float3(-1.0f, -1.0f, -1.0f); }