net_message.h

Go to the documentation of this file.

//       _________ __                 __
//      /   _____//  |_____________ _/  |______     ____  __ __  ______
//      \_____  \\   __\_  __ \__  \\   __\__  \   / ___\|  |  \/  ___/
//      /        \|  |  |  | \// __ \|  |  / __ \_/ /_/  >  |  /\___ |
//     /_______  /|__|  |__|  (____  /__| (____  /\___  /|____//____  >
//             \/                  \/          \//_____/            \/
//  ______________________                           ______________________
//                        T H E   W A R   B E G I N S
//         Stratagus - A free fantasy real time strategy game engine
//
//
//      (c) Copyright 2013 by Joris Dauphin
//
//      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; only version 2 of the License.
//
//      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., 59 Temple Place - Suite 330, Boston, MA
//      02111-1307, USA.
 
#ifndef NET_MESSAGE_H
#define NET_MESSAGE_H
 
 
#include <stdint.h>
#include <vector>
 
#include "settings.h"
 
/*----------------------------------------------------------------------------
--  Declarations
----------------------------------------------------------------------------*/
 
#define NetPlayerNameSize 16
 
#define MaxNetworkCommands 9  
 
 
class CNetworkHost
{
public:
        CNetworkHost() { Clear(); }
        size_t Serialize(unsigned char *buf) const;
        size_t Deserialize(const unsigned char *buf);
        void Clear();
        static size_t Size() { return 4 + 2 + 2 + NetPlayerNameSize; }
 
        void SetName(const char *name);
 
        bool IsValid() { return (PlyNr != 0) || (PlyName[0] != '\0'); }
 
        uint32_t Host;         
        uint16_t Port;         
        uint16_t PlyNr;        
        char PlyName[NetPlayerNameSize];  
};
 
ENUM_CLASS SlotOption : uint8_t {
        Available,
        Computer,
        Closed
};
 
#if USING_TOLUAPP
class ServerSetupStateRacesArray {
public:
        ServerSetupStateRacesArray() : p(nullptr) {}
        int8_t& operator[](int idx) { return p[idx].Race; }
        int8_t& operator[](int idx) const { return p[idx].Race; }
        SettingsPresets *p;
};
#endif
 
class CServerSetup
{
public:
        CServerSetup() { Clear(); }
        size_t Serialize(unsigned char *p) const;
        size_t Deserialize(const unsigned char *p);
        static size_t Size() {
                // This must be kept in sync with GameSettings
                return \
                1 + // DefeatReveal
                1 + // Difficulty
                1 + // FoV
                1 + // GameType
                1 + // NumUnits
                1 + // Opponents
                1 + // Resources
                1 + // RevealMap
                4 + // Bitfield
                4 * PlayerMax + // Races, PlayerColors, Teams, Types
                1 * PlayerMax + // CompOpt
                1 * PlayerMax; // Ready
        }
        void Clear();
 
        bool operator == (const CServerSetup &rhs) const;
        bool operator != (const CServerSetup &rhs) const { return !(*this == rhs); }
public:
        Settings ServerGameSettings;
        SlotOption CompOpt[PlayerMax];    
        uint8_t Ready[PlayerMax];         
        // Fill in here...
 
#if USING_TOLUAPP
        // TODO: can be removed once tolua++ is gone
        inline char get_ResourcesOption() { return (char)ServerGameSettings.Resources; }
        inline char get_UnitsOption() { return (char)ServerGameSettings.NumUnits; }
        inline char get_FogOfWar() { return (char)!ServerGameSettings.NoFogOfWar; }
        inline char get_Inside() { return (char)ServerGameSettings.Inside; }
        inline char get_RevealMap() { return (char)ServerGameSettings.RevealMap; }
        inline char get_GameTypeOption() { return (char)ServerGameSettings.GameType; }
        inline char get_Difficulty() { return (char)ServerGameSettings.Difficulty; }
        inline char get_Opponents() { return (char)ServerGameSettings.Opponents; }
        inline char set_ResourcesOption(char v) { return ServerGameSettings.Resources = v; }
        inline char set_UnitsOption(char v) { return ServerGameSettings.NumUnits = v; }
        inline char set_FogOfWar(char v) { return ServerGameSettings.NoFogOfWar = !v; }
        inline char set_Inside(char v) { return ServerGameSettings.Inside = v; }
        inline char set_RevealMap(char v) { return ServerGameSettings.RevealMap = (MapRevealModes)v; }
        inline char set_GameTypeOption(char v) { return ServerGameSettings.GameType = (GameTypes)v; }
        inline char set_Difficulty(char v) { return ServerGameSettings.Difficulty = v; }
        inline char set_Opponents(char v) { return ServerGameSettings.Opponents = v; }
 
