DestinyManager Class Reference

#include "DestinyManager.h"

Collaboration diagram for DestinyManager:

Classes
class	WarpState

Public Member Functions
	DestinyManager (SystemEntity *self)
	~DestinyManager ()
void	Process ()
void	SendSingleDestinyEvent (PyTuple **ev, bool self_only=false) const
void	SendSingleDestinyUpdate (PyTuple **up, bool self_only=false) const
void	SendDestinyUpdate (std::vector< PyTuple * > &updates, bool self_only=false) const
void	SendDestinyUpdate (std::vector< PyTuple * > &updates, std::vector< PyTuple * > &events, bool self_only=false) const
const GPoint &	GetPosition () const
const GVector &	GetVelocity () const
float	GetSpeedFraction ()
float	GetSpeed ()
uint8	GetState ()
void	EntityRemoved (SystemEntity *pSE)
void	WebbedMe (InventoryItemRef modRef, bool apply=false)
void	SetBubble (bool set=false)
void	SpeedBoost (bool deactivate=false)
void	SetPosition (const GPoint &pt, bool update=false)
void	SetMaxVelocity (float maxVelocity)
void	UpdateShipVariables ()
void	Stop ()
void	Halt ()
void	Eject ()
void	SetCloak (bool set=false)
void	TractorBeamStop ()
void	TractorBeamStart (SystemEntity *pShipSE, EvilNumber speed)
void	Orbit (SystemEntity *pSE, uint32 distance=0)
void	Follow (SystemEntity *pSE, uint32 distance)
void	AlignTo (SystemEntity *pSE)
void	GotoPoint (const GPoint &point)
void	GotoDirection (const GPoint &direction)
void	SetSpeedFraction (float fraction=1.0f, bool startMovement=false)
void	WarpTo (const GPoint &where, int32 distance=0, bool autoPilot=false, SystemEntity *pSE=nullptr)
bool	IsMoving ()
bool	IsAligned (GPoint &targetPoint)
bool	IsGoto ()
bool	IsStopped ()
bool	IsOrbiting ()
bool	IsFollowing ()
bool	IsWarping ()
bool	IsCloaked ()
bool	IsTurning ()
bool	IsTractored ()
void	Jump (bool showCloak=true)
void	Cloak ()
void	UnCloak ()
PyResult	AttemptDockOperation ()
void	Undock (GPoint dir)
void	SetUndockSpeed ()
void	DockingAccepted ()
void	SendSetState () const
void	SendJumpOut (uint32 gateID) const
void	SendGateActivity (uint32 gateID) const
void	SendJumpInEffect (std::string JumpEffect) const
void	SendJumpOutEffect (std::string JumpEffect, uint32 locationID) const
void	SendTerminalExplosion (uint32 shipID, uint32 bubbleID, bool isGlobal=false) const
void	SendBallInteractive (const ShipItemRef shipRef, bool set=false) const
void	UpdateNewShip (const ShipItemRef newShipRef)
void	UpdateOldShip (ShipSE *pShipSE)
void	SendJettisonPacket () const
void	SendAnchorDrop () const
void	SendAnchorLift () const
void	SendCloakFx (bool apply=false, bool module=false) const
void	SendSpecialEffect10 (uint32 entityID, uint32 targetID, std::string guid, bool isOffensive, bool start, bool isActive) const
void	SendSpecialEffect (uint32 entityID, uint32 moduleID, uint32 moduleTypeID, uint32 targetID, uint32 chargeTypeID, std::string guid, bool isOffensive, bool start, bool isActive, int32 duration, uint32 repeat, int32 graphicInfo=0) const
int32	GetDistance ()
int32	GetWarpSpeed ()
uint32	GetTargetID ()
SystemEntity *	GetTargetEntity ()
GPoint	GetTargetPoint ()
double	GetMaxVelocity ()
double	GetFollowDistance ()
double	GetMass ()
double	GetAgility ()
double	GetInertia ()
uint32	GetStateStamp ()
GVector	GetHeading ()
float	GetAlignTime ()
float	GetAccelTime ()
float	GetWarpTime ()
float	GetWarpDropSpeed ()
double	GetRadius ()
double	GetCapNeed ()
float	GetRadTic ()
void	MakeMissile (Missile *missile)
bool	IsFrozen ()
void	SetFrozen (bool set=false)

Protected Member Functions
void	ProcessState ()
bool	IsTargetInvalid ()
void	MoveObject ()
void	Orbit ()
void	Follow ()
void	BeginMovement ()
void	UpdateVelocity (bool isMoving=false)

Protected Attributes
SystemEntity *const	mySE
SystemBubble *	m_targBubble
bool	m_hasSentShipUpdates
uint8	m_warpAccelTime
uint8	m_warpDecelTime
float	m_mass
float	m_massMKg
float	m_alignTime
float	m_prevSpeed
float	m_maxShipSpeed
float	m_shipWarpSpeed
float	m_timeToEnterWarp
float	m_speedToLeaveWarp
double	m_radius
double	m_capNeeded
double	m_warpCapacitorNeed
double	m_shipAgility
double	m_shipInertia
float	m_maxSpeed
float	m_degPerTic
float	m_shipMaxAccelTime
double	m_radians
GPoint	m_position
GVector	m_velocity
bool	m_stop
bool	m_accel
bool	m_decel
bool	m_cloaked
bool	m_turning
bool	m_inBubble
bool	m_tractored
bool	m_tractorPause
uint8	m_ballMode
int32	m_stopDistance
uint8	m_turnTic
int8	m_orbiting
uint32	m_stateStamp
float	m_orbitTime
float	m_orbitRadTic
float	m_turnFraction
float	m_prevSpeedFraction
float	m_userSpeedFraction
float	m_currentSpeedFraction
float	m_activeSpeedFraction
float	m_maxOrbitSpeedFraction
uint32	m_followDistance
uint32	m_targetDistance
double	m_moveTime
GPoint	m_targetPoint
GVector	m_shipHeading
GVector	m_targetHeading
std::pair< uint32, SystemEntity * >	m_targetEntity

Private Member Functions
void	CheckBump ()
void	Bump (SystemEntity *who)
void	Bounce (GVector direction, float speed)
bool	IsTurn ()
void	Turn ()
void	ClearTurn ()
GPoint	ComputePosition (double curRad)
void	ClearOrbit ()
void	InitWarp ()
void	WarpAccel (uint16 sec_into_warp)
void	WarpCruise (uint16 sec_into_warp)
void	WarpDecel (uint16 sec_into_warp)
void	WarpStop (double currentShipSpeed)
void	WarpUpdate (double currentShipSpeed)

Private Attributes
bool	m_frozen
bool	m_changeDelay
bool	m_bump
double	m_inclination
double	m_longAscNode
Timer	m_warpTimer
WarpState *	m_warpState

Detailed Description

Definition at line 96 of file DestinyManager.h.

Constructor & Destructor Documentation

DestinyManager::DestinyManager

(

SystemEntity *

self

)

Definition at line 49 of file DestinyManager.cpp.

References SystemEntity::GetPosition(), SystemEntity::GetRadius(), m_accel, m_activeSpeedFraction, m_bump, m_capNeeded, m_changeDelay, m_cloaked, m_currentSpeedFraction, m_decel, m_degPerTic, m_hasSentShipUpdates, m_inBubble, m_inclination, m_longAscNode, m_maxOrbitSpeedFraction, m_orbiting, m_orbitRadTic, m_orbitTime, m_position, m_prevSpeed, m_prevSpeedFraction, m_radius, m_shipHeading, m_stateStamp, m_stop, m_targetEntity, m_targetHeading, m_targetPoint, m_tractored, m_tractorPause, m_turnFraction, m_turning, m_turnTic, m_userSpeedFraction, m_velocity, mySE, and NULL_ORIGIN().

: mySE(self),
m_maxSpeed(1.0f),
m_shipMaxAccelTime(0.0f),
m_ballMode(Destiny::Ball::Mode::STOP),
m_warpTimer(0),
m_moveTime(0.0),
m_targetDistance(0),
m_followDistance(0),
m_stopDistance(0),
m_mass(1.0f),
m_turnTic(1),
m_massMKg(1.0f),
m_alignTime(1.0f),
m_timeToEnterWarp(10.0f),
m_shipWarpSpeed(1.0f),
m_maxShipSpeed(100.0f),
m_shipAgility(1.0f),
m_shipInertia(1.0f),
m_warpAccelTime(1),
m_warpDecelTime(1),
m_warpState(nullptr),
m_targBubble(nullptr),
m_warpCapacitorNeed(0.00001f),
m_frozen(false)
{
    m_bump = false;
    m_stop = false;
    m_accel = false;
    m_decel = false;
    m_cloaked = false;
    m_turning = false;
    m_inBubble = true;
    m_orbiting = 0;
    m_tractored = false;
    m_changeDelay = false;
    m_tractorPause = false;
    m_hasSentShipUpdates = false;

    m_capNeeded = 0.0f;
    m_prevSpeed = 0.0f;
    m_degPerTic = 0.0f;
    m_orbitTime = 0.0f;
    m_orbitRadTic = 0.0f;
    m_prevSpeedFraction = 0.0f;
    m_userSpeedFraction = 0.0f;
    m_activeSpeedFraction = 0.0f;
    m_currentSpeedFraction = 0.0f;
    m_maxOrbitSpeedFraction = 1.0f;

    m_targetEntity.first = 0;
    m_targetEntity.second = nullptr;
    m_velocity = GVector( NULL_ORIGIN );
    m_targetPoint = GPoint( NULL_ORIGIN );
    m_shipHeading = GVector( NULL_ORIGIN );
    m_targetHeading = GVector( NULL_ORIGIN );

    m_radius = mySE->GetRadius();
    m_position = mySE->GetPosition();

    m_turnTic = 0;
    m_turning = false;
    m_turnFraction = 0;

    m_inclination = 0;
    m_longAscNode = 0;

    m_stateStamp = 0;
}

Here is the call graph for this function:

DestinyManager::~DestinyManager

(

)

Definition at line 119 of file DestinyManager.cpp.

References Timer::Disable(), m_warpState, m_warpTimer, and SafeDelete().

                                {
    m_warpTimer.Disable();
    SafeDelete(m_warpState);
}

Here is the call graph for this function:

Member Function Documentation

void DestinyManager::AlignTo

(

SystemEntity *

pSE

)

Definition at line 1863 of file DestinyManager.cpp.

References Follow().

