Modernize client code (#6250)

[oweals/minetest.git] / src / client.cpp

diff --git a/src/client.cpp b/src/client.cpp
index d0c90b108d9062708f7a0f3126d935c842da0546..f7834a02b46117ad030ebe1b6a11572b6980a45f 100644 (file)
--- a/src/client.cpp
+++ b/src/client.cpp
@@ -47,6 +47,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "guiscalingfilter.h"
 #include "script/scripting_client.h"
 #include "game.h"
+#include "chatmessage.h"
 
 extern gui::IGUIEnvironment* guienv;
 
@@ -83,6 +84,7 @@ Client::Client(
        m_con(PROTOCOL_ID, 512, CONNECTION_TIMEOUT, ipv6, this),
        m_address_name(address_name),
        m_server_ser_ver(SER_FMT_VER_INVALID),
+       m_last_chat_message_sent(time(NULL)),
        m_password(password),
        m_chosen_auth_mech(AUTH_MECHANISM_NONE),
        m_media_downloader(new ClientMediaDownloader()),
@@ -387,13 +389,21 @@ void Client::step(float dtime)
                }
        }
 
+       /*
+               Send pending messages on out chat queue
+       */
+       if (!m_out_chat_queue.empty() && canSendChatMessage()) {
+               sendChatMessage(m_out_chat_queue.front());
+               m_out_chat_queue.pop();
+       }
+
        /*
                Handle environment
        */
        // Control local player (0ms)
        LocalPlayer *player = m_env.getLocalPlayer();
        assert(player);
-       player->applyControl(dtime);
+       player->applyControl(dtime, &m_env);
 
        // Step environment
        m_env.step(dtime);
@@ -1143,13 +1153,50 @@ void Client::sendInventoryAction(InventoryAction *a)
        Send(&pkt);
 }
 
+bool Client::canSendChatMessage() const
+{
+       u32 now = time(NULL);
+       float time_passed = now - m_last_chat_message_sent;
+
+       float virt_chat_message_allowance = m_chat_message_allowance + time_passed *
+                       (CLIENT_CHAT_MESSAGE_LIMIT_PER_10S / 8.0f);
+
+       if (virt_chat_message_allowance < 1.0f)
+               return false;
+
+       return true;
+}
+
 void Client::sendChatMessage(const std::wstring &message)
 {
-       NetworkPacket pkt(TOSERVER_CHAT_MESSAGE, 2 + message.size() * sizeof(u16));
+       const s16 max_queue_size = g_settings->getS16("max_out_chat_queue_size");
+       if (canSendChatMessage()) {
+               u32 now = time(NULL);
+               float time_passed = now - m_last_chat_message_sent;
+               m_last_chat_message_sent = time(NULL);
 
-       pkt << message;
+               m_chat_message_allowance += time_passed * (CLIENT_CHAT_MESSAGE_LIMIT_PER_10S / 8.0f);
+               if (m_chat_message_allowance > CLIENT_CHAT_MESSAGE_LIMIT_PER_10S)
+                       m_chat_message_allowance = CLIENT_CHAT_MESSAGE_LIMIT_PER_10S;
 
-       Send(&pkt);
+               m_chat_message_allowance -= 1.0f;
+
+               NetworkPacket pkt(TOSERVER_CHAT_MESSAGE, 2 + message.size() * sizeof(u16));
+
+               pkt << message;
+
+               Send(&pkt);
+       } else if (m_out_chat_queue.size() < (u16) max_queue_size || max_queue_size == -1) {
+               m_out_chat_queue.push(message);
+       } else {
+               infostream << "Could not queue chat message because maximum out chat queue size ("
+                               << max_queue_size << ") is reached." << std::endl;
+       }
+}
+
+void Client::clearOutChatQueue()
+{
+       m_out_chat_queue = std::queue<std::wstring>();
 }
 
 void Client::sendChangePassword(const std::string &oldpassword,
@@ -1314,8 +1361,22 @@ void Client::removeNode(v3s16 p)
        }
 }
 
+/**
+ * Helper function for Client Side Modding
+ * Flavour is applied there, this should not be used for core engine
+ * @param p
+ * @param is_valid_position
+ * @return
+ */
 MapNode Client::getNode(v3s16 p, bool *is_valid_position)
 {
+       if (checkCSMFlavourLimit(CSMFlavourLimit::CSM_FL_LOOKUP_NODES)) {
+               v3s16 ppos = floatToInt(m_env.getLocalPlayer()->getPosition(), BS);
+               if ((u32) ppos.getDistanceFrom(p) > m_csm_noderange_limit) {
+                       *is_valid_position = false;
+                       return MapNode();
+               }
+       }
        return m_env.getMap().getNodeNoEx(p, is_valid_position);
 }
 
@@ -1472,12 +1533,34 @@ u16 Client::getHP()
        return player->hp;
 }
 
-bool Client::getChatMessage(std::wstring &message)
+bool Client::getChatMessage(std::wstring &res)
 {
-       if(m_chat_queue.size() == 0)
+       if (m_chat_queue.empty())
                return false;
-       message = m_chat_queue.front();
+
+       ChatMessage *chatMessage = m_chat_queue.front();
        m_chat_queue.pop();
+
+       res = L"";
+
+       switch (chatMessage->type) {
+               case CHATMESSAGE_TYPE_RAW:
+               case CHATMESSAGE_TYPE_ANNOUNCE:
+               case CHATMESSAGE_TYPE_SYSTEM:
+                       res = chatMessage->message;
+                       break;
+               case CHATMESSAGE_TYPE_NORMAL: {
+                       if (!chatMessage->sender.empty())
+                               res = L"<" + chatMessage->sender + L"> " + chatMessage->message;
+                       else
+                               res = chatMessage->message;
+                       break;
+               }
+               default:
+                       break;
+       }
+
+       delete chatMessage;
        return true;
 }
 
@@ -1496,14 +1579,13 @@ void Client::typeChatMessage(const std::wstring &message)
        sendChatMessage(message);
 
        // Show locally
-       if (message[0] != L'/')
-       {
+       if (message[0] != L'/') {
                // compatibility code
                if (m_proto_ver < 29) {
                        LocalPlayer *player = m_env.getLocalPlayer();
                        assert(player);
                        std::wstring name = narrow_to_wide(player->getName());
-                       pushToChatQueue((std::wstring)L"<" + name + L"> " + message);
+                       pushToChatQueue(new ChatMessage(CHATMESSAGE_TYPE_NORMAL, message, name));
                }
        }
 }
@@ -1760,7 +1842,8 @@ void Client::makeScreenshot()
                        } else {
                                sstr << "Failed to save screenshot '" << filename << "'";
                        }
-                       pushToChatQueue(narrow_to_wide(sstr.str()));
+                       pushToChatQueue(new ChatMessage(CHATMESSAGE_TYPE_SYSTEM,
+                                       narrow_to_wide(sstr.str())));
                        infostream << sstr.str() << std::endl;
                        image->drop();
                }