        ServerSetupStateRacesArray racesArray;
        inline ServerSetupStateRacesArray *get_Race() {
                if (racesArray.p == nullptr) {
                        racesArray.p = ((SettingsPresets*)ServerGameSettings.Presets);
                }
                return &racesArray;
        }
#endif
};
 
enum _ic_message_subtype_ {
        ICMHello,               
        ICMConfig,              
 
        ICMEngineMismatch,      
        ICMLuaFilesMismatch,    
        ICMEngineConfMismatch,  
        ICMMapUidMismatch,      
 
        ICMGameFull,            
        ICMWelcome,             
 
        ICMWaiting,             
        ICMMap,                 
        ICMState,               
        ICMResync,              
 
        ICMServerQuit,          
        ICMGoodBye,             
        ICMSeeYou,              
 
        ICMGo,                  
 
        ICMAYT,                 
        ICMIAH,                 
 
        ICMMapNeeded,                   
};
 
class CInitMessage_Header
{
public:
        CInitMessage_Header() {}
        CInitMessage_Header(unsigned char type, unsigned char subtype) :
                type(type),
                subtype(subtype)
        {}
 
        unsigned char GetType() const { return type; }
        unsigned char GetSubType() const { return subtype; }
 
        size_t Serialize(unsigned char *p) const;
        size_t Deserialize(const unsigned char *p);
        static size_t Size() { return 2; }
private:
        unsigned char type;
        unsigned char subtype;
};
 
class CInitMessage_Hello
{
public:
        CInitMessage_Hello() {}
        explicit CInitMessage_Hello(const char *name);
        const CInitMessage_Header &GetHeader() const { return header; }
        const unsigned char *Serialize() const;
        void Deserialize(const unsigned char *p);
        static size_t Size() { return CInitMessage_Header::Size() + NetPlayerNameSize + 2 * 4; }
private:
        CInitMessage_Header header;
public:
        char PlyName[NetPlayerNameSize];  
        int32_t Stratagus;  
        uint32_t Version;   
};
 
class CInitMessage_Config
{
public:
        CInitMessage_Config();
        const CInitMessage_Header &GetHeader() const { return header; }
        const unsigned char *Serialize() const;
        void Deserialize(const unsigned char *p);
        static size_t Size() { return CInitMessage_Header::Size() + 1 + PlayerMax * CNetworkHost::Size(); }
private:
        CInitMessage_Header header;
public:
        uint8_t clientIndex; 
        CNetworkHost hosts[PlayerMax]; 
};
 
class CInitMessage_EngineMismatch
{
public:
        CInitMessage_EngineMismatch();
        const CInitMessage_Header &GetHeader() const { return header; }
        const unsigned char *Serialize() const;
        void Deserialize(const unsigned char *p);
        static size_t Size() { return CInitMessage_Header::Size() + 4; }
private:
        CInitMessage_Header header;
public:
        int32_t Stratagus;  
};
 
