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
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
|
/*
Minetest-c55
Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#ifndef ENVIRONMENT_HEADER
#define ENVIRONMENT_HEADER
/*
This class is the game's environment.
It contains:
- The map
- Players
- Other objects
- The current time in the game (actually it only contains the brightness)
- etc.
*/
#include <list>
#include "common_irrlicht.h"
#include "player.h"
#include "map.h"
#include <ostream>
class Environment
{
public:
// Environment will delete the map passed to the constructor
Environment();
virtual ~Environment();
/*
Step everything in environment.
- Move players
- Step mobs
- Run timers of map
*/
virtual void step(f32 dtime) = 0;
virtual Map & getMap() = 0;
virtual void addPlayer(Player *player);
void removePlayer(u16 peer_id);
Player * getPlayer(u16 peer_id);
Player * getPlayer(const char *name);
Player * getRandomConnectedPlayer();
Player * getNearestConnectedPlayer(v3f pos);
core::list<Player*> getPlayers();
core::list<Player*> getPlayers(bool ignore_disconnected);
void printPlayers(std::ostream &o);
void setDayNightRatio(u32 r);
u32 getDayNightRatio();
protected:
// peer_ids in here should be unique, except that there may be many 0s
core::list<Player*> m_players;
// Brightness
u32 m_daynight_ratio;
};
/*
The server-side environment.
This is not thread-safe. Server uses an environment mutex.
*/
#include "serverobject.h"
class Server;
class ServerEnvironment : public Environment
{
public:
ServerEnvironment(ServerMap *map, Server *server);
~ServerEnvironment();
Map & getMap()
{
return *m_map;
}
ServerMap & getServerMap()
{
return *m_map;
}
Server * getServer()
{
return m_server;
}
void step(f32 dtime);
void serializePlayers(const std::string &savedir);
void deSerializePlayers(const std::string &savedir);
/*
ActiveObjects
*/
ServerActiveObject* getActiveObject(u16 id);
/*
Adds an active object to the environment.
Environment handles deletion of object.
Object may be deleted by environment immediately.
If id of object is 0, assigns a free id to it.
Returns the id of the object.
Returns 0 if not added and thus deleted.
*/
u16 addActiveObject(ServerActiveObject *object);
/*
Finds out what new objects have been added to
inside a radius around a position
*/
void getAddedActiveObjects(v3s16 pos, s16 radius,
core::map<u16, bool> ¤t_objects,
core::map<u16, bool> &added_objects);
/*
Finds out what new objects have been removed from
inside a radius around a position
*/
void getRemovedActiveObjects(v3s16 pos, s16 radius,
core::map<u16, bool> ¤t_objects,
core::map<u16, bool> &removed_objects);
/*
Gets the next message emitted by some active object.
Returns a message with id=0 if no messages are available.
*/
ActiveObjectMessage getActiveObjectMessage();
private:
ServerMap *m_map;
Server *m_server;
core::map<u16, ServerActiveObject*> m_active_objects;
Queue<ActiveObjectMessage> m_active_object_messages;
float m_random_spawn_timer;
};
#ifndef SERVER
#include "clientobject.h"
/*
The client-side environment.
This is not thread-safe.
Must be called from main (irrlicht) thread (uses the SceneManager)
Client uses an environment mutex.
*/
class ClientEnvironment : public Environment
{
public:
ClientEnvironment(ClientMap *map, scene::ISceneManager *smgr);
~ClientEnvironment();
Map & getMap()
{
return *m_map;
}
ClientMap & getClientMap()
{
return *m_map;
}
void step(f32 dtime);
virtual void addPlayer(Player *player);
LocalPlayer * getLocalPlayer();
void updateMeshes(v3s16 blockpos);
void expireMeshes(bool only_daynight_diffed);
/*
ActiveObjects
*/
ClientActiveObject* getActiveObject(u16 id);
/*
Adds an active object to the environment.
Environment handles deletion of object.
Object may be deleted by environment immediately.
If id of object is 0, assigns a free id to it.
Returns the id of the object.
Returns 0 if not added and thus deleted.
*/
u16 addActiveObject(ClientActiveObject *object);
void addActiveObject(u16 id, u8 type, const std::string &init_data);
void removeActiveObject(u16 id);
void processActiveObjectMessage(u16 id, const std::string &data);
// Get all nearby objects
void getActiveObjects(v3f origin, f32 max_d,
core::array<DistanceSortedActiveObject> &dest);
private:
ClientMap *m_map;
scene::ISceneManager *m_smgr;
core::map<u16, ClientActiveObject*> m_active_objects;
};
#endif
#endif
|
