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
|
/**
* @file components.hpp
* @brief Where all of an enities possible components are stored.
* Using an ECS (Entity component system) the entities are given components on the fly,
* this allows the entity to change stats or skills on the go. This also allows every "object"
* the be an entity, and it gives the game a much better customizability over xml.
*/
#ifndef COMPONENTS_HPP
#define COMPONENTS_HPP
#include <entityx/entityx.h>
/**
* @struct Position
* @brief Stores the position of an entity on the xy plane.
*/
struct Position {
/**
* Constructor that sets the position of the object, if nothing is passed it will default to 0.
* @param x The x position the object will be placed at.
* @param y the y position the object will be placed at.
*/
Position(float x = 0.0f, float y = 0.0f): x(x), y(y) {}
float x; /**< The x position in the world */
float y; /**< The y position in the world */
};
/**
* @struct Direction
* @brief Store an entities velocity.
* This allows the entity to move throughout the world.
*/
struct Direction {
/**
* Constructor that sets the velocity, if no position is passed, it defaults to (0,0).
* @param x The velocity of the object on the x axis.
* @param y The velocity of the object on the y axis.
*/
Direction(float x = 0.0f, float y = 0.0f): x(x), y(y) {}
float x; /**< Velocity the object is moving in the x direction, this is added to the position */
float y; /**< Velocity the object is moving in the y direction, this is added to the position */
};
/**
* @struct Physics
* @brief Allows and entity to react to gravity and frictions.
* When an entity inherits this component it will react with gravity and move with friction.
*/
struct Physics {
/**
* Constructor that sets the gravity constant, if not specified it becomes 0.
* @param g The non default gravity constant.
*/
Physics(float g = 0.0f): g(g) {}
float g; /**< The gravity constant, how fast the object falls */
};
/**
* @struct Solid
* @brief Allows an entity to collide with other objects.
* When an entity has this component it can collide with the world and other objects.
*/
struct Solid {
/**
* Constructor that sets the entities dimensions based on what is passed.
* @param w The desired width of the entity.
* @param h The desired height of the entity.
*/
Solid(float w = 0.0f, float h = 0.0f): width(w), height(h) {}
float width; /**< The width of the entity in units */
float height; /**< The height of the entity in units */
};
struct SpriteData {
uint sheetID;
vec2 offset;
vec2 size;
};
//TODO
/**
* @struct Sprite
* @brief If an entity is visible we want to be able to see it.
* Each entity is given a sprite, a sprite can consist of manu frames or pieces to make one.
*/
struct Sprite {
std::vector<std::pair<SpriteData, vec2>> getSprite() {
return sprite;
}
int clearSprite() {
if (sprite.empty())
return 0;
sprite.clear();
return 1;
}
int addSpriteSegment(SpriteData data, vec2 loc) {
//TODO if sprite is in this spot, do something
sprite.push_back(std::make_pair(data, loc));
return 1;
}
int changeSpriteSegment(SpriteData data, vec2 loc) {
for (auto &s : sprite) {
if (s.second == loc) {
s.first = data;
return 1;
}
}
addSpriteSegment(data, loc);
return 0;
}
std::vector<std::pair<SpriteData, vec2>> sprite;
};
//TODO
struct Animate {
std::vector<std::pair<SpriteData, vec2>> sprite_e;
std::vector<std::pair<SpriteData, vec2>> sprite_c;
};
//TODO
struct Input {
};
#endif //COMPONENTS_HPP
|