class CInitMessage_LuaFilesMismatch
{
public:
        CInitMessage_LuaFilesMismatch();
        const CInitMessage_Header &GetHeader() const { return header; }
        const unsigned char *Serialize() const;
        void Deserialize(const unsigned char *p);
        static size_t Size() { return CInitMessage_Header::Size() + 4; }
private:
        CInitMessage_Header header;
public:
        uint32_t Version;  
};
 
class CInitMessage_Welcome
{
public:
        CInitMessage_Welcome();
        const CInitMessage_Header &GetHeader() const { return header; }
        const unsigned char *Serialize() const;
        void Deserialize(const unsigned char *p);
        static size_t Size() { return CInitMessage_Header::Size() + PlayerMax * CNetworkHost::Size() + 2 + 4 + 4; }
private:
        CInitMessage_Header header;
public:
        CNetworkHost hosts[PlayerMax]; 
        uint16_t NetHostSlot;          
        int32_t Lag;                   
        int32_t gameCyclesPerUpdate;   
};
 
class CInitMessage_Map
{
public:
        CInitMessage_Map() {}
        CInitMessage_Map(const char *path, uint32_t mapUID);
        const CInitMessage_Header &GetHeader() const { return header; }
        const unsigned char *Serialize() const;
        void Deserialize(const unsigned char *p);
        static size_t Size() { return CInitMessage_Header::Size() + 256 + 4; }
private:
        CInitMessage_Header header;
public:
        char MapPath[256];
        uint32_t MapUID;  
};
 
class CInitMessage_MapFileFragment
{
public:
        CInitMessage_MapFileFragment() {}
        CInitMessage_MapFileFragment(const char *path, const char *data, uint32_t dataSize, uint32_t Fragment);
        CInitMessage_MapFileFragment(uint32_t Fragment);
        const CInitMessage_Header &GetHeader() const { return header; }
        const unsigned char *Serialize() const;
        void Deserialize(const unsigned char *p);
        static size_t Size() { return CInitMessage_Header::Size() + 384 + 1 + 2 + 4; }
private:
        CInitMessage_Header header;
public:
        char Data[384]; // path directly followed by data fragment
        uint8_t PathSize;
        uint16_t DataSize;
        uint32_t FragmentIndex;
};
 
class CInitMessage_State
{
public:
        CInitMessage_State() {}
        CInitMessage_State(int type, const CServerSetup &data);
        const CInitMessage_Header &GetHeader() const { return header; }
        const unsigned char *Serialize() const;
        void Deserialize(const unsigned char *p);
        static size_t Size() { return CInitMessage_Header::Size() + CServerSetup::Size(); }
private:
        CInitMessage_Header header;
public:
        CServerSetup State;  
};
 
class CInitMessage_Resync
{
public:
        CInitMessage_Resync();
        const CInitMessage_Header &GetHeader() const { return header; }
        const unsigned char *Serialize() const;
        void Deserialize(const unsigned char *p);
        static size_t Size() { return CInitMessage_Header::Size() + CNetworkHost::Size() * PlayerMax; }
private:
        CInitMessage_Header header;
public:
        CNetworkHost hosts[PlayerMax]; 
};
 
enum _message_type_ {
        MessageNone,                   
        MessageInit_FromClient,        
        MessageInit_FromServer,        
 
        MessageSync,                   
        MessageSelection,              
        MessageQuit,                   
        MessageResend,                 
 
        MessageChat,                   
 
        MessageCommandStop,            
        MessageCommandStand,           
        MessageCommandDefend,          
        MessageCommandFollow,          
        MessageCommandMove,            
        MessageCommandRepair,          
        MessageCommandAutoRepair,      
        MessageCommandAttack,          
        MessageCommandGround,          
        MessageCommandPatrol,          
        MessageCommandBoard,           
        MessageCommandUnload,          
        MessageCommandBuild,           
        MessageCommandExplore,         
        MessageCommandDismiss,         
        MessageCommandResourceLoc,     
        MessageCommandResource,        
        MessageCommandReturn,          
        MessageCommandTrain,           
        MessageCommandCancelTrain,     
        MessageCommandUpgrade,         
        MessageCommandCancelUpgrade,   
        MessageCommandResearch,        
        MessageCommandCancelResearch,  
 
