#include <set>
#include <list>
-#include "irrlichttypes_extrabloated.h"
-#include "player.h"
-#include <ostream>
+#include <map>
+#include "irr_v3d.h"
#include "activeobject.h"
-#include "util/container.h"
#include "util/numeric.h"
#include "mapnode.h"
#include "mapblock.h"
class ServerEnvironment;
class ActiveBlockModifier;
class ServerActiveObject;
-typedef struct lua_State lua_State;
class ITextureSource;
class IGameDef;
+class IBackgroundBlockEmerger;
class Map;
class ServerMap;
class ClientMap;
+class GameScripting;
+class Player;
class Environment
{
Player * getNearestConnectedPlayer(v3f pos);
std::list<Player*> getPlayers();
std::list<Player*> getPlayers(bool ignore_disconnected);
- void printPlayers(std::ostream &o);
u32 getDayNightRatio();
private:
};
-class IBackgroundBlockEmerger
-{
-public:
- virtual void queueBlockEmerge(v3s16 blockpos, bool allow_generate)=0;
-};
-
/*
The server-side environment.
class ServerEnvironment : public Environment
{
public:
- ServerEnvironment(ServerMap *map, lua_State *L, IGameDef *gamedef,
+ ServerEnvironment(ServerMap *map, GameScripting *scriptIface,
+ IGameDef *gamedef,
IBackgroundBlockEmerger *emerger);
~ServerEnvironment();
ServerMap & getServerMap();
- lua_State* getLua()
- { return m_lua; }
+ //TODO find way to remove this fct!
+ GameScripting* getScriptIface()
+ { return m_script; }
IGameDef *getGameDef()
{ return m_gamedef; }
// This makes stuff happen
void step(f32 dtime);
+ //check if there's a line of sight between two positions
+ bool line_of_sight(v3f pos1, v3f pos2, float stepsize=1.0);
+
+ u32 getGameTime() { return m_game_time; }
+
+ void reportMaxLagEstimate(float f) { m_max_lag_estimate = f; }
+ float getMaxLagEstimate() { return m_max_lag_estimate; }
+
+ // is weather active in this environment?
+ bool m_use_weather;
+
private:
/*
// The map
ServerMap *m_map;
// Lua state
- lua_State *m_lua;
+ GameScripting* m_script;
// Game definition
IGameDef *m_gamedef;
- // Background block emerger (the server, in practice)
+ // Background block emerger (the EmergeManager, in practice)
IBackgroundBlockEmerger *m_emerger;
// Active object list
std::map<u16, ServerActiveObject*> m_active_objects;
// Outgoing network message buffer for active objects
- Queue<ActiveObjectMessage> m_active_object_messages;
+ std::list<ActiveObjectMessage> m_active_object_messages;
// Some timers
float m_random_spawn_timer; // used for experimental code
float m_send_recommended_timer;
std::list<ABMWithState> m_abms;
// An interval for generally sending object positions and stuff
float m_recommended_send_interval;
+ // Estimate for general maximum lag as determined by server.
+ // Can raise to high values like 15s with eg. map generation mods.
+ float m_max_lag_estimate;
};
#ifndef SERVER
enum ClientEnvEventType
{
CEE_NONE,
- CEE_PLAYER_DAMAGE
+ CEE_PLAYER_DAMAGE,
+ CEE_PLAYER_BREATH
};
struct ClientEnvEvent
u8 amount;
bool send_to_server;
} player_damage;
+ struct{
+ u16 amount;
+ } player_breath;
};
};
*/
void damageLocalPlayer(u8 damage, bool handle_hp=true);
+ void updateLocalPlayerBreath(u16 breath);
/*
Client likes to call these
ClientEnvEvent getClientEvent();
std::vector<core::vector2d<int> > attachment_list; // X is child ID, Y is parent ID
+
+ std::list<std::string> getPlayerNames()
+ { return m_player_names; }
+ void addPlayerName(std::string name)
+ { m_player_names.push_back(name); }
+ void removePlayerName(std::string name)
+ { m_player_names.remove(name); }
private:
ClientMap *m_map;
IrrlichtDevice *m_irr;
std::map<u16, ClientActiveObject*> m_active_objects;
std::list<ClientSimpleObject*> m_simple_objects;
- Queue<ClientEnvEvent> m_client_event_queue;
+ std::list<ClientEnvEvent> m_client_event_queue;
IntervalLimiter m_active_object_light_update_interval;
IntervalLimiter m_lava_hurt_interval;
+ IntervalLimiter m_drowning_interval;
+ IntervalLimiter m_breathing_interval;
+ std::list<std::string> m_player_names;
};
#endif