Packages/p/pioneer-20240203-2.fc38.x86_64.rpm

// Copyright © 2008-2024 Pioneer Developers. See AUTHORS.txt for details

// Licensed under the terms of the GPL v3. See licenses/GPL-3.txt


#ifndef _SPACE_H

#define _SPACE_H


#include "Background.h"

#include "FrameId.h"

#include "IterationProxy.h"

#include "RefCounted.h"

#include "galaxy/StarSystem.h"

#include "vector3.h"


class Body;

class Frame;

class Game;

enum class ObjectType;


class Space {

public:

    // empty space (eg for hyperspace)

    Space(Game *game, RefCountedPtr<Galaxy> galaxy, Space *oldSpace = nullptr);


    // initialise with system bodies

    Space(Game *game, RefCountedPtr<Galaxy> galaxy, const SystemPath &path, Space *oldSpace = nullptr);


    // initialise from save file

    Space(Game *game, RefCountedPtr<Galaxy> galaxy, const Json &jsonObj, double at_time);


    ~Space();


    void ToJson(Json &jsonObj);


    // body/sbody indexing for save/load. valid after

    // construction/ToJson(), invalidated by TimeStep(). they will assert

    // if called while invalid

    Body *GetBodyByIndex(Uint32 idx) const;

    SystemBody *GetSystemBodyByIndex(Uint32 idx) const;

    Uint32 GetIndexForBody(const Body *body) const;

    Uint32 GetIndexForSystemBody(const SystemBody *sbody) const;


    RefCountedPtr<StarSystem> GetStarSystem() const { return m_starSystem; }


    FrameId GetRootFrame() const { return m_rootFrameId; }


    void AddBody(Body *);

    void RemoveBody(Body *);

    void KillBody(Body *);


    void TimeStep(float step);


    void GetHyperspaceExitParams(const SystemPath &source, const SystemPath &dest,

        vector3d &pos, vector3d &vel) const;

    vector3d GetHyperspaceExitPoint(const SystemPath &source, const SystemPath &dest) const

    {

        vector3d pos, vel;

        GetHyperspaceExitParams(source, dest, pos, vel);

        return pos;

    }

    vector3d GetHyperspaceExitPoint(const SystemPath &source) const

    {

        return GetHyperspaceExitPoint(source, m_starSystem->GetPath());

    }


    Body *FindNearestTo(const Body *b, ObjectType t) const;

    Body *FindBodyForPath(const SystemPath *path) const;


    Uint32 GetNumBodies() const { return static_cast<Uint32>(m_bodies.size()); }

    IterationProxy<std::vector<Body *>> GetBodies() { return MakeIterationProxy(m_bodies); }

    const IterationProxy<const std::vector<Body *>> GetBodies() const { return MakeIterationProxy(m_bodies); }


    Background::Container *GetBackground() { return m_background.get(); }

    void RefreshBackground();


    // body finder delegates

    typedef const std::vector<Body *> BodyNearList;

    BodyNearList GetBodiesMaybeNear(const Body *b, double dist)

    {

        return m_bodyNearFinder.GetBodiesMaybeNear(b, dist);

    }

    BodyNearList GetBodiesMaybeNear(const vector3d &pos, double dist)

    {

        return m_bodyNearFinder.GetBodiesMaybeNear(pos, dist);

    }


    void DebugDumpFrames(bool details);


    struct BodyDist {

        BodyDist(Body *_body, double _dist) :

            body(_body),

            dist(_dist) {}

        Body *body;

        double dist;


        bool operator<(const BodyDist &a) const { return dist < a.dist; }


        friend bool operator<(const BodyDist &a, double d) { return a.dist < d; }

        friend bool operator<(double d, const BodyDist &a) { return d < a.dist; }

    };


    //Find bodies within angle to given direction. dir and offset relative to b like in ship coordinates

    //returns unsorted vector of bodies with their distance from b+offset

    //It calculates distance from b for all the bodies so it is quite inefficiet,

    //it is not designed to be called in each game loop!

    std::vector<BodyDist> BodiesInAngle(const Body *b, const vector3d &offset, const vector3d &dir, double cosOfMaxAngle) const;


    // Don't call this unless you really have to

    // A bit of a hack but required so we can add a player

    // into space as we emerge from hyperspace

    // and then find stuff.

    void UpdateBodies();


private:

    void GenSectorCache(RefCountedPtr<Galaxy> galaxy, const SystemPath *here);

    void UpdateStarSystemCache(const SystemPath *here);

    void GenBody(const double at_time, SystemBody *b, FrameId fId, std::vector<vector3d> &posAccum);

    // make sure SystemBody* is in Pi::currentSystem

    FrameId GetFrameWithSystemBody(const SystemBody *b) const;


    void CollideFrame(FrameId fId);


    FrameId m_rootFrameId;


    RefCountedPtr<SectorCache::Slave> m_sectorCache;

    RefCountedPtr<StarSystemCache::Slave> m_starSystemCache;


    RefCountedPtr<StarSystem> m_starSystem;


    Game *m_game;


    // all the bodies we know about

    std::vector<Body *> m_bodies;


    // bodies that were removed/killed/added this timestep and need pruning/adding at the end

    enum class BodyAssignation {

        KILL = 0,

        REMOVE = 1,

        CREATE = 2

    };


    std::vector<std::pair<Body *, BodyAssignation>> m_assignedBodies;


    void RebuildBodyIndex();

    void RebuildSystemBodyIndex();


    void AddSystemBodyToIndex(SystemBody *sbody);


    bool m_bodyIndexValid, m_sbodyIndexValid;

    std::vector<Body *> m_bodyIndex;