Referenced by AttemptDockOperation().

                                              {
    Follow(ent, 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

PyResult DestinyManager::AttemptDockOperation

(

)

Definition at line 2254 of file DestinyManager.cpp.

References _log, AlignTo(), Client::CanThrow(), codelog, Ga::GaVec3::distance(), Player::State::Dock, Client::GetDockStationID(), GetFileTimeNow(), Client::GetName(), SystemEntity::GetPilot(), SystemEntity::GetPosition(), SystemEntity::GetRadius(), SystemManager::GetSE(), SystemEntity::HasPilot(), m_position, mySE, PyStatic, sConfig, Client::SendErrorMsg(), Client::SetAutoPilot(), Client::SetStateTimer(), and SystemEntity::SystemMgr().

                                              {
    Client *pClient = mySE->GetPilot();
    uint32 stationID = pClient->GetDockStationID();
    SystemEntity *station = mySE->SystemMgr()->GetSE(stationID);

    if (station == nullptr) {
        codelog(CLIENT__ERROR, "%s: Station %u not found.", pClient->GetName(), stationID);
        pClient->SendErrorMsg("Station Not Found, Docking Aborted.");
        return PyStatic.NewNone();
    }

    //get the station Docking Perimiter
    const GPoint stationPos = station->GetPosition();
    double rangeToStationPerimiter = m_position.distance(stationPos);
    rangeToStationPerimiter -= mySE->GetRadius();
    rangeToStationPerimiter -= station->GetRadius();

    // Verify range to station is within docking perimeter of 2500 meters:
    _log(DESTINY__TRACE, "Destiny::AttemptDockOperation() rangeToStationPerimiter is %.2fm", rangeToStationPerimiter);
    if (rangeToStationPerimiter > 2500.0) {
        AlignTo( station );   // Turn ship and move toward docking point - client will usually call Dock() automatically...sometimes
        if (mySE->HasPilot() and mySE->GetPilot()->CanThrow())
            throw UserError ("DockingApproach");
    }

    pClient->SetStateTimer(Player::State::Dock, sConfig.world.StationDockDelay *1000); // default @ 4sec();
    pClient->SetAutoPilot(false);

    return new PyLong(GetFileTimeNow());
}

Here is the call graph for this function:

void DestinyManager::BeginMovement ( )

protected

Definition at line 1739 of file DestinyManager.cpp.

References _log, NPC::GetAIMgr(), SystemEntity::GetID(), SystemEntity::GetName(), SystemEntity::GetNPCSE(), GetTimeMSeconds(), IsCloaked(), NPCAIMgr::IsIdle(), Ga::GaVec3::isInf(), Ga::GaVec3::isNaN(), Ga::GaVec3::isNotZero(), SystemEntity::IsNPCSE(), Ga::GaVec3::isZero(), Ga::GaVec3::length(), m_accel, m_currentSpeedFraction, m_decel, m_hasSentShipUpdates, m_mass, m_maxOrbitSpeedFraction, m_moveTime, m_orbiting, m_orbitRadTic, m_position, m_shipAgility, m_shipHeading, m_shipInertia, m_shipMaxAccelTime, m_stateStamp, m_stop, m_targetDistance, m_targetHeading, m_targetPoint, m_turning, m_turnTic, m_userSpeedFraction, MoveObject(), mySE, Destiny::Ball::Orbit::None, Ga::GaVec3::normalize(), sConfig, SendDestinyUpdate(), sEntityList, SetPosition(), SetSpeedFraction(), and UnCloak().

Referenced by Follow(), GotoDirection(), GotoPoint(), and Orbit().

                                   {
    // common movement for all types
    if (!m_hasSentShipUpdates) {
        // error fix for setting ship movement variables before ship is in bubble (cannot BubbleCast)
        std::vector<PyTuple*> updates;
        SetBallAgility sbagility;
            sbagility.entityID =  mySE->GetID();
            sbagility.agility = m_shipInertia;
        updates.push_back(sbagility.Encode());
        SetBallMassive sbmassive;
            sbmassive.entityID = mySE->GetID();
            sbmassive.is_massive = false;       // disable client-side bump checks
        updates.push_back(sbmassive.Encode());
        SetBallMass sbmass;
            sbmass.entityID = mySE->GetID();
            sbmass.mass = m_mass;
        updates.push_back(sbmass.Encode());
        SendDestinyUpdate(updates); //consumed
        m_hasSentShipUpdates = true;
    }

    // reset turn and movement checks for possible velocity change.
    m_turnTic = 0;
    m_stop = m_accel = m_decel = m_turning = false;

    //reset max accel time in case it was changed previously
    m_shipMaxAccelTime = (-log(0.0001) * m_shipAgility);

    if (!mySE->IsNPCSE() or (mySE->IsNPCSE() and mySE->GetNPCSE()->GetAIMgr()->IsIdle())) {
        m_moveTime = GetTimeMSeconds();
        m_stateStamp = sEntityList.GetStamp();
    }

    // do any of these next 3 need to be on every movement check??
    if (m_position.isNaN()) {
        _log(DESTINY__ERROR, "%s position is NaN.", mySE->GetName());
    }
    if (m_position.isZero()) {
        _log(DESTINY__ERROR, "%s position is zero.", mySE->GetName());
    }
    if (m_position.isInf()) {
        _log(DESTINY__ERROR, "%s position is inf.", mySE->GetName());
    }

    if (m_targetPoint.isNotZero()) {
        GVector targHeading(m_position, m_targetPoint);
        targHeading.normalize();
        m_targetHeading = targHeading;
        if (m_shipHeading.isZero())
            m_shipHeading = targHeading;
    }

    if (m_shipHeading.isZero() and m_targetHeading.isZero()) {
        GVector point(m_position);
        point.normalize();
        m_targetPoint =  (point * 1.0e16);
        GVector targHeading(m_position, m_targetPoint);
        targHeading.normalize();
        m_targetHeading = m_shipHeading = targHeading;
    }

    if (m_orbiting == Destiny::Ball::Orbit::None) {
        // reset target distance just in case it changed.
        GVector shipVector(m_position, m_targetPoint);
        m_targetDistance = (uint32)shipVector.length();
        m_orbitRadTic = 0.0f;
        m_maxOrbitSpeedFraction = 1;
    }

    // this will have to be adjusted for cloak mod.
    if (IsCloaked())
        UnCloak();

    // if ship is not moving, set initial movement variables
    if (m_userSpeedFraction < 0.05) {
        SetSpeedFraction(1.0f, true);
        //MoveObject();
    } else {
        // reset m_moveTime for current ship speed vs time to allow correct movement calculations after velocity change
        double newTime = (-log(1 - m_currentSpeedFraction) * m_shipAgility);
        m_moveTime = (GetTimeMSeconds() - (newTime * 1000));
        // TODO: verify m_moveTime is being set properly here.
        SetSpeedFraction(m_userSpeedFraction, true);
        // dont call MoveObject() here, as changes wont take affect till next tic.
    }

    SetPosition(m_position, sConfig.debug.PositionHack);   // (PositionHack == true) here will force position update to client
    MoveObject();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DestinyManager::Bounce ( GVector  direction, float  speed  )

private

Definition at line 664 of file DestinyManager.cpp.

References SystemEntity::GetID(), GetTimeMSeconds(), Destiny::Ball::Mode::GOTO, m_ballMode, m_currentSpeedFraction, m_maxShipSpeed, m_maxSpeed, m_moveTime, m_shipHeading, m_shipMaxAccelTime, m_stateStamp, m_stop, m_userSpeedFraction, m_velocity, mySE, SendDestinyUpdate(), sEntityList, Stop(), Ga::GaVec3::x, Ga::GaVec3::y, and Ga::GaVec3::z.

{
    // bounce code here (not used yet)
    /*  this code will update ship movement after being bumped
     *  all items will drift to a complete stop, unless other movement is called.
     */
    m_ballMode = Destiny::Ball::Mode::GOTO;
    m_stop = false;
    m_stateStamp = sEntityList.GetStamp();
    m_moveTime = GetTimeMSeconds();
    m_shipMaxAccelTime = 0.1f;
    m_userSpeedFraction = 1.0f;
    m_currentSpeedFraction = 1.0f;
    m_maxSpeed = m_maxShipSpeed;
    m_velocity = m_shipHeading * m_maxSpeed;

    std::vector<PyTuple*> updates;
    SetBallVelocity bv;
        bv.entityID = mySE->GetID();
        bv.x = m_velocity.x;
        bv.y = m_velocity.y;
        bv.z = m_velocity.z;
    updates.push_back(bv.Encode());
    CmdGotoDirection du;
        du.entityID = mySE->GetID();
        du.x = m_shipHeading.x;
        du.y = m_shipHeading.y;
        du.z = m_shipHeading.z;
    updates.push_back(du.Encode());
    SendDestinyUpdate(updates);
    Stop();
}

Here is the call graph for this function:

void DestinyManager::Bump ( SystemEntity *  who )

private

Definition at line 629 of file DestinyManager.cpp.

References Client::GetName(), SystemEntity::GetPilot(), SystemEntity::HasPilot(), m_bump, mySE, and Client::SendNotifyMsg().

Referenced by CheckBump().

{
    if (m_bump)
        return;
    // bump code here
    /*  determine most massive object...maybe not.  use percentiles here (becham math)
     *  determine direction(s) involved
     *  determine speed(s) involved
     *  determine new headings based on above
     *  determine new speed based on above
     *
     * NOTE static or large objects wont move, but will apply equal and opposite force.
     * un-anchored objects WILL move (jetcans, wrecks, portable hangers)
     */

    /* bump math, by Scheulagh Santorine, Ph.D.
     *  velocity of bumped object immediately after bump
     * v2(t=0+) = 2v1*m1/m1+m2
     */

    /*  run-time options for bumping jetcans, biomass, and other space objects
     *   bump drones??  prolly not, for simplicity
     */
    std::string msg1 = "You have bumped ";
    msg1 += pSE->GetPilot()->GetName();
    mySE->GetPilot()->SendNotifyMsg(msg1.c_str());
    // this test isnt needed right now, as it's ONLY checking against players and will always return true.
    //  will keep it in here for later expansion.
    if (pSE->HasPilot()) {
        std::string msg2 = "You have been bumped by ";
        msg2 += mySE->GetPilot()->GetName();
        pSE->GetPilot()->SendNotifyMsg(msg2.c_str());
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DestinyManager::CheckBump ( )

private

Todo:

add data and checks for each ship bumped to give single bump msg for each ship combo without spamming their overview

Definition at line 589 of file DestinyManager.cpp.

References Bump(), BUMP_DISTANCE, Profile::collision, Ga::GaVec3::distance(), SystemEntity::GetPilot(), SystemBubble::GetPlayers(), GetPosition(), SystemEntity::GetRadius(), GetTimeUSeconds(), m_bump, mySE, sConfig, sProfiler, and SystemEntity::SysBubble().

Referenced by MoveObject().

{
    double profileStartTime = GetTimeUSeconds();

    //  collision detection code here
    /*  in this case, we are ONLY interested in objects
     *   that have drifted within each others radius (for whatever reason)
     *  this only checks for ships running sub-warp speeds
     *   in relation to other objects in bubble.
     */

    // NOTE:  object's "massive = true" means it can bump/collide  (massive = solid)

    // initial implementation will ONLY check player ships for bumping.
    std::vector<Client*> vPlayers;
    mySE->SysBubble()->GetPlayers(vPlayers);
    Client* pClient = mySE->GetPilot();
    GPoint pos(GetPosition());
    float distance = 0.0f;
    for (auto cur : vPlayers) {
        if (cur == pClient)
            continue;
        distance = pos.distance(cur->GetShipSE()->GetPosition());
        distance -= (mySE->GetRadius() - cur->GetShipSE()->GetRadius());
        if (distance < BUMP_DISTANCE) {
            Bump(cur->GetShipSE());
            m_bump = true;
        } else {
            m_bump = false;
        }
    }
    if (sConfig.debug.UseProfiling)
        sProfiler.AddTime(Profile::collision, GetTimeUSeconds() - profileStartTime);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DestinyManager::ClearOrbit ( )

private

Definition at line 1446 of file DestinyManager.cpp.

References m_followDistance, m_maxOrbitSpeedFraction, m_orbiting, m_orbitRadTic, m_orbitTime, m_targetDistance, and Destiny::Ball::Orbit::None.

Referenced by Follow(), GotoDirection(), GotoPoint(), and Stop().

                                {
    m_orbiting = Destiny::Ball::Orbit::None;
    m_orbitTime = 0.0f;
    m_orbitRadTic = 0.0f;
    m_targetDistance = 0;
    m_followDistance = 0;
    m_maxOrbitSpeedFraction = 1.0f;
}

Here is the caller graph for this function:

void DestinyManager::ClearTurn ( )

private

Definition at line 1090 of file DestinyManager.cpp.

References m_alignTime, m_position, m_radians, m_timeToEnterWarp, m_turnFraction, m_turning, m_turnTic, and SetPosition().

Referenced by Halt(), InitWarp(), IsTurn(), Stop(), and Turn().

                               {
    //SetPosition(m_position, sConfig.debug.PositionHack);   // (PositionHack == true) here will force position update to client
    SetPosition(m_position, true);
    m_turnTic = 0;
    m_turning = false;
    m_radians = 0.0f;
    m_turnFraction = 0.0f;
    m_alignTime = m_timeToEnterWarp;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DestinyManager::Cloak

(

)

Definition at line 2676 of file DestinyManager.cpp.

References m_cloaked, mySE, SystemBubble::RemoveExclusive(), SendCloakFx(), and SystemEntity::SysBubble().

Referenced by Command_cloak(), and Client::SetCloakTimer().

                           {
    if (m_cloaked)
        return;
    m_cloaked = true;
    SendCloakFx(true);
    if (mySE->SysBubble() != nullptr)
        mySE->SysBubble()->RemoveExclusive(mySE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

GPoint DestinyManager::ComputePosition ( double  curRad )

private

Definition at line 1357 of file DestinyManager.cpp.

References _log, EvE::Trig::Deg2Rad(), Ga::GaVec3::isNaN(), LogMacro, m_orbitRadTic, m_orbitTime, m_position, m_radius, m_targetDistance, m_targetEntity, NULL_ORIGIN(), Stop(), Ga::GaVec3::x, Ga::GaVec3::y, and Ga::GaVec3::z.

                                                    {
    /*
     *   orbital definitions for EVEmu:
     * node line = ascending node
     * ascending node = line of intersection between orbit plane and reference plane, on the 'upward' side
     * periapsis = closest point of orbit to target point
     * apoapsis = farthest point of orbit to target point
     * ecliptic = plane of orbit
     * reference direction = line on reference plane inline with periapsis
     *
     *   primary orbital elements:
     * Y = reference direction (vector on reference plane that lines up with periapsis)
     * i = inclination to the positive ecliptic at node line
     * a = semi-major axis, or mean distance to target.  this will adjust ship's orbit based on distance
     * e = eccentricity (0=circle, 0-1=ellipse, 1=parabola)
     * w = argument of periapsis, angle from the node line to the periapsis
     * N = longitude of the ascending node (from Y, ccw to node line)
     * NOTE: w + N = 360*
     * M = mean anomaly, radians between our current position and periapsis.  increases uniformly with time from 0 to 2pi (360_deg)
     *
     *   calculated orbital elements:
     * L  = M + p   = mean longitude, measure of how far around its orbit a body has progressed since passing the argument of periapsis (w)
     * P  = orbital period,  time in seconds to complete one orbit (assuming all other variables remain constant)
     * T  = Epoch_of_M - (M(deg)/360_deg) / P  = time of periapsis
     * v  = true anomaly, position of the orbiting body along the orbit at a specific time, measured from w
     * E  = eccentric anomaly, angle from target side of center point of line qQ, at which we are located
     *
     * Under ideal conditions of a perfectly spherical central body and zero perturbations,
     *    all orbital elements except the mean anomaly (M) are constants.
     *
     * As we're using circular orbits, the reference direction (Y) will be +x
     *
     */

    GPoint Tp(m_targetEntity.second->GetPosition());
    //i = inclination to the positive ecliptic (plane of our orbit) at node line
    double adj = sqrt(pow(m_position.x - Tp.x, 2) * pow(m_position.z - Tp.z, 2));
    double opp = m_position.y - Tp.y;
    double i = atan2(opp, adj);

    /*  not needed yet, but here just in case...
    // to determine orbiters position relative to target, use RA and dec (from their point of view, with vernal equinox being their heading)
    // calculating right ascension (RA)
    double A = cos(w) * cos(N) - sin(w) * sin(N) * cos(i);
    double B = cos(cos(w) * cos(N) + sin(w) * sin(N) * cos(i)) - sin(sin(w) * sin(i));
    double RA = atan2(B, A);
    // calculating declination (dec)
    double C = sin(cos(w) * cos(N) + sin(w) * sin(N) * cos(i)) + cos(sin(w) * sin(i));
    double dec = asin(C);
    */

    GPoint mPos(NULL_ORIGIN);
    // fig 8 on nw of targ sphere
    float radius = m_targetDistance + (m_radius *2); // fudge a bit as using targetDistance is a hair too close
    // angle around y axis (from +x) - horizontal movement  - cw from +x using ships orbit in rad/tic
    float theta = m_orbitRadTic * 0/*timeStamp*/;
    // angle around xz axis (from 0) - vertical movement
    GVector target(m_position, Tp);
    LogMacro(target);
    float hyp = sqrt(pow(target.z, 2) + pow(target.x, 2));
    float inclination = 45; //atan(hyp / target.y);
    // fractional value of orbit period (0 < x < 1)
    float period = fmod(0/*timeStamp*/, m_orbitTime) /m_orbitTime;
    // calculate a pendulum value here to adjust elevation (+/-y) where +x is 1, 0x is 0, -x is -1
    float c = cos(EvE::Trig::Deg2Rad(360 * period));
    // get elevation modifier based on orbit period
    float phi = EvE::Trig::Deg2Rad(inclination * c);
    // set xz plane modifier from elevation
    //float s = sin(EvE::Trig::Deg2Rad(360 * period));
    //float mu = EvE::Trig::Deg2Rad(inclination * s);
    // here we will adjust orbit plane by adding OrbitRotation angle to theta
    // calculate position using trig.
    mPos.x = radius /* mu */* cos( theta );
    mPos.z = radius /* mu */* sin( theta );
    mPos.y = radius * phi;

    //_log(DESTINY__ORBIT_TRACE, "Destiny::ComputePosition() - a:%.5f, i:%.5f, v:%.5f, N:%.5f, M:%.5f, w:%.5f, e:%.5f, E:%f, P:%f", a,i,v,N,M,w,e,E,P);
    //_log(DESTINY__ORBIT_TRACE, "Destiny::ComputePosition() - mPos(%.3f, %.3f, %.3f) - radius check %.3f, q:%.3f", mPos.x, mPos.y, mPos.z, r,q);

    // position test
    if (mPos.isNaN()) {
        _log(DESTINY__ERROR, "mPos calculated as NaN.  Stopping Orbit.");
        Stop();
        return NULL_ORIGIN;
    }
    // get new position as reference to target
    return mPos;
}

Here is the call graph for this function:

void DestinyManager::DockingAccepted

(

)

Definition at line 2285 of file DestinyManager.cpp.

References Client::GetDockStationID(), SystemEntity::GetPilot(), SystemEntity::GetPosition(), SystemManager::GetSE(), m_position, mySE, Client::SendNotification(), Stop(), SystemEntity::SystemMgr(), UnCloak(), Ga::GaVec3::x, Ga::GaVec3::y, and Ga::GaVec3::z.

Referenced by Client::DockToStation().

{
    Stop();
    UnCloak();
    Client *pClient = mySE->GetPilot();
    if (pClient == nullptr)
        return;

    SystemEntity *pSE = mySE->SystemMgr()->GetSE(pClient->GetDockStationID());
    if (pSE == nullptr)
        return;

    const GPoint stationPos = pSE->GetPosition();
    OnDockingAccepted oda;
        oda.ship_x = m_position.x;
        oda.ship_y = m_position.y;
        oda.ship_z = m_position.z;
        oda.station_x = stationPos.x;
        oda.station_y = stationPos.y;
        oda.station_z = stationPos.z;
        oda.stationID = pClient->GetDockStationID();
    PyTuple* ev = oda.Encode();
    pClient->SendNotification("OnDockingAccepted", "charid", &ev);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DestinyManager::Eject

(

)

Definition at line 579 of file DestinyManager.cpp.

References SystemEntity::GetShipSE(), mySE, SendJettisonPacket(), Stop(), and UpdateOldShip().

Referenced by Client::Board(), Client::Eject(), and Client::ResetAfterPopped().

{
    // basic updates for ejecting from ship
    Stop();
    UpdateOldShip(mySE->GetShipSE());
    SendJettisonPacket();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DestinyManager::EntityRemoved

(

SystemEntity *

pSE

)

Definition at line 1698 of file DestinyManager.cpp.

References _log, Destiny::Ball::Mode::FOLLOW, SystemEntity::GetID(), m_ballMode, m_targetEntity, mySE, Destiny::Ball::Mode::ORBIT, and Stop().

Referenced by TargetManager::TargetLost().

                                                    {
    if (m_targetEntity.second == pSE) {
        m_targetEntity.first = 0;
        m_targetEntity.second = nullptr;

        switch(m_ballMode) {
            case Destiny::Ball::Mode::FOLLOW:
            case Destiny::Ball::Mode::ORBIT: {
                _log(DESTINY__DEBUG, "%u: Our target entity has gone away. Stopping.", mySE->GetID());
                Stop();
            } break;
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DestinyManager::Follow	(	SystemEntity *	pSE,
		uint32	distance
	)

Definition at line 1829 of file DestinyManager.cpp.

References BeginMovement(), ClearOrbit(), Destiny::Ball::Mode::FOLLOW, SystemEntity::GetID(), SystemEntity::GetPosition(), SystemEntity::IsStationSE(), m_ballMode, m_followDistance, m_orbiting, m_targetEntity, m_targetPoint, m_userSpeedFraction, mySE, SendSingleDestinyUpdate(), stDataMgr, and Ga::GaVec3::y.

Referenced by DroneAIMgr::Return(), ConcordAI::SetChasing(), NPCAIMgr::SetFollowing(), and ConcordAI::SetFollowing().

                                                              {
    //called from client as 'CmdFollowBall'
    //  also used by 'Approach'
    if ((m_ballMode == Destiny::Ball::Mode::FOLLOW)
    and (m_targetEntity.second == pSE)
    and (m_followDistance == distance)
    and (m_userSpeedFraction))
        return;

    //reset orbit vars in case we were orbiting before
    if (m_orbiting)
        ClearOrbit();

    m_ballMode = Destiny::Ball::Mode::FOLLOW;
    m_targetPoint = pSE->GetPosition();

    if (pSE->IsStationSE()) {
        // this makes ship approach station dock elevation (y), instead of approaching to stations "center point" position (where icon is)
        m_targetPoint.y = stDataMgr.GetDockPosY(pSE->GetID());
    }

    m_targetEntity.first = pSE->GetID();
    m_targetEntity.second = pSE;
    m_followDistance = distance;
    BeginMovement();

    CmdFollowBall du;
        du.entityID = mySE->GetID();
        du.targetID = pSE->GetID();
        du.range = (int32)distance;
    PyTuple *up = du.Encode();
    SendSingleDestinyUpdate(&up);   // consumed
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DestinyManager::Follow ( )

protected

Definition at line 1100 of file DestinyManager.cpp.

References _log, SystemEntity::GetID(), SystemEntity::GetPilot(), GetTimeMSeconds(), SystemEntity::HasPilot(), Client::IsAutoPilot(), Ga::GaVec3::length(), m_activeSpeedFraction, m_currentSpeedFraction, m_followDistance, m_maxSpeed, m_moveTime, m_position, m_prevSpeedFraction, m_radius, m_shipHeading, m_stateStamp, m_targetDistance, m_targetEntity, m_targetPoint, m_tractored, m_tractorPause, m_userSpeedFraction, m_velocity, MoveObject(), mySE, Ga::GaVec3::normalize(), NULL_ORIGIN_V(), SendDestinyUpdate(), sEntityList, SetSpeedFraction(), and Stop().

Referenced by AlignTo(), ProcessState(), and WarpTo().

                            {
    //  Follow is also used by client as AlignTo.
    const GPoint& target_point = m_targetEntity.second->GetPosition();
    GVector heading(m_position, target_point);
    m_targetDistance = (uint32)(heading.length() - m_radius);

    if (m_targetDistance < m_followDistance) {
        if (mySE->HasPilot())
            if (mySE->GetPilot()->IsAutoPilot()) {
                SetSpeedFraction(0.1);
                _log(AUTOPILOT__TRACE, "DestinyManager::Follow() - Target within FollowDistance.  SpeedFraction = 0.1.");
                return;
            }
    // this will allow following entities to keep their follow state, yet stop movement if within their follow distance.
    //  by keeping their follow state, once the distance is greater than their follow distance, they will begin movement again.
        if (m_tractored) {
            // specific to tractored entities.  sudden halt to mimic tractor stopping
            if (!m_tractorPause) {
                std::vector<PyTuple*> updates;
                CmdSetSpeedFraction ssf;
                    ssf.entityID = mySE->GetID();
                    ssf.fraction = 0;
                updates.push_back(ssf.Encode());
                SendDestinyUpdate(updates);
            }
            m_velocity = NULL_ORIGIN_V;
            m_tractorPause = true;
            m_activeSpeedFraction = m_userSpeedFraction = m_currentSpeedFraction = m_prevSpeedFraction = 0.0f;
            return;
        } else {
            if ((m_targetEntity.second->IsDynamicEntity()) and (m_targetEntity.second->DestinyMgr()->IsMoving())) {
                // this will mimic real movement, where ship will decel instead of a sudden halt
                //  still need to call MoveObject() here
                SetSpeedFraction(0.2);
            } else {
                Stop();
            }
        }
    } else {
        if (m_tractored and m_tractorPause) {
            // tractored object is outside follow distance.  begin movement again
            if (m_tractorPause) {
                std::vector<PyTuple*> updates;
                CmdSetSpeedFraction ssf;
                    ssf.entityID = mySE->GetID();
                    ssf.fraction = 1;
                updates.push_back(ssf.Encode());
                SendDestinyUpdate(updates);
            }
            m_tractorPause = false;
            m_velocity = m_shipHeading * m_maxSpeed;
            m_moveTime = GetTimeMSeconds();
            m_stateStamp = sEntityList.GetStamp();
            m_prevSpeedFraction = 0.0f;
            // there is no accel/decel for tractor'd items
            m_activeSpeedFraction = m_userSpeedFraction = m_currentSpeedFraction = 1;
        } else if (m_userSpeedFraction != 0.0f) {
            SetSpeedFraction(1.0f);
        }
    }

    heading.normalize();
    m_targetPoint = target_point + (heading * m_targetDistance);

    MoveObject();
}

Here is the call graph for this function:

Here is the caller graph for this function:

float DestinyManager::GetAccelTime ( )

inline

Definition at line 203 of file DestinyManager.h.

References m_shipMaxAccelTime.

Referenced by Command_shipvars().

{ return m_shipMaxAccelTime; }

Here is the caller graph for this function:

double DestinyManager::GetAgility ( )

inline

Definition at line 197 of file DestinyManager.h.

References m_shipAgility.

Referenced by Command_shipvars().

{ return m_shipAgility; }

Here is the caller graph for this function:

float DestinyManager::GetAlignTime ( )

inline

Definition at line 202 of file DestinyManager.h.

References m_alignTime.

Referenced by Command_shipvars().

{ return m_alignTime; }

Here is the caller graph for this function:

double DestinyManager::GetCapNeed ( )

inline

Definition at line 207 of file DestinyManager.h.

References m_warpCapacitorNeed.

Referenced by Command_shipvars().

{ return m_warpCapacitorNeed; }

Here is the caller graph for this function:

int32 DestinyManager::GetDistance ( )

inline

Definition at line 189 of file DestinyManager.h.

References m_stopDistance.

{ return m_stopDistance; }

double DestinyManager::GetFollowDistance ( )

inline

Definition at line 195 of file DestinyManager.h.

References m_targetDistance.

Referenced by Concord::EncodeDestiny(), Missile::EncodeDestiny(), NPC::EncodeDestiny(), DroneSE::EncodeDestiny(), and ShipSE::EncodeDestiny().

{ return m_targetDistance; }

Here is the caller graph for this function:

GVector DestinyManager::GetHeading ( )

inline

Definition at line 200 of file DestinyManager.h.

References m_shipHeading.

Referenced by Command_shipvars().

{ return m_shipHeading; }

Here is the caller graph for this function:

double DestinyManager::GetInertia ( )

inline

Definition at line 198 of file DestinyManager.h.

References m_shipInertia.

Referenced by Command_shipvars(), Concord::EncodeDestiny(), Missile::EncodeDestiny(), NPC::EncodeDestiny(), DroneSE::EncodeDestiny(), ShipSE::EncodeDestiny(), and DynamicSystemEntity::EncodeDestiny().

{ return m_shipInertia; }

Here is the caller graph for this function:

double DestinyManager::GetMass ( )

inline

Definition at line 196 of file DestinyManager.h.

References m_mass.

Referenced by Command_shipvars(), Concord::EncodeDestiny(), Missile::EncodeDestiny(), NPC::EncodeDestiny(), DroneSE::EncodeDestiny(), ShipSE::EncodeDestiny(), and DynamicSystemEntity::EncodeDestiny().

{ return m_mass; }

Here is the caller graph for this function:

double DestinyManager::GetMaxVelocity ( )

inline

Definition at line 194 of file DestinyManager.h.

References m_maxShipSpeed.

Referenced by CynoModule::Activate(), Command_shipvars(), Concord::EncodeDestiny(), NPC::EncodeDestiny(), DroneSE::EncodeDestiny(), ShipSE::EncodeDestiny(), and DynamicSystemEntity::EncodeDestiny().

{ return m_maxShipSpeed; }

Here is the caller graph for this function:

const GPoint& DestinyManager::GetPosition ( ) const

inline

Definition at line 109 of file DestinyManager.h.

References m_position.

Referenced by CheckBump(), Command_location(), TurretFormulas::GetDroneToHit(), TurretFormulas::GetNPCToHit(), TurretFormulas::GetSentryToHit(), TurretFormulas::GetToHit(), Sentry::Killed(), CustomsSE::Killed(), NPC::Killed(), DroneSE::Killed(), StructureSE::Killed(), and ShipSE::Killed().

{ return m_position; }

Here is the caller graph for this function:

double DestinyManager::GetRadius ( )

inline

Definition at line 206 of file DestinyManager.h.

References m_radius.

Referenced by Command_shipvars().

{ return m_radius; }

Here is the caller graph for this function:

float DestinyManager::GetRadTic ( )

inline

Definition at line 209 of file DestinyManager.h.

References m_orbitRadTic.

{ return m_orbitRadTic; }

float DestinyManager::GetSpeed ( )

inline

Definition at line 112 of file DestinyManager.h.

References m_currentSpeedFraction, and m_maxShipSpeed.

Referenced by Orbit().

{ return (m_maxShipSpeed * m_currentSpeedFraction); }

Here is the caller graph for this function:

float DestinyManager::GetSpeedFraction ( )

inline

Definition at line 111 of file DestinyManager.h.

References m_currentSpeedFraction.

Referenced by Concord::EncodeDestiny(), Missile::EncodeDestiny(), NPC::EncodeDestiny(), DroneSE::EncodeDestiny(), ShipSE::EncodeDestiny(), and DynamicSystemEntity::EncodeDestiny().

{ return m_currentSpeedFraction; }

Here is the caller graph for this function:

uint8 DestinyManager::GetState ( )

inline

Definition at line 115 of file DestinyManager.h.

References m_ballMode.

Referenced by Concord::EncodeDestiny(), NPC::EncodeDestiny(), DroneSE::EncodeDestiny(), and ShipSE::EncodeDestiny().

{ return m_ballMode; }

Here is the caller graph for this function:

uint32 DestinyManager::GetStateStamp ( )

inline

Definition at line 199 of file DestinyManager.h.

References m_stateStamp.

Referenced by Missile::EncodeDestiny().

{ return m_stateStamp; }

Here is the caller graph for this function:

SystemEntity* DestinyManager::GetTargetEntity ( )

inline

Definition at line 192 of file DestinyManager.h.

References m_targetEntity.

{ return m_targetEntity.second; }

uint32 DestinyManager::GetTargetID ( )

inline

Definition at line 191 of file DestinyManager.h.

References m_targetEntity.

Referenced by Concord::EncodeDestiny(), Missile::EncodeDestiny(), NPC::EncodeDestiny(), DroneSE::EncodeDestiny(), and ShipSE::EncodeDestiny().

{ return m_targetEntity.first; }

Here is the caller graph for this function:

GPoint DestinyManager::GetTargetPoint ( )

inline

Definition at line 193 of file DestinyManager.h.

References m_targetPoint.

Referenced by Concord::EncodeDestiny(), NPC::EncodeDestiny(), DroneSE::EncodeDestiny(), and ShipSE::EncodeDestiny().

{ return m_targetPoint; }

Here is the caller graph for this function:

const GVector& DestinyManager::GetVelocity ( ) const

inline

Definition at line 110 of file DestinyManager.h.

References m_velocity.

Referenced by Command_location(), Concord::EncodeDestiny(), Missile::EncodeDestiny(), NPC::EncodeDestiny(), DroneSE::EncodeDestiny(), ShipSE::EncodeDestiny(), DynamicSystemEntity::EncodeDestiny(), and SystemEntity::GetVelocity().

{ return m_velocity; }

Here is the caller graph for this function:

float DestinyManager::GetWarpDropSpeed ( )

inline

Definition at line 205 of file DestinyManager.h.

References m_speedToLeaveWarp.

Referenced by Command_shipvars().

{ return m_speedToLeaveWarp; }

Here is the caller graph for this function:

int32 DestinyManager::GetWarpSpeed ( )

inline

Definition at line 190 of file DestinyManager.h.

References m_shipWarpSpeed.

Referenced by Command_shipvars(), Concord::EncodeDestiny(), NPC::EncodeDestiny(), DroneSE::EncodeDestiny(), ShipSE::EncodeDestiny(), and WarpTo().

{ return static_cast<int32>(m_shipWarpSpeed * 10); }

Here is the caller graph for this function:

float DestinyManager::GetWarpTime ( )

inline

Definition at line 204 of file DestinyManager.h.

References m_timeToEnterWarp.

Referenced by Command_shipvars().

{ return m_timeToEnterWarp; }

Here is the caller graph for this function:

void DestinyManager::GotoDirection

(

const GPoint &

direction

)

Definition at line 1867 of file DestinyManager.cpp.

References BeginMovement(), ClearOrbit(), SystemEntity::GetID(), Destiny::Ball::Mode::GOTO, m_ballMode, m_orbiting, m_targetPoint, mySE, SendSingleDestinyUpdate(), Ga::GaVec3::x, Ga::GaVec3::y, and Ga::GaVec3::z.

                                                          {
    //reset orbit vars in case we were orbiting before
    if (m_orbiting)
        ClearOrbit();

    m_ballMode = Destiny::Ball::Mode::GOTO;
    m_targetPoint = direction *1.0e16;
    BeginMovement();

    CmdGotoDirection du;
        du.entityID = mySE->GetID();
        du.x = direction.x;
        du.y = direction.y;
        du.z = direction.z;
    PyTuple* up = du.Encode();
    SendSingleDestinyUpdate(&up);   // consumed
}

Here is the call graph for this function:

void DestinyManager::GotoPoint

(

const GPoint &

point

)

Definition at line 1885 of file DestinyManager.cpp.

References BeginMovement(), ClearOrbit(), SystemEntity::GetID(), Destiny::Ball::Mode::GOTO, m_ballMode, m_orbiting, m_targetPoint, mySE, SendSingleDestinyUpdate(), Ga::GaVec3::x, Ga::GaVec3::y, and Ga::GaVec3::z.

Referenced by NPCAIMgr::SetChasing(), and WarpTo().

                                                  {
    //reset orbit vars in case we were orbiting before
    if (m_orbiting)
        ClearOrbit();

    m_ballMode = Destiny::Ball::Mode::GOTO;
    m_targetPoint = point;
    BeginMovement();

    CmdGotoPoint gtpoint;
        gtpoint.entityID = mySE->GetID();
        gtpoint.x = m_targetPoint.x;
        gtpoint.y = m_targetPoint.y;
        gtpoint.z = m_targetPoint.z;
    PyTuple* up = gtpoint.Encode();
    SendSingleDestinyUpdate(&up);   // consumed
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DestinyManager::Halt

(

)

Definition at line 541 of file DestinyManager.cpp.

References _log, ClearTurn(), SystemEntity::GetID(), SystemEntity::GetName(), is_log_enabled, SystemEntity::IsDynamicEntity(), m_accel, m_activeSpeedFraction, m_ballMode, m_currentSpeedFraction, m_decel, m_followDistance, m_maxOrbitSpeedFraction, m_maxSpeed, m_moveTime, m_prevSpeed, m_prevSpeedFraction, m_shipAgility, m_shipHeading, m_shipMaxAccelTime, m_stateStamp, m_stop, m_stopDistance, m_targetDistance, m_targetEntity, m_targetPoint, m_turning, m_userSpeedFraction, m_velocity, m_warpState, mySE, NULL_ORIGIN(), SafeDelete(), Destiny::Ball::Mode::STOP, Ga::GaVec3::x, Ga::GaVec3::y, and Ga::GaVec3::z.

Referenced by Command_entityspawn(), Command_halt(), Command_warpto(), IsTurn(), Jump(), MoveObject(), Client::MoveToLocation(), Client::MoveToPosition(), Process(), TractorBeamStop(), and UpdateVelocity().

                          {

    SafeDelete(m_warpState);

    //  reset ALL movement variables and states.  calling this will set object to a COMPLETE and IMMEDIATE stop.
    m_ballMode = Destiny::Ball::Mode::STOP;
    m_stop = true;
    m_accel = false;
    m_decel = false;
    m_turning = false;
    m_maxSpeed = 0.0f;
    m_velocity = GVector(NULL_ORIGIN);
    m_moveTime = 0.0;
    m_prevSpeed = 0.0f;
    m_stateStamp = 0;
    m_targetPoint = GPoint(NULL_ORIGIN);
    m_stopDistance = 0;
    m_targetDistance = 0;
    m_followDistance = 0;
    m_prevSpeedFraction = 0.0f;
    m_userSpeedFraction = 0.0f;
    m_activeSpeedFraction = 0.0f;
    m_currentSpeedFraction = 0.0f;
    m_maxOrbitSpeedFraction = 1.0f;

    m_targetEntity.first = 0;
    m_targetEntity.second = nullptr;

    ClearTurn();

    if ((m_shipMaxAccelTime < 1.0) and (mySE->IsDynamicEntity()))
        m_shipMaxAccelTime = (-log(0.0001) * m_shipAgility);

    if (is_log_enabled(DESTINY__MOVE_TRACE))
        _log(DESTINY__MOVE_TRACE, "Destiny::Halt() - %s(%u): m_shipHeading: %.3f,%.3f,%.3f", \
                mySE->GetName(), mySE->GetID(), m_shipHeading.x, m_shipHeading.y, m_shipHeading.z);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DestinyManager::InitWarp ( )

private

Definition at line 1455 of file DestinyManager.cpp.

References _log, AttrCapacitorCharge, TargetManager::ClearAllTargets(), ClearTurn(), SystemEntity::GetID(), SystemEntity::GetName(), SystemEntity::GetSelf(), SystemEntity::GetShipSE(), SystemEntity::HasPilot(), is_log_enabled, m_capNeeded, m_position, m_shipWarpSpeed, m_stateStamp, m_targetDistance, m_targetPoint, m_turning, m_warpAccelTime, m_warpDecelTime, m_warpState, mySE, Ga::GaVec3::normalize(), ONE_AU_IN_METERS, SafeDelete(), sEntityList, InventoryItem::SetAttribute(), SystemEntity::TargetMgr(), ShipSE::Warp(), WarpAccel(), Ga::GaVec3::x, Ga::GaVec3::y, and Ga::GaVec3::z.

Referenced by ProcessState().

                              {
    //init warp:

    // warp time and distance math
    //   allan 1Nov14 - 14Nov14
    //  rewrite 3jan15  to use distance instead of time for warping.  more accurate now, and covers ALL distances.
    //  calculation and implementation update   9Jan15      accuracy is within 1000m

    /*  my research into warp formulas, i have used these sites, with a few excerpts and ideas from each...
     *     https://wiki.eveonline.com/en/wiki/Acceleration
     *     http://oldforums.eveonline.com/?a=topic&threadID=1251486
     *     http://gaming.stackexchange.com/questions/115271/how-does-one-calculate-a-ships-agility
     *     http://eve-search.com/thread/1514884-0
     *     http://www.eve-search.com/thread/478431-0/page/1
     */

    /* this is my version of how warp should be timed and followed by the server.
     * checks here for distance < warp speed and distance < 2AU, (with all distances in meters)
     *  and adjusts accel/decel times accordingly
     *
     *   accel/decel are logarithmic per ccp (see above).
     *
     * times are as follows, per this table.  http://cdn1.eveonline.com/www/newssystem/media/65418/1/numbers_table.png
     *
     * all warps are in same time groups for all ships, except freighters and caps.
     * distance checks are separated into 4 time groups, with subgroups for freighters and caps.
     *
     * the client seems to accept and agree with the math here.
     */
    // reset turn variables for warping
    if (m_turning)
        ClearTurn();

    if (is_log_enabled(DESTINY__WARP_TRACE))
        _log(DESTINY__WARP_TRACE, "Destiny::InitWarp(): %s(%u) has initialized warp.", mySE->GetName(), mySE->GetID());

    double warpSpeedInMeters(m_shipWarpSpeed * ONE_AU_IN_METERS);

    /*  this is from http://community.eveonline.com/news/dev-blogs/warp-drive-active/
     * x = e^(k*t)
     * v = k*e^(k*t)
     *
     * x = distance in meters
     * t = time in seconds
     * v = speed in m/s
     * k = 3 for accel, 1 for decel
     *
     * this gives distances as functions of time.
     *  the client seems to agree with this reasoning, and follows the same idea.
     */

    bool cruise(true);
    float cruiseTime(0.0f);
    double accelDistance(0.0), decelDistance(0.0), cruiseDistance(0.0);
    // fudge this a bit for accel/decel distances
    if (m_targetDistance < warpSpeedInMeters) {
        //  short warp....no cruise
        // this isnt very accurate....times and distances are a bit off....
        cruise = false;
        // accel = 1/3 decel
        accelDistance = (m_targetDistance /3);
        decelDistance = (m_targetDistance - accelDistance);
        warpSpeedInMeters = accelDistance;
        m_warpDecelTime = log(decelDistance /3);
        m_warpAccelTime = log(accelDistance /3) /3;
    } else {
        // all ships base time is 29s for distances > ship warp speed
        m_warpAccelTime = 7;
        m_warpDecelTime = 21; // accel *3
        decelDistance = exp(m_warpDecelTime);   // ship warp speed in meters * 1.7
        accelDistance = exp(3 * m_warpAccelTime);       // ship warp speed in meters
        cruiseDistance = (m_targetDistance - accelDistance - decelDistance);
        cruiseTime = (cruiseDistance / warpSpeedInMeters);
    }

    //  set total warp time based on above math.
    float warpTime(m_warpAccelTime + m_warpDecelTime + std::floor(cruiseTime));

    GVector warp_vector(m_position, m_targetPoint);
    warp_vector.normalize();

    if (is_log_enabled(DESTINY__WARP_TRACE)) {
        _log(DESTINY__WARP_TRACE, "Destiny::InitWarp():Calculate - %s(%u): Warp will accelerate for %us, cruise for %.3f, then decelerate for %us, with total time of %.3fs, and warp speed of %.4f m/s.", \
            mySE->GetName(), mySE->GetID(), m_warpAccelTime, cruiseTime, m_warpDecelTime, warpTime, warpSpeedInMeters);
        _log(DESTINY__WARP_TRACE, "Destiny::InitWarp():Calculate - %s(%u): Accel distance is %.4f. Cruise distance is %.4f.  Decel distance is %.4f.  Direction is %.3f,%.3f,%.3f.", \
            mySE->GetName(), mySE->GetID(), accelDistance, cruiseDistance, decelDistance, warp_vector.x, warp_vector.y, warp_vector.z);
        _log(DESTINY__WARP_TRACE, "Destiny::InitWarp():Calculate - %s(%u): We will exit warp at %.2f,%.2f,%.2f at a distance of %.4f AU (%um).", \
            mySE->GetName(), mySE->GetID(), m_targetPoint.x, m_targetPoint.y, m_targetPoint.z, m_targetDistance/ONE_AU_IN_METERS, m_targetDistance);
        GPoint destination = m_position + (warp_vector * m_targetDistance);
        _log(DESTINY__WARP_TRACE, "Destiny::InitWarp():Calculate - %s(%u): calculated exit is %.2f,%.2f,%.2f and vector is %.4f,%.4f,%.4f.", \
            mySE->GetName(), mySE->GetID(), destination.x, destination.y, destination.z, warp_vector.x, warp_vector.y, warp_vector.z);
        GVector diff(m_targetPoint, destination);
        _log(DESTINY__WARP_TRACE, "Destiny::InitWarp():Calculate - target vs calculated is %.2fm.", diff.length());
    }
    //  reset deceltime (from duration to time) for time check in WarpDecel()
    m_warpDecelTime = m_warpAccelTime + floor(cruiseTime);
    m_stateStamp = sEntityList.GetStamp();

    SafeDelete(m_warpState);
    m_warpState = new WarpState(
                        m_stateStamp,
                        m_targetDistance,
                        warpSpeedInMeters,
                        accelDistance,
                        cruiseDistance,
                        decelDistance,
                        warpTime,
                        true,
                        false,
                        false,
                        warp_vector );

    //drain cap
    if (mySE->HasPilot()) {
        mySE->GetSelf()->SetAttribute(AttrCapacitorCharge, m_capNeeded);
        mySE->GetShipSE()->Warp();
        m_capNeeded = 0;
    }

    //clear targets
    mySE->TargetMgr()->ClearAllTargets();
    //mySE->TargetMgr()->OnTarget(nullptr, TargMgr::Mode::Clear, TargMgr::Msg::WarpingOut);

    WarpAccel(0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool DestinyManager::IsAligned

(

GPoint &

targetPoint

)

Definition at line 2192 of file DestinyManager.cpp.

References Ga::GaVec3::dotProduct(), Ga::GaVec3::isZero(), m_position, m_shipHeading, Ga::GaVec3::normalize(), EvE::Trig::Rad2Deg(), and TURN_ALIGNMENT.

{
    if (m_shipHeading.isZero()) {
        GVector moveVector(m_position, targetPoint);
        moveVector.normalize();
        m_shipHeading = moveVector;
    }
    GVector toVec(m_position, targetPoint);
    toVec.normalize();
    float dot = toVec.dotProduct(m_shipHeading);
    float degrees = EvE::Trig::Rad2Deg(std::acos(dot));
    if (degrees < TURN_ALIGNMENT)
        return true;
    return false;
}

Here is the call graph for this function:

bool DestinyManager::IsCloaked ( )

inline

Definition at line 159 of file DestinyManager.h.

References m_cloaked.

Referenced by ModuleManager::Activate(), SystemBubble::AddBallExclusive(), SentryAI::Attack(), DroneAIMgr::Attack(), NPCAIMgr::Attack(), ConcordAI::Attack(), BeginMovement(), Client::CheckBallparkTimer(), Command_cloak(), Command_destinyvars(), Concord::EncodeDestiny(), NPC::EncodeDestiny(), ShipSE::EncodeDestiny(), DynamicSystemEntity::EncodeDestiny(), Client::JumpInEffect(), Client::JumpOutEffect(), NPCAIMgr::Process(), Client::ProcessClient(), and Client::SetDestiny().

{ return m_cloaked; }

Here is the caller graph for this function:

bool DestinyManager::IsFollowing ( )

inline

Definition at line 156 of file DestinyManager.h.

References Destiny::Ball::Mode::FOLLOW, and m_ballMode.

Referenced by NPCAIMgr::SetChasing(), and NPCAIMgr::SetFollowing().

{ return (m_ballMode == Destiny::Ball::Mode::FOLLOW); }

Here is the caller graph for this function:

bool DestinyManager::IsFrozen ( )

inline

Definition at line 215 of file DestinyManager.h.

References m_frozen.

{ return m_frozen; }

bool DestinyManager::IsGoto ( )

inline

Definition at line 153 of file DestinyManager.h.

References Destiny::Ball::Mode::GOTO, and m_ballMode.

Referenced by NPCAIMgr::SetChasing(), and NPCAIMgr::SetFollowing().

{ return (m_ballMode == Destiny::Ball::Mode::GOTO); }

Here is the caller graph for this function:

bool DestinyManager::IsMoving ( )

inline

Definition at line 149 of file DestinyManager.h.

References m_currentSpeedFraction.

Referenced by Client::MoveToPosition(), ProcessState(), NPCAIMgr::SetFleeing(), and Stop().

{ return (m_currentSpeedFraction > 0); }

Here is the caller graph for this function:

bool DestinyManager::IsOrbiting ( )

inline

Definition at line 155 of file DestinyManager.h.

References m_ballMode, and Destiny::Ball::Mode::ORBIT.

Referenced by NPCAIMgr::SetEngaged(), and NPCAIMgr::SetSignaling().

{ return (m_ballMode == Destiny::Ball::Mode::ORBIT); }

Here is the caller graph for this function:

bool DestinyManager::IsStopped ( )

inline

Definition at line 154 of file DestinyManager.h.

References m_ballMode, and Destiny::Ball::Mode::STOP.

{ return (m_ballMode == Destiny::Ball::Mode::STOP); }

bool DestinyManager::IsTargetInvalid ( )

protected

Todo:

this needs a good lookover

Definition at line 1713 of file DestinyManager.cpp.

References SystemManager::GetSE(), m_targetEntity, mySE, Stop(), and SystemEntity::SystemMgr().

Referenced by ProcessState().

{
    if (mySE->SystemMgr()->GetSE(m_targetEntity.first) == nullptr) {
        // Our target was removed
        Stop();
        return true;
    }
    if (!m_targetEntity.second->IsDynamicEntity())
        return false;
    if (m_targetEntity.second->HasPilot()) {
        if (m_targetEntity.second->GetPilot()->IsDocked()) {  // Our target docked, so STOP
            //mySE->TargetMgr()->ClearTarget(m_targetEntity.second);
            Stop();
            return true;
        }
    }
    if (m_targetEntity.second->DestinyMgr()->IsWarping()) { // The target is warping
        //mySE->TargetMgr()->ClearTarget(m_targetEntity.second);
        Stop();
        return true;
    }
    return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool DestinyManager::IsTractored ( )

inline

Definition at line 161 of file DestinyManager.h.

References m_tractored.

Referenced by ModuleManager::Activate().

{ return m_tractored; }

Here is the caller graph for this function:

bool DestinyManager::IsTurn ( )

private

Todo:

revisit this to verify angle calcs

Definition at line 915 of file DestinyManager.cpp.

References _log, ClearTurn(), Ga::GaVec3::dotProduct(), SystemEntity::GetID(), SystemEntity::GetName(), Halt(), is_log_enabled, Ga::GaVec3::isZero(), m_activeSpeedFraction, m_currentSpeedFraction, m_position, m_radians, m_shipHeading, m_targetHeading, m_targetPoint, mySE, Ga::GaVec3::normalize(), EvE::Trig::Rad2Deg(), sLog, TURN_ALIGNMENT, Ga::GaVec3::x, Ga::GaVec3::y, and Ga::GaVec3::z.

Referenced by Turn().

                            {    //this is working.  dont change
    if (m_targetPoint.isZero()) {
        _log(DESTINY__ERROR, "Destiny::IsTurn() - %s(%u): TargetPoint is null.", mySE->GetName(), mySE->GetID());
        ClearTurn();
        Halt();
        return false;
    }
    // if ship is stopped, there is no turn.  immediately begin movement in desired direction
    if ((m_currentSpeedFraction < 0.1) and (m_activeSpeedFraction < 0.1)) {
        GVector toVec(m_position, m_targetPoint);
        toVec.normalize();
        m_shipHeading = toVec;
        return false;
    }

    // check for turning angle.  returns true if angle is enough to change movement variables
    // create isosceles triangle where legs are current direction and destination, then find angle between legs
    //  it will set m_radians in the range of [-pi,pi].
    GVector toVec(m_position, m_targetPoint);
    toVec.normalize();
    float dot(toVec.dotProduct(m_shipHeading));
    if ((dot > 1.0f) or (dot < -1.0f)) {
        sLog.Error("Destiny::IsTurn()", "%s(%u) - shipHeading has screwed up.  dot is %.5f", mySE->GetName(), mySE->GetID(), dot);
        _log(DESTINY__ERROR, "Destiny::IsTurn() m_shipHeading: %.3f,%.3f,%.3f.  m_targetHeading: %.3f,%.3f,%.3f, toVec:%.3f,%.3f,%.3f", \
                m_shipHeading.x, m_shipHeading.y, m_shipHeading.z, m_targetHeading.x, m_targetHeading.y, m_targetHeading.z, toVec.x, toVec.y, toVec.z);
        // try to correct for bad heading vector and retest...
             if (m_shipHeading.x > 1.0f)  { m_shipHeading.x -= 1; }
        else if (m_shipHeading.x < 1.0f)  { m_shipHeading.x += 1; }
             if (m_shipHeading.y > 1.0f)  { m_shipHeading.y -= 1; }
        else if (m_shipHeading.y < 1.0f)  { m_shipHeading.y += 1; }
             if (m_shipHeading.z > 1.0f)  { m_shipHeading.z -= 1; }
        else if (m_shipHeading.z < 1.0f)  { m_shipHeading.z += 1; }
        dot = toVec.dotProduct(m_shipHeading);
        if ((dot > 1.0f) or (dot < -1.0f)) {
            sLog.Error("Destiny::IsTurn()", "%s(%u) - shipHeading has screwed up AGAIN.  dot is %.5f", mySE->GetName(), mySE->GetID(), dot);
            return false;
        }
    }
    m_radians = std::acos(dot);
    float degrees(EvE::Trig::Rad2Deg(m_radians));
    if (degrees < TURN_ALIGNMENT/*4*/) {
        m_shipHeading = toVec;
        return false;
    }
    if (is_log_enabled(DESTINY__TURN_TRACE)) {
        _log(DESTINY__TURN_TRACE, "Destiny::IsTurn() - %s(%u): dot: %.5f, radians:%.5f, degrees:%.3f",\
            mySE->GetName(), mySE->GetID(), dot, m_radians, degrees);
        _log(DESTINY__TURN_TRACE, "Destiny::IsTurn() m_shipHeading: %.3f,%.3f,%.3f.  m_targetHeading: %.3f,%.3f,%.3f", \
            m_shipHeading.x, m_shipHeading.y, m_shipHeading.z, m_targetHeading.x, m_targetHeading.y, m_targetHeading.z);
    }
    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool DestinyManager::IsTurning ( )

inline

Definition at line 160 of file DestinyManager.h.

References m_turning.

{ return m_turning; }

bool DestinyManager::IsWarping ( )

inline

Definition at line 158 of file DestinyManager.h.

References m_warpState.

Referenced by ModuleManager::Activate(), Command_destinyvars(), NPCAIMgr::Process(), ConcordAI::Process(), SystemBubble::ProcessWander(), ActiveModule::ShowEffect(), and Stop().

{ return (m_warpState ? true : false); }

Here is the caller graph for this function:

void DestinyManager::Jump

(

bool

showCloak = true

)

Definition at line 2666 of file DestinyManager.cpp.

References Halt(), m_cloaked, mySE, SystemBubble::RemoveExclusive(), and SystemEntity::SysBubble().

Referenced by ShipSE::Jump().

{
    Halt();
    if (showCloak) {
        m_cloaked = true;
    }
    if (mySE->SysBubble() != nullptr)
        mySE->SysBubble()->RemoveExclusive(mySE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DestinyManager::MakeMissile

(

Missile *

missile

)

Definition at line 2557 of file DestinyManager.cpp.

References SystemManager::AddEntity(), AttrInetia, Ga::GaVec3::distance(), EvilNumber::get_float(), InventoryItem::GetAttribute(), SystemEntity::GetID(), Missile::GetLauncherID(), SystemEntity::GetPosition(), SystemEntity::GetSelf(), Missile::GetSpeed(), Missile::GetTargetSE(), m_ballMode, m_mass, m_massMKg, m_maxShipSpeed, m_position, m_shipAgility, m_shipHeading, m_shipInertia, m_stateStamp, m_stop, m_targetDistance, m_targetEntity, m_targetPoint, ItemType::mass(), Destiny::Ball::Mode::MISSILE, mySE, Ga::GaVec3::normalize(), InventoryItem::position(), SendDestinyUpdate(), sEntityList, SetMaxVelocity(), SetPosition(), SetUndockSpeed(), SystemEntity::SystemMgr(), and InventoryItem::type().

Referenced by ActiveModule::LaunchMissile(), and NPCAIMgr::LaunchMissile().

                                                  {
    SetMaxVelocity(pMissile->GetSpeed());
    SetPosition(pMissile->GetSelf()->position());
    m_mass = pMissile->GetSelf()->type().mass();
    m_massMKg = m_mass / 1000000; //changes mass from Kg to MillionKg (10^-6)
    m_shipInertia = pMissile->GetSelf()->GetAttribute(AttrInetia).get_float();
    m_shipAgility = m_massMKg * m_shipInertia;

    m_stop = false;
    m_ballMode = Destiny::Ball::Mode::MISSILE;
    m_stateStamp = sEntityList.GetStamp();

    SystemEntity* pTarget = pMissile->GetTargetSE();
    m_targetPoint = GPoint(pTarget->GetPosition());
    m_targetEntity.first = pTarget->GetID();
    m_targetEntity.second = pTarget;
    m_targetDistance = m_position.distance(m_targetPoint);

    GVector moveVector(m_position, m_targetPoint);
    moveVector.normalize();     //change vector to direction
    m_shipHeading = moveVector;

    SetUndockSpeed();   /* sets all needed variables for max velocity */
    mySE->SystemMgr()->AddEntity(pMissile, false); // we are not adding missiles to anomaly map

    std::vector<PyTuple*> updates;
    SetBallSpeed maxspeed;
        maxspeed.entityID = pMissile->GetID();
        maxspeed.speed = m_maxShipSpeed;
    updates.push_back(maxspeed.Encode());
    Rsp_LaunchMissile miss;
        miss.shipID = pMissile->GetLauncherID();
        miss.targetID = pTarget->GetID();
        miss.missileID = pMissile->GetID();
        miss.unk1 = 1;
        miss.unk2 = 1;
    updates.push_back(miss.Encode());
    SendDestinyUpdate(updates); //consumed
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DestinyManager::MoveObject ( )

protected

Definition at line 698 of file DestinyManager.cpp.

References _log, SystemManager::AddEntity(), SystemManager::AddMarker(), CheckBump(), Destiny::Ball::Orbit::Far, flagNone, SystemEntity::GetID(), SystemEntity::GetLocationID(), SystemEntity::GetName(), SystemEntity::GetServices(), GetTimeMSeconds(), Halt(), SystemEntity::HasPilot(), SystemBubble::HasPlayers(), is_log_enabled, itoa(), m_accel, m_activeSpeedFraction, m_changeDelay, m_currentSpeedFraction, m_decel, m_maxOrbitSpeedFraction, m_maxSpeed, m_moveTime, m_orbiting, m_position, m_prevSpeed, m_prevSpeedFraction, m_shipAgility, m_shipHeading, m_shipMaxAccelTime, m_stateStamp, m_stop, m_tractored, m_tractorPause, m_turning, m_turnTic, m_userSpeedFraction, m_velocity, mySE, ownerSystem, sConfig, sEntityList, SetPosition(), CargoContainer::SpawnTemp(), SystemEntity::SysBubble(), SystemEntity::SystemMgr(), Destiny::Ball::Orbit::TooClose, Turn(), Ga::GaVec3::x, Ga::GaVec3::y, and Ga::GaVec3::z.

Referenced by BeginMovement(), Follow(), Orbit(), and ProcessState().

                                {
    if (mySE->SysBubble() == nullptr)
        mySE->SystemMgr()->AddEntity(mySE);

    if (m_stateStamp > sEntityList.GetStamp()) {
        if (is_log_enabled(DESTINY__MOVE_TRACE))
            _log(DESTINY__MOVE_TRACE, "Destiny::MoveObject() - %s(%u): stateStamp (%u) > GetStamp (%u).", \
            mySE->GetName(), mySE->GetID(), m_stateStamp, sEntityList.GetStamp());
        return;
    }

    if (m_changeDelay) {
        m_changeDelay = false;
        m_moveTime = GetTimeMSeconds();
        _log(DESTINY__MOVE_TRACE, "Destiny::MoveObject() - ChangeDelay - %s(%u): stateStamp: %u", \
                    mySE->GetName(), mySE->GetID(), m_stateStamp);
        return;
    }

    //apply our velocity to our position for 1 unit of time (second)

    /* acceleration and deceleration are both logarithmic, and the server needs to keep up with client position.
     * this is another step towards getting ready for collision detection.
     *
     * formula for time taken to accelerate from v to V, from https://wiki.eveonline.com/en/wiki/Acceleration
     *
     *   t=IM(10^-6) * -ln(1-(v/V))
     *
     * as this uses the natural log, the higher the speed, the slower the acceleration, to the limits of ln(0)
     * since lim ln(x) = -INFINITY where x->0+. and ln(0) is undefined, we will use
     *
     *   m_shipMaxAccelTime = (-log(0.0001) * m_shipAgility);
     *
     * to define the time it will take a given ship to reach 99.9999% of m_maxShipSpeed, at which point,
     * the server will set m_velocity = (m_maxShipSpeed * direction) (or 100% ship speed).
     *
     * to define speed at X time, we will use the following equation.
     *
     *   Vt = Vm * (1 - e(-t * 10^6 / IM))
     *
     * where
     * Vt = ships velocity at t
     * Vm = ships maximum velocity
     *  t = time
     *  I = ships inertia in s/kg
     *  M = ships mass in kg
     *  e = base of natural logarithms
     */

    /* **UPDATE**  this now uses time AND (m_currentSpeedFraction > 0.9999f) for min/max speeds.  -allan 6Aug14
     * **UPDATE**  this is now tracking ALL speed changes correctly.  -allan 21Nov15
     * **UPDATE**  initial orbit implementation.  -allan 13July16
     * **UPDATE**  removed speed fraction checks for min/max speeds.  -allan 02Jul17
     */

    double timeStamp(0);   // keep all these timers in seconds.
    // check for moving ship changing heading
    if (m_userSpeedFraction) {
        if (!m_orbiting or (m_orbiting > Destiny::Ball::Orbit::Far))
            Turn();
    }

    timeStamp = (GetTimeMSeconds() - m_moveTime) /1000;

    float speed(0.0f);
    std::string move = "";
    // check to make sure we dont overrun usf/asf
    if (m_activeSpeedFraction == m_userSpeedFraction)
        m_currentSpeedFraction = 1.0f;

    if (timeStamp > m_shipMaxAccelTime) { // and ((m_currentSpeedFraction > 0.9999f) or (m_activeSpeedFraction > m_prevSpeedFraction)))
        m_accel = m_decel = false;
        if (m_prevSpeed > m_maxSpeed) {
            speed = m_prevSpeed - ((m_prevSpeed - m_maxSpeed) * m_currentSpeedFraction);
            if (is_log_enabled(DESTINY__MOVE_TRACE))
                _log(DESTINY__MOVE_TRACE, "Destiny::MoveObject() - %s(%u) has decel'd from %.2fm/s to %.2fm/s of max %.2f in %.3fs.", \
                    mySE->GetName(), mySE->GetID(), m_prevSpeed, speed, m_maxSpeed, timeStamp);
            m_prevSpeed = 0.0f;
            m_prevSpeedFraction = 0.0f;
            m_shipMaxAccelTime = (-log(0.0001) * m_shipAgility);
        }
        if (m_userSpeedFraction) {
            // ship has reached full speed (whatever the fraction was set to)
            m_currentSpeedFraction = 1.0f;
            m_activeSpeedFraction = m_userSpeedFraction;
            move = "at constant speed, going";
            speed = m_maxSpeed * m_activeSpeedFraction;
        } else {
            //ship has reached full stop
            // update position one final time (for last bit of drift) and exit movement functions by calling Halt()
            SetPosition(m_position + m_velocity, sConfig.debug.PositionHack);   // (PositionHack == true) here will force position update to client
            if (is_log_enabled(DESTINY__MOVE_TRACE))
                _log(DESTINY__MOVE_TRACE, "Destiny::MoveObject() - %s(%u) is at full stop after %.3f seconds.", \
                    mySE->GetName(), mySE->GetID(), timeStamp);
            Halt();
            return;
        }
    } else {
        //not full speed yet or has changed speed
        if (m_turning) {
            move = "turning";
        } else {
            move = "accelerating";
        }

        m_currentSpeedFraction = (1 - exp(-timeStamp / m_shipAgility));

        if (m_accel) {
            m_activeSpeedFraction = m_userSpeedFraction * m_currentSpeedFraction;
        } else if (m_decel) {
            m_activeSpeedFraction = m_prevSpeedFraction * m_currentSpeedFraction;
        } else if (m_userSpeedFraction != m_activeSpeedFraction) {
            m_activeSpeedFraction = m_currentSpeedFraction;
        } else if (m_tractored or m_tractorPause or (m_activeSpeedFraction == 1)) {
            ;   // do nothing here.  this is to remove error reporting from next line.
        } else {
            _log(DESTINY__ERROR, "Destiny::MoveObject() - %s(%u) - move checks are not set right. Acc:%s, Dec:%s, Turn:%s, Tic:%u, Tractored:%s, TractorPause:%s", \
                    mySE->GetName(), mySE->GetID(), (m_accel ? "True" : "False"), (m_decel ? "True" : "False"), (m_turning ? "True" : "False"), \
                    m_turnTic, (m_tractored ? "True" : "False"), (m_tractorPause ? "True" : "False"));
        }

        if (m_prevSpeed) {
            if (m_prevSpeedFraction and (m_prevSpeedFraction == m_userSpeedFraction)) {
                speed = m_prevSpeed * m_activeSpeedFraction;
            //else if (m_turning)
            //    speed = m_maxSpeed * m_activeSpeedFraction;
            } else if (m_prevSpeed > m_maxSpeed) {
                speed = m_prevSpeed - (m_prevSpeed - m_maxSpeed) * m_activeSpeedFraction;
            //else if (m_prevSpeed < m_maxSpeed)
            //    speed = (m_maxSpeed - m_prevSpeed) * m_activeSpeedFraction;
            } else {
                speed = m_maxSpeed * m_activeSpeedFraction;
            }
        } else {
            speed = m_maxSpeed * m_activeSpeedFraction;
        }

        if ((!m_userSpeedFraction) or m_decel) {
            if (m_turning) {
                // decel for turn
                move = "decelerating for turn";
            } else {
                //just decelerating
                move = "decelerating";
            }

            //if (m_prevSpeedFraction < 1.0f) {
            //    //m_currentSpeedFraction -= m_activeSpeedFraction + m_prevSpeedFraction;
            //    speed = m_maxSpeed * m_currentSpeedFraction;
            //} else {
                if (m_prevSpeed) {
                    speed = m_maxSpeed + speed;
                } else {
                    speed = m_maxSpeed - speed;
                }
                m_currentSpeedFraction = 1 - m_activeSpeedFraction;
            //}
        }
    }
    // ships tend to "level out" when stopping.  try to mimic that here (wip)
    if (m_stop and (m_currentSpeedFraction < 0.85f) and (m_currentSpeedFraction > 0.09f)) {
        if (m_shipHeading.y < -0.05) {
            m_shipHeading.y += 0.03;
        } else if (m_shipHeading.y > 0.05) {
            m_shipHeading.y -= 0.03;
        }
    }

    if (m_orbiting)
        if (m_orbiting < Destiny::Ball::Orbit::TooClose) {
            // object is orbiting...set orbit speed correctly.
            speed *= m_maxOrbitSpeedFraction;
            move += " in orbit";
    }

    if ((m_prevSpeed) or (m_prevSpeedFraction)) {
        if (is_log_enabled(DESTINY__MOVE_TRACE))
            _log(DESTINY__MOVE_TRACE, "Destiny::MoveObject() - %s(%u) is %s at %.4f m/s (csf:%.4f asf:%.4f pSpeed:%.2f(%.3f), sec: %.3f).", \
                mySE->GetName(), mySE->GetID(), move.c_str(), speed, m_currentSpeedFraction, m_activeSpeedFraction, m_prevSpeed, m_prevSpeedFraction, timeStamp);
    } else {
        if (is_log_enabled(DESTINY__MOVE_TRACE))
            _log(DESTINY__MOVE_TRACE, "Destiny::MoveObject() - %s(%u) is %s at %.4f m/s (csf:%.4f asf:%.4f  sec: %.3f).", \
                mySE->GetName(), mySE->GetID(), move.c_str(), speed, m_currentSpeedFraction, m_activeSpeedFraction, timeStamp);
    }

    //set speed, direction and position for this round of movement
    m_velocity = m_shipHeading * speed;
    SetPosition(m_position + m_velocity, sConfig.debug.PositionHack);   // (PositionHack == true) here will force position update to client

    if (is_log_enabled(DESTINY__MOVE_DEBUG))
        _log(DESTINY__MOVE_DEBUG, "Destiny::MoveObject() - %s(%u) Pos:%.2f,%.2f,%.2f  Vel:%.3f,%.3f,%.3f  Head:%.3f,%.3f,%.3f", \
            mySE->GetName(), mySE->GetID(), m_position.x, m_position.y, m_position.z, m_velocity.x, m_velocity.y, m_velocity.z,\
            m_shipHeading.x, m_shipHeading.y, m_shipHeading.z);

    if (sConfig.cosmic.BumpEnabled)
        if (mySE->HasPilot() and mySE->SysBubble()->HasPlayers()) // no players in bubble = nothing to check against (for now)
            CheckBump();

    if (sEntityList.GetTracking()) {
        // create jetcan to visualize object movement
        std::string str = mySE->GetName();
        str += "  ";
        str += itoa(timeStamp);
        ItemData idata(23, ownerSystem, mySE->GetLocationID(), flagNone, str.c_str(), m_position, "Position Test");
        CargoContainerRef iRef = CargoContainer::SpawnTemp(idata);
        if (iRef.get() != nullptr) {
            // create new container
            FactionData data = FactionData();
            ContainerSE* cSE = new ContainerSE(iRef, mySE->GetServices(), mySE->SystemMgr(), data);
            if (cSE == nullptr)
                return;
            iRef->SetMySE(cSE);
            mySE->SystemMgr()->AddMarker(cSE);
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DestinyManager::Orbit	(	SystemEntity *	pSE,
		uint32	distance = 0
	)

Definition at line 2078 of file DestinyManager.cpp.

References _log, AttrMass, BeginMovement(), SystemEntity::DestinyMgr(), EvilNumber::get_float(), InventoryItem::GetAttribute(), SystemEntity::GetID(), SystemEntity::GetName(), SystemEntity::GetPosition(), SystemEntity::GetRadius(), SystemEntity::GetSelf(), GetSpeed(), is_log_enabled, m_ballMode, m_followDistance, m_massMKg, m_maxOrbitSpeedFraction, m_maxShipSpeed, m_orbiting, m_orbitRadTic, m_orbitTime, m_radius, m_shipAgility, m_shipHeading, m_shipInertia, m_targetDistance, m_targetEntity, m_targetPoint, ItemType::mass(), mySE, NULL_ORIGIN_V(), Destiny::Ball::Mode::ORBIT, Destiny::Ball::Orbit::Orbiting, EvE::Trig::Pi2, SendSingleDestinyUpdate(), and InventoryItem::type().

Referenced by DroneSE::IdleOrbit(), DroneAIMgr::SetEngaged(), NPCAIMgr::SetEngaged(), ConcordAI::SetEngaged(), NPCAIMgr::SetSignaling(), ConcordAI::SetSignaling(), and NPCAIMgr::SetWander().

                                                              {
    if ((m_ballMode == Destiny::Ball::Mode::ORBIT)
    and (m_targetEntity.second == pSE)
    and (m_targetDistance == distance))
        return;

    if (m_orbiting)
        m_shipHeading = NULL_ORIGIN_V;

    /* this initial Orbit() call will, based on position data, determine the orbit plane, rotation (cw/ccw)
     *  initial heading, actual orbit radius, actual orbit velocity, and some other shit i havent thought about yet.
     *
     * m_targetPoint    - updated in Orbit()
     * m_shipHeading    - updated in Orbit()
     * m_targetEntity   - SE object to orbit
     * m_targetDistance - commanded orbit distance
     * m_followDistance - calculated orbit distance based on mass, velocity, gravity, and other ship variables
     * m_stateStamp (via BeginMovement())
     * speed fractions (usf, csf, asf - via SetSpeedFraction() to begin or alter speed)
     * m_maxOrbitSpeedFraction - calculated max speed to maintain commanded orbit distance.  set in Orbit()
     */
    m_ballMode = Destiny::Ball::Mode::ORBIT;
    m_orbiting = Destiny::Ball::Orbit::Orbiting;
    m_targetEntity.first = pSE->GetID();
    m_targetEntity.second = pSE;
    m_targetPoint = pSE->GetPosition();
    m_targetDistance = distance;
    BeginMovement();

    if (is_log_enabled(DESTINY__ORBIT_TRACE))
        _log(DESTINY__ORBIT_TRACE, "%s(%u) - Ship Data - agility:%.3f, inertia:%.3f, massMkg:%.3f, maxSpeed:%.2f, radius:%.2f", \
            mySE->GetName(), mySE->GetID(), m_shipAgility, m_shipInertia, m_massMKg, m_maxShipSpeed, m_radius);
    //EvE::traceStack();

    // Target (orbited object)
    double Tr = pSE->GetRadius();
    double Tm = pSE->GetSelf()->GetAttribute(AttrMass).get_float();
    if (Tm != 0.0)
        Tm = pSE->GetSelf()->type().mass();

    if (is_log_enabled(DESTINY__ORBIT_TRACE))
        _log(DESTINY__ORBIT_TRACE, "%s(%u) - Target Data - mass:%.3f, speed:%.2f, radius:%.2f", \
            mySE->GetName(), mySE->GetID(), Tm, (pSE->DestinyMgr() ? pSE->DestinyMgr()->GetSpeed() : 0 ), Tr);

    // fudge distance to work 'close enough' with all targets...this was trial-n-error
    double Rc = ((distance + 150 + m_radius - (pSE->GetRadius() /12)) * 1.2);
    double Rc2 =  std::pow(Rc,2);
    double Vm2 =  std::pow(m_maxShipSpeed,2);
    double t2 =  std::pow(m_shipAgility,2);

    // the following equation is from "Ship Motion in Eve Online" by Scheulagh Santorine, Ph.D
    // radius needs target mass and grav const factored in....somehow.
    // orbit radius
    /* r = sqrt(6 * cbrt(108t^2*Vm^2 * Rc^2 + 8Rc^6 + 12sqrt(81t^4 *Vm^4 + 12t^2 * Vm^2 * Rc^10))
     * + (24Rc^4 / (108t^2 * Vm^2 * Rc^2 + 8Rc^2 + 12sqrt(81t^4 * Vm^4 * Rc^8 + 12t^2 * Vm^2 * Rc^10)^1/3)) + 12Rc^2) /6
     */
    double one = (108 * t2 * Vm2 * Rc2);
    double two = (12 * t2 * Vm2 *  std::pow(Rc,10));
    double three = (12 * std::sqrt(81 *  std::pow(m_shipAgility,4) *  std::pow(m_maxShipSpeed,4) + two));
    double four = (6 *  std::cbrt(one + 8 *  std::pow(Rc,6) + three));
    double five =  std::cbrt( std::sqrt(three *  std::pow(Rc,8) + two));
    double six = (one + (8 * Rc2) + (12 * five));
    m_followDistance =  std::sqrt(four + (24 *  std::pow(Rc, 4) / six) + 12 * Rc2) / 6;

    double velocity = m_maxShipSpeed * ((distance / m_followDistance) + 0.065); // dunno where i got this from but seems to work very well.
    m_maxOrbitSpeedFraction = velocity / m_maxShipSpeed;

    double circ = EvE::Trig::Pi2 * m_followDistance;
    m_orbitTime = circ / velocity;
    m_orbitRadTic = EvE::Trig::Pi2 / m_orbitTime;

    if (is_log_enabled(DESTINY__ORBIT_TRACE))
        _log(DESTINY__ORBIT_TRACE, "%s(%u) - Orbit Data - Rc:%.3f, velocity:%.2f, osf:%.2f, targetDistance:%u, followDistance:%u, orbitTime:%.1f, radTic:%.5f", \
                mySE->GetName(), mySE->GetID(), Rc, velocity, m_maxOrbitSpeedFraction, \
                m_targetDistance, m_followDistance, m_orbitTime, m_orbitRadTic);
/*  dont really need this here yet.....maybe not at all.
    double current = m_position.distance(pSE->GetPosition());
    double actual = (current - m_radius - Tr);
    // m_orbiting: -2=way too close  -1=too close, 0=no orbit, 1=at distance 2=too far, 3=way too far
    if ((actual - m_followDistance) > m_followDistance) {
        // too far to engage target.
        m_orbiting = 3;
    } else if (current > m_followDistance) {
        // too far outside orbit.  move closer
        m_orbiting = 2;
    } else if (actual < m_followDistance) {
        // way too close inside orbit.  move away quickly.
        m_orbiting = -2;
    } else if (current < m_followDistance) {
        // too close inside orbit; move away slowly.
        m_orbiting = -1;
    } else {
        // within orbit distance tolerance
        m_orbiting = 1;
    }

    if (m_orbiting > 1) {
        // outside target distance.  set orbit parameters based on current position.

    }
*/
    if (m_followDistance == 0) {
        _log(DESTINY__ERROR, "%s(%u) - FollowDistance is 0.", mySE->GetName(), mySE->GetID());
        m_followDistance = (uint32)(m_targetDistance + Tr + m_radius); // fudge something here.  will have to fix later, but this is close enough
    }

    CmdOrbit du;
        du.entityID = mySE->GetID();
        du.orbitEntityID = pSE->GetID();
        du.distance = (int32)m_targetDistance;
    PyTuple *up = du.Encode();
    SendSingleDestinyUpdate(&up);   // consumed
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DestinyManager::Orbit ( )

protected

Todo:

will have to set/reset orbit time once actual orbit is started for proper radian setting

Definition at line 1172 of file DestinyManager.cpp.

References _log, BUBBLE_RADIUS_METERS, Destiny::Ball::Orbit::Close, EvE::Trig::Deg2Rad(), Ga::GaVec3::distance(), Destiny::Ball::Orbit::Far, SystemEntity::GetID(), SystemEntity::GetName(), SystemEntity::GetPilot(), SystemEntity::HasPilot(), is_log_enabled, LogMacro, m_activeSpeedFraction, m_followDistance, m_maxOrbitSpeedFraction, m_maxSpeed, m_orbiting, m_orbitRadTic, m_orbitTime, m_position, m_radius, m_shipHeading, m_stateStamp, m_targetDistance, m_targetEntity, m_targetPoint, MoveObject(), mySE, Ga::GaVec3::normalize(), NULL_ORIGIN(), NULL_ORIGIN_V(), Destiny::Ball::Orbit::Orbiting, EvE::Trig::Pi2, Client::SendErrorMsg(), sEntityList, sLog, Stop(), Destiny::Ball::Orbit::TooClose, Destiny::Ball::Orbit::TooFar, Ga::GaVec3::x, Ga::GaVec3::y, and Ga::GaVec3::z.

Referenced by ProcessState(), and SetSpeedFraction().

                           {
    // data consistency checks...
    if ((m_targetDistance > BUBBLE_RADIUS_METERS) or (m_followDistance > BUBBLE_RADIUS_METERS)) {
        // well, something fucked up.  stop object and throw error.   player can reset if they want to.
        if (mySE->HasPilot())
            mySE->GetPilot()->SendErrorMsg("Internal Server Error.  Ref: ServerError 35412");
        sLog.Error("Destiny::Orbit()", "%s(%u) - Distance check OOB. ", mySE->GetName(), mySE->GetID());
        Stop();
        return;
    }

    // this will set position of ship relative to target, based on period of orbit.

    /*   destiny variables used here
     * m_position - probably the most important calculated value.
     * m_velocity - 2nd most important calculated value
     * m_targetDistance - commanded orbit distance
     * m_followDistance - calculated orbit distance based on mass, velocity, gravity, and other ship variables
     * m_targetHeading - direction to target from current position
     * m_targetPoint - calculated distant point from above variable
     * m_shipHeading - current direction ship is pointed
     * m_stateStamp - time movement started.  1Hz tic
     * m_orbiting - 0=no orbit, >0=in orbit, 1=at distance, 2=too close , 3=too far, 4=way too close, 5=way too far
     * m_orbitRadTic - rad/sec in current orbit.  set by Orbit() (~2090)
     * m_maxOrbitSpeedFraction - calculated max speed to maintain commanded orbit distance.  set in Orbit() but not used here yet
     *
     *   our target variables
     * Tr = target radius
     * Tp = target position  (updated for movement, if applicable)
     * Tv = target velocity
     * Th = target heading   (updated for movement, if applicable)
     * Tm = target mass
     *
     * centers = distance between object and target centers
     * edges = distance between object and target closest edges (counting for radius)
     *
     */

    // get current times
    uint32 timeStamp = sEntityList.GetStamp() - m_stateStamp;
    float Tr = m_targetEntity.second->GetRadius();
    //float Tm = m_targetEntity.second->GetSelf()->GetAttribute(AttrMass).get_float();
    GPoint Tp(m_targetEntity.second->GetPosition());

    // current and edges are used to determine ship's orbit distance, and adjust position accordingly
    double centers(m_position.distance(Tp));
    double edges(centers - m_radius - Tr);
    if (is_log_enabled(DESTINY__ORBIT_TRACE))
        _log(DESTINY__ORBIT_TRACE, "1 - %s(%u): time:%u, centers:%.2f, edges:%.2f, target:%u, follow:%u", \
            mySE->GetName(), mySE->GetID(), timeStamp, centers, edges, m_targetDistance, m_followDistance);

    // distances checks for orbit calculations
    GPoint mPos(NULL_ORIGIN);
    float mPosAdj(0.0f);
    // check distances for this tic
    if ((edges /2) > m_followDistance) {
        if (m_orbiting == Destiny::Ball::Orbit::TooFar) {
            MoveObject();
            return;
        }
        // too far to realistically orbit.
        m_orbiting = Destiny::Ball::Orbit::TooFar;
        // TODO: update this to determine orbit and set heading/target to smoothly go from turn into orbit trajectory
        // set point to side of target (based on current position), to avoid near-zero angular velocity
        double radTarg = atan2(Tp.z - m_position.z, Tp.x - m_position.x);  // rad from '0' to target
        radTarg += atan2(m_followDistance, edges);  // rad from 'distance line' to target 'offset'
        mPos.x = m_followDistance * cos(radTarg);
        mPos.z = m_followDistance * sin(radTarg);
        if (Tp.y > m_position.y) { // target is above us.  set point below target using calculated distance
            mPos.y = Tp.y - m_position.y;
        } else { // opposite of above
            mPos.y = m_position.y - Tp.y;
        }
        m_targetPoint = Tp + mPos;
        GVector heading(m_position, m_targetPoint);
        heading.normalize();
        m_shipHeading = heading;    // this sets object velocity using speed
        _log(DESTINY__ORBIT_TRACE, "2 - way too far - rads:%.3f, heading: %.3f, %.3f, %.3f", \
                radTarg, m_shipHeading.x, m_shipHeading.y, m_shipHeading.z);
        MoveObject();
        return;
    } else if ( (centers + m_targetDistance / 3) < m_followDistance) {
        if (m_orbiting == Destiny::Ball::Orbit::TooClose) {
            MoveObject();
            return;
        }
        // to close to realistically orbit.  move away from target
        m_orbiting = Destiny::Ball::Orbit::TooClose;
        // set point to side of target (based on current position), to avoid near-zero angular velocity
        double radTarg = atan2(Tp.z - m_position.z, Tp.x - m_position.x);  // rad from '0' to target
        //radTarg += atan2(m_followDistance, edges);  // rad from 'distance line' to target 'offset'
        mPos.x = m_followDistance * cos(radTarg);
        mPos.z = m_followDistance * sin(radTarg);
        if (Tp.y > m_position.y) {  // target is above us.  set point below target using calculated distance
            mPos.y = Tp.y - m_position.y;
        } else { // opposite of above
            mPos.y = m_position.y - Tp.y;
        }
        m_targetPoint = Tp + mPos;
        GVector heading(m_position, m_targetPoint);
        heading.normalize();
        m_shipHeading = heading;    // this sets object velocity using speed
        _log(DESTINY__ORBIT_TRACE, "2 - way too close - rads:%.3f, heading: %.3f, %.3f, %.3f", \
                radTarg, m_shipHeading.x, m_shipHeading.y, m_shipHeading.z);
        MoveObject();
        return;
    } else if ((edges - m_targetDistance /4) > m_followDistance) {
        m_orbiting = Destiny::Ball::Orbit::Far;
        // fudge distance for a smaller orbit
        // modify this based on calculated distance
        mPosAdj = -m_followDistance / 25;
        _log(DESTINY__ORBIT_TRACE, "2 - too far");
    } else if (centers < m_followDistance) {
        m_orbiting = Destiny::Ball::Orbit::Close;
        // fudge distance for larger orbit
        // modify this based on calculated distance
        mPosAdj = m_followDistance / 25;
        _log(DESTINY__ORBIT_TRACE, "2 - too close");
    } else {
        m_orbiting = Destiny::Ball::Orbit::Orbiting;
        _log(DESTINY__ORBIT_TRACE, "2 - within tolerance");
    }

    #define LogMacro(v) _log(DESTINY__ORBIT_TRACE, "m - " #v ": (%.3f, %.3f, %.3f)   len=%.3f", v.x, v.y, v.z, v.length())

    // new orbit code
    float radius = m_followDistance + mPosAdj;// fudge a bit as using targetDistance is a hair too close
    // angle around y axis (from +x) - horizontal movement  - ccw from +x using ships orbit in rad/tic
    float theta = EvE::Trig::Pi2 - EvE::Trig::Deg2Rad(360) - (m_orbitRadTic * timeStamp);
    // angle around xz axis (from 0) - vertical movement
    //GVector target(m_position, Tp);
    //LogMacro(target);
    //float hyp = sqrt(pow(target.z, 2) + pow(target.x, 2));
    float inclination = 45; //atan(hyp / target.y);
    // fractional value of orbit period (0 < x < 1)
    float period = fmod(timeStamp, m_orbitTime) /m_orbitTime;
    // calculate a pendulum value here to adjust elevation (+/-y) where +x is 1, 0x is 0, -x is -1
    float c = cos(EvE::Trig::Deg2Rad(360 * period));
    // get elevation modifier based on orbit period
    float phi = EvE::Trig::Deg2Rad(inclination * c);
    // set xz plane modifier from elevation
    float s = sin(EvE::Trig::Deg2Rad(360 * period));
    float mu = EvE::Trig::Deg2Rad(inclination * s);
    // here we will adjust orbit plane by adding OrbitRotation angle to theta
    // calculate position
    mPos.x = radius /* mu */* cos( theta );
    mPos.z = radius /* mu */* sin( theta );
    mPos.y = radius * phi;
    _log(DESTINY__ORBIT_TRACE, "4 - theta:%.5f, phi:%.3f, mu:%.2f period:%.5f, radius:%.3f, inc:%.5f", theta,phi,mu,period,radius,inclination);
    LogMacro(mPos);
    // apply origin to our calculated position
    mPos += Tp;
    // set position for this tic
    m_position = mPos;

    // set heading for this tic
    GPoint mPosNext(NULL_ORIGIN);
    theta += m_orbitRadTic;
    period = fmod(timeStamp+1, m_orbitTime) /m_orbitTime;
    c = cos(EvE::Trig::Deg2Rad(360 * period));
    phi = EvE::Trig::Deg2Rad(inclination * c);
    mPosNext.x = radius * cos( theta );
    mPosNext.z = radius * sin( theta );
    mPosNext.y = radius * phi;
    LogMacro(mPosNext);
    // determine where our target should be next tic, and figure that into our heading calculation
    float Tv = (m_targetEntity.second->DestinyMgr() != nullptr ? m_targetEntity.second->DestinyMgr()->GetSpeed() : 0);
    GVector Th(m_targetEntity.second->DestinyMgr() != nullptr ? m_targetEntity.second->DestinyMgr()->GetHeading() : NULL_ORIGIN_V);
    Tp += (Tv*Th); // use Tv*Th and add to position to account for target movement.  Tv for non-moving targets return 0.
    mPosNext += Tp;
    GVector heading(m_position, mPosNext);
    heading.normalize();
    m_shipHeading = heading;
    m_targetPoint = m_position + (m_shipHeading * 1.0e16);
    LogMacro( heading );

    double curSpeed = m_maxSpeed * m_activeSpeedFraction * m_maxOrbitSpeedFraction;
    if (is_log_enabled(DESTINY__ORBIT_TRACE))
        _log(DESTINY__ORBIT_TRACE, "5(%u) - orbiting at %.2f. timestamp:%u, speed:%.2f", \
            m_orbiting, m_position.distance(Tp), timeStamp, curSpeed);

    MoveObject();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DestinyManager::Process

(

)

Definition at line 125 of file DestinyManager.cpp.

References Profile::destiny, GetTimeUSeconds(), Halt(), SystemEntity::IsFrozen(), mySE, ProcessState(), sConfig, and sProfiler.

Referenced by SystemEntity::Process().

                             {
    if (mySE->IsFrozen()) {
        Halt();
        return;
    }

    double profileStartTime = GetTimeUSeconds();
    //check for and process Destiny::Ball::State changes.
    ProcessState();

    if (sConfig.debug.UseProfiling)
        sProfiler.AddTime(Profile::destiny, GetTimeUSeconds() - profileStartTime);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DestinyManager::ProcessState ( )

protected

Definition at line 139 of file DestinyManager.cpp.

References _log, DestinyManager::WarpState::accel, Destiny::Ball::Mode::BOID, DestinyManager::WarpState::cruise, DestinyManager::WarpState::decel, Ga::GaVec3::dotProduct(), Destiny::Ball::Mode::FIELD, Destiny::Ball::Mode::FOLLOW, Follow(), Destiny::Ball::Mode::FORMATION, Client::GetCharacterID(), SystemEntity::GetID(), Client::GetName(), SystemEntity::GetName(), SystemEntity::GetPilot(), Destiny::Ball::Mode::GOTO, SystemEntity::HasPilot(), InitWarp(), IsMoving(), IsTargetInvalid(), m_ballMode, m_currentSpeedFraction, m_maxSpeed, m_position, m_shipHeading, m_stateStamp, m_targetPoint, m_timeToEnterWarp, m_userSpeedFraction, m_velocity, m_warpState, Destiny::Ball::Mode::MINIBALL, Destiny::Ball::Mode::MISSILE, MoveObject(), Destiny::Ball::Mode::MUSHROOM, mySE, Ga::GaVec3::normalize(), Destiny::Ball::Mode::ORBIT, Orbit(), EvE::Trig::Rad2Deg(), Destiny::Ball::Mode::RIGID, Client::SendErrorMsg(), sEntityList, SetPosition(), SetSpeedFraction(), Destiny::Ball::Mode::STOP, Stop(), Destiny::Ball::Mode::TROLL, Destiny::Ball::Mode::WARP, WARP_ALIGNMENT, WarpAccel(), WarpCruise(), and WarpDecel().

Referenced by Process().

                                  {
    using namespace Destiny;
    switch(m_ballMode) {
        case Ball::Mode::STOP: {
            if (IsMoving()) {
                MoveObject();
                return;
            }
            Stop();
        } break;
        case Ball::Mode::GOTO: {
            MoveObject();
        } break;
        case Ball::Mode::MISSILE: {
            // if target was removed, continue movement and wait for Missile::EndOfLife() call to do cleanup
            //set current direction based on position and targetPoint.  this will keep missile aligned properly
            GVector moveVector(m_position, m_targetPoint);
            moveVector.normalize();
            //set position and direction for this round of movement
            m_shipHeading = moveVector;
            m_velocity = (moveVector * m_maxSpeed);
            SetPosition(m_position + m_velocity);
        } break;
        case Ball::Mode::ORBIT: {
            if (IsTargetInvalid())
                return;
            Orbit();
        } break;
        case Ball::Mode::FOLLOW: {
            if (IsTargetInvalid())
                return;
            Follow();
        } break;
        case Ball::Mode::WARP: {
            /*
             * There are three stages of warp, which are functions of time, speed and distance:
             *
             *  1) Acceleration.
             *      this is a fixed attribute, which is roughly 9s to full warp speed for all ships
             *  2) Cruising.
             *      traveling at maximum warp speed
             *  3) Deceleration.
             *      this also is a fixed attribute, which is roughly 22s from full warp speed for all ships
             *
             *  Acceleration and Deceleration are logarithmic with finite caps (instead of infinity) at the ends.
             *      see also:  my notes in InitWarp()
             */
            if (m_warpState != nullptr) {
                //warp is in progress
                uint16 sec_into_warp = (sEntityList.GetStamp() - m_stateStamp);
                //  speed and distance formulas based on current warp distance
                if (m_warpState->accel) {
                    WarpAccel(sec_into_warp);
                } else if (m_warpState->cruise) {
                    WarpCruise(sec_into_warp);
                } else if (m_warpState->decel) {
                    WarpDecel(sec_into_warp);
                } else {// houston, we have a problem...
                    if (mySE->HasPilot()) {
                        _log(DESTINY__ERROR, "Destiny::ProcessState() Error!  Ship %s(%u) for Player %s(%u) Has WarpState but checks are false.",  \
                                    mySE->GetName(), mySE->GetID(), mySE->GetPilot()->GetName(), mySE->GetPilot()->GetCharacterID());
                        mySE->GetPilot()->SendErrorMsg("Internal Server Error. Ref: ServerError 35928.   Please Dock or Relog to reset your ship.");
                    } else {
                        _log(DESTINY__ERROR, "Destiny::ProcessState() Error!  NPC %s(%u) Has WarpState but checks are false.",  \
                                    mySE->GetName(), mySE->GetID());
                    }
                }
                return;
            }

            // Updated warp alignment and speed check.  -allan  17nov15
            GVector toVec(m_position, m_targetPoint);
            toVec.normalize();
            float dot = toVec.dotProduct(m_shipHeading);
            float degrees = EvE::Trig::Rad2Deg(std::acos(dot));

            if ((degrees < WARP_ALIGNMENT) and (m_currentSpeedFraction > 0.749)) {
                m_shipHeading = toVec;
                InitWarp();
                return;
            } else if (m_currentSpeedFraction < 0.749) {
                if (m_userSpeedFraction < 0.7499)
                    SetSpeedFraction(1.0f, true);
            } else if ((sEntityList.GetStamp() - m_stateStamp) > m_timeToEnterWarp + 0.3) {
                // catchall for turn checks messed up, and m_moveTime > ship align time
                if (mySE->HasPilot()) {
                    _log(DESTINY__ERROR, "Destiny::ProcessState() Error!  Ship %s(%u) for Player %s(%u) - warp align/speed is incorrect, but time > shipTimeToWarp.",  \
                                mySE->GetName(), mySE->GetID(), mySE->GetPilot()->GetName(), mySE->GetPilot()->GetCharacterID());
                } else {
                    _log(DESTINY__ERROR, "Destiny::ProcessState() Error!  NPC %s(%u) - warp align/speed is incorrect, but time > shipTimeToWarp.",  \
                            mySE->GetName(), mySE->GetID());
                }
                m_shipHeading = toVec;
                InitWarp();
                return;
            }

            MoveObject();
        } break;
        case Ball::Mode::MUSHROOM:      // aoe?
        case Ball::Mode::BOID:          // this will turn RIGID after a set time
        case Ball::Mode::TROLL:         // seen for wrecks
        case Ball::Mode::MINIBALL:      // used for sentrys
        case Ball::Mode::FIELD:         // dunno
        case Ball::Mode::FORMATION:     // dunno
        case Ball::Mode::RIGID:         // item that never moves
            //no default on purpose
            break;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DestinyManager::SendAnchorDrop

(

)

const

Definition at line 2818 of file DestinyManager.cpp.

References GetFileTimeNow(), SystemEntity::GetID(), SystemEntity::GetTypeID(), mySE, and SendSingleDestinyUpdate().

                                          {
    OnSpecialFX13 effect;
        effect.entityID = mySE->GetID();
        effect.moduleID = mySE->GetID();
        effect.moduleTypeID = mySE->GetTypeID();
        effect.guid = "effects.AnchorDrop";
        effect.isOffensive = 0;
        effect.start = 1;
        effect.active = 1;
        effect.startTime = GetFileTimeNow();
    PyTuple* up = effect.Encode();
    SendSingleDestinyUpdate(&up);   // consumed
}

Here is the call graph for this function:

void DestinyManager::SendAnchorLift

(

)

const

Definition at line 2832 of file DestinyManager.cpp.

References GetFileTimeNow(), SystemEntity::GetID(), SystemEntity::GetTypeID(), mySE, and SendSingleDestinyUpdate().

                                          {
    OnSpecialFX13 effect;
        effect.entityID = mySE->GetID();
        effect.moduleID = mySE->GetID();
        effect.moduleTypeID = mySE->GetTypeID();
        effect.guid = "effects.AnchorLift";
        effect.isOffensive = 0;
        effect.start = 1;
        effect.startTime = GetFileTimeNow();
    PyTuple* up = effect.Encode();
    SendSingleDestinyUpdate(&up);   // consumed
}

Here is the call graph for this function:

void DestinyManager::SendBallInteractive	(	const ShipItemRef	shipRef,
		bool	set = false
	)		const

Definition at line 2998 of file DestinyManager.cpp.

References InventoryItem::itemID(), and SendSingleDestinyUpdate().

Referenced by UpdateNewShip(), and UpdateOldShip().

                                                                                   {
    // interactive means "ship has pilot"
    SetBallInteractive sbi;
        sbi.entityID = shipRef->itemID();
        sbi.interactive = set;
    PyTuple* up = sbi.Encode();
    SendSingleDestinyUpdate(&up);   // consumed
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DestinyManager::SendCloakFx	(	bool	apply = false,
		bool	module = false
	)		const

Todo:

verify 'start' and 'active' here...

Definition at line 2884 of file DestinyManager.cpp.

References SystemEntity::GetID(), mySE, and SendSingleDestinyUpdate().

Referenced by Cloak(), and UnCloak().

                                                                {
    PyTuple *up(nullptr);
    if (module) {
        OnSpecialFX13 effect;
        effect.entityID = mySE->GetID();
        effect.isOffensive = 0;
        if (apply) {
            effect.guid = "effects.Cloaking";
            effect.start = 1;
            effect.active = 1;
        } else {
            effect.guid = "effects.Uncloak";
        }
        up = effect.Encode();
    } else {
        OnSpecialFX10 effect;
        if (apply) {
            effect.guid = "effects.Cloak";
        } else {
            effect.guid = "effects.Uncloak";
        }
        effect.entityID = mySE->GetID();
        effect.isOffensive = 0;
        effect.start = 1;
        effect.active = 0;
        up = effect.Encode();
    }
    SendSingleDestinyUpdate(&up);   // consumed
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DestinyManager::SendDestinyUpdate	(	std::vector< PyTuple * > &	updates,
		bool	self_only = false
	)		const

Definition at line 3098 of file DestinyManager.cpp.

Referenced by BeginMovement(), Bounce(), Follow(), MakeMissile(), SendJumpInEffect(), SendJumpOutEffect(), SendSingleDestinyEvent(), SendSingleDestinyUpdate(), CustomsSE::SetAnchor(), StructureSE::SetAnchor(), SetSpeedFraction(), SetUndockSpeed(), SpeedBoost(), TractorBeamStart(), TractorBeamStop(), UpdateNewShip(), TowerSE::UpdatePassword(), UpdateShipVariables(), WarpTo(), and WebbedMe().

                                                                                          {
    std::vector<PyTuple*> events;
    SendDestinyUpdate(updates, events, self_only);
}

Here is the caller graph for this function:

void DestinyManager::SendDestinyUpdate	(	std::vector< PyTuple * > &	updates,
		std::vector< PyTuple * > &	events,
		bool	self_only = false
	)		const

Definition at line 3103 of file DestinyManager.cpp.

References _log, SystemBubble::BubblecastDestiny(), Client::GetCharacterID(), Client::GetCharID(), SystemManager::GetClientList(), SystemBubble::GetID(), SystemEntity::GetID(), Client::GetName(), SystemEntity::GetName(), SystemEntity::GetPilot(), SystemEntity::HasPilot(), is_log_enabled, SystemManager::IsLoaded(), SystemEntity::IsOperSE(), mySE, PyIncRef, Client::QueueDestinyEvent(), Client::QueueDestinyUpdate(), sConfig, sEntityList, SystemEntity::SysBubble(), SystemEntity::SystemMgr(), and EvE::traceStack().

                                                                                                                        {
    // this check shouldnt be needed...
    if (!mySE->SystemMgr()->IsLoaded())
        return;
    if (self_only) {
        if (!mySE->HasPilot()) {
            // this entity is NOT a player ship...change to BubbleCast (or silently fail)
            if (mySE->SysBubble() != nullptr) {
                if (is_log_enabled(DESTINY__UPDATES))
                    _log( DESTINY__UPDATES, "[%u] BubbleCasting destiny update (u:%u, e:%u) for stamp %u to bubbleID %u from %s(%u)", \
                            sEntityList.GetStamp(), updates.size(), events.size(), sEntityList.GetStamp(), mySE->SysBubble()->GetID(), mySE->GetName(), mySE->GetID() );
                mySE->SysBubble()->BubblecastDestiny( updates, events, "destiny" );
            }
            return;
        }
        if (is_log_enabled(PLAYER__MESSAGE))
            _log(PLAYER__MESSAGE, "[%u] DestinyManager::SendDestinyUpdate() (u:%i, e:%i) called as 'self_only' for %s(%u)", \
                    sEntityList.GetStamp(), updates.size(), events.size(), mySE->GetPilot()->GetName(), mySE->GetPilot()->GetCharacterID());

        for (std::vector<PyTuple*>::iterator cur = updates.begin(); cur != updates.end(); ++cur) {
            PyIncRef(*cur);
            mySE->GetPilot()->QueueDestinyUpdate(&(*cur));
        }

        for (std::vector<PyTuple*>::iterator cur = events.begin(); cur != events.end(); ++cur) {
            PyIncRef(*cur);
            mySE->GetPilot()->QueueDestinyEvent(&(*cur));
        }
    } else if (mySE->IsOperSE()) { //These are global entities, so we have to send update to all bubbles in a system
        if (is_log_enabled(DESTINY__UPDATES))
            _log(DESTINY__UPDATES, "[%u] BubbleCasting global structure destiny update (u:%u, e:%u) for stamp %u to all bubbles from %s(%u)", \
                    sEntityList.GetStamp(), updates.size(), events.size(), sEntityList.GetStamp(), \
                    (mySE->HasPilot()?mySE->GetPilot()->GetName():mySE->GetName()),\
                    (mySE->HasPilot()?mySE->GetPilot()->GetCharID():mySE->GetID()) );

        //Get all clients in the system which the SE is in
        std::vector<Client*> cv;
        mySE->SystemMgr()->GetClientList(cv);
        for(auto const& value: cv) {
            value->GetShipSE()->SysBubble()->BubblecastDestiny(updates, events, "destiny");
        }
    } else if (mySE->SysBubble() != nullptr) {
        if (is_log_enabled(DESTINY__UPDATES))
            _log(DESTINY__UPDATES, "[%u] BubbleCasting destiny update (u:%u, e:%u) for stamp %u to bubbleID %u from %s(%u)", \
                    sEntityList.GetStamp(), updates.size(), events.size(), sEntityList.GetStamp(), mySE->SysBubble()->GetID(),   \
                    (mySE->HasPilot()?mySE->GetPilot()->GetName():mySE->GetName()),\
                    (mySE->HasPilot()?mySE->GetPilot()->GetCharID():mySE->GetID()) );
        mySE->SysBubble()->BubblecastDestiny( updates, events, "destiny" );
    } else {
        _log(DESTINY__WARNING, "[%u] Cannot BubbleCast destiny update (u:%u, e:%u); entity (%u) is not in any bubble.", \
                sEntityList.GetStamp(), updates.size(), events.size(), mySE->GetID() );
        if (sConfig.debug.IsTestServer)
            EvE::traceStack();
        //sBubbleMgr.Add(mySE);
        //mySE->SysBubble()->BubblecastDestiny( updates, events, "destiny" );
    }
}

Here is the call graph for this function:

void DestinyManager::SendGateActivity

(

uint32

gateID

)

const

Definition at line 2987 of file DestinyManager.cpp.

References SendSingleDestinyUpdate().

Referenced by Client::StargateJump().

                                                         {
    OnSpecialFX10 du;
        du.entityID = gateID;
        du.guid = "effects.GateActivity";
        du.isOffensive = 0;
        du.start = 1;
        du.active = 0;
    PyTuple* up = du.Encode();
    SendSingleDestinyUpdate(&up);   // consumed
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DestinyManager::SendJettisonPacket

(

)

const

Definition at line 2787 of file DestinyManager.cpp.

References SystemEntity::GetID(), mySE, and SendSingleDestinyUpdate().

Referenced by NPC::CmdDropLoot(), Prospector::DropSalvage(), Eject(), Sentry::Killed(), CustomsSE::Killed(), NPC::Killed(), DroneSE::Killed(), StructureSE::Killed(), and ShipSE::Killed().

                                              {
    OnSpecialFX10 effect;
        effect.entityID = mySE->GetID();
        effect.guid = "effects.Jettison";
        effect.isOffensive = 0;
        effect.start = 1;
        effect.active = 0;
    PyTuple* up = effect.Encode();
    SendSingleDestinyUpdate(&up);   // consumed
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DestinyManager::SendJumpInEffect

(

std::string

JumpEffect

)

const

Definition at line 3023 of file DestinyManager.cpp.

References SystemEntity::GetID(), mySE, and SendDestinyUpdate().

Referenced by Client::JumpInEffect().

                                                                {
    std::vector<PyTuple*> updates;
    OnSpecialFX10 effect;
        effect.guid = "effects.JumpDriveIn";
        effect.entityID = mySE->GetID();
        effect.isOffensive = 0;
        effect.start = 1;
        effect.active = 0;
    updates.push_back(effect.Encode());
    CmdSetSpeedFraction ssf;
        ssf.entityID = mySE->GetID();
        ssf.fraction = 0.0;
    updates.push_back(ssf.Encode());
    SetBallVelocity sbv;
        sbv.entityID = mySE->GetID();
        sbv.x = 0.0;
        sbv.y = 0.0;
        sbv.z = 0.0;
    updates.push_back(sbv.Encode());
    SendDestinyUpdate(updates);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DestinyManager::SendJumpOut

(

uint32

gateID

)

const

Definition at line 2975 of file DestinyManager.cpp.

References SystemEntity::GetID(), mySE, and SendSingleDestinyUpdate().

Referenced by Client::StargateJump().

                                                    {
    OnSpecialFX10 effect;
        effect.entityID = mySE->GetID();
        effect.targetID = gateID;
        effect.guid = "effects.JumpOut";
        effect.isOffensive = 0;
        effect.start = 1;
        effect.active = 0;
    PyTuple *up = effect.Encode();
    SendSingleDestinyUpdate(&up);   // consumed
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DestinyManager::SendJumpOutEffect	(	std::string	JumpEffect,
		uint32	locationID
	)		const

Definition at line 3007 of file DestinyManager.cpp.

References SystemEntity::GetID(), mySE, and SendDestinyUpdate().

Referenced by Client::JumpOutEffect().

                                                                                    {
    std::vector<PyTuple*> updates;
    CmdStop du;
        du.entityID = mySE->GetID();
    updates.push_back(du.Encode());
    OnSpecialFX10 effect;
        effect.entityID = mySE->GetID();
        effect.targetID = locationID;
        effect.guid = "effects.JumpDriveOut";   /* JumpDriveInBO */
        effect.isOffensive = 0;
        effect.start = 1;
        effect.active = 0;
    updates.push_back(effect.Encode());
    SendDestinyUpdate(updates);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DestinyManager::SendSetState

(

)

const

Definition at line 3066 of file DestinyManager.cpp.

References _log, Client::GetCharacterID(), SystemEntity::GetID(), Client::GetName(), SystemEntity::GetName(), SystemEntity::GetPilot(), SystemEntity::HasPilot(), is_log_enabled, SystemManager::MakeSetState(), mySE, Client::QueueDestinyUpdate(), sEntityList, SetState(), Client::SetStateSent(), SystemEntity::SysBubble(), and SystemEntity::SystemMgr().

Referenced by Command_sendstate(), Command_update(), and Client::SetBallPark().

                                        {
    if (!mySE->HasPilot())
        return;

    if (is_log_enabled(DESTINY__MESSAGE))
        _log(DESTINY__MESSAGE, "Destiny::SendSetState() Called for Ship:%s(%u) Pilot:%s(%u)", \
                        mySE->GetName(), mySE->GetID(), mySE->GetPilot()->GetName(), mySE->GetPilot()->GetCharacterID());

    SetState ss;
        ss.stamp = sEntityList.GetStamp();
        ss.ego = mySE->GetID();

    mySE->SystemMgr()->MakeSetState(mySE->SysBubble(), ss);
    PyTuple* tmp(ss.Encode());
    //setstate should be alone and immediate.  send directly
    mySE->GetPilot()->QueueDestinyUpdate(&tmp, true, true);   // consumed
    mySE->GetPilot()->SetStateSent(true);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DestinyManager::SendSingleDestinyEvent	(	PyTuple **	ev,
		bool	self_only = false
	)		const

Definition at line 3085 of file DestinyManager.cpp.

References SendDestinyUpdate().

Referenced by CustomsSE::SendEffectUpdate(), and StructureSE::SendEffectUpdate().

{
    std::vector<PyTuple*> updates;
    std::vector<PyTuple*> events(1, *ev);   // create vector of size "1" and insert "*ev" into it
    SendDestinyUpdate(updates, events, self_only);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DestinyManager::SendSingleDestinyUpdate	(	PyTuple **	up,
		bool	self_only = false
	)		const

Definition at line 3092 of file DestinyManager.cpp.

References SendDestinyUpdate().

Referenced by Follow(), GotoDirection(), GotoPoint(), Orbit(), SendAnchorDrop(), SendAnchorLift(), SendBallInteractive(), SendCloakFx(), SendGateActivity(), SendJettisonPacket(), SendJumpOut(), ProbeSE::SendSlimChange(), CustomsSE::SendSlimUpdate(), StructureSE::SendSlimUpdate(), SendSpecialEffect(), SendSpecialEffect10(), SendTerminalExplosion(), SetPosition(), Stop(), UpdateOldShip(), and WarpTo().

                                                                                {
    std::vector<PyTuple*> updates(1, *up);
    std::vector<PyTuple*> events;
    SendDestinyUpdate(updates, events, self_only);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DestinyManager::SendSpecialEffect	(	uint32	entityID,
		uint32	moduleID,
		uint32	moduleTypeID,
		uint32	targetID,
		uint32	chargeTypeID,
		std::string	guid,
		bool	isOffensive,
		bool	start,
		bool	isActive,
		int32	duration,
		uint32	repeat,
		int32	graphicInfo = 0
	)		const

Definition at line 2932 of file DestinyManager.cpp.

References GetFileTimeNow(), PyStatic, and SendSingleDestinyUpdate().

Referenced by StructureSE::Activate(), SentryAI::AttackTarget(), DroneAIMgr::AttackTarget(), NPCAIMgr::AttackTarget(), ConcordAI::AttackTarget(), StructureSE::Process(), CustomsSE::PullAnchor(), StructureSE::PullAnchor(), CustomsSE::SetAnchor(), StructureSE::SetAnchor(), TowerSE::SetOnline(), StructureSE::SetOnline(), and ActiveModule::ShowEffect().

{
    OnSpecialFX13 effect;
        effect.entityID = entityID;
        effect.moduleID = moduleID;
        effect.moduleTypeID = moduleTypeID;     // npc typeID for npc's/drones
        effect.targetID = (targetID == 0 ? PyStatic.NewNone() : new PyInt(targetID));
        effect.chargeTypeID = (chargeTypeID == 0 ? PyStatic.NewNone() : new PyInt(chargeTypeID));
        effect.guid = guid;
        effect.isOffensive = isOffensive;                  // bool
        effect.start = start;                   // bool
        effect.active = isActive;                  // bool
        effect.duration = duration;
        effect.repeat = repeat;
        effect.startTime = GetFileTimeNow();
        effect.graphicInfo = (graphicInfo == 0 ? PyStatic.NewNone() : new PyInt(graphicInfo));
    PyTuple *up = effect.Encode();
    SendSingleDestinyUpdate(&up);   // consumed
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DestinyManager::SendSpecialEffect10	(	uint32	entityID,
		uint32	targetID,
		std::string	guid,
		bool	isOffensive,
		bool	start,
		bool	isActive
	)		const

Definition at line 2916 of file DestinyManager.cpp.

References SendSingleDestinyUpdate().

{
    OnSpecialFX10 effect;
        effect.entityID = entityID;
        effect.targetID = targetID;
        effect.guid = guid;
        effect.area = new PyList();     // this is unused variable in client.
        effect.isOffensive = isOffensive;
        effect.start = start;
        effect.active = isActive;
    PyTuple *up = effect.Encode();
    SendSingleDestinyUpdate(&up);   // consumed
}

Here is the call graph for this function:

void DestinyManager::SendTerminalExplosion	(	uint32	shipID,
		uint32	bubbleID,
		bool	isGlobal = false
	)		const

Definition at line 3045 of file DestinyManager.cpp.

References SendSingleDestinyUpdate().

Referenced by SystemEntity::ApplyDamage().

                                                                                               {
    //exploders = [ x[1][1][0] for x in state if x[1][0] == 'TerminalExplosion' ]
    /*
                  [PyTuple 2 items]                         x
                    [PyInt 62609]                           x[0]
                    [PyTuple 2 items]                       x[1]
                      [PyString "TerminalExplosion"]        x[1][0]
                      [PyTuple 3 items]                     x[1][1]
                        [PyIntegerVar 9000000000001190702]  x[1][1][0]
                        [PyInt 39]
                        [PyBool False]
                */
    //send an explosion special effects update...
     TerminalExplosion du;
        du.shipID = shipID;
        du.bubbleID = bubbleID;
        du.ballIsGlobal = isGlobal;
    PyTuple* up = du.Encode();
    SendSingleDestinyUpdate(&up);   // consumed
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DestinyManager::SetBubble ( bool  set = false )

inline

Definition at line 121 of file DestinyManager.h.

References m_inBubble.

{ m_inBubble = set; }

void DestinyManager::SetCloak ( bool  set = false )

inline

Definition at line 131 of file DestinyManager.h.

References m_cloaked.

{ m_cloaked = set; }

void DestinyManager::SetFrozen ( bool  set = false )

inline

Definition at line 216 of file DestinyManager.h.

References m_frozen.

Referenced by CynoModule::Activate(), and CynoModule::DeactivateCycle().

{ m_frozen = set; }

Here is the caller graph for this function:

void DestinyManager::SetMaxVelocity

(

float

maxVelocity

)

Definition at line 2336 of file DestinyManager.cpp.

References _log, AttrMaxDirectionalVelocity, AttrMaxVelocity, EvilNumber::get_float(), InventoryItem::GetAttribute(), Client::GetCharacterID(), SystemEntity::GetID(), Client::GetName(), SystemEntity::GetName(), SystemEntity::GetPilot(), SystemEntity::GetSelf(), is_log_enabled, SystemEntity::IsShipSE(), m_maxShipSpeed, and mySE.

Referenced by DroneSE::IdleOrbit(), MakeMissile(), DroneAIMgr::Return(), NPCAIMgr::SetChasing(), ConcordAI::SetChasing(), DroneAIMgr::SetEngaged(), NPCAIMgr::SetEngaged(), ConcordAI::SetEngaged(), NPCAIMgr::SetFleeing(), ConcordAI::SetFleeing(), NPCAIMgr::SetFollowing(), ConcordAI::SetFollowing(), NPCAIMgr::SetIdle(), ConcordAI::SetIdle(), NPCAIMgr::SetSignaling(), ConcordAI::SetSignaling(), and NPCAIMgr::SetWander().

{
    float maxSpeed = mySE->GetSelf()->GetAttribute(AttrMaxVelocity).get_float();
    /*
    if (mySE->IsMissileSE() or mySE->IsNPCSE())
        maxSpeed = mySE->GetSelf()->GetAttribute(AttrMaxVelocity).get_float();
    else if (mySE->IsShipSE() or mySE->IsDroneSE())
        maxSpeed = mySE->GetSelf()->GetAttribute(AttrMaxDirectionalVelocity).get_float();   // this is depreciated.  used as an absolute max speed, accounting for ab/mwd
    else
        ; // make error here?
        */
    if (mySE->IsShipSE())
        if (is_log_enabled(DESTINY__TRACE))
            _log(DESTINY__TRACE, "Destiny::SetMaxVelocity() - Ship:%s(%u) Pilot:%s(%u) - AttrMaxDirectionalVelocity is %.1f", \
                    mySE->GetName(), mySE->GetID(), mySE->GetPilot()->GetName(), mySE->GetPilot()->GetCharacterID(), \
                    mySE->GetSelf()->GetAttribute(AttrMaxDirectionalVelocity).get_float());

    if (maxVelocity > maxSpeed) {
        m_maxShipSpeed = maxSpeed;
    } else {
        m_maxShipSpeed = maxVelocity;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DestinyManager::SetPosition	(	const GPoint &	pt,
		bool	update = false
	)

Definition at line 2310 of file DestinyManager.cpp.

References _log, SystemEntity::GetID(), SystemEntity::GetName(), SystemEntity::IsPOSSE(), SystemEntity::IsProbeSE(), Ga::GaVec3::isZero(), m_position, mySE, SendSingleDestinyUpdate(), SystemEntity::SetPosition(), EvE::traceStack(), Ga::GaVec3::x, Ga::GaVec3::y, and Ga::GaVec3::z.

Referenced by BubbleManager::Add(), BeginMovement(), ClearTurn(), Command_syncloc(), Command_update(), MakeMissile(), MoveObject(), Client::MoveToPosition(), ProcessState(), CustomsSE::SetAnchor(), StructureSE::SetAnchor(), Client::SetDestiny(), WarpTo(), and WarpUpdate().

                                                                {
    _log(DESTINY__TRACE, "Destiny::SetPosition() called by %s(%u)", mySE->GetName(), mySE->GetID());

    if (pt.isZero()) {
        _log(DESTINY__TRACE, "Destiny::SetPosition() - %s(%u) point is zero", mySE->GetName(), mySE->GetID());
        EvE::traceStack();
    }

    m_position = pt;

    // this sets InventoryItemRef.m_position correctly, which is used for all position references
    mySE->SetPosition(m_position);

    //according to packet sniffs, this is only used for 'Structure' and 'Probe" items.  'update' is for syncing client position data with ours
    if (mySE->IsPOSSE() or mySE->IsProbeSE() or update) {
        SetBallPosition du;
            du.entityID = mySE->GetID();
            du.x = m_position.x;
            du.y = m_position.y;
            du.z = m_position.z;
        PyTuple* up = du.Encode();
        SendSingleDestinyUpdate(&up);   // consumed
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DestinyManager::SetSpeedFraction	(	float	fraction = 1.0f,
		bool	startMovement = false
	)

Definition at line 255 of file DestinyManager.cpp.

References _log, SystemEntity::GetID(), SystemEntity::GetName(), SystemEntity::GetPilot(), Destiny::Ball::Mode::GOTO, SystemEntity::HasPilot(), is_log_enabled, SystemEntity::IsContainerSE(), SystemEntity::IsDroneSE(), SystemEntity::IsDynamicEntity(), SystemEntity::IsMissileSE(), SystemEntity::IsNPCSE(), Client::IsUndock(), SystemEntity::IsWreckSE(), m_accel, m_activeSpeedFraction, m_ballMode, m_currentSpeedFraction, m_decel, m_hasSentShipUpdates, m_maxSpeed, m_orbiting, m_prevSpeed, m_prevSpeedFraction, m_shipAgility, m_shipMaxAccelTime, m_stop, m_targetDistance, m_targetEntity, m_userSpeedFraction, mySE, Orbit(), SendDestinyUpdate(), Destiny::Ball::Mode::STOP, UpdateVelocity(), and Destiny::Ball::Mode::WARP.

Referenced by BeginMovement(), Follow(), DroneSE::IdleOrbit(), ProcessState(), Client::SetBallPark(), SpeedBoost(), Stop(), WarpStop(), and WebbedMe().

                                                                          {
    // this sets current speed fraction for object.

    // if orbiting, call Orbit() and let code reset the variables
    if (m_orbiting != 0)
        Orbit(m_targetEntity.second, m_targetDistance);

    if ((fraction == m_userSpeedFraction) and (!startMovement))
        return;
    if (is_log_enabled(DESTINY__MOVE_TRACE))
        _log(DESTINY__MOVE_TRACE, "Destiny::SetSpeedFraction() - %s(%u):  fraction: %.2f, start: %i, stop: %i, prevSpeed:%.2f, accel: %s, decel: %s",
             mySE->GetName(), mySE->GetID(), fraction, startMovement, m_stop, m_prevSpeed, m_accel ? "true" : "false", m_decel ? "true": "false");

    // this is to start movement when setting fractional speeds from speedo in client.
    //  also a hack to circumvent above check when called again by goto, warp, align, follow for changing direction.
    if (startMovement) {
        if (m_ballMode == Destiny::Ball::Mode::STOP)
            m_ballMode = Destiny::Ball::Mode::GOTO;
        m_stop = false;
    }

    // prevent multiple client calls to Stop() from resetting ship speed.
    if (m_stop)
        return;

    /* movement is set according to time vs speed fraction.  -allan 8Oct14  -major update 20Nov15  -added prop mod code 29Mar17
     * all *SpeedFraction variables use fuzzy logic
     *  m_userSpeedFraction (USF) is user-set speed control (fractional from speedo or full from goto, warp, align, follow, and stop).
     *   -> sets m_maxSpeed
     *  m_prevSpeedFraction (PSF) is previously-user-set speed fraction used for decel checks, as USF = 0 OR deactivated prop mod.
     *   this allows for proper decel speeds when USF was previously < 1.
     *   -> caps decel when USF = 0, or sets 'decel to' when m_prevSpeed > 0
     *  m_activeSpeedFraction (ASF) holds ship's current speed setting.  set in MoveObject()
     *   this is actually a ratio of CSF to USF, capped by USF and/or OSF
     *   -> sets accel/decel when changing speeds while moving
     *  m_currentSpeedFraction (CSF) holds current euler value for time.  set in MoveObject()
     *   this is reset on initial turn based on turn angle, then follows normal progression.
     *   this is the only SpeedFraction value that runs the full range of 0 - 1 no matter value of other SpeedFractions.
     *   -> sets m_velocity
     *  m_maxOrbitSpeedFraction (OSF) is ship's max speed based on orbit data
     *   -> modifies m_velocity
     *  m_maxSpeed is ship maximum speed based on user input.  set in UpdateVelocity()
     *   -> sets m_velocity
     *  m_targetPoint holds current target coords.  set by goto, warp, align, follow, orbit
     *   -> sets m_shipHeading
     *  m_shipHeading holds current direction and is set in _Turn()
     *   -> sets m_velocity
     *  m_velocity is current ship velocity.  set in MoveObject()
     *   m_velocity = m_shipHeading * (m_currentSpeedFraction * m_maxSpeed)
     */
    if ((m_shipMaxAccelTime < 1.0) and (mySE->IsDynamicEntity()))
        if (!mySE->HasPilot()) {
            m_shipMaxAccelTime = (-log(0.001) * m_shipAgility);
        } else if (!mySE->GetPilot()->IsUndock()) {
            m_shipMaxAccelTime = (-log(0.001) * m_shipAgility);
        }

    // this needs to distinguish between fraction change and speedboost change
    if ((m_userSpeedFraction) and ((!fraction) or (m_prevSpeed) or (fraction != m_userSpeedFraction))) {
        m_prevSpeedFraction = m_userSpeedFraction;
    } else {
        m_prevSpeedFraction = 0.0f;
    }

    m_userSpeedFraction = fraction;
    bool isMoving = false;
    if ((m_currentSpeedFraction > 0.01) or (m_activeSpeedFraction > 0.01))
        isMoving = true;
    UpdateVelocity(isMoving);

    if (m_ballMode == Destiny::Ball::Mode::WARP) {
        // set state to Ball::Mode::GOTO after setting warp decel variables, so warp completion will decel properly
        m_ballMode = Destiny::Ball::Mode::GOTO;
        return;
    }

    std::vector<PyTuple*> updates;
    updates.clear();
    if (fraction) {
         CmdSetSpeedFraction du;
            du.entityID = mySE->GetID();
            du.fraction = fraction;
        updates.push_back(du.Encode());
    }
    if (((mySE->IsNPCSE() or mySE->IsDroneSE()) and !m_hasSentShipUpdates)
    or mySE->IsMissileSE() or mySE->IsContainerSE() or mySE->IsWreckSE()) {
        SetBallSpeed ms;   //NPCs and Missiles only.
            ms.entityID = mySE->GetID();
            ms.speed = m_maxSpeed;
        updates.push_back(ms.Encode());
        m_hasSentShipUpdates = true;
    }

    if (!updates.empty())
        SendDestinyUpdate(updates);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DestinyManager::SetUndockSpeed

(

)

Definition at line 2217 of file DestinyManager.cpp.

References SystemEntity::GetID(), Destiny::Ball::Mode::GOTO, m_activeSpeedFraction, m_ballMode, m_changeDelay, m_currentSpeedFraction, m_maxShipSpeed, m_maxSpeed, m_orbiting, m_prevSpeedFraction, m_shipHeading, m_shipMaxAccelTime, m_stateStamp, m_stop, m_userSpeedFraction, m_velocity, Destiny::Ball::Mode::MISSILE, mySE, SendDestinyUpdate(), sEntityList, Ga::GaVec3::x, Ga::GaVec3::y, and Ga::GaVec3::z.

Referenced by MakeMissile(), and Undock().

                                    {
    //start ship movement @ max velocity for undocking.
    // this simulates being forcefully "ejected" from station (and is currently ~500m off)
    m_stop = false;
    m_orbiting = 0;
    m_stateStamp = sEntityList.GetStamp();
    //m_moveTime = GetTimeMSeconds();
    m_changeDelay = true;   // skip a single tic before making change
    m_shipMaxAccelTime = 0.5f;
    m_prevSpeedFraction = 0.0f;
    m_userSpeedFraction = 1.1f;
    m_maxSpeed = m_maxShipSpeed;
    m_velocity = m_shipHeading * m_maxSpeed;
    // may need to tweak these for larger ships...
    m_activeSpeedFraction = 1.1f;
    m_currentSpeedFraction = 1.1f;

    if (m_ballMode == Destiny::Ball::Mode::MISSILE)
        return;

    m_ballMode = Destiny::Ball::Mode::GOTO;
    std::vector<PyTuple*> updates;
    SetBallVelocity bv;
        bv.entityID = mySE->GetID();
        bv.x = m_velocity.x;
        bv.y = m_velocity.y;
        bv.z = m_velocity.z;
    updates.push_back(bv.Encode());
    CmdGotoDirection du;
        du.entityID = mySE->GetID();
        du.x = m_shipHeading.x;
        du.y = m_shipHeading.y;
        du.z = m_shipHeading.z;
    updates.push_back(du.Encode());
    SendDestinyUpdate(updates);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DestinyManager::SpeedBoost

(

bool

deactivate = false

)

Definition at line 2360 of file DestinyManager.cpp.

References _log, AttrMass, AttrMaxVelocity, EvilNumber::get_float(), InventoryItem::GetAttribute(), SystemEntity::GetID(), SystemEntity::GetSelf(), GetTimeMSeconds(), is_log_enabled, m_activeSpeedFraction, m_alignTime, m_currentSpeedFraction, m_degPerTic, m_hasSentShipUpdates, m_mass, m_massMKg, m_maxShipSpeed, m_maxSpeed, m_moveTime, m_prevSpeed, m_prevSpeedFraction, m_shipAgility, m_shipInertia, m_shipMaxAccelTime, m_userSpeedFraction, mySE, SendDestinyUpdate(), and SetSpeedFraction().

Referenced by ActiveModule::Activate(), ActiveModule::DeactivateCycle(), and FxAction::DoAction().

{
    float timeStamp = (GetTimeMSeconds() - m_moveTime) /1000;
    m_currentSpeedFraction = (1 - exp(-timeStamp / m_shipAgility));
    m_prevSpeed = m_maxSpeed * m_currentSpeedFraction;  //get current ship speed

    // prop mod state changed.  reset ship movement variables and update current movement, if applicable
    m_mass = mySE->GetSelf()->GetAttribute(AttrMass).get_float();
    m_massMKg = m_mass / 1000000; //changes mass from Kg to MillionKg (10^-6)
    m_shipAgility = m_massMKg * m_shipInertia;
    m_alignTime = (-log(0.25) * m_shipAgility);
    m_shipMaxAccelTime = (-log(0.0001) * m_shipAgility);
    m_degPerTic = (65.0f - m_shipAgility) /10;  // this isnt right....
    m_maxShipSpeed = mySE->GetSelf()->GetAttribute(AttrMaxVelocity).get_float();
    float fracCheck = m_prevSpeed / m_maxShipSpeed;

    if (is_log_enabled(DESTINY__MOVE_TRACE)) {
        _log(DESTINY__MOVE_TRACE, "Destiny::SpeedBoost() - nMass: %.5f, nAg: %.5f, csf: %.2f, usf: %.2f, asf: %.3f", \
                m_mass, m_shipAgility, m_currentSpeedFraction, m_userSpeedFraction, m_activeSpeedFraction);
        _log(DESTINY__MOVE_TRACE, "Destiny::SpeedBoost() - pSpeed:%.2f, prevMaxSpeed:%.2f, newMaxShipSpeed:%.2f, fraction: %.3f", \
                m_prevSpeed, m_maxSpeed, m_maxShipSpeed, fracCheck);
    }

    // check current movement and reset variables using modified values
    // ship is currently....
    if (deactivate) {
        // ....deactivating prop mod
        // - use accel formula to determine decel time
        // t=IM(10^-6) * -ln(1-(v/V))
        float deltaTime = m_shipMaxAccelTime - (log(m_prevSpeed - (m_maxShipSpeed * m_userSpeedFraction)) * m_shipAgility);
        // -  set speed fractions and decel timers for new max speed
        m_activeSpeedFraction = deltaTime / m_shipMaxAccelTime;
        // reset ship max speed using updated m_maxShipSpeed
        m_maxSpeed = m_maxShipSpeed * m_userSpeedFraction;
        // reset csf
        m_currentSpeedFraction = 1 - m_activeSpeedFraction;
        // reset move timer
        m_moveTime = GetTimeMSeconds();
        if (is_log_enabled(DESTINY__MOVE_TRACE))
            _log(DESTINY__MOVE_TRACE, "Destiny::SpeedBoost()::Deactivate - decelTime: %.3f, deltaTime: %.3f, maxspeed: %.2f", \
                    m_shipMaxAccelTime, deltaTime, m_maxSpeed);
    } else if ((m_userSpeedFraction < m_currentSpeedFraction) and (m_prevSpeedFraction)) {
        // ....moving and decelerating
        // - this hits when prop mod activated while ship is decel
        m_maxSpeed = m_maxShipSpeed * m_prevSpeedFraction;      // reset ship max speed using updated m_maxShipSpeed
        m_activeSpeedFraction = fracCheck;
        m_currentSpeedFraction = m_prevSpeed / m_maxSpeed;          //get updated csf
        if (is_log_enabled(DESTINY__MOVE_TRACE))
            _log(DESTINY__MOVE_TRACE, "Destiny::SpeedBoost()::(psf!=0&csf>usf) - decelerating. - csf: %.3f. asf: %.3f, accelTime: %.3f, newMaxSpeed:%.2f", \
                    m_currentSpeedFraction, m_activeSpeedFraction, m_shipMaxAccelTime, m_maxSpeed);
    } else if (m_activeSpeedFraction) {
        // ....moving and not decelerating (this includes turning)
        m_activeSpeedFraction = fracCheck;
        m_currentSpeedFraction = fracCheck;
        // reset ship max speed using updated m_maxShipSpeed
        m_maxSpeed = m_maxShipSpeed * m_userSpeedFraction;
        // adjust m_moveTime time to fit current speed onto new max speed range.  (previous max < new max)
        float test = -log(1 - fracCheck) * m_shipAgility;
        m_moveTime = (GetTimeMSeconds() - ( test * 1000));
        if (is_log_enabled(DESTINY__MOVE_TRACE))
            _log(DESTINY__MOVE_TRACE, "Destiny::SpeedBoost()::(0<asf<=usf) - test: %.2f, asf: %.3f, csf: %.2f, check: %.3f, accelTime: %.3f, newMaxSpeed:%.2f", \
                   test, m_activeSpeedFraction, m_currentSpeedFraction, fracCheck, m_shipMaxAccelTime, m_maxSpeed);
    } else {
        // ....sitting still
        // - do nothing
        if (m_userSpeedFraction) {
            _log(DESTINY__MOVE_TRACE, "Destiny::SpeedBoost()::(usf>asf=0) -  sitting still.");
        } else {
            _log(DESTINY__MOVE_TRACE, "Destiny::SpeedBoost()::(usf=asf=0) -  sitting still.");
        }
    }

    // for SpeedBoost (prop mods)
    std::vector<PyTuple*> updates;
    SetBallAgility sbagility;
        sbagility.entityID =  mySE->GetID();
        sbagility.agility = m_shipInertia;
        updates.push_back(sbagility.Encode());
    SetBallMass sbmass;
        sbmass.entityID = mySE->GetID();
        sbmass.mass = m_mass;
        updates.push_back(sbmass.Encode());
    SetBallSpeed sbms;
        sbms.entityID = mySE->GetID();
        sbms.speed = m_maxShipSpeed;
        updates.push_back(sbms.Encode());
    SendDestinyUpdate(updates);
    m_hasSentShipUpdates = true;    // just in case, as this is re-sent in BeginMovement() (called from Orbit())

    SetSpeedFraction(m_userSpeedFraction, true);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DestinyManager::Stop

(

)

Definition at line 494 of file DestinyManager.cpp.

References ClearOrbit(), ClearTurn(), SystemEntity::GetID(), SystemEntity::GetPilot(), GetTimeMSeconds(), SystemEntity::HasPilot(), IsMoving(), IsWarping(), m_accel, m_ballMode, m_decel, m_moveTime, m_prevSpeed, m_prevSpeedFraction, m_shipAgility, m_shipMaxAccelTime, m_stateStamp, m_stop, m_userSpeedFraction, mySE, PyDecRef, SendSingleDestinyUpdate(), sEntityList, Client::SetAutoPilot(), SetSpeedFraction(), Destiny::Ball::Mode::STOP, and Destiny::Ball::Mode::WARP.

Referenced by Bounce(), ComputePosition(), DockingAccepted(), Eject(), EntityRemoved(), Follow(), IsTargetInvalid(), Client::MoveToLocation(), DroneSE::Offline(), Orbit(), ProcessState(), NPCAIMgr::SetIdle(), ConcordAI::SetIdle(), and NPCAIMgr::SetWander().

                          {
    if (m_stop)
        return;

    // AP not implemented yet in this version  -allan 4Mar15
    //Clear autopilot
    if (mySE->HasPilot())
        mySE->GetPilot()->SetAutoPilot(false);

    if (m_userSpeedFraction == 0.0f) {
        //state is already at stop. but m_stop wasnt set.
        // set m_stop and return.
        m_stop = true;
        return;
    } else if  ((m_ballMode == Destiny::Ball::Mode::WARP) and (!IsWarping()))  {
        //warp aborted before initialized.  standard Stop() applies.
        m_ballMode = Destiny::Ball::Mode::STOP;
    } else if (IsMoving()) {
        //stop called while moving
        m_ballMode = Destiny::Ball::Mode::STOP;
    }

    m_accel = false;
    m_decel = false;
    m_prevSpeed = 0.0f;
    m_prevSpeedFraction = 0.0f;

    ClearTurn();
    ClearOrbit();

    // reset move timers for new state
    //m_changeDelay = true;   // skip a single tic before making change
    m_moveTime = GetTimeMSeconds();
    m_stateStamp = sEntityList.GetStamp();
    //reset max accel time in case it was changed previously
    m_shipMaxAccelTime = (-log(0.0001) * m_shipAgility);

    SetSpeedFraction(0.0f);
    m_stop = true;

    CmdStop du;
        du.entityID = mySE->GetID();
    PyTuple *up = du.Encode();
    SendSingleDestinyUpdate(&up);
    PyDecRef(up);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DestinyManager::TractorBeamStart	(	SystemEntity *	pShipSE,
		EvilNumber	speed
	)

Todo:

need to update this

Definition at line 2694 of file DestinyManager.cpp.

References Destiny::Ball::Mode::FOLLOW, EvilNumber::get_float(), SystemEntity::GetID(), SystemEntity::GetPosition(), SystemEntity::GetRadius(), GetTimeMSeconds(), Ga::GaVec3::length(), m_accel, m_activeSpeedFraction, m_ballMode, m_currentSpeedFraction, m_decel, m_followDistance, m_maxShipSpeed, m_maxSpeed, m_moveTime, m_position, m_shipHeading, m_shipMaxAccelTime, m_stateStamp, m_stop, m_targetDistance, m_targetEntity, m_targetPoint, m_tractored, m_turning, m_userSpeedFraction, m_velocity, mySE, Ga::GaVec3::normalize(), SendDestinyUpdate(), and sEntityList.

Referenced by ActiveModule::CanActivate().

{
    m_ballMode = Destiny::Ball::Mode::FOLLOW;

    m_stop = false;
    m_accel = false;
    m_decel = false;
    m_turning = false;
    m_tractored = true;
    m_moveTime = GetTimeMSeconds();
    m_stateStamp = sEntityList.GetStamp();

    m_targetPoint = pShipSE->GetPosition();
    GVector moveVector(m_position, m_targetPoint);
    m_targetDistance = moveVector.length();
    moveVector.normalize();
    m_shipHeading = moveVector;

    m_maxShipSpeed = speed.get_float();   //AttrMaxTractorVelocity
    m_maxSpeed = m_maxShipSpeed;
    m_velocity = m_shipHeading * m_maxSpeed;

    m_followDistance = 500 + pShipSE->GetRadius();
    m_shipMaxAccelTime = 0.1f;

    m_activeSpeedFraction = m_userSpeedFraction = m_currentSpeedFraction = 1.0f;

    m_targetEntity.first = pShipSE->GetID();
    m_targetEntity.second = pShipSE;

    std::vector<PyTuple*> updates;
    SetBallSpeed ms;
        ms.entityID = mySE->GetID();
        ms.speed = m_maxShipSpeed;
    updates.push_back(ms.Encode());
    SetBallFree bf;
        bf.entityID = mySE->GetID();
        bf.is_free = 1;
    updates.push_back(bf.Encode());
    SetBallMass sbmass;
        sbmass.entityID = mySE->GetID();
        sbmass.mass = 10000;
    updates.push_back(sbmass.Encode());
    CmdSetSpeedFraction ssf;
        ssf.entityID = mySE->GetID();
        ssf.fraction = 1;
    updates.push_back(ssf.Encode());
    CmdFollowBall fb;
        fb.entityID = mySE->GetID();
        fb.targetID = pShipSE->GetID();
        fb.range = m_followDistance;
    updates.push_back(fb.Encode());
    SendDestinyUpdate(updates);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DestinyManager::TractorBeamStop

(

)

Definition at line 2750 of file DestinyManager.cpp.

References SystemEntity::GetID(), Halt(), m_mass, m_tractored, mySE, and SendDestinyUpdate().

Referenced by ActiveModule::DeactivateCycle().

{
    Halt();
    m_tractored = false;
    std::vector<PyTuple*> updates;
    SetBallSpeed ms;
        ms.entityID = mySE->GetID();
        ms.speed = 0;
    updates.push_back(ms.Encode());
    SetBallFree bf;
        bf.entityID = mySE->GetID();
        bf.is_free = 0;
    updates.push_back(bf.Encode());
    SetBallMass sbmass;
        sbmass.entityID = mySE->GetID();
        sbmass.mass = m_mass;
    updates.push_back(sbmass.Encode());
    SendDestinyUpdate(updates);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DestinyManager::Turn ( )

private

Definition at line 998 of file DestinyManager.cpp.

References _log, ClearTurn(), SystemEntity::GetID(), SystemEntity::GetName(), SystemEntity::GetPilot(), SystemEntity::HasPilot(), is_log_enabled, IsTurn(), Client::IsUndock(), m_alignTime, m_currentSpeedFraction, m_decel, m_degPerTic, m_radians, m_shipAgility, m_shipHeading, m_shipInertia, m_targetHeading, m_turnFraction, m_turning, m_turnTic, mySE, EvE::Trig::Rad2Deg(), UpdateVelocity(), Ga::GaVec3::x, Ga::GaVec3::y, and Ga::GaVec3::z.

Referenced by MoveObject().

                          {   // tracking within 900m for Frigates, 1k4m for BS.  05Jun17
    if (mySE->HasPilot())
        if (mySE->GetPilot()->IsUndock())
            return;

    if (!IsTurn()) {
        if (m_turning)
            ClearTurn();
        return;
    }
    /*when changing directions....
     *  m_moveTime will have to be reset - call UpdateVelocity() when turn starts
     *  m_shipHeading will have to be reset - reset here and used in MoveObject() (our calling function)
     *  check for decel, then call UpdateVelocity() to set variables as needed.  Move() will handle the rest.
     *
     *   m_degPerTic = (65.0f - m_shipAgility) /10;  ([this file]:2317, reset for ab/mwd [this file]:2154)
     */

    // this is off for rookie ship (maybe others)
    float turnTime(m_shipAgility /2);
    if (!m_turning) {
        m_turning = true;
        //m_radians is set in IsTurn() on every tic
        m_turnFraction = std::sqrt((std::cos(m_radians) + 1) / 2);
        //this isnt used yet...used as comparison for testing time calc's
        m_alignTime = (EvE::Trig::Rad2Deg(m_radians) / m_degPerTic);
        if (is_log_enabled(DESTINY__TURN_TRACE))
            _log(DESTINY__TURN_TRACE, "Destiny::Turn() - %s(%u): Agility:%.3f, Inertia:%.3f, alignTime:%.3f, turnTime:%.3f, turnFraction:%.3f, m_degPerTic:%.3f", \
                mySE->GetName(), mySE->GetID(), m_shipAgility, m_shipInertia, m_alignTime, turnTime, m_turnFraction, m_degPerTic);
    }

    ++m_turnTic;

    // logic to determine speed changes for turning
    if (m_turnTic == 1)
        if (m_turnFraction < m_currentSpeedFraction)
            UpdateVelocity(true);

    // need to check turnFraction vs m_currentSpeedFraction to hold speed when turning.

    /*  class          agility
     * Capsule          .06
     * Shuttle          1.6
     * Rookie           5
     * Frigates         3 - 6 (adv. 3 - 4)  (2s) 1s         < 0.15 not enough.
     * Destroyers       4 - 5
     * Cruisers         4 - 8
     * T3 Cruiser       2.4 - 2.8
     * HAC              5 - 7
     * Battlecruisers   6 - 9
     * Battleships      8 - 14      (12s) 4s        0.15 works well  0.2 is very well.   > 0.25 is too much.
     * Industrials      8 - 12
     * Marauder         ~12
     * Orca             40          (40s) 18s   0.05 turnPercent seems to work very well.  > 0.1 is wrong.
     * Freighters       ~60
     * Supercarrier     ~60
     * Command          ~9
     * Transport        5 or 19
     * Barges           10 - 18
     * Dreadnought      ~55
     * Zephyr           5
     */
    // set ship turn amount based on position in turn, current speed and ship agility
    GVector deltaHeading(m_shipHeading, m_targetHeading);
    float turnPercent(0.1f);
    float degrees(EvE::Trig::Rad2Deg(m_radians));
    if (degrees > 100) {
        if (m_decel and (m_turnTic > turnTime)) {
            // turn half of remaining turn (simulate greatest turn angle when (turn > 90*) and (speed < time)
            turnPercent = 0.4f;
        } else {
            turnPercent = m_degPerTic / (degrees - 100);
        }
    } else if (degrees > m_degPerTic) {
        turnPercent = m_degPerTic / (degrees * 0.5);
    } else {
        // degrees < m_degPerTic, so complete turn and continue accel
        if (m_decel)
            UpdateVelocity(true);
    }

    if (turnPercent > 1.0) {
        _log(DESTINY__ERROR, "Destiny::Turn() - turnTic:%u, degRemain:%.3f, turnPercent:%.2f", m_turnTic, degrees, turnPercent);
        turnPercent = 0.9;
    }
    deltaHeading *= turnPercent;
    m_shipHeading += deltaHeading;
    if (is_log_enabled(DESTINY__TURN_TRACE))
        _log(DESTINY__TURN_TRACE, "Destiny::Turn() - csf:%.3f, turnTic:%u, degRemain:%.3f  (deltaHeading:%.5f, %.5f, %.5f * turnPercent:%.2f) = shipHeading:%.3f, %.3f, %.3f", \
            m_currentSpeedFraction, m_turnTic, degrees, deltaHeading.x, deltaHeading.y, deltaHeading.z, turnPercent, m_shipHeading.x, m_shipHeading.y, m_shipHeading.z);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DestinyManager::UnCloak

(

)

Definition at line 2685 of file DestinyManager.cpp.

References SystemBubble::AddBallExclusive(), m_cloaked, mySE, SendCloakFx(), and SystemEntity::SysBubble().

Referenced by BeginMovement(), Command_cloak(), DockingAccepted(), Client::ProcessClient(), and Client::SetCloakTimer().

                             {
    if (!m_cloaked)
        return;
    m_cloaked = false;
    SendCloakFx();
    if (mySE->SysBubble() != nullptr)
        mySE->SysBubble()->AddBallExclusive(mySE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DestinyManager::Undock

(

GPoint

dir

)

Definition at line 2208 of file DestinyManager.cpp.

References ShipSE::GetShipItemRef(), SystemEntity::GetShipSE(), SystemEntity::IsShipSE(), m_shipHeading, m_targetPoint, mySE, ShipItem::SetUndocking(), and SetUndockSpeed().

Referenced by Client::ProcessClient().

                                      {
    //set movement direction
    m_targetPoint = dir *1.0e16;
    m_shipHeading = GVector(dir);
    SetUndockSpeed();
    if (mySE->IsShipSE())
        mySE->GetShipSE()->GetShipItemRef()->SetUndocking(false);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DestinyManager::UpdateNewShip

(

const ShipItemRef

newShipRef

)

Definition at line 2597 of file DestinyManager.cpp.

References InventoryItem::categoryID(), SystemEntity::GetAllianceID(), Client::GetBounty(), Client::GetCharacterID(), SystemEntity::GetCorporationID(), ShipSE::GetLauncherID(), SystemEntity::GetOwnerID(), SystemEntity::GetPilot(), Client::GetSecurityRating(), SystemEntity::GetShipSE(), SystemEntity::GetWarFactionID(), InventoryItem::groupID(), IsAlliance, IsCorp, IsFaction, InventoryItem::itemID(), InventoryItem::itemName(), itemTypeCapsule, m_hasSentShipUpdates, mySE, PyStatic, SendBallInteractive(), SendDestinyUpdate(), PyTuple::SetItem(), PyDict::SetItemString(), ShipItem::ShipGetModuleList(), InventoryItem::typeID(), and UpdateShipVariables().

Referenced by Client::UpdateNewShip().

                                                               {
    if (m_hasSentShipUpdates)
        return;

    Client* pClient = mySE->GetPilot();
    if (pClient == nullptr)
        return;
    // exactly why do we need this here??
    PyDict* slim = new PyDict();
        slim->SetItemString("name",                     new PyString(newShipRef->itemName()));
        slim->SetItemString("itemID",                   new PyInt(newShipRef->itemID()));
        slim->SetItemString("typeID",                   new PyInt(newShipRef->typeID()));
        slim->SetItemString("ownerID",                  new PyInt(mySE->GetOwnerID()));
        slim->SetItemString("charID",                   new PyInt(pClient->GetCharacterID()));
        slim->SetItemString("corpID",                   IsCorp(mySE->GetCorporationID()) ? new PyInt(mySE->GetCorporationID()) : PyStatic.NewNone());
        slim->SetItemString("allianceID",               IsAlliance(mySE->GetAllianceID()) ? new PyInt(mySE->GetAllianceID()) : PyStatic.NewNone());
        slim->SetItemString("warFactionID",             IsFaction(mySE->GetWarFactionID()) ? new PyInt(mySE->GetWarFactionID()) : PyStatic.NewNone());
        slim->SetItemString("bounty",                   new PyFloat(pClient->GetBounty()));
        slim->SetItemString("securityStatus",           new PyFloat(pClient->GetSecurityRating()));
    if (newShipRef->typeID() == itemTypeCapsule) {
        slim->SetItemString("launcherID",               new PyInt(mySE->GetShipSE()->GetLauncherID()));
        slim->SetItemString("modules",                  new PyList());
    } else {
        slim->SetItemString("categoryID",               new PyInt(newShipRef->categoryID()));
        slim->SetItemString("groupID",                  new PyInt(newShipRef->groupID()));
        slim->SetItemString("modules",                  newShipRef->ShipGetModuleList());
    }

    std::vector<PyTuple*> updates;
    PyTuple* shipData = new PyTuple(2);
        shipData->SetItem(0, new PyLong(newShipRef->itemID()));
        shipData->SetItem(1, new PyObject( "foo.SlimItem", slim));
    PyTuple* shipItem = new PyTuple(2);
        shipItem->SetItem(0, new PyString("OnSlimItemChange"));
        shipItem->SetItem(1, shipData);
    updates.push_back(shipItem);
    SendDestinyUpdate(updates);

    UpdateShipVariables();
    SendBallInteractive(newShipRef, true);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DestinyManager::UpdateOldShip

(

ShipSE *

pShipSE

)

Definition at line 2639 of file DestinyManager.cpp.

References SystemEntity::GetAllianceID(), SystemEntity::GetCategoryID(), SystemEntity::GetCorporationID(), SystemEntity::GetID(), SystemEntity::GetOwnerID(), ShipSE::GetShipItemRef(), SystemEntity::GetTypeID(), SystemEntity::GetWarFactionID(), SystemEntity::IsDead(), m_hasSentShipUpdates, PyStatic, SendBallInteractive(), SendSingleDestinyUpdate(), PyTuple::SetItem(), and PyDict::SetItemString().

Referenced by Eject().

{
    if (pShipSE->IsDead())
        return;
    PyDict* slimPod = new PyDict();
        slimPod->SetItemString("itemID",                new PyInt(pShipSE->GetID()));
        slimPod->SetItemString("typeID",                new PyInt(pShipSE->GetTypeID()));
        slimPod->SetItemString("categoryID",            new PyInt(pShipSE->GetCategoryID()));
        slimPod->SetItemString("ownerID",               new PyInt(pShipSE->GetOwnerID()));
        slimPod->SetItemString("charID",                PyStatic.NewNone());
        slimPod->SetItemString("corpID",                new PyInt(pShipSE->GetCorporationID()));
        slimPod->SetItemString("allianceID",            new PyInt(pShipSE->GetAllianceID()));
        slimPod->SetItemString("warFactionID",          new PyInt(pShipSE->GetWarFactionID()));
        slimPod->SetItemString("bounty",                PyStatic.NewNone());
        slimPod->SetItemString("securityStatus",        PyStatic.NewNone());
    PyTuple* shipData = new PyTuple(2);
        shipData->SetItem(0, new PyLong(pShipSE->GetID()));
        shipData->SetItem(1, new PyObject( "foo.SlimItem", slimPod));
    PyTuple* shipItem = new PyTuple(2);
        shipItem->SetItem(0, new PyString("OnSlimItemChange"));
        shipItem->SetItem(1, shipData);
    SendSingleDestinyUpdate(&shipItem);   // consumed

    SendBallInteractive(pShipSE->GetShipItemRef(), false);
    m_hasSentShipUpdates = false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DestinyManager::UpdateShipVariables

(

)

Todo:

check for movement when fleet boosts are applied and this is called

Definition at line 2472 of file DestinyManager.cpp.

References AttrEntityCruiseSpeed, AttrInetia, AttrMass, AttrMaxVelocity, AttrWarpCapacitorNeed, AttrWarpSpeedMultiplier, EvilNumber::get_float(), InventoryItem::GetAttribute(), SystemEntity::GetID(), SystemEntity::GetPilot(), SystemEntity::GetSelf(), InventoryItem::HasAttribute(), SystemEntity::HasPilot(), SystemEntity::IsDroneSE(), Client::IsInSpace(), SystemEntity::IsNPCSE(), m_alignTime, m_degPerTic, m_hasSentShipUpdates, m_mass, m_massMKg, m_maxShipSpeed, m_shipAgility, m_shipInertia, m_shipMaxAccelTime, m_shipWarpSpeed, m_speedToLeaveWarp, m_timeToEnterWarp, m_warpCapacitorNeed, mySE, SendDestinyUpdate(), and SystemEntity::SysBubble().

Referenced by ShipSE::ApplyBoost(), Concord::Concord(), DroneSE::DroneSE(), NPC::Load(), ShipSE::RemoveBoost(), and UpdateNewShip().

{
    /*
Frigates (incl. CovOps, Inty, AF) have an agility of 3.1
Destroyers 3.5
Industrials 1.0
Cruisers 0.55 (Elite/Faction 0.65)
Battlecruisers 1.1
Battleships 0.155
*/
    /* this sets variables needed for correct movement math.
     *  these attribs are set from ship item when shipSE created.  DO NOT modify anything here
     * this is also called when fleet boosts are updated.
     */
    InventoryItemRef sRef = mySE->GetSelf();
    m_mass = sRef->GetAttribute(AttrMass).get_float();
    m_massMKg = m_mass / 1000000; //changes mass from Kg to milliKg (10^-6)

    // this will catch speeds/needs for all ships (player and npc), and is easier to do here.
    if (sRef->HasAttribute(AttrWarpSpeedMultiplier))
        m_shipWarpSpeed = sRef->GetAttribute(AttrWarpSpeedMultiplier).get_float();
    if (sRef->HasAttribute(AttrInetia))
        m_shipInertia = sRef->GetAttribute(AttrInetia).get_float();
    if (sRef->HasAttribute(AttrMaxVelocity))
        m_maxShipSpeed = sRef->GetAttribute(AttrMaxVelocity).get_float();
    if (sRef->HasAttribute(AttrWarpCapacitorNeed))
        m_warpCapacitorNeed = sRef->GetAttribute(AttrWarpCapacitorNeed).get_float() *2;

    if (mySE->IsNPCSE() or mySE->IsDroneSE())
        m_maxShipSpeed = sRef->GetAttribute(AttrEntityCruiseSpeed).get_float();

    /*  per https://forums.eveonline.com/default.aspx?g=posts&m=3912843   post#103
     *
     * Ships will exit warp mode when their warping speed drops below
     * 75% of sub-warp max speed, or 100m/s, whichever is the lower.
     */
    m_speedToLeaveWarp = m_maxShipSpeed *0.75;
    if ((m_speedToLeaveWarp < 100) and (m_maxShipSpeed > 135))      // 75% of 135 is 101.25
        m_speedToLeaveWarp = 100;

    /* The product of Mass and the Inertia Modifier gives the ship's agility
     * Agility = Mass x Inertia Modifier
     *  agility is an internal-use variable.
     */
    m_shipAgility = m_massMKg * m_shipInertia;
    m_degPerTic = (65.0f - m_shipAgility) /10;
    // set a maximum acceleration time (based on ship variables)
    //   this is no longer correct.  Vmax/T is the correct formula
    m_shipMaxAccelTime = (-log(0.0001) * m_shipAgility);

    //  both of these formulas have identical products
    //TimeToWarp = -ln(0.25) x Mass Mkg x Inertia Mod
    //float alignTime = ((log(2) * m_shipInertia * m_mass) / 500000);
    m_alignTime = (-log(0.25) * m_shipAgility);
    m_timeToEnterWarp = m_alignTime;

    m_hasSentShipUpdates = true;

    if (!mySE->HasPilot())
        return;
    if (mySE->GetPilot()->IsInSpace() and (mySE->SysBubble() != nullptr)) {
        std::vector<PyTuple*> updates;
        SetBallAgility sbagility;
            sbagility.entityID =  mySE->GetID();
            sbagility.agility = m_shipInertia;
        updates.push_back(sbagility.Encode());
        SetBallMassive sbmassive;
            sbmassive.entityID = mySE->GetID();
            sbmassive.is_massive = false;       // disable client-side bump checks
        updates.push_back(sbmassive.Encode());
        SetBallMass sbmass;
            sbmass.entityID = mySE->GetID();
            sbmass.mass = m_mass;
        updates.push_back(sbmass.Encode());
        SetBallSpeed sbspeed;
            sbspeed.entityID = mySE->GetID();
            sbspeed.speed = m_maxShipSpeed;
        updates.push_back(sbspeed.Encode());
        SendDestinyUpdate(updates); //consumed
    } else {
        m_hasSentShipUpdates = false;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DestinyManager::UpdateVelocity ( bool  isMoving = false )

protected

Definition at line 352 of file DestinyManager.cpp.

References _log, SystemEntity::GetID(), SystemEntity::GetName(), GetTimeMSeconds(), Halt(), is_log_enabled, m_accel, m_activeSpeedFraction, m_ballMode, m_changeDelay, m_currentSpeedFraction, m_decel, m_maxShipSpeed, m_maxSpeed, m_moveTime, m_prevSpeed, m_prevSpeedFraction, m_shipAgility, m_shipHeading, m_shipMaxAccelTime, m_speedToLeaveWarp, m_targBubble, m_turnFraction, m_turning, m_userSpeedFraction, m_velocity, m_warpState, mySE, and Destiny::Ball::Mode::WARP.

Referenced by SetSpeedFraction(), and Turn().

                                                 {
    uint8 logType = 0;
    if ((m_ballMode == Destiny::Ball::Mode::WARP) and (m_warpState != nullptr)) {
        /*  Warp() finished, and ship dropped out of warp at m_speedToLeaveWarp,
         *  reset m_shipMaxAccelTime as a fraction of m_speedToLeaveWarp/m_maxShipSpeed
         *  to set decel correctly, as m_speedToLeaveWarp varies with ship and warp distance.
         */
        logType = 1;
        m_decel = true;
        m_accel = false;
        m_targBubble = nullptr;
        m_shipMaxAccelTime *= (m_speedToLeaveWarp / m_maxShipSpeed);
        m_velocity = m_shipHeading * m_speedToLeaveWarp;
        m_maxSpeed = m_speedToLeaveWarp;
    } else if (m_userSpeedFraction) {   //moving
        if (isMoving) { //change speed
            if ((m_activeSpeedFraction == m_userSpeedFraction) and (!m_prevSpeed))
                return;
            //  the times are a bit off when usf < 1.0, but acceptable for now.  will revisit later.    -allan 21Nov15
            float delta = 1.0f;
            logType = 2;
            if (m_turning) {    //  if i was smart, i could write this shit where this "turning" check wasnt needed.
                if (m_decel) {
                    logType = 4;
                    m_accel = true;
                    m_decel = false;
                    m_prevSpeed = 0.0f;
                    m_prevSpeedFraction = 0.0f;
                    m_activeSpeedFraction = m_currentSpeedFraction;
                    delta = 1 - m_currentSpeedFraction;
                } else {
                    logType = 3;
                    m_decel = true;
                    m_accel = false;
                    m_moveTime = GetTimeMSeconds();
                    m_changeDelay = true;   // skip a single tic before making change
                    m_prevSpeedFraction = m_currentSpeedFraction;
                    delta = m_turnFraction / m_currentSpeedFraction;
                }
            } else if (m_decel) {
                m_accel = true;
                m_decel = false;
                m_prevSpeedFraction = m_currentSpeedFraction;
                m_currentSpeedFraction = 1 - m_activeSpeedFraction;    // reset csf
                //m_activeSpeedFraction = m_currentSpeedFraction;
            } else if (m_prevSpeed) {
                delta = m_userSpeedFraction - m_activeSpeedFraction;
                if (m_prevSpeed > m_maxSpeed * m_currentSpeedFraction) {
                    // decel from deactivated prop mod
                    m_decel = true;
                    m_accel = false;
                } else {
                    // accel from activated prop mod
                    m_accel = true;
                    m_decel = false;
                    m_prevSpeedFraction = 0.0f;
                }
            } else if (m_userSpeedFraction < m_activeSpeedFraction) {
                // decrease usf
                m_decel = true;
                m_accel = false;
                m_prevSpeedFraction = 0.0f;
                //get current ship speed and reset for speed change
                m_prevSpeed = m_maxSpeed * m_currentSpeedFraction;
                delta = m_activeSpeedFraction - m_userSpeedFraction;
            } else {
                // increase usf
                m_accel = true;
                m_decel = false;
                delta = m_userSpeedFraction - m_activeSpeedFraction;
            }

            m_shipMaxAccelTime *= delta;
            // will need a test here for (prevMaxSpeed > m_maxSpeed) to set ship velocity correctly (and avoid negatives)
            if (m_prevSpeed > m_maxSpeed)
                m_velocity = m_shipHeading * m_prevSpeed * delta;

            if ((!m_turning) and (!m_decel)) {
                m_maxSpeed = m_maxShipSpeed * m_userSpeedFraction;
                m_velocity = m_shipHeading * m_maxSpeed * m_activeSpeedFraction;
            }
        } else {    //begin movement
            logType = 5;
            m_accel = true;
            m_decel = false;
            m_shipMaxAccelTime *= m_userSpeedFraction;      // for accel with user speeds <= 1.0
            m_maxSpeed = m_maxShipSpeed * m_userSpeedFraction;
            //  see notes in MoveObject() for information relating to accel equations
            m_currentSpeedFraction = (1 - exp(-0.01 / m_shipAgility));
            m_velocity = m_shipHeading * m_maxSpeed * m_currentSpeedFraction;
        }
        if (is_log_enabled(DESTINY__MOVE_TRACE))
            _log(DESTINY__MOVE_TRACE, "Destiny::UpdateVelocity - %s(%u): Speed Change - USF: %.2f, ASF: %.2f, CSF: %.2f, PSF: %.2f, pSpeed: %.2f, mSpeed: %.2f, accel: %s, decel: %s", \
            mySE->GetName(), mySE->GetID(), m_userSpeedFraction, m_activeSpeedFraction, m_currentSpeedFraction, m_prevSpeedFraction, m_prevSpeed, m_maxSpeed, \
                 m_accel ? "true" : "false", m_decel ? "true": "false");
    } else if ((m_currentSpeedFraction) or (m_prevSpeedFraction)) {
        if (isMoving) { //stop movement
            logType = 6;
            // will need a test here for (prevMaxSpeed > m_maxSpeed) to set ship velocity correctly (and avoid negatives)
            //  see notes in MoveObject() for information relating to decel equations
            m_decel = true;
            m_accel = false;
            m_shipMaxAccelTime *= m_activeSpeedFraction;

            // this is speed from prop mod, which is now deactivated
            if (m_prevSpeed) {
                m_maxSpeed = m_prevSpeed * m_activeSpeedFraction;
            } else {
                m_maxSpeed = m_maxShipSpeed * m_activeSpeedFraction;
            }
            m_velocity = m_shipHeading * m_maxSpeed;
        } else {    //halt
            logType = 7;
            Halt();
        }
    } else {
        //WARNING conditional should never arrive here.
        logType = 8;
        //assert(0);  // change this to a correct error-handling implementation
    }
    std::string msg = "";
    switch (logType) {
        case 1: { msg = "state == warp.  --Begin Decel"; } break;
        case 2: { msg = "USF != 0 and ship isMoving.  --Different Heading or Speed"; } break;
        case 3: { msg = "USF != 0 and ship isMoving.  --Decel for Turn"; } break;
        case 4: { msg = "USF != 0 and ship isMoving.  --Accel after Turn"; } break;
        case 5: { msg = "USF != 0 and ship stopped.   --Begin Accel"; } break;
        case 6: { msg = "USF == 0 and ship isMoving.  --Stop"; } break;
        case 7: { msg = "USF == 0 and ship stopped.   --Halt"; } break;
        case 8: {
            _log(DESTINY__ERROR, "Destiny::UpdateVelocity Error!  Ship %s(%u) Has No WarpState or Speed Fraction.",
                                    mySE->GetName(), mySE->GetID());
            Halt();
            return;
        } break;
    }
    if (is_log_enabled(DESTINY__MOVE_TRACE))
        _log(DESTINY__MOVE_TRACE, "Destiny::UpdateVelocity - %s(%u):  %s  AccelTime: %.2f, USF: %.2f, ASF: %.2f, CSF: %.2f, PSF: %.2f", \
            mySE->GetName(), mySE->GetID(), msg.c_str(), m_shipMaxAccelTime, m_userSpeedFraction, m_activeSpeedFraction, m_currentSpeedFraction, m_prevSpeedFraction);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DestinyManager::WarpAccel ( uint16  sec_into_warp )

private

Definition at line 1581 of file DestinyManager.cpp.

References _log, DestinyManager::WarpState::accel, DestinyManager::WarpState::accelDist, BUBBLE_RADIUS_METERS, DestinyManager::WarpState::cruise, DestinyManager::WarpState::cruiseDist, DestinyManager::WarpState::decel, SystemBubble::GetID(), SystemEntity::GetID(), SystemEntity::GetName(), is_log_enabled, m_inBubble, m_targBubble, m_targetDistance, m_warpState, mySE, SystemBubble::Remove(), SystemEntity::SysBubble(), and WarpUpdate().

Referenced by InitWarp(), and ProcessState().

                                                   {
    /* For acceleration, k = 3.
     * distance = e^(k*s)
     * speed = k*e^(k*s)
     */
    double currentDistance = exp(3 * sec_into_warp);

    if (m_inBubble)
        if (currentDistance > BUBBLE_RADIUS_METERS)
            if (mySE->SysBubble() != m_targBubble) {
                if (is_log_enabled(DESTINY__WARP_TRACE))
                    _log(DESTINY__WARP_TRACE, "Destiny::WarpAccel(): %s(%u) is being removed from bubble %u.",\
                            mySE->GetName(), mySE->GetID(), mySE->SysBubble()->GetID());
                mySE->SysBubble()->Remove(mySE);
                m_inBubble = false;
            }

    if (currentDistance > m_warpState->accelDist) {
        currentDistance = m_warpState->accelDist;
        m_warpState->accel = false;
        if (m_warpState->cruiseDist > 0) {
            m_warpState->cruise = true;
        } else {
            m_warpState->decel = true;
        }
    }

    m_targetDistance -= currentDistance;
    double currentShipSpeed = (3 * currentDistance);

    if (m_warpState->accel)
        if (is_log_enabled(DESTINY__WARP_TRACE))
            _log(DESTINY__WARP_TRACE, "Destiny::WarpAccel(): %s(%u) - Warp Accelerating(%us): velocity %.4f m/s with %u m left to go. Current distance %.4f from origin.", \
                    mySE->GetName(), mySE->GetID(), sec_into_warp, currentShipSpeed, m_targetDistance, currentDistance);

    WarpUpdate(currentShipSpeed);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DestinyManager::WarpCruise ( uint16  sec_into_warp )

private

Definition at line 1619 of file DestinyManager.cpp.

References _log, DestinyManager::WarpState::cruise, DestinyManager::WarpState::decel, DestinyManager::WarpState::decelDist, SystemEntity::GetID(), SystemEntity::GetName(), is_log_enabled, m_targetDistance, m_warpState, mySE, DestinyManager::WarpState::warpSpeed, and WarpUpdate().

Referenced by ProcessState().

                                                    {
    /* in cruise....calculate distance only to update internal position data. */
    m_targetDistance -= m_warpState->warpSpeed;

    if ((m_targetDistance - m_warpState->warpSpeed) < m_warpState->decelDist) {
        m_warpState->cruise = false;
        m_warpState->decel = true;
    }

    if (is_log_enabled(DESTINY__WARP_TRACE))
        _log(DESTINY__WARP_TRACE, "Destiny::WarpCruise(): %s(%u) - Warp Crusing(%us): velocity %.4f m/s. with %u m left to go.", \
                mySE->GetName(), mySE->GetID(), sec_into_warp, m_warpState->warpSpeed, m_targetDistance);

    WarpUpdate(m_warpState->warpSpeed);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DestinyManager::WarpDecel ( uint16  sec_into_warp )

private

Definition at line 1635 of file DestinyManager.cpp.

References _log, DestinyManager::WarpState::decelDist, SystemEntity::GetID(), SystemEntity::GetName(), is_log_enabled, m_speedToLeaveWarp, m_targetDistance, m_warpDecelTime, m_warpState, mySE, DestinyManager::WarpState::total_distance, DestinyManager::WarpState::warpSpeed, WarpStop(), and WarpUpdate().

Referenced by ProcessState().

                                                   {
    /* For deceleration, k = -1.
     * distance = e^(k*s)
     * speed = -k*e^(k*s)
     */
    uint8 decelTime = (sec_into_warp - m_warpDecelTime);
    double currentDistance = (m_warpState->total_distance - (exp(-decelTime) * m_warpState->decelDist));
    m_targetDistance = (int32)(m_warpState->total_distance - currentDistance);
    double currentShipSpeed = (m_warpState->warpSpeed * exp(-decelTime));

    if (is_log_enabled(DESTINY__WARP_TRACE))
        _log(DESTINY__WARP_TRACE, "Destiny::WarpDecel(): %s(%u) - Warp Decelerating(%us/%us): velocity %.4f m/s with %u m left to go.", \
                mySE->GetName(), mySE->GetID(), decelTime, sec_into_warp, currentShipSpeed, m_targetDistance);

    WarpUpdate(currentShipSpeed);
    if (currentShipSpeed <= m_speedToLeaveWarp)
        WarpStop(currentShipSpeed);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DestinyManager::WarpStop ( double  currentShipSpeed )

private

Definition at line 1677 of file DestinyManager.cpp.

References _log, NPC::GetAIMgr(), SystemEntity::GetID(), SystemEntity::GetName(), SystemEntity::GetNPCSE(), is_log_enabled, SystemEntity::IsNPCSE(), SystemEntity::IsShipSE(), m_position, m_stop, m_targBubble, m_targetDistance, m_targetPoint, m_warpState, mySE, SafeDelete(), SetSpeedFraction(), DestinyManager::WarpState::warp_vector, NPCAIMgr::WarpOutComplete(), Ga::GaVec3::x, Ga::GaVec3::y, and Ga::GaVec3::z.

Referenced by WarpDecel().

                                                     {
    if (is_log_enabled(DESTINY__WARP_TRACE)) {
        _log(DESTINY__WARP_TRACE, "Destiny::WarpStop(): %s(%u) - Warp complete. Exit velocity %.4f m/s with %u m left to go.", \
                mySE->GetName(), mySE->GetID(), currentShipSpeed, m_targetDistance);
        _log(DESTINY__WARP_TRACE, "Destiny::WarpStop(): %s(%u): Ship currently at %.2f,%.2f,%.2f.", \
                mySE->GetName(), mySE->GetID(), m_position.x, m_position.y, m_position.z);
    }
    if (mySE->IsShipSE())
        _log(AUTOPILOT__MESSAGE, "Destiny::WarpStop(): %s(%u) - Warp complete.", mySE->GetName(), mySE->GetID());
    m_targetPoint += (m_warpState->warp_vector *10000);
    // SetSpeedFraction() checks for m_state = Warp and warpstate != null to set decel variables correctly with warp decel.
    //   have to call this BEFORE deleting or reseting m_state or WarpState.
    SetSpeedFraction(0.0f);
    m_stop = true;
    SafeDelete(m_warpState);
    m_targBubble = nullptr;
    if ((mySE->IsNPCSE()) and (mySE->GetNPCSE()->GetAIMgr() != nullptr))
        mySE->GetNPCSE()->GetAIMgr()->WarpOutComplete();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DestinyManager::WarpTo	(	const GPoint &	where,
		int32	distance = 0,
		bool	autoPilot = false,
		SystemEntity *	pSE = nullptr
	)

Definition at line 1903 of file DestinyManager.cpp.

References _log, AttrCapacitorCharge, AttrWarpBubbleImmune, Follow(), EvilNumber::get_float(), InventoryItem::GetAttribute(), Client::GetChar(), SystemBubble::GetID(), SystemEntity::GetID(), SystemEntity::GetName(), SystemEntity::GetPilot(), SystemEntity::GetPosition(), SystemEntity::GetSelf(), Client::GetShip(), Character::GetSkillLevel(), GetWarpSpeed(), GotoPoint(), InventoryItem::HasAttribute(), SystemEntity::HasPilot(), SystemBubble::HasWarpBubble(), is_log_enabled, SystemEntity::IsDroneSE(), SystemEntity::IsNPCSE(), Ga::GaVec3::length(), m_ballMode, m_capNeeded, m_mass, m_position, m_stopDistance, m_targBubble, m_targetDistance, m_targetEntity, m_targetPoint, m_warpCapacitorNeed, m_warpState, minWarpDistance(), mySE, Ga::GaVec3::normalize(), ONE_AU_IN_METERS, SafeDelete(), sBubbleMgr, sConfig, SendDestinyUpdate(), Client::SendErrorMsg(), SendSingleDestinyUpdate(), SetPosition(), Destiny::Ball::Mode::STOP, SystemEntity::SysBubble(), SystemEntity::SystemMgr(), Destiny::Ball::Mode::WARP, EvESkill::WarpDriveOperation, Ga::GaVec3::x, Ga::GaVec3::y, and Ga::GaVec3::z.

Referenced by Command_bubblewarp(), SpawnMgr::ReSpawn(), NPCAIMgr::WarpOut(), and SpawnMgr::WarpOutSpawn().

                                                                                                     {
    /* warp order..
     * pick destination -> align/accel -> aura "warp drive active" -> cap drain -> accel
     *      -> enter warp -> warp -> decel -> leave warp -> coast -> stop
     */
    SafeDelete(m_warpState);

    // check for autopilot.  it has 'special' checks in client for auto-disable by destiny update
    if (autoPilot) {
        Follow(pSE, distance);
    } else {
        GotoPoint(where);
    }

    m_targetEntity.first = 0;
    m_targetEntity.second = nullptr;

    m_stopDistance = distance;
    // get warp target point
    GVector warp_distance(m_position, where);
    m_targetDistance = warp_distance.length();
    m_targetDistance -= m_stopDistance;
    // change to heading
    warp_distance.normalize();
    // adjust for stop distance from our travel direction
    warp_distance *= m_stopDistance;
    // adjust target point by calculated stopping point
    m_targetPoint -= warp_distance;

    m_targBubble = sBubbleMgr.GetBubble(mySE->SystemMgr(), m_targetPoint);
    if (is_log_enabled(DESTINY__WARP_TRACE))
        _log(DESTINY__TRACE, "Destiny::WarpTo() - %s(%u) target bubble: %u  m_stopDistance: %i  m_targetDistance: %u",
            mySE->GetName(), mySE->GetID(), m_targBubble->GetID(), m_stopDistance, m_targetDistance);

    // npcs have no warp restrictions (yet)
    if (mySE->IsNPCSE() or mySE->IsDroneSE()) {
        // do drones warp??
        m_ballMode = Destiny::Ball::Mode::WARP;

        std::vector<PyTuple*> updates;
        CmdWarpTo wt;
            wt.entityID = mySE->GetID();
            wt.dest_x = m_targetPoint.x;
            wt.dest_y = m_targetPoint.y;
            wt.dest_z = m_targetPoint.z;
            wt.distance = m_stopDistance;
            wt.warpSpeed = GetWarpSpeed();
        updates.push_back(wt.Encode());
        OnSpecialFX10 sfx;
            sfx.guid = "effects.Warping";
            sfx.entityID = mySE->GetID();
            sfx.isOffensive = false;
            sfx.start = true;
            sfx.active = true;
        updates.push_back(sfx.Encode());
        SendDestinyUpdate(updates);
        if (is_log_enabled(NPC__MESSAGE))
            _log(NPC__MESSAGE, "Destiny::WarpTo() NPC %s(%u) to:%u from:%u, m_targetPoint: %.2f,%.2f,%.2f  m_stopDistance: %i  m_targetDistance: %u",\
                    mySE->GetName(), mySE->GetID(), m_targBubble->GetID(), mySE->SysBubble()->GetID(), \
                    m_targetPoint.x, m_targetPoint.y, m_targetPoint.z, m_stopDistance, m_targetDistance);
        return;
    }

    /*supercap warp modifiers
     * these will go here, and modify distance, target, and range accordingly
     *
     * AttrWarpAccuracyMaxRange = 1021,
     * AttrWarpAccuracyFactor = 1022,
     * AttrWarpAccuracyFactorMultiplier = 1023,
     * AttrWarpAccuracyMaxRangeMultiplier = 1024,
     * AttrWarpAccuracyFactorPercentage = 1025,
     * AttrWarpAccuracyMaxRangePercentage = 1026,
     */

    if (mySE->HasPilot()) {
        if (m_targetDistance < minWarpDistance) {
            mySE->GetPilot()->SendErrorMsg("That is too close for your Warp Drive.");
            // warp distance too close.  cancel warp and return
            // we may need to send pos update
            if (sConfig.debug.PositionHack)
                SetPosition(mySE->GetPosition(), true);
            m_ballMode = Destiny::Ball::Mode::STOP;
            SafeDelete(m_warpState);
            return;
        }

        Client *pClient = mySE->GetPilot();

        /*  capacitor for warp formulas from https://oldforums.eveonline.com/?a=topic&threadID=332116
         *  Energy to warp = warpCapacitorNeed * mass * au * (1 - warp_drive_operation_skill_level * 0.10)
         */
        float currentShipCap = pClient->GetShip()->GetAttribute(AttrCapacitorCharge).get_float();
        float capNeeded = m_mass * m_warpCapacitorNeed * (m_targetDistance / ONE_AU_IN_METERS);
        capNeeded *= (1.0f - (0.1f *pClient->GetChar()->GetSkillLevel(EvESkill::WarpDriveOperation)));

        _log(DESTINY__WARNING, "Warp Cap need for %s(%u) is %.4f", mySE->GetName(), mySE->GetID(), capNeeded);

        //  check if ship has enough capacitor to warp full distance
        if (capNeeded > currentShipCap) {
            // not enough cap.  reset everything based on available cap
            capNeeded = (currentShipCap /m_warpCapacitorNeed) /m_mass;
            if (capNeeded > 1) {
                m_targetDistance = (uint32)capNeeded * ONE_AU_IN_METERS;
                GVector warp_direction(m_position, where);
                GPoint newTarget(m_position + (warp_direction *m_targetDistance));

                m_targBubble = sBubbleMgr.GetBubble(mySE->SystemMgr(), newTarget);
                if (is_log_enabled(DESTINY__WARP_TRACE))
                    _log(DESTINY__TRACE, "Destiny::WarpTo():Update - %s(%u) target bubble: %u  m_stopDistance: %i  m_targetDistance: %u",
                        mySE->GetName(), mySE->GetID(), m_targBubble->GetID(), m_stopDistance, m_targetDistance);
            } else {
                // if not enough cap to do min warp, cancel and return
                pClient->SendErrorMsg("You don't have enough capacitor charge to warp.");
                _log(DESTINY__WARNING, "Destiny::WarpTo() - %s(%u): Capacitor needed vs current  %.3f / %.3f",
                        mySE->GetName(), mySE->GetID(), capNeeded, currentShipCap);

                m_ballMode = Destiny::Ball::Mode::STOP;
                m_targBubble = nullptr;
                SafeDelete(m_warpState);
                return;
            }
        } else {
            capNeeded = currentShipCap - capNeeded;
        }

        m_capNeeded = capNeeded;
    }

    /*  TODO PUT CHECK HERE FOR WARP BUBBLES
     *     and other things that affect warp-in point.....when we get to there.
     * AttrWarpBubbleImmune = 1538,
     * AttrWarpBubbleImmuneModifier = 1539,
     *   NOTE:  warp bubble in path (or within 100km of m_targetPoint) will change m_targetDistance and m_targetPoint
     *   however, this does NOT affect original calculations for energy needed, etc...
     */
    if (m_targBubble->HasWarpBubble()) {
        if (!mySE->GetSelf()->HasAttribute(AttrWarpBubbleImmune))
            ;   // not immune to bubble
    }

    m_ballMode = Destiny::Ball::Mode::WARP;

    // send client updates
    std::vector<PyTuple*> updates;
    // acknowledge client's warpto request
    CmdWarpTo wt;
        wt.entityID = mySE->GetID();
        wt.dest_x = m_targetPoint.x;
        wt.dest_y = m_targetPoint.y;
        wt.dest_z = m_targetPoint.z;
        wt.distance = m_stopDistance;
        wt.warpSpeed = GetWarpSpeed();      // warp speed x10
    updates.push_back(wt.Encode());
    //send a warp effect...
    OnSpecialFX10 sfx;
        sfx.guid = "effects.Warping";
        sfx.entityID = mySE->GetID();
        sfx.isOffensive = false;
        sfx.start = true;
        sfx.active = true;
    updates.push_back(sfx.Encode());
    SendDestinyUpdate(updates);
    updates.clear();
    //set massive for warp, per client, but self-only
     SetBallMassive bm;
        bm.entityID = mySE->GetID();
        bm.is_massive = false;       // disable client-side bump checks
    PyTuple *up = bm.Encode();
    SendSingleDestinyUpdate(&up, true);   // consumed

    if (is_log_enabled(DESTINY__WARP_TRACE))
        _log(DESTINY__WARP_TRACE, "Destiny::WarpTo() toBubble:%u from:%u, m_targetPoint: %.2f,%.2f,%.2f  m_stopDistance: %i  m_targetDistance: %u",
             m_targBubble->GetID(), mySE->SysBubble()->GetID(), m_targetPoint.x, m_targetPoint.y, m_targetPoint.z, m_stopDistance, m_targetDistance);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DestinyManager::WarpUpdate ( double  currentShipSpeed )

private

Definition at line 1654 of file DestinyManager.cpp.

References _log, SystemBubble::Add(), DestinyManager::WarpState::decel, Ga::GaVec3::distance(), SystemBubble::GetCenter(), SystemBubble::GetID(), SystemEntity::GetID(), SystemEntity::GetName(), SystemBubble::InBubble(), is_log_enabled, m_inBubble, m_position, m_targBubble, m_targetDistance, m_targetPoint, m_velocity, m_warpState, mySE, SetPosition(), DestinyManager::WarpState::warp_vector, Ga::GaVec3::x, Ga::GaVec3::y, and Ga::GaVec3::z.

Referenced by WarpAccel(), WarpCruise(), and WarpDecel().

                                                       {
    //  update position and velocity for all stages.
    //  this method is ~1000m off actual.  could be due to rounding.   -allan 9Jan15
    m_velocity = (m_warpState->warp_vector * currentShipSpeed);
    SetPosition(m_targetPoint - (m_warpState->warp_vector * m_targetDistance));

    if (m_warpState->decel) {
        if (!m_inBubble) {
            if (is_log_enabled(DESTINY__WARP_TRACE))
                _log(DESTINY__WARP_TRACE, "Destiny::WarpUpdate()  %s(%u): Ship is %f from center of target bubble %u.",\
                        mySE->GetName(), mySE->GetID(), m_targBubble->GetCenter().distance(m_position), m_targBubble->GetID());
            if (m_targBubble->InBubble(m_position, true)) {
                if (is_log_enabled(DESTINY__WARP_TRACE))
                    _log(DESTINY__WARP_TRACE, "Destiny::WarpUpdate()  %s(%u): Ship at %.2f,%.2f,%.2f is calling Add() for bubble %u.", \
                            mySE->GetName(), mySE->GetID(), m_position.x, m_position.y, m_position.z, m_targBubble->GetID());
                m_targBubble->Add(mySE);
                SetPosition(m_position, true);
                m_inBubble = true;
            }
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DestinyManager::WebbedMe	(	InventoryItemRef	modRef,
		bool	apply = false
	)

Definition at line 2452 of file DestinyManager.cpp.

References AttrSpeedFactor, EvilNumber::get_float(), InventoryItem::GetAttribute(), SystemEntity::GetID(), m_activeSpeedFraction, m_hasSentShipUpdates, m_maxShipSpeed, m_userSpeedFraction, mySE, SendDestinyUpdate(), and SetSpeedFraction().

Referenced by ActiveModule::Activate(), and ActiveModule::DeactivateCycle().

{
    if (apply) {
        m_maxShipSpeed *= (1 + (modRef->GetAttribute(AttrSpeedFactor).get_float() / 100.0f));
    } else {
        m_maxShipSpeed /= (1 + (modRef->GetAttribute(AttrSpeedFactor).get_float() / 100.0f));
    }
    m_activeSpeedFraction = m_activeSpeedFraction * 0.999f;
    std::vector<PyTuple*> updates;
    SetBallSpeed sbms;
        sbms.entityID = mySE->GetID();
        sbms.speed = m_maxShipSpeed;
        updates.push_back(sbms.Encode());
    SendDestinyUpdate(updates);
    m_hasSentShipUpdates = true;    // just in case, as this is re-sent in BeginMovement()

    SetSpeedFraction(m_userSpeedFraction, true);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

bool DestinyManager::m_accel

protected

Definition at line 262 of file DestinyManager.h.

Referenced by BeginMovement(), DestinyManager(), Halt(), MoveObject(), SetSpeedFraction(), Stop(), TractorBeamStart(), and UpdateVelocity().

float DestinyManager::m_activeSpeedFraction

protected

Definition at line 286 of file DestinyManager.h.

Referenced by DestinyManager(), Follow(), Halt(), IsTurn(), MoveObject(), Orbit(), SetSpeedFraction(), SetUndockSpeed(), SpeedBoost(), TractorBeamStart(), UpdateVelocity(), and WebbedMe().

float DestinyManager::m_alignTime

protected

Definition at line 234 of file DestinyManager.h.

Referenced by ClearTurn(), GetAlignTime(), SpeedBoost(), Turn(), and UpdateShipVariables().

uint8 DestinyManager::m_ballMode

protected

Definition at line 270 of file DestinyManager.h.

Referenced by Bounce(), EntityRemoved(), Follow(), GetState(), GotoDirection(), GotoPoint(), Halt(), IsFollowing(), IsGoto(), IsOrbiting(), IsStopped(), MakeMissile(), Orbit(), ProcessState(), SetSpeedFraction(), SetUndockSpeed(), Stop(), TractorBeamStart(), UpdateVelocity(), and WarpTo().

bool DestinyManager::m_bump

private

Definition at line 310 of file DestinyManager.h.

Referenced by Bump(), CheckBump(), and DestinyManager().

double DestinyManager::m_capNeeded

protected

Definition at line 242 of file DestinyManager.h.

Referenced by DestinyManager(), InitWarp(), and WarpTo().

bool DestinyManager::m_changeDelay

private

Definition at line 307 of file DestinyManager.h.

Referenced by DestinyManager(), MoveObject(), SetUndockSpeed(), and UpdateVelocity().

bool DestinyManager::m_cloaked

protected

Definition at line 264 of file DestinyManager.h.

Referenced by Cloak(), DestinyManager(), IsCloaked(), Jump(), SetCloak(), and UnCloak().

float DestinyManager::m_currentSpeedFraction

protected

Definition at line 285 of file DestinyManager.h.

Referenced by BeginMovement(), Bounce(), DestinyManager(), Follow(), GetSpeed(), GetSpeedFraction(), Halt(), IsMoving(), IsTurn(), MoveObject(), ProcessState(), SetSpeedFraction(), SetUndockSpeed(), SpeedBoost(), TractorBeamStart(), Turn(), and UpdateVelocity().

bool DestinyManager::m_decel

protected

Definition at line 263 of file DestinyManager.h.

Referenced by BeginMovement(), DestinyManager(), Halt(), MoveObject(), SetSpeedFraction(), Stop(), TractorBeamStart(), Turn(), and UpdateVelocity().

float DestinyManager::m_degPerTic

protected

Definition at line 252 of file DestinyManager.h.

Referenced by DestinyManager(), SpeedBoost(), Turn(), and UpdateShipVariables().

uint32 DestinyManager::m_followDistance

protected

Definition at line 289 of file DestinyManager.h.

Referenced by ClearOrbit(), Follow(), Halt(), Orbit(), and TractorBeamStart().

bool DestinyManager::m_frozen

private

Definition at line 306 of file DestinyManager.h.

Referenced by IsFrozen(), and SetFrozen().

bool DestinyManager::m_hasSentShipUpdates

protected

Definition at line 226 of file DestinyManager.h.

Referenced by BeginMovement(), DestinyManager(), SetSpeedFraction(), SpeedBoost(), UpdateNewShip(), UpdateOldShip(), UpdateShipVariables(), and WebbedMe().

bool DestinyManager::m_inBubble

protected

Definition at line 266 of file DestinyManager.h.

Referenced by DestinyManager(), SetBubble(), WarpAccel(), and WarpUpdate().

double DestinyManager::m_inclination

private

Definition at line 322 of file DestinyManager.h.

Referenced by DestinyManager().

double DestinyManager::m_longAscNode

private

Definition at line 323 of file DestinyManager.h.

Referenced by DestinyManager().

float DestinyManager::m_mass

protected

Definition at line 232 of file DestinyManager.h.

Referenced by BeginMovement(), GetMass(), MakeMissile(), SpeedBoost(), TractorBeamStop(), UpdateShipVariables(), and WarpTo().

float DestinyManager::m_massMKg

protected

Definition at line 233 of file DestinyManager.h.

Referenced by MakeMissile(), Orbit(), SpeedBoost(), and UpdateShipVariables().

float DestinyManager::m_maxOrbitSpeedFraction

protected

Definition at line 287 of file DestinyManager.h.

Referenced by BeginMovement(), ClearOrbit(), DestinyManager(), Halt(), MoveObject(), and Orbit().

float DestinyManager::m_maxShipSpeed

protected

Definition at line 236 of file DestinyManager.h.

Referenced by Bounce(), GetMaxVelocity(), GetSpeed(), MakeMissile(), Orbit(), SetMaxVelocity(), SetUndockSpeed(), SpeedBoost(), TractorBeamStart(), UpdateShipVariables(), UpdateVelocity(), and WebbedMe().

float DestinyManager::m_maxSpeed

protected

Definition at line 251 of file DestinyManager.h.

Referenced by Bounce(), Follow(), Halt(), MoveObject(), Orbit(), ProcessState(), SetSpeedFraction(), SetUndockSpeed(), SpeedBoost(), TractorBeamStart(), and UpdateVelocity().

double DestinyManager::m_moveTime

protected

Definition at line 291 of file DestinyManager.h.

Referenced by BeginMovement(), Bounce(), Follow(), Halt(), MoveObject(), SpeedBoost(), Stop(), TractorBeamStart(), and UpdateVelocity().

int8 DestinyManager::m_orbiting

protected

Definition at line 275 of file DestinyManager.h.

Referenced by BeginMovement(), ClearOrbit(), DestinyManager(), Follow(), GotoDirection(), GotoPoint(), MoveObject(), Orbit(), SetSpeedFraction(), and SetUndockSpeed().

float DestinyManager::m_orbitRadTic

protected

Definition at line 281 of file DestinyManager.h.

Referenced by BeginMovement(), ClearOrbit(), ComputePosition(), DestinyManager(), GetRadTic(), and Orbit().

float DestinyManager::m_orbitTime

protected

Definition at line 280 of file DestinyManager.h.

Referenced by ClearOrbit(), ComputePosition(), DestinyManager(), and Orbit().

GPoint DestinyManager::m_position

protected

Definition at line 257 of file DestinyManager.h.

Referenced by AttemptDockOperation(), BeginMovement(), ClearTurn(), ComputePosition(), DestinyManager(), DockingAccepted(), Follow(), GetPosition(), InitWarp(), IsAligned(), IsTurn(), MakeMissile(), MoveObject(), Orbit(), ProcessState(), SetPosition(), TractorBeamStart(), WarpStop(), WarpTo(), and WarpUpdate().

float DestinyManager::m_prevSpeed

protected

Definition at line 235 of file DestinyManager.h.

Referenced by DestinyManager(), Halt(), MoveObject(), SetSpeedFraction(), SpeedBoost(), Stop(), and UpdateVelocity().

float DestinyManager::m_prevSpeedFraction

protected

Definition at line 283 of file DestinyManager.h.

Referenced by DestinyManager(), Follow(), Halt(), MoveObject(), SetSpeedFraction(), SetUndockSpeed(), SpeedBoost(), Stop(), and UpdateVelocity().

double DestinyManager::m_radians

protected

Definition at line 255 of file DestinyManager.h.

Referenced by ClearTurn(), IsTurn(), and Turn().

double DestinyManager::m_radius

protected

Definition at line 241 of file DestinyManager.h.

Referenced by ComputePosition(), DestinyManager(), Follow(), GetRadius(), and Orbit().

double DestinyManager::m_shipAgility

protected

Definition at line 245 of file DestinyManager.h.

Referenced by BeginMovement(), GetAgility(), Halt(), MakeMissile(), MoveObject(), Orbit(), SetSpeedFraction(), SpeedBoost(), Stop(), Turn(), UpdateShipVariables(), and UpdateVelocity().

GVector DestinyManager::m_shipHeading

protected

Definition at line 294 of file DestinyManager.h.

Referenced by BeginMovement(), Bounce(), DestinyManager(), Follow(), GetHeading(), Halt(), IsAligned(), IsTurn(), MakeMissile(), MoveObject(), Orbit(), ProcessState(), SetUndockSpeed(), TractorBeamStart(), Turn(), Undock(), and UpdateVelocity().

double DestinyManager::m_shipInertia

protected

Definition at line 247 of file DestinyManager.h.

Referenced by BeginMovement(), GetInertia(), MakeMissile(), Orbit(), SpeedBoost(), Turn(), and UpdateShipVariables().

float DestinyManager::m_shipMaxAccelTime

protected

Definition at line 253 of file DestinyManager.h.

Referenced by BeginMovement(), Bounce(), GetAccelTime(), Halt(), MoveObject(), SetSpeedFraction(), SetUndockSpeed(), SpeedBoost(), Stop(), TractorBeamStart(), UpdateShipVariables(), and UpdateVelocity().

float DestinyManager::m_shipWarpSpeed

protected

Definition at line 237 of file DestinyManager.h.

Referenced by GetWarpSpeed(), InitWarp(), and UpdateShipVariables().

float DestinyManager::m_speedToLeaveWarp

protected

Definition at line 239 of file DestinyManager.h.

Referenced by GetWarpDropSpeed(), UpdateShipVariables(), UpdateVelocity(), and WarpDecel().

uint32 DestinyManager::m_stateStamp

protected

Definition at line 278 of file DestinyManager.h.

Referenced by BeginMovement(), Bounce(), DestinyManager(), Follow(), GetStateStamp(), Halt(), InitWarp(), MakeMissile(), MoveObject(), Orbit(), ProcessState(), SetUndockSpeed(), Stop(), and TractorBeamStart().

bool DestinyManager::m_stop

protected

Definition at line 261 of file DestinyManager.h.

Referenced by BeginMovement(), Bounce(), DestinyManager(), Halt(), MakeMissile(), MoveObject(), SetSpeedFraction(), SetUndockSpeed(), Stop(), TractorBeamStart(), and WarpStop().

int32 DestinyManager::m_stopDistance

protected

Definition at line 272 of file DestinyManager.h.

Referenced by GetDistance(), Halt(), and WarpTo().

SystemBubble* DestinyManager::m_targBubble

protected

Definition at line 222 of file DestinyManager.h.

Referenced by UpdateVelocity(), WarpAccel(), WarpStop(), WarpTo(), and WarpUpdate().

uint32 DestinyManager::m_targetDistance

protected

Definition at line 290 of file DestinyManager.h.

Referenced by BeginMovement(), ClearOrbit(), ComputePosition(), Follow(), GetFollowDistance(), Halt(), InitWarp(), MakeMissile(), Orbit(), SetSpeedFraction(), TractorBeamStart(), WarpAccel(), WarpCruise(), WarpDecel(), WarpStop(), WarpTo(), and WarpUpdate().

std::pair<uint32, SystemEntity*> DestinyManager::m_targetEntity

protected

Definition at line 296 of file DestinyManager.h.

Referenced by ComputePosition(), DestinyManager(), EntityRemoved(), Follow(), GetTargetEntity(), GetTargetID(), Halt(), IsTargetInvalid(), MakeMissile(), Orbit(), SetSpeedFraction(), TractorBeamStart(), and WarpTo().

GVector DestinyManager::m_targetHeading

protected

Definition at line 295 of file DestinyManager.h.

Referenced by BeginMovement(), DestinyManager(), IsTurn(), and Turn().

GPoint DestinyManager::m_targetPoint

protected

Definition at line 293 of file DestinyManager.h.

Referenced by BeginMovement(), DestinyManager(), Follow(), GetTargetPoint(), GotoDirection(), GotoPoint(), Halt(), InitWarp(), IsTurn(), MakeMissile(), Orbit(), ProcessState(), TractorBeamStart(), Undock(), WarpStop(), WarpTo(), and WarpUpdate().

float DestinyManager::m_timeToEnterWarp

protected

Definition at line 238 of file DestinyManager.h.

Referenced by ClearTurn(), GetWarpTime(), ProcessState(), and UpdateShipVariables().

bool DestinyManager::m_tractored

protected

Definition at line 267 of file DestinyManager.h.

Referenced by DestinyManager(), Follow(), IsTractored(), MoveObject(), TractorBeamStart(), and TractorBeamStop().

bool DestinyManager::m_tractorPause

protected

Definition at line 268 of file DestinyManager.h.

Referenced by DestinyManager(), Follow(), and MoveObject().

float DestinyManager::m_turnFraction

protected

Definition at line 282 of file DestinyManager.h.

Referenced by ClearTurn(), DestinyManager(), Turn(), and UpdateVelocity().

bool DestinyManager::m_turning

protected

Definition at line 265 of file DestinyManager.h.

Referenced by BeginMovement(), ClearTurn(), DestinyManager(), Halt(), InitWarp(), IsTurning(), MoveObject(), TractorBeamStart(), Turn(), and UpdateVelocity().

uint8 DestinyManager::m_turnTic

protected

Definition at line 274 of file DestinyManager.h.

Referenced by BeginMovement(), ClearTurn(), DestinyManager(), MoveObject(), and Turn().

float DestinyManager::m_userSpeedFraction

protected

Definition at line 284 of file DestinyManager.h.

Referenced by BeginMovement(), Bounce(), DestinyManager(), Follow(), Halt(), MoveObject(), ProcessState(), SetSpeedFraction(), SetUndockSpeed(), SpeedBoost(), Stop(), TractorBeamStart(), UpdateVelocity(), and WebbedMe().

GVector DestinyManager::m_velocity

protected

Definition at line 258 of file DestinyManager.h.

Referenced by Bounce(), DestinyManager(), Follow(), GetVelocity(), Halt(), MoveObject(), ProcessState(), SetUndockSpeed(), TractorBeamStart(), UpdateVelocity(), and WarpUpdate().

uint8 DestinyManager::m_warpAccelTime

protected

Definition at line 229 of file DestinyManager.h.

Referenced by InitWarp().

double DestinyManager::m_warpCapacitorNeed

protected

Definition at line 243 of file DestinyManager.h.

Referenced by GetCapNeed(), UpdateShipVariables(), and WarpTo().

uint8 DestinyManager::m_warpDecelTime

protected

Definition at line 230 of file DestinyManager.h.

Referenced by InitWarp(), and WarpDecel().

WarpState* DestinyManager::m_warpState

private

Definition at line 374 of file DestinyManager.h.

Referenced by Halt(), InitWarp(), IsWarping(), ProcessState(), UpdateVelocity(), WarpAccel(), WarpCruise(), WarpDecel(), WarpStop(), WarpTo(), WarpUpdate(), and ~DestinyManager().

Timer DestinyManager::m_warpTimer

private

Definition at line 327 of file DestinyManager.h.

Referenced by ~DestinyManager().

SystemEntity* const DestinyManager::mySE

protected

Definition at line 221 of file DestinyManager.h.

Referenced by AttemptDockOperation(), BeginMovement(), Bounce(), Bump(), CheckBump(), Cloak(), DestinyManager(), DockingAccepted(), Eject(), EntityRemoved(), Follow(), GotoDirection(), GotoPoint(), Halt(), InitWarp(), IsTargetInvalid(), IsTurn(), Jump(), MakeMissile(), MoveObject(), Orbit(), Process(), ProcessState(), SendAnchorDrop(), SendAnchorLift(), SendCloakFx(), SendDestinyUpdate(), SendJettisonPacket(), SendJumpInEffect(), SendJumpOut(), SendJumpOutEffect(), SendSetState(), SetMaxVelocity(), SetPosition(), SetSpeedFraction(), SetUndockSpeed(), SpeedBoost(), Stop(), TractorBeamStart(), TractorBeamStop(), Turn(), UnCloak(), Undock(), UpdateNewShip(), UpdateShipVariables(), UpdateVelocity(), WarpAccel(), WarpCruise(), WarpDecel(), WarpStop(), WarpTo(), WarpUpdate(), and WebbedMe().

---

The documentation for this class was generated from the following files:

• /backups/local/src/eve/EvEmu_Crucible/src/eve-server/system/DestinyManager.h
• /backups/local/src/eve/EvEmu_Crucible/src/eve-server/system/DestinyManager.cpp