Fixed a temporary solution of server shutting down to an assert(0) when a too large...

[minetest.git] / src / server.h

diff --git a/src/server.h b/src/server.h
index 292e2d5cd84affc902812010e3fb272b079c903e..4603f98ed5eed3b242c10d27ab8f2053af4d5928 100644 (file)
--- a/src/server.h
+++ b/src/server.h
@@ -1,6 +1,6 @@
 /*
 Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Copyright (C) 2010-2011 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
@@ -30,7 +30,18 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include <string>
 #include "utility.h"
 #include "porting.h"
+#include "map.h"
+#include "inventory.h"
 
+/*
+       Some random functions
+*/
+v3f findSpawnPos(ServerMap &map);
+
+/*
+       A structure containing the data needed for queueing the fetching
+       of blocks.
+*/
 struct QueuedBlockEmerge
 {
        v3s16 pos;
@@ -239,6 +250,8 @@ class RemoteClient
                pending_serialization_version = SER_FMT_VER_INVALID;
                m_nearest_unsent_d = 0;
                m_nearest_unsent_reset_timer = 0.0;
+               m_nothing_to_send_counter = 0;
+               m_nothing_to_send_pause_timer = 0;
        }
        ~RemoteClient()
        {
@@ -283,7 +296,7 @@ class RemoteClient
        void PrintInfo(std::ostream &o)
        {
                o<<"RemoteClient "<<peer_id<<": "
-                               <<", m_blocks_sent.size()="<<m_blocks_sent.size()
+                               <<"m_blocks_sent.size()="<<m_blocks_sent.size()
                                <<", m_blocks_sending.size()="<<m_blocks_sending.size()
                                <<", m_nearest_unsent_d="<<m_nearest_unsent_d
                                <<", m_excess_gotblocks="<<m_excess_gotblocks
@@ -339,14 +352,20 @@ class RemoteClient
                This is resetted by PrintInfo()
        */
        u32 m_excess_gotblocks;
+       
+       // CPU usage optimization
+       u32 m_nothing_to_send_counter;
+       float m_nothing_to_send_pause_timer;
 };
 
-class Server : public con::PeerHandler
+class Server : public con::PeerHandler, public MapEventReceiver,
+               public InventoryManager
 {
 public:
        /*
                NOTE: Every public method should be thread-safe
        */
+
        Server(
                std::string mapsavedir
        );
@@ -361,29 +380,30 @@ class Server : public con::PeerHandler
        void Receive();
        void ProcessData(u8 *data, u32 datasize, u16 peer_id);
 
-       // Environment and Connection must be locked when  called
-       void SendBlockNoLock(u16 peer_id, MapBlock *block, u8 ver);
-       
-       //
-       
        core::list<PlayerInfo> getPlayerInfo();
 
        u32 getDayNightRatio()
        {
-               s32 d = 8;
-               s32 t = (((m_time_of_day.get() + 24000/d/2)%24000)/(24000/d));
-               if(t == d/4 || t == (d-d/4))
-                       return 600;
-               else if(t < d/4 || t > (d-d/4))
-                       return 300;
-               else
-                       return 1000;
+               return time_to_daynight_ratio(m_time_of_day.get());
        }
 
        bool getShutdownRequested()
        {
                return m_shutdown_requested.get();
        }
+       
+       /*
+               Shall be called with the environment locked.
+               This is accessed by the map, which is inside the environment,
+               so it shouldn't be a problem.
+       */
+       void onMapEditEvent(MapEditEvent *event);
+
+       /*
+               Shall be called with the environment and the connection locked.
+       */
+       Inventory* getInventory(InventoryContext *c, std::string id);
+       void inventoryModified(InventoryContext *c, std::string id);
 
 private:
 
@@ -392,15 +412,45 @@ class Server : public con::PeerHandler
        void peerAdded(con::Peer *peer);
        void deletingPeer(con::Peer *peer, bool timeout);
        
+       /*
+               Static send methods
+       */
+       
+       static void SendHP(con::Connection &con, u16 peer_id, u8 hp);
+       
+       /*
+               Non-static send methods
+       */
+
        // Envlock and conlock should be locked when calling these
        void SendObjectData(float dtime);
        void SendPlayerInfos();
        void SendInventory(u16 peer_id);
        void SendChatMessage(u16 peer_id, const std::wstring &message);
        void BroadcastChatMessage(const std::wstring &message);
+       void SendPlayerHP(Player *player);
+       void SendMovePlayer(Player *player);
+       /*
+               Send a node removal/addition event to all clients except ignore_id.
+               Additionally, if far_players!=NULL, players further away than
+               far_d_nodes are ignored and their peer_ids are added to far_players
+       */
+       void sendRemoveNode(v3s16 p, u16 ignore_id=0,
+                       core::list<u16> *far_players=NULL, float far_d_nodes=100);
+       void sendAddNode(v3s16 p, MapNode n, u16 ignore_id=0,
+                       core::list<u16> *far_players=NULL, float far_d_nodes=100);
+       
+       // Environment and Connection must be locked when  called
+       void SendBlockNoLock(u16 peer_id, MapBlock *block, u8 ver);
        
        // Sends blocks to clients
        void SendBlocks(float dtime);
+
+       /*
+               Something random
+       */
+       
+       void UpdateCrafting(u16 peer_id);
        
        // When called, connection mutex should be locked
        RemoteClient* getClient(u16 peer_id);
@@ -484,6 +534,24 @@ class Server : public con::PeerHandler
        std::string m_mapsavedir;
 
        MutexedVariable<bool> m_shutdown_requested;
+       
+       /*
+               Queue of map edits from the environment for sending to the clients
+               This is behind m_env_mutex
+       */
+       Queue<MapEditEvent*> m_unsent_map_edit_queue;
+       /*
+               Set to true when the server itself is modifying the map and does
+               all sending of information by itself.
+               This is behind m_env_mutex
+       */
+       bool m_ignore_map_edit_events;
+       /*
+               If set to !=0, the incoming MapEditEvents are modified to have
+               this peed id as the disabled recipient
+               This is behind m_env_mutex
+       */
+       u16 m_ignore_map_edit_events_peer_id;
 
        friend class EmergeThread;
        friend class RemoteClient;