// relpos and relvel are position and velocity of ship relative to target in ship's frame // targvel is in direction of motion, must be positive // returns difference in closing speed from ideal, or zero if it thinks it's at the target // flip == true means it uses main thruster value for determining decel point double Ship::AIMatchPosVel(const vector3d &relpos, const vector3d &relvel, double targspeed, const vector3d &maxthrust) { matrix4x4d rot; GetRotMatrix(rot); vector3d objpos = relpos * rot; vector3d reldir = objpos.NormalizedSafe(); vector3d endvel = targspeed * reldir; double invmass = 1.0 / GetMass(); // find ideal velocities at current time given reverse thrust level vector3d ivel; ivel.x = calc_ivel(objpos.x, endvel.x, maxthrust.x * invmass); ivel.y = calc_ivel(objpos.y, endvel.y, maxthrust.y * invmass); ivel.z = calc_ivel(objpos.z, endvel.z, maxthrust.z * invmass); vector3d objvel = relvel * rot; vector3d diffvel = ivel - objvel; // required change in velocity AIChangeVelBy(diffvel); return diffvel.Dot(reldir); }
bool AICmdFormation::TimeStepUpdate() { if (!m_target) return true; if (!ProcessChild()) return false; // In case we're doing an intercept if (m_ship->GetFlightState() == Ship::FLYING) m_ship->SetWheelState(false); else { LaunchShip(m_ship); return false; } // if too far away, do an intercept first // TODO: adjust distance cap by timestep so we don't bounce? if (m_target->GetPositionRelTo(m_ship).Length() > 30000.0) { m_child = new AICmdFlyTo(m_ship, m_target); ProcessChild(); return false; } matrix3x3d torient = m_target->GetOrientRelTo(m_ship->GetFrame()); vector3d relpos = m_target->GetPositionRelTo(m_ship) + torient * m_posoff; vector3d relvel = -m_target->GetVelocityRelTo(m_ship); double targdist = relpos.Length(); vector3d reldir = (targdist < 1e-16) ? vector3d(1,0,0) : relpos/targdist; // adjust for target acceleration matrix3x3d forient = m_target->GetFrame()->GetOrientRelTo(m_ship->GetFrame()); vector3d targaccel = forient * m_target->GetLastForce() / m_target->GetMass(); relvel -= targaccel * Pi::game->GetTimeStep(); double maxdecel = m_ship->GetAccelFwd() + targaccel.Dot(reldir); if (maxdecel < 0.0) maxdecel = 0.0; // linear thrust double ispeed = calc_ivel(targdist, 0.0, maxdecel); vector3d vdiff = ispeed*reldir - relvel; m_ship->AIChangeVelDir(vdiff * m_ship->GetOrient()); if (m_target->IsDecelerating()) m_ship->SetDecelerating(true); m_ship->AIFaceDirection(-torient.VectorZ()); return false; // never self-terminates }
// reldir*targdist and relvel are pos and vel of ship relative to target in ship's frame // endspeed is in direction of motion, must be positive // maxdecel is maximum deceleration thrust bool Ship::AIMatchPosVel2(const vector3d &reldir, double targdist, const vector3d &relvel, double endspeed, double maxdecel) { matrix4x4d rot; GetRotMatrix(rot); double parspeed = relvel.Dot(reldir); double ivel = calc_ivel(targdist, endspeed, maxdecel); double diffspeed = ivel - parspeed; vector3d diffvel = diffspeed * reldir * rot; bool rval = false; // crunch diffvel by relative thruster power to get acceleration in right direction if (diffspeed > 0.0) { vector3d maxFA = GetMaxThrust(diffvel) * Pi::game->GetTimeStep() / GetMass(); if (abs(diffvel.x) > maxFA.x) diffvel *= maxFA.x / abs(diffvel.x); if (abs(diffvel.y) > maxFA.y) diffvel *= maxFA.y / abs(diffvel.y); // if (abs(diffvel.z) > maxFA.z) diffvel *= maxFA.z / abs(diffvel.z); if (maxFA.z < diffspeed) rval = true; } // add perpendicular velocity vector3d perpvel = relvel - parspeed*reldir; diffvel -= perpvel * rot; AIChangeVelBy(diffvel); return rval; // true if acceleration was capped }
bool AICmdFlyAround::TimeStepUpdate() { if (m_targmode == 1 && !m_target) return true; if (!ProcessChild()) return false; // Not necessary unless it's a tier 1 AI if (m_ship->GetFlightState() == Ship::FLYING) m_ship->SetWheelState(false); else { LaunchShip(m_ship); return false; } double timestep = Pi::game->GetTimeStep(); vector3d targpos = Targpos(); // target position in ship's frame vector3d obspos = m_obstructor->GetPositionRelTo(m_ship); double obsdist = obspos.Length(); vector3d obsdir = obspos / obsdist; vector3d relpos = targpos - m_ship->GetPosition(); // if too far away, fly to tangent if (obsdist > 1.1*m_alt) { double v; Frame *obsframe = GetNonRotFrame(m_obstructor); vector3d tangent = GenerateTangent(m_ship, obsframe, targpos, m_alt); vector3d tpos_obs = GetPosInFrame(obsframe, m_ship->GetFrame(), targpos); if (m_targmode != 1 && m_targmode != 2) v = m_vel; else if (relpos.LengthSqr() < obsdist) v = 0.0; else v = MaxVel((tpos_obs-tangent).Length(), tpos_obs.Length()); m_child = new AICmdFlyTo(m_ship, obsframe, tangent, v, true); ProcessChild(); return false; } // limit m_vel by target proximity & distance covered per frame double vel = (m_targmode != 1 && m_targmode != 2) ? m_vel : MaxVel(relpos.Length(), targpos.Length()); // all calculations in ship's frame vector3d fwddir = (obsdir.Cross(relpos).Cross(obsdir)).Normalized(); vector3d tanvel = vel * fwddir; // frame body suicide check, response if (CheckSuicide(m_ship, -obsdir)) { m_ship->AIFaceDirection(m_ship->GetPosition()); // face away from planet m_ship->AIMatchVel(vector3d(0.0)); return false; } // max feature avoidance check, response if (obsdist < MaxFeatureRad(m_obstructor)) { double ang = m_ship->AIFaceDirection(-obsdir); m_ship->AIMatchVel(ang < 0.05 ? 1000.0 * -obsdir : 0.0); return false; } // calculate target velocity double alt = (tanvel * timestep + obspos).Length(); // unnecessary? double ivel = calc_ivel(alt - m_alt, 0.0, m_ship->GetAccelMin()); vector3d finalvel = tanvel + ivel * obsdir; m_ship->AIMatchVel(finalvel); m_ship->AIFaceDirection(fwddir); // vector3d newhead = GenerateTangent(m_ship, m_obstructor->GetFrame(), fwddir); // newhead = GetPosInFrame(m_ship->GetFrame(), m_obstructor->GetFrame(), newhead); // m_ship->AIFaceDirection(newhead-m_ship->GetPosition()); // termination condition for orbits vector3d thrust = m_ship->GetThrusterState(); if (m_targmode >= 3 && thrust.LengthSqr() < 0.01) m_targmode++; if (m_targmode == 5) { m_ship->SetThrusterState(vector3d(0.0)); return true; } return false; }
bool AICmdFlyTo::TimeStepUpdate() { double timestep = Pi::game->GetTimeStep(); vector3d targvel = GetVelInFrame(m_ship->GetFrame(), m_targframe, m_posoff); vector3d relvel = m_ship->GetVelocity() - targvel; vector3d targpos = GetPosInFrame(m_ship->GetFrame(), m_targframe, m_posoff); bool safe = ParentSafetyAdjust(m_ship, m_targframe, m_posoff, targpos); double endvel = safe ? 0.0 : m_endvel; // don't use endvel if safety-adjusted vector3d relpos = targpos - m_ship->GetPosition(); vector3d reldir = relpos.NormalizedSafe(); double targdist = relpos.Length(); // sort out gear, launching if (m_ship->GetFlightState() == Ship::FLYING) m_ship->SetWheelState(false); else { LaunchShip(m_ship); return false; } // frame switch stuff - clear children/collision state if (m_frame != m_ship->GetFrame()) { if (m_child) { delete m_child; m_child = 0; } if (m_frame && m_tangent) return true; // regen tangent on frame switch m_frame = m_ship->GetFrame(); m_reldir = reldir; // for +vel termination condition } #ifdef DEBUG_AUTOPILOT if (m_ship->IsType(Object::PLAYER)) printf("Autopilot dist = %.1f, speed = %.1f, zthrust = %.2f, term = %.3f, state = %i\n", targdist, relvel.Length(), m_ship->GetThrusterState().z, reldir.Dot(m_reldir), m_state); #endif Body *body = m_frame->GetBodyFor(); double erad = MaxEffectRad(body, m_ship); if (!m_tangent || !(body == m_targframe->GetBodyFor())) { // process path collisions with frame body int coll = CheckCollision(m_ship, reldir, targdist, targpos, endvel, erad); if (coll == 0) { // no collision if (m_child) { delete m_child; m_child = 0; m_state = -1; } } else if (coll == 1) { // below feature height, target not below double ang = m_ship->AIFaceDirection(m_ship->GetPosition()); m_ship->AIMatchVel(ang < 0.05 ? 1000.0 * m_ship->GetPosition().Normalized() : 0.0); m_state = -3; return false; } else { // same thing for 2/3/4 if (!m_child) m_child = new AICmdFlyAround(m_ship, body, erad, 0.0, m_targframe, m_posoff); ProcessChild(); m_state = -5; return false; } } // if dangerously close to local body, pretend target isn't moving if (body) { double localdist = m_ship->GetPosition().Length(); if (targdist > localdist && localdist < 1.5*MaxFeatureRad(body)) relvel += targvel; } // regenerate state to flipmode if we're off course bool overshoot = CheckOvershoot(m_ship, reldir, targdist, relvel, endvel); if (m_tangent && m_state == -4 && !overshoot) return true; // bail out if (m_state < 0) m_state = GetFlipMode(m_ship, relpos, relvel); // linear thrust double ang, maxdecel = GetMaxDecel(m_ship, reldir, m_state, &ang); maxdecel -= GetGravityAtPos(m_targframe, m_posoff); if(maxdecel <= 0) { m_ship->AIMessage(Ship::AIERROR_GRAV_TOO_HIGH); return true; } bool cap = m_ship->AIMatchPosVel2(reldir, targdist, relvel, endvel, maxdecel); // path overshoot check, response if (m_state < 3 && overshoot) { double ispeed = calc_ivel(targdist, endvel, maxdecel); m_ship->AIFaceDirection(ispeed*reldir - relvel); m_state = -4; return false; } // flip check - if facing forward and not accelerating at maximum if (m_state == 1 && ang > 0.99 && !cap) m_state = 2; // termination conditions if (m_state == 3) m_state++; // finished last adjustment, hopefully else if (endvel > 0.0) { if (reldir.Dot(m_reldir) < 0.9) m_state = 4; } else if (targdist < 0.5*m_ship->GetAccelMin()*timestep*timestep) m_state = 3; // set heading according to current state if (m_state < 2) { // this shit still needed? yeah, sort of vector3d newrelpos = targpos - m_ship->AIGetNextFramePos(); if ((newrelpos + reldir*100.0).Dot(relpos) <= 0.0) m_ship->AIFaceDirection(reldir); // last frames turning workaround else m_ship->AIFaceDirection(newrelpos); } else if (m_state == 2) m_ship->AIFaceDirection(-reldir); // hmm. -relvel instead? else m_ship->AIMatchAngVelObjSpace(vector3d(0.0)); if (m_state == 4) return true; return false; }
bool AICmdDock::TimeStepUpdate() { if (!ProcessChild()) return false; if (!m_target) return true; if (m_state == 1) m_state = 2; // finished moving into dock start pos if (m_ship->GetFlightState() != Ship::FLYING) { // todo: should probably launch if docked with something else m_ship->ClearThrusterState(); return true; // docked, hopefully } // if we're not close to target, do a flyto first double targdist = m_target->GetPositionRelTo(m_ship).Length(); if (targdist > 16000.0) { m_child = new AICmdFlyTo(m_ship, m_target); ProcessChild(); return false; } int port = m_target->GetMyDockingPort(m_ship); if (port == -1) { std::string msg; m_target->GetDockingClearance(m_ship, msg); port = m_target->GetMyDockingPort(m_ship); if (port == -1) { m_ship->AIMessage(Ship::AIERROR_REFUSED_PERM); return true; } } // state 0,2: Get docking data if (m_state == 0 || m_state == 2 || m_state == 4) { const SpaceStationType *type = m_target->GetStationType(); SpaceStationType::positionOrient_t dockpos; type->GetShipApproachWaypoints(port, (m_state==0)?1:2, dockpos); if (m_state != 2) m_dockpos = dockpos.pos; m_dockdir = dockpos.xaxis.Cross(dockpos.yaxis).Normalized(); m_dockupdir = dockpos.yaxis.Normalized(); // don't trust these enough if (type->dockMethod == SpaceStationType::ORBITAL) m_dockupdir = -m_dockupdir; else if (m_state == 4) m_dockpos -= m_dockupdir * (m_ship->GetAabb().min.y + 1.0); if (m_state != 2) m_dockpos = m_target->GetOrient() * m_dockpos + m_target->GetPosition(); m_state++; // should have m_dockpos in target frame, dirs relative to target orient } if (m_state == 1) { // fly to first docking waypoint m_child = new AICmdFlyTo(m_ship, m_target->GetFrame(), m_dockpos, 0.0, false); ProcessChild(); return false; } // second docking waypoint m_ship->SetWheelState(true); vector3d targpos = GetPosInFrame(m_ship->GetFrame(), m_target->GetFrame(), m_dockpos); vector3d relpos = targpos - m_ship->GetPosition(); vector3d reldir = relpos.NormalizedSafe(); vector3d relvel = -m_target->GetVelocityRelTo(m_ship); double maxdecel = m_ship->GetAccelUp() - GetGravityAtPos(m_target->GetFrame(), m_dockpos); double ispeed = calc_ivel(relpos.Length(), 0.0, maxdecel); vector3d vdiff = ispeed*reldir - relvel; m_ship->AIChangeVelDir(vdiff * m_ship->GetOrient()); if (vdiff.Dot(reldir) < 0) m_ship->SetDecelerating(true); // get rotation of station for next frame matrix3x3d trot = m_target->GetOrientRelTo(m_ship->GetFrame()); double av = m_target->GetAngVelocity().Length(); double ang = av * Pi::game->GetTimeStep(); if (ang > 1e-16) { vector3d axis = m_target->GetAngVelocity().Normalized(); trot = trot * matrix3x3d::Rotate(ang, axis); } double af; if (m_target->GetStationType()->dockMethod == SpaceStationType::ORBITAL) af = m_ship->AIFaceDirection(trot * m_dockdir); else af = m_ship->AIFaceDirection(m_ship->GetPosition().Cross(m_ship->GetOrient().VectorX())); if (af < 0.01) af = m_ship->AIFaceUpdir(trot * m_dockupdir, av) - ang; if (m_state < 5 && af < 0.01 && m_ship->GetWheelState() >= 1.0f) m_state++; #ifdef DEBUG_AUTOPILOT printf("AICmdDock dist = %.1f, speed = %.1f, ythrust = %.2f, state = %i\n", targdist, relvel.Length(), m_ship->GetThrusterState().y, m_state); #endif return false; }
bool AICmdFlyTo::TimeStepUpdate() { if (!m_target && !m_targframe) return true; // deleted object // sort out gear, launching if (m_ship->GetFlightState() == Ship::FLYING) m_ship->SetWheelState(false); else { LaunchShip(m_ship); return false; } // generate base target pos (with vicinity adjustment) & vel double timestep = Pi::game->GetTimeStep(); vector3d targpos, targvel; if (m_target) { targpos = m_target->GetPositionRelTo(m_ship->GetFrame()); targpos -= (targpos - m_ship->GetPosition()).NormalizedSafe() * m_dist; targvel = m_target->GetVelocityRelTo(m_ship->GetFrame()); } else { targpos = GetPosInFrame(m_ship->GetFrame(), m_targframe, m_posoff); targvel = GetVelInFrame(m_ship->GetFrame(), m_targframe, m_posoff); } Frame *targframe = m_target ? m_target->GetFrame() : m_targframe; ParentSafetyAdjust(m_ship, targframe, targpos, targvel); vector3d relpos = targpos - m_ship->GetPosition(); vector3d reldir = relpos.NormalizedSafe(); vector3d relvel = targvel - m_ship->GetVelocity(); double targdist = relpos.Length(); #ifdef DEBUG_AUTOPILOT if (m_ship->IsType(Object::PLAYER)) printf("Autopilot dist = %.1f, speed = %.1f, zthrust = %.2f, state = %i\n", targdist, relvel.Length(), m_ship->GetThrusterState().z, m_state); #endif // frame switch stuff - clear children/collision state if (m_frame != m_ship->GetFrame()) { if (m_child) { delete m_child; m_child = 0; } if (m_tangent && m_frame) return true; // regen tangent on frame switch m_reldir = reldir; // for +vel termination condition m_frame = m_ship->GetFrame(); } // TODO: collision needs to be processed according to vdiff, not reldir? Body *body = m_frame->GetBody(); double erad = MaxEffectRad(body, m_ship); if ((m_target && body != m_target) || (m_targframe && (!m_tangent || body != m_targframe->GetBody()))) { int coll = CheckCollision(m_ship, reldir, targdist, targpos, m_endvel, erad); if (coll == 0) { // no collision if (m_child) { delete m_child; m_child = 0; } } else if (coll == 1) { // below feature height, target not below double ang = m_ship->AIFaceDirection(m_ship->GetPosition()); m_ship->AIMatchVel(ang < 0.05 ? 1000.0 * m_ship->GetPosition().Normalized() : vector3d(0.0)); } else { // same thing for 2/3/4 if (!m_child) m_child = new AICmdFlyAround(m_ship, m_frame->GetBody(), erad*1.05, 0.0); static_cast<AICmdFlyAround*>(m_child)->SetTargPos(targpos); ProcessChild(); } if (coll) { m_state = -coll; return false; } } if (m_state < 0 && m_state > -6 && m_tangent) return true; // bail out if (m_state < 0) m_state = targdist > 10000000.0 ? 1 : 0; // still lame double maxdecel = m_state ? m_ship->GetAccelFwd() : m_ship->GetAccelRev(); double gravdir = -reldir.Dot(m_ship->GetPosition().Normalized()); maxdecel -= gravdir * GetGravityAtPos(m_ship->GetFrame(), m_ship->GetPosition()); if (maxdecel < 0) maxdecel = 0.0; // target ship acceleration adjustment if (m_target && m_target->IsType(Object::SHIP)) { Ship *targship = static_cast<Ship*>(m_target); matrix3x3d orient = m_target->GetFrame()->GetOrientRelTo(m_frame); vector3d targaccel = orient * targship->GetLastForce() / m_target->GetMass(); // fudge: targets accelerating towards you are usually going to flip if (targaccel.Dot(reldir) < 0.0 && !targship->IsDecelerating()) targaccel *= 0.5; relvel += targaccel * timestep; maxdecel += targaccel.Dot(reldir); // if we have margin lower than 10%, fly as if 10% anyway maxdecel = std::max(maxdecel, 0.1*m_ship->GetAccelFwd()); } double curspeed = -relvel.Dot(reldir); double tt = sqrt(2.0*targdist / maxdecel); if (tt < timestep) tt = timestep; vector3d perpvel = relvel + reldir * curspeed; double perpspeed = perpvel.Length(); vector3d perpdir = (perpspeed > 1e-30) ? perpvel / perpspeed : vector3d(0,0,1); double sidefactor = perpspeed / (tt*0.5); if (curspeed > (tt+timestep)*maxdecel || maxdecel < sidefactor) { m_ship->AIFaceDirection(relvel); m_ship->AIMatchVel(targvel); m_state = -5; return false; } else maxdecel = sqrt(maxdecel*maxdecel - sidefactor*sidefactor); // ignore targvel if we could clear with side thrusters in a fraction of minimum time // if (perpspeed < tt*0.01*m_ship->GetAccelMin()) perpspeed = 0; // calculate target speed double ispeed = (maxdecel < 1e-10) ? 0.0 : calc_ivel(targdist, m_endvel, maxdecel); // cap target speed according to spare fuel remaining double fuelspeed = m_ship->GetSpeedReachedWithFuel(); if (m_target && m_target->IsType(Object::SHIP)) fuelspeed -= m_ship->GetVelocityRelTo(Pi::game->GetSpace()->GetRootFrame()).Length(); if (ispeed > curspeed && curspeed > 0.9*fuelspeed) ispeed = curspeed; // Don't exit a frame faster than some fraction of radius // double maxframespeed = 0.2 * m_frame->GetRadius() / timestep; // if (m_frame->GetParent() && ispeed > maxframespeed) ispeed = maxframespeed; // cap perpspeed according to what's needed now perpspeed = std::min(perpspeed, 2.0*sidefactor*timestep); // cap sdiff by thrust... double sdiff = ispeed - curspeed; double linaccel = sdiff < 0 ? std::max(sdiff, -m_ship->GetAccelFwd()*timestep) : std::min(sdiff, m_ship->GetAccelFwd()*timestep); // linear thrust application, decel check vector3d vdiff = linaccel*reldir + perpspeed*perpdir; bool decel = sdiff <= 0; m_ship->SetDecelerating(decel); if (decel) m_ship->AIChangeVelBy(vdiff * m_ship->GetOrient()); else m_ship->AIChangeVelDir(vdiff * m_ship->GetOrient()); // work out which way to head vector3d head = reldir; if (!m_state && sdiff < -1.2*maxdecel*timestep) m_state = 1; if (m_state && sdiff < maxdecel*timestep*60) head = -head; if (!m_state && decel) sidefactor = -sidefactor; head = head*maxdecel + perpdir*sidefactor; // face appropriate direction if (m_state >= 3) m_ship->AIMatchAngVelObjSpace(vector3d(0.0)); else m_ship->AIFaceDirection(head); if (body && body->IsType(Object::PLANET) && m_ship->GetPosition().LengthSqr() < 2*erad*erad) m_ship->AIFaceUpdir(m_ship->GetPosition()); // turn bottom thruster towards planet // termination conditions: check if (m_state >= 3) return true; // finished last adjustment, hopefully if (m_endvel > 0.0) { if (reldir.Dot(m_reldir) < 0.9) return true; } else if (targdist < 0.5*m_ship->GetAccelMin()*timestep*timestep) m_state = 3; return false; }
bool AICmdFlyTo::TimeStepUpdate() { double timestep = Pi::game->GetTimeStep(); vector3d targvel = GetVelInFrame(m_ship->GetFrame(), m_targframe, m_posoff); vector3d relvel = m_ship->GetVelocity() - targvel; vector3d targpos = GetPosInFrame(m_ship->GetFrame(), m_targframe, m_posoff); // only if pursuing a ship -- repeat actions from contructor again, since the position of the ship changed if(m_targetShip != 0) { m_targframe = m_targetShip->GetFrame(); m_posoff = m_ship->GetPositionRelTo(m_targframe); m_posoff += m_targetShip->GetPosition(); targpos = m_targetShip->GetPositionRelTo(m_ship->GetFrame()); targpos.x += VICINITY_MIN/2; // avoid collisions, set target a bit away targvel = m_targetShip->GetVelocityRelTo(m_ship->GetFrame()); // todo: check general frame! relvel = m_ship->GetVelocity() - targvel; } bool safe = ParentSafetyAdjust(m_ship, m_targframe, m_posoff, targpos); double endvel = safe ? 0.0 : m_endvel; // don't use endvel if safety-adjusted vector3d relpos = targpos - m_ship->GetPosition(); vector3d reldir = relpos.NormalizedSafe(); double targdist = relpos.Length(); double haveFuelToReachThisVelSafely; m_fuelEconomy = Clamp(m_fuelEconomy, 0.0f, 1.0f); haveFuelToReachThisVelSafely = m_ship->GetVelocityReachedWithFuelUsed(1.0/(6-3*m_fuelEconomy) * m_ship->GetFuel()); // sort out gear, launching if (m_ship->GetFlightState() == Ship::FLYING) m_ship->SetWheelState(false); else { LaunchShip(m_ship); return false; } // frame switch stuff - clear children/collision state if (m_frame != m_ship->GetFrame()) { if (m_child) { delete m_child; m_child = 0; } if (m_frame && m_tangent) return true; // regen tangent on frame switch m_frame = m_ship->GetFrame(); m_reldir = reldir; // for +vel termination condition } #ifdef DEBUG_AUTOPILOT if (m_ship->IsType(Object::PLAYER)) printf("Autopilot dist = %.1f, speed = %.1f, zthrust = %.2f, term = %.3f, crit = %.3f, fuel = %.3f, exhaust = %.0f, safeVel = %.0f, state = %i\n", targdist, relvel.Length(), m_ship->GetThrusterState().z, reldir.Dot(m_reldir), relvel.Dot(reldir)/(relvel.Length()+1e-7), m_ship->GetFuel(), m_ship->GetEffectiveExhaustVelocity() , haveFuelToReachThisVelSafely, m_state); #endif Body *body = m_frame->GetBodyFor(); double erad = MaxEffectRad(body, m_ship); if (m_targetShip == 0 && (!m_tangent || !(body == m_targframe->GetBodyFor()))) { // process path collisions with frame body int coll = CheckCollision(m_ship, reldir, targdist, targpos, endvel, erad); if (coll == 0) { // no collision if (m_child) { delete m_child; m_child = 0; m_state = -1; } } else if (coll == 1) { // below feature height, target not below double ang = m_ship->AIFaceDirection(m_ship->GetPosition()); m_ship->AIMatchVel(ang < 0.05 ? 1000.0 * m_ship->GetPosition().Normalized() : vector3d(0.0)); m_state = -3; return false; } else { // same thing for 2/3/4 if (!m_child) m_child = new AICmdFlyAround(m_ship, body, erad, 0.0, m_targframe, m_posoff, m_fuelEconomy); ProcessChild(); m_state = -5; return false; } } // if dangerously close to local body, pretend target isn't moving if (body) { double localdist = m_ship->GetPosition().Length(); if (targdist > localdist && localdist < 1.5*MaxFeatureRad(body)) relvel += targvel; } // regenerate state to flipmode if we're off course bool overshoot = CheckOvershoot(m_ship, reldir, targdist, relvel, endvel); if (m_tangent && m_state == -4 && !overshoot) return true; // bail out if (m_state < 0) m_state = GetFlipMode(m_ship, relpos, relvel); // linear thrust double ang, maxdecel = GetMaxDecel(m_ship, reldir, m_state, &ang); maxdecel -= GetGravityAtPos(m_targframe, m_posoff); if(maxdecel <= 0) { m_ship->AIMessage(Ship::AIERROR_GRAV_TOO_HIGH); return true; } bool cap = m_ship->AIMatchPosVel2(reldir, targdist, relvel, endvel, maxdecel); // path overshoot check, response if (m_state < 3 && overshoot) { double ispeed = calc_ivel(targdist, endvel, maxdecel); m_ship->AIFaceDirection(ispeed*reldir - relvel); m_state = -4; return false; } // turn thrusters off when in acceleration phase and low on fuel double angleCos = relvel.Dot(reldir)/(relvel.Length()+1e-7); if(m_state == 1 && relvel.Length() > haveFuelToReachThisVelSafely && // match direction precisely if close, if more than a day far, save the fuel and do not be so strict about the direction (angleCos > 0.9999 || (angleCos > 0.995 && targdist/(haveFuelToReachThisVelSafely+1e-7) > 86400)) ) { m_ship->SetThrusterState(vector3d(0.0)); } else if(m_state == 1 && relvel.Length() > 1.1*haveFuelToReachThisVelSafely) { // match direction without increasing speed .. saves fuel in deceleration phase vector3d v; matrix4x4d m; m_ship->GetRotMatrix(m); v = targvel + relvel.NormalizedSafe()*haveFuelToReachThisVelSafely; m_ship->AIMatchVel(v); } // flip check - if facing forward and not accelerating at maximum if (m_state == 1 && ang > 0.99 && !cap) m_state = 2; // termination conditions if (m_state == 3) m_state++; // finished last adjustment, hopefully else if (endvel > 0.0) { if (reldir.Dot(m_reldir) < 0.9) m_state = 4; } else if (targdist < 0.5*m_ship->GetAccelMin()*timestep*timestep) m_state = 3; // set heading according to current state if (m_state < 2) { // this shit still needed? yeah, sort of vector3d newrelpos = targpos - m_ship->AIGetNextFramePos(); if ((newrelpos + reldir*100.0).Dot(relpos) <= 0.0) m_ship->AIFaceDirection(reldir); // last frames turning workaround else m_ship->AIFaceDirection(newrelpos); } else if (m_state == 2) m_ship->AIFaceDirection(-reldir); // hmm. -relvel instead? else m_ship->AIMatchAngVelObjSpace(vector3d(0.0)); if (m_state == 4) return true; return false; }