        MessageExtendedCommand,        
 
        // ATTN: __MUST__ be last due to spellid encoding!!!
        MessageCommandSpellCast        
};
 
enum _extended_message_type_ {
        ExtendedMessageDiplomacy,                       
        ExtendedMessageSharedVision,            
        ExtendedMessageAutoTargetingDB,         
        ExtendedMessageFieldOfViewDB,           
        ExtendedMessageMapFieldsOpacityDB,      
        ExtendedMessageRevealMapDB,                     
        ExtendedMessageFogOfWarDB                       
};
 
class CNetworkCommand
{
public:
        CNetworkCommand() : Unit(0), X(0), Y(0), Dest(0) {}
        void Clear() { this->Unit = this->X = this->Y = this->Dest = 0; }
 
        size_t Serialize(unsigned char *buf) const;
        size_t Deserialize(const unsigned char *buf);
        static size_t Size() { return 2 + 2 + 2 + 2; }
 
public:
        uint16_t Unit;         
        uint16_t X;            
        uint16_t Y;            
        uint16_t Dest;         
};
 
class CNetworkExtendedCommand
{
public:
        CNetworkExtendedCommand() : ExtendedType(0), Arg1(0), Arg2(0), Arg3(0), Arg4(0) {}
 
        size_t Serialize(unsigned char *buf) const;
        size_t Deserialize(const unsigned char *buf);
        static size_t Size() { return 1 + 1 + 2 + 2 + 2; }
 
        uint8_t  ExtendedType;  
        uint8_t  Arg1;          
        uint16_t Arg2;          
        uint16_t Arg3;          
        uint16_t Arg4;          
};
 
class CNetworkChat
{
public:
        size_t Serialize(unsigned char *buf) const;
        size_t Deserialize(const unsigned char *buf);
        size_t Size() const;
 
public:
        std::string Text;  
};
 
class CNetworkCommandSync
{
public:
        CNetworkCommandSync() : syncSeed(0), syncHash(0) {}
        size_t Serialize(unsigned char *buf) const;
        size_t Deserialize(const unsigned char *buf);
        static size_t Size() { return 4 + 4; };
 
public:
        uint32_t syncSeed;
        uint32_t syncHash;
};
 
class CNetworkCommandQuit
{
public:
        CNetworkCommandQuit() : player(0) {}
        size_t Serialize(unsigned char *buf) const;
        size_t Deserialize(const unsigned char *buf);
        static size_t Size() { return 2; };
 
public:
        uint16_t player;
};
 
class CNetworkSelection
{
public:
        CNetworkSelection() : player(0) {}
 
        size_t Serialize(unsigned char *buf) const;
        size_t Deserialize(const unsigned char *buf);
        size_t Size() const;
 
public:
        uint16_t player;
        std::vector<uint16_t> Units;  
};
 
class CNetworkPacketHeader
{
public:
        CNetworkPacketHeader()
        {
                Cycle = 0;
                memset(Type, 0, sizeof(Type));
                OrigPlayer = 255;
        }
 
        size_t Serialize(unsigned char *buf) const;
        size_t Deserialize(const unsigned char *buf);
        static size_t Size() { return 1 + 1 + 1 * MaxNetworkCommands; }
 
        uint8_t Type[MaxNetworkCommands];  
        uint8_t Cycle;                     
        uint8_t OrigPlayer;                
};
 
class CNetworkPacket
{
public:
        size_t Serialize(unsigned char *buf, int numcommands) const;
        void Deserialize(const unsigned char *buf, unsigned int len, int *numcommands);
        size_t Size(int numcommands) const;
 
        CNetworkPacketHeader Header;  
        std::vector<unsigned char> Command[MaxNetworkCommands];
};
 
 
#endif // !NET_MESSAGE_H