BIG REFACTOR

include/game/World.h

@@ -12,23 +12,30 @@
 
 namespace td {
 namespace game {
-typedef std::pair<std::int16_t, std::int16_t> ChunkCoord;
+
+struct ChunkCoord {
+    std::int16_t x, y;
+
+    friend bool operator==(const td::game::ChunkCoord& first, const td::game::ChunkCoord& other) {
+        return first.x == other.x && first.y == other.y;
+    }
+};
+
+
 }
 }
+
+
 namespace std {
 template <>
 struct hash<td::game::ChunkCoord> {
     std::size_t operator()(const td::game::ChunkCoord& key) const {
-        // Compute individual hash values for first,
-        // second and third and combine them using XOR
-        // and bit shifting:
-        return ((std::hash<std::int16_t>()(key.first) ^ (std::hash<std::int16_t>()(key.second) << 1)) >> 1);
+        return std::hash<std::int16_t>()(key.x) ^ std::hash<std::int16_t>()(key.y);
     }
 };
 }
 
 namespace td {
-
 namespace protocol {
 
 class WorldBeginDataPacket;
@@ -91,12 +98,13 @@ typedef std::vector<std::uint16_t> ChunkPalette;
 
 typedef std::shared_ptr<WalkableTile> WalkableTilePtr;
 
-typedef std::array<std::uint16_t, 32 * 32> ChunkData;
 typedef std::uint32_t TileIndex;
 
 //32 x 32 area
 struct Chunk {
     enum { ChunkWidth = 32, ChunkHeight = 32, ChunkSize = ChunkWidth * ChunkHeight };
+    typedef std::array<std::uint16_t, ChunkSize> ChunkData;
+
     // stores index of tile palette
     ChunkData tiles{ 0 };
     ChunkPalette palette;

include/misc/Compression.h

@@ -6,6 +6,9 @@
 namespace td {
 namespace utils {
 
+std::uint64_t inflate(const std::string& source, std::string& dest);
+std::uint64_t deflate(const std::string& source, std::string& dest);
+
 DataBuffer Compress(const DataBuffer& buffer);
 DataBuffer Decompress(DataBuffer& buffer);
 DataBuffer Decompress(DataBuffer& buffer, std::uint64_t packetLength);

include/misc/DataBuffer.h

@@ -1,5 +1,4 @@
-#ifndef MCLIB_COMMON_DATA_BUFFER_H_
-#define MCLIB_COMMON_DATA_BUFFER_H_
+#pragma once
 
 #include <vector>
 #include <algorithm>
@@ -13,7 +12,7 @@ class DataBuffer {
 private:
     typedef std::vector<std::uint8_t> Data;
     Data m_Buffer;
-    std::size_t m_ReadOffset = 0;
+    std::size_t m_ReadOffset;
 
 public:
     typedef Data::iterator iterator;
@@ -23,7 +22,7 @@ public:
 
     DataBuffer();
     DataBuffer(const DataBuffer& other);
-    DataBuffer(const DataBuffer& other, std::size_t offset);
+    DataBuffer(const DataBuffer& other, Data::difference_type offset);
     DataBuffer(DataBuffer&& other);
     DataBuffer(const std::string& str);
 
@@ -64,7 +63,7 @@ public:
     template <typename T>
     DataBuffer& operator>>(T& data) {
         assert(m_ReadOffset + sizeof(T) <= GetSize());
-        data = *(T*)&m_Buffer[m_ReadOffset];
+        data = *(reinterpret_cast<T*>(&m_Buffer[m_ReadOffset]));
         //std::reverse((std::uint8_t*)&data, (std::uint8_t*)&data + sizeof(T));
         m_ReadOffset += sizeof(T);
         return *this;
@@ -72,42 +71,43 @@ public:
 
     DataBuffer& operator>>(DataBuffer& data) {
         data.Resize(GetSize() - m_ReadOffset);
-        std::copy(m_Buffer.begin() + m_ReadOffset, m_Buffer.end(), data.begin());
+        std::copy(m_Buffer.begin() + static_cast<Data::difference_type>(m_ReadOffset), m_Buffer.end(), data.begin());
         m_ReadOffset = m_Buffer.size();
         return *this;
     }
 
     DataBuffer& operator>>(std::string& str) {
-        std::size_t stringSize = strlen((const char*)m_Buffer.data() + m_ReadOffset) + 1; // including null character
+        std::size_t stringSize = strlen(reinterpret_cast<const char*>(m_Buffer.data()) + m_ReadOffset) + 1; // including null character
         str.resize(stringSize);
-        std::copy(m_Buffer.begin() + m_ReadOffset, m_Buffer.begin() + m_ReadOffset + stringSize, str.begin());
+        std::copy(m_Buffer.begin() + static_cast<Data::difference_type>(m_ReadOffset),
+            m_Buffer.begin() + static_cast<Data::difference_type>(m_ReadOffset + stringSize), str.begin());
         m_ReadOffset += stringSize;
         return *this;
     }
 
     void ReadSome(char* buffer, std::size_t amount) {
         assert(m_ReadOffset + amount <= GetSize());
-        std::copy_n(m_Buffer.begin() + m_ReadOffset, amount, buffer);
+        std::copy_n(m_Buffer.begin() + static_cast<Data::difference_type>(m_ReadOffset), amount, buffer);
         m_ReadOffset += amount;
     }
 
     void ReadSome(std::uint8_t* buffer, std::size_t amount) {
         assert(m_ReadOffset + amount <= GetSize());
-        std::copy_n(m_Buffer.begin() + m_ReadOffset, amount, buffer);
+        std::copy_n(m_Buffer.begin() + static_cast<Data::difference_type>(m_ReadOffset), amount, buffer);
         m_ReadOffset += amount;
     }
 
     void ReadSome(DataBuffer& buffer, std::size_t amount) {
         assert(m_ReadOffset + amount <= GetSize());
         buffer.Resize(amount);
-        std::copy_n(m_Buffer.begin() + m_ReadOffset, amount, buffer.begin());
+        std::copy_n(m_Buffer.begin() + static_cast<Data::difference_type>(m_ReadOffset), amount, buffer.begin());
         m_ReadOffset += amount;
     }
 
     void ReadSome(std::string& buffer, std::size_t amount) {
         assert(m_ReadOffset + amount <= GetSize());
         buffer.resize(amount);
-        std::copy_n(m_Buffer.begin() + m_ReadOffset, amount, buffer.begin());
+        std::copy_n(m_Buffer.begin() + static_cast<Data::difference_type>(m_ReadOffset), amount, buffer.begin());
         m_ReadOffset += amount;
     }
 
@@ -163,5 +163,3 @@ public:
 std::ostream& operator<<(std::ostream& os, const DataBuffer& buffer);
 
 } // ns td
-
-#endif

include/network/TCPSocket.h

@@ -15,7 +15,7 @@ class TCPSocket : public Socket {
 private:
     IPAddress m_RemoteIP;
     uint16_t m_Port;
-    sockaddr_in m_RemoteAddr;
+    sockaddr m_RemoteAddr;
 
 public:
     TCPSocket();

include/network/UDPSocket.h

@@ -20,7 +20,9 @@ public:
 
     bool Connect(const IPAddress& address, std::uint16_t port);
     std::size_t Send(const std::uint8_t* data, std::size_t size);
-    DataBuffer Receive(std::size_t amount);
+
+    virtual DataBuffer Receive(std::size_t amount);
+    virtual std::size_t Receive(DataBuffer& buffer, std::size_t amount);
 };
 
 } // ns network