    std::vector<SystemBody *> m_sbodyIndex;


    //background (elements that are infinitely far away,

    //e.g. starfield and milky way)

    std::unique_ptr<Background::Container> m_background;


    class BodyNearFinder {

    public:

        BodyNearFinder(const Space *space) :

            m_space(space) {}

        void Prepare();


        BodyNearList GetBodiesMaybeNear(const Body *b, double dist);

        BodyNearList GetBodiesMaybeNear(const vector3d &pos, double dist);


    private:


        const Space *m_space;

        std::vector<BodyDist> m_bodyDist;

        std::vector<Body *> m_nearBodies;

    };


    BodyNearFinder m_bodyNearFinder;


#ifndef NDEBUG

    //to check RemoveBody and KillBody are not called from within

    //the NotifyRemoved callback (#735)

    bool m_processingFinalizationQueue;

#endif

};


#endif /* _SPACE_H */

Background.h

ObjectType
ObjectType
Definition: Body.h:29

FrameId.h

IterationProxy.h

MakeIterationProxy
IterationProxy< Container > MakeIterationProxy(Container &container)
Definition: IterationProxy.h:51

Json
nlohmann::json Json
Definition: Json.h:8

RefCounted.h

StarSystem.h

Background::Container
Definition: Background.h:90

Body
Definition: Body.h:65

Frame
Definition: Frame.h:28

Game
Definition: Game.h:38

IterationProxy
Definition: IterationProxy.h:13

RefCountedPtr
Definition: RefCounted.h:36

Space
Definition: Space.h:19

Space::~Space
~Space()
Definition: Space.cpp:309

Space::UpdateBodies
void UpdateBodies()
Definition: Space.cpp:1090

Space::FindNearestTo
Body * FindNearestTo(const Body *b, ObjectType t) const
Definition: Space.cpp:555

Space::GetHyperspaceExitParams
void GetHyperspaceExitParams(const SystemPath &source, const SystemPath &dest, vector3d &pos, vector3d &vel) const
Definition: Space.cpp:492

Space::BodiesInAngle
std::vector< BodyDist > BodiesInAngle(const Body *b, const vector3d &offset, const vector3d &dir, double cosOfMaxAngle) const
Definition: Space.cpp:572

Space::GetHyperspaceExitPoint
vector3d GetHyperspaceExitPoint(const SystemPath &source) const
Definition: Space.h:60

Space::GetBackground
Background::Container * GetBackground()
Definition: Space.h:73

Space::KillBody
void KillBody(Body *)
Definition: Space.cpp:473

Space::RefreshBackground
void RefreshBackground()
Definition: Space.cpp:324

Space::GetBodiesMaybeNear
BodyNearList GetBodiesMaybeNear(const vector3d &pos, double dist)
Definition: Space.h:82

Space::GetRootFrame
FrameId GetRootFrame() const
Definition: Space.h:44

Space::GetIndexForSystemBody
Uint32 GetIndexForSystemBody(const SystemBody *sbody) const
Definition: Space.cpp:407

Space::GetNumBodies
Uint32 GetNumBodies() const
Definition: Space.h:69

Space::GetHyperspaceExitPoint
vector3d GetHyperspaceExitPoint(const SystemPath &source, const SystemPath &dest) const
Definition: Space.h:54

Space::GetBodies
IterationProxy< std::vector< Body * > > GetBodies()
Definition: Space.h:70

Space::GetSystemBodyByIndex
SystemBody * GetSystemBodyByIndex(Uint32 idx) const
Definition: Space.cpp:390

Space::GetBodyByIndex
Body * GetBodyByIndex(Uint32 idx) const
Definition: Space.cpp:379

Space::ToJson
void ToJson(Json &jsonObj)
Definition: Space.cpp:339

Space::AddBody
void AddBody(Body *)
Definition: Space.cpp:457

Space::BodyNearList
const std::vector< Body * > BodyNearList
Definition: Space.h:77

Space::RemoveBody
void RemoveBody(Body *)
Definition: Space.cpp:465

Space::TimeStep
void TimeStep(float step)
Definition: Space.cpp:1055

Space::GetStarSystem
RefCountedPtr< StarSystem > GetStarSystem() const
Definition: Space.h:42

Space::DebugDumpFrames
void DebugDumpFrames(bool details)
Definition: Space.cpp:1147

Space::GetBodies
const IterationProxy< const std::vector< Body * > > GetBodies() const
Definition: Space.h:71

Space::GetBodiesMaybeNear
BodyNearList GetBodiesMaybeNear(const Body *b, double dist)
Definition: Space.h:78

Space::FindBodyForPath
Body * FindBodyForPath(const SystemPath *path) const
Definition: Space.cpp:594

Space::GetIndexForBody
Uint32 GetIndexForBody(const Body *body) const
Definition: Space.cpp:397

SystemBody
Definition: SystemBody.h:137

SystemPath
Definition: SystemPath.h:13

vector3< double >

FrameId
Definition: FrameId.h:9

Space::BodyDist
Definition: Space.h:89

Space::BodyDist::operator<
bool operator<(const BodyDist &a) const
Definition: Space.h:96

Space::BodyDist::body
Body * body
Definition: Space.h:93

Space::BodyDist::operator<
friend bool operator<(double d, const BodyDist &a)
Definition: Space.h:99

Space::BodyDist::BodyDist
BodyDist(Body *_body, double _dist)
Definition: Space.h:90

Space::BodyDist::dist
double dist
Definition: Space.h:94

Space::BodyDist::operator<
friend bool operator<(const BodyDist &a, double d)
Definition: Space.h:98

vector3.h