source/network/NetMessage.h

   1 /* Copyright (C) 2017 Wildfire Games.
   2  * This file is part of 0 A.D.
   3  *
   4  * 0 A.D. is free software: you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation, either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * 0 A.D. is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 #ifndef NETMESSAGE_H
  19 #define NETMESSAGE_H
  20
  21 #include "Serialization.h"
  22
  23 // We need the enum from NetMessages.h, but we can't create any classes in
  24 // NetMessages.h, since they in turn require CNetMessage to be defined
  25 #define ALLNETMSGS_DONT_CREATE_NMTS
  26 #include "NetMessages.h"
  27 #undef ALLNETMSGS_DONT_CREATE_NMTS
  28
  29 /**
  30  * The base class for all network messages exchanged within the game.
  31  */
  32 class CNetMessage : public ISerializable
  33 {
  34         friend class CNetSession;
  35
  36 public:
  37
  38         CNetMessage();
  39         CNetMessage(NetMessageType type);
  40         virtual ~CNetMessage();
  41
  42         /**
  43          * Retrieves the message type.
  44          * @return                                              Message type
  45          */
  46         NetMessageType GetType() const { return m_Type; }
  47
  48         /**
  49          * Serialize the message into the specified buffer parameter. The size
  50          * required by the buffer parameter can be found by a call to
  51          * GetSerializedLength method. The information contained within the message
  52          * must be serialized before the message is sent. By default only the
  53          * message type and its size are serialized in the buffer parameter.
  54          *
  55          * @param pBuffer                               Buffer where to serialize the message
  56          * @return                                              The position in the buffer right after the
  57          *                                                              serialized message
  58          */
  59         virtual u8* Serialize(u8* pBuffer) const;
  60
  61         /**
  62          * Deserializes the message from the specified buffer.
  63          *
  64          * @param pStart                                Message start within the serialized buffer
  65          * @param pEnd                                  Message end within the serialized buffer
  66          * @return                                              The position in the buffer right after the
  67          *                                                              message or NULL if an error occurred
  68          */
  69         virtual const u8* Deserialize(const u8* pStart, const u8* pEnd);
  70
  71         /**
  72          * Retrieves the size in bytes of the serialized message. Before calling
  73          * Serialize, the memory size for the buffer where to serialize the message
  74          * object can be found by calling this method.
  75          *
  76          * @return                                                      The size of serialized message
  77          */
  78         virtual size_t GetSerializedLength() const;
  79
  80         /**
  81          * Returns a string representation for the message
  82          *
  83          * @return                                                      The message as a string
  84          */
  85         virtual CStr ToString() const;
  86
  87 private:
  88         NetMessageType  m_Type;                         // Message type
  89 };
  90
  91 /**
  92  * Creates messages from data received through the network.
  93  */
  94 class CNetMessageFactory
  95 {
  96 public:
  97
  98         /**
  99          * Factory method which creates a message object based on the given data
 100          *
 101          * @param pData                                         Data buffer
 102          * @param dataSize                                      Size of data buffer
 103          * @param scriptInterface                       Script instance to use when constructing scripted messages
 104          * @return                                                      The new message created
 105          */
 106         static CNetMessage* CreateMessage(const void* pData, size_t dataSize, const ScriptInterface& scriptInterface);
 107 };
 108
 109 /**
 110  * Special message type for simulation commands.
 111  * These commands are exposed as arbitrary JS objects, associated with a specific player.
 112  */
 113 class CSimulationMessage : public CNetMessage
 114 {
 115 public:
 116         CSimulationMessage(const ScriptInterface& scriptInterface);
 117         CSimulationMessage(const ScriptInterface& scriptInterface, u32 client, i32 player, u32 turn, JS::HandleValue data);
 118
 119         /** The compiler can't create a copy constructor because of the PersistentRooted member,
 120          * so we have to write it manually.
 121          * NOTE: It doesn't clone the m_Data member and the copy will reference the same JS::Value!
 122          */
 123         CSimulationMessage(const CSimulationMessage& orig);
 124
 125         virtual u8* Serialize(u8* pBuffer) const;
 126         virtual const u8* Deserialize(const u8* pStart, const u8* pEnd);
 127         virtual size_t GetSerializedLength() const;
 128         virtual CStr ToString() const;
 129
 130         u32 m_Client;
 131         i32 m_Player;
 132         u32 m_Turn;
 133         JS::PersistentRooted<JS::Value> m_Data;
 134 private:
 135         const ScriptInterface& m_ScriptInterface;
 136 };
 137
 138 /**
 139  * Special message type for updated to game startup settings.
 140  */
 141 class CGameSetupMessage : public CNetMessage
 142 {
 143         NONCOPYABLE(CGameSetupMessage);
 144 public:
 145         CGameSetupMessage(const ScriptInterface& scriptInterface);
 146         CGameSetupMessage(const ScriptInterface& scriptInterface, JS::HandleValue data);
 147         virtual u8* Serialize(u8* pBuffer) const;
 148         virtual const u8* Deserialize(const u8* pStart, const u8* pEnd);
 149         virtual size_t GetSerializedLength() const;
 150         virtual CStr ToString() const;
 151
 152         JS::PersistentRootedValue m_Data;
 153 private:
 154         const ScriptInterface& m_ScriptInterface;
 155 };
 156
 157 // This time, the classes are created
 158 #include "NetMessages.h"
 159
 160 #endif // NETMESSAGE_H