opengw/entity.hpp at master · capehill/opengw · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
#pragma once

#include "mathutils.hpp"
#include "model.hpp"
#include "point3d.hpp"
#include "vector.hpp"

class game;

class entity
{
  public:
    typedef enum
    {
        ENTITY_TYPE_UNDEF = 0,
        ENTITY_TYPE_PLAYER1,
        ENTITY_TYPE_PLAYER2,
        ENTITY_TYPE_PLAYER3,
        ENTITY_TYPE_PLAYER4,
        ENTITY_TYPE_PLAYER_MISSILE,
        ENTITY_TYPE_GRUNT,
        ENTITY_TYPE_WANDERER,
        ENTITY_TYPE_WEAVER,
        ENTITY_TYPE_SPINNER,
        ENTITY_TYPE_TINYSPINNER,
        ENTITY_TYPE_MAYFLY,
        ENTITY_TYPE_SNAKE,
        ENTITY_TYPE_SNAKE_SEGMENT,
        ENTITY_TYPE_BLACKHOLE,
        ENTITY_TYPE_REPULSOR,
        ENTITY_TYPE_REPULSOR_SHIELD,
        ENTITY_TYPE_PROTON,
        ENTITY_TYPE_LINE,
        ENTITY_NUM_TYPES // Must be last
    } EntityType;

    typedef enum
    {
        ENTITY_STATE_INACTIVE = 0,
        ENTITY_STATE_SPAWN_TRANSITION,
        ENTITY_STATE_SPAWNING,
        ENTITY_STATE_RUN_TRANSITION,
        ENTITY_STATE_RUNNING,
        ENTITY_STATE_DESTROY_TRANSITION,
        ENTITY_STATE_DESTROYED,
        ENTITY_STATE_INDICATE_TRANSITION,
        ENTITY_STATE_INDICATING
    } EntityState;

    entity();
    virtual ~entity() = default;

    static entity* createEntity(EntityType _entity, const game& gameRef); // Static class factory

    EntityType getType() const { return mType; }

    Point3d getPos() const { return mPos; }
    void setPos(const Point3d& pos) { mPos = pos; }

    Point3d getSpeed() const { return mSpeed; }
    void setSpeed(const Point3d& speed) { mSpeed = speed; }

    Point3d getDrift() const { return mDrift; }
    void setDrift(const Point3d& drift) { mDrift = drift; }

    float getAngle() const { return mAngle; }
    void setAngle(const float& angle) { mAngle = mathutils::wrapRadians(angle); }

    float getRotationRate() const { return mRotationRate; }
    void setRotationRate(const float& rate) { mRotationRate = rate; }

    Point3d getScale() const { return mScale; }
    void setScale(const Point3d& scale) { mScale = scale; }
    void setScale(float scale) { mScale = scale; }

    vector::pen getPen() const { return mPen; }
    void setPen(const vector::pen& pen) { mPen = pen; }

    bool getEnabled() const { return mState != ENTITY_STATE_INACTIVE; }
    void setEnabled(const bool& enabled) { mState = (enabled) ? ENTITY_STATE_SPAWN_TRANSITION : ENTITY_STATE_INACTIVE; }

    EntityState getState() const { return mState; }
    void setState(const EntityState& state) { mState = state; }

    int getStateTimer() const { return mStateTimer; }
    void setStateTimer(int stateTimer) { mStateTimer = stateTimer; }

    model* getModel() { return &mModel; }

    int getScoreValue() const { return mScoreValue; }

    float getRadius() const { return mRadius; }

    float getAggression() const { return mAggression; }

    void setEdgeBounce(bool bounce) { mEdgeBounce = bounce; }

    void setGridBound(bool gridBound) { mGridBound = gridBound; }

    virtual void runTransition();
    virtual void run();
    virtual void spawnTransition();
    virtual void spawn();
    virtual void destroyTransition();
    virtual void destroy();
    virtual void indicateTransition();
    virtual void indicating();

    virtual void hit(entity* aEntity);
    virtual entity* hitTest(const Point3d& pos, float radius);

    virtual void draw();

    virtual entity* getParent() { return this; }

    int getGenId() const { return mGenId; }
    void incGenId() { ++mGenId; }

  protected:
    EntityType mType;
    Point3d mPos;
    Point3d mSpeed;
    Point3d mDrift;
    float mAngle { 0.0f };
    float mRotationRate { 0.0f };
    Point3d mScale;
    float mRadius { 0.0f };
    bool mEdgeBounce;
    bool mGridBound;
    vector::pen mPen;

    float mAggression;

    EntityState mState;

    int mSpawnTime;
    int mDestroyTime;
    int mIndicateTime;
    float mStateTimer;

    int mScoreValue { 0 };

    int mGenId;

    model mModel;
};