Externals: Update SFML to 2.5.0

Among other things, this finally allows pushing 64-bit values into
packets without needing to manually subdivide the value into two 32-bit
values.

Externals/SFML/build/vc2010/SFML_Network.vcxproj

@@ -72,6 +72,7 @@
     <ClInclude Include="..\..\include\SFML\System\Export.hpp" />
     <ClInclude Include="..\..\include\SFML\System\NonCopyable.hpp" />
     <ClInclude Include="..\..\include\SFML\System\String.hpp" />
+    <ClInclude Include="..\..\include\SFML\System\String.inl" />
     <ClInclude Include="..\..\include\SFML\System\Time.hpp" />
     <ClInclude Include="..\..\include\SFML\System\Utf.hpp" />
     <ClInclude Include="..\..\include\SFML\System\Utf.inl" />

Externals/SFML/build/vc2010/SFML_Network.vcxproj.filters

@@ -34,6 +34,7 @@
     <ClInclude Include="..\..\include\SFML\System\Export.hpp" />
     <ClInclude Include="..\..\include\SFML\System\NonCopyable.hpp" />
     <ClInclude Include="..\..\include\SFML\System\String.hpp" />
+    <ClInclude Include="..\..\include\SFML\System\String.inl" />
     <ClInclude Include="..\..\include\SFML\System\Time.hpp" />
     <ClInclude Include="..\..\include\SFML\System\Utf.hpp" />
     <ClInclude Include="..\..\include\SFML\System\Utf.inl" />

Externals/SFML/include/SFML/Config.hpp

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -30,13 +30,15 @@
 // Define the SFML version
 ////////////////////////////////////////////////////////////
 #define SFML_VERSION_MAJOR 2
-#define SFML_VERSION_MINOR 1
+#define SFML_VERSION_MINOR 5
+#define SFML_VERSION_PATCH 0
 
 
 ////////////////////////////////////////////////////////////
 // Identify the operating system
+// see http://nadeausoftware.com/articles/2012/01/c_c_tip_how_use_compiler_predefined_macros_detect_operating_system
 ////////////////////////////////////////////////////////////
-#if defined(_WIN32) || defined(__WIN32__)
+#if defined(_WIN32)
 
     // Windows
     #define SFML_SYSTEM_WINDOWS
@@ -44,21 +46,58 @@
         #define NOMINMAX
     #endif
 
-#elif defined(linux) || defined(__linux)
+#elif defined(__APPLE__) && defined(__MACH__)
 
-    // Linux
+    // Apple platform, see which one it is
-    #define SFML_SYSTEM_LINUX
+    #include "TargetConditionals.h"
 
-#elif defined(__APPLE__) || defined(MACOSX) || defined(macintosh) || defined(Macintosh)
+    #if TARGET_OS_IPHONE || TARGET_IPHONE_SIMULATOR
+
+        // iOS
+        #define SFML_SYSTEM_IOS
+
+    #elif TARGET_OS_MAC
 
         // MacOS
         #define SFML_SYSTEM_MACOS
 
-#elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
+    #else
+
+        // Unsupported Apple system
+        #error This Apple operating system is not supported by SFML library
+
+    #endif
+
+#elif defined(__unix__)
+
+    // UNIX system, see which one it is
+    #if defined(__ANDROID__)
+
+        // Android
+        #define SFML_SYSTEM_ANDROID
+
+    #elif defined(__linux__)
+
+         // Linux
+        #define SFML_SYSTEM_LINUX
+
+    #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
 
         // FreeBSD
         #define SFML_SYSTEM_FREEBSD
 
+    #elif defined(__OpenBSD__)
+
+        // OpenBSD
+        #define SFML_SYSTEM_OPENBSD
+
+    #else
+
+        // Unsupported UNIX system
+        #error This UNIX operating system is not supported by SFML library
+
+    #endif
+
 #else
 
     // Unsupported system
@@ -91,7 +130,7 @@
         // For Visual C++ compilers, we also need to turn off this annoying C4251 warning
         #ifdef _MSC_VER
 
-            #pragma warning(disable : 4251)
+            #pragma warning(disable: 4251)
 
         #endif
 
@@ -123,6 +162,44 @@
 #endif
 
 
+////////////////////////////////////////////////////////////
+// Cross-platform warning for deprecated functions and classes
+//
+// Usage:
+// class SFML_DEPRECATED MyClass
+// {
+//     SFML_DEPRECATED void memberFunc();
+// };
+//
+// SFML_DEPRECATED void globalFunc();
+////////////////////////////////////////////////////////////
+#if defined(SFML_NO_DEPRECATED_WARNINGS)
+
+    // User explicitly requests to disable deprecation warnings
+    #define SFML_DEPRECATED
+
+#elif defined(_MSC_VER)
+
+    // Microsoft C++ compiler
+    // Note: On newer MSVC versions, using deprecated functions causes a compiler error. In order to
+    // trigger a warning instead of an error, the compiler flag /sdl- (instead of /sdl) must be specified.
+    #define SFML_DEPRECATED __declspec(deprecated)
+
+#elif defined(__GNUC__)
+
+    // g++ and Clang
+    #define SFML_DEPRECATED __attribute__ ((deprecated))
+
+#else
+
+    // Other compilers are not supported, leave class or function as-is.
+    // With a bit of luck, the #pragma directive works, otherwise users get a warning (no error!) for unrecognized #pragma.
+    #pragma message("SFML_DEPRECATED is not supported for your compiler, please contact the SFML team")
+    #define SFML_DEPRECATED
+
+#endif
+
+
 ////////////////////////////////////////////////////////////
 // Define portable fixed-size types
 ////////////////////////////////////////////////////////////

Externals/SFML/include/SFML/Network.hpp

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -36,6 +36,8 @@
 // This file is "IpAddress.hpp" upstream
 #include <SFML/Network/IPAddress.hpp>
 #include <SFML/Network/Packet.hpp>
+#include <SFML/Network/Socket.hpp>
+#include <SFML/Network/SocketHandle.hpp>
 #include <SFML/Network/SocketSelector.hpp>
 #include <SFML/Network/TcpListener.hpp>
 #include <SFML/Network/TcpSocket.hpp>

Externals/SFML/include/SFML/Network/Export.hpp

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.

Externals/SFML/include/SFML/Network/Http.hpp

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -45,7 +45,7 @@ namespace sf
 ////////////////////////////////////////////////////////////
 class SFML_NETWORK_API Http : NonCopyable
 {
-public :
+public:
 
     ////////////////////////////////////////////////////////////
     /// \brief Define a HTTP request
@@ -53,7 +53,7 @@ public :
     ////////////////////////////////////////////////////////////
     class SFML_NETWORK_API Request
     {
-    public :
+    public:
 
         ////////////////////////////////////////////////////////////
         /// \brief Enumerate the available HTTP methods for a request
@@ -63,7 +63,9 @@ public :
         {
             Get,   ///< Request in get mode, standard method to retrieve a page
             Post,  ///< Request in post mode, usually to send data to a page
-            Head  ///< Request a page's header only
+            Head,  ///< Request a page's header only
+            Put,   ///< Request in put mode, useful for a REST API
+            Delete ///< Request in delete mode, useful for a REST API
         };
 
         ////////////////////////////////////////////////////////////
@@ -83,7 +85,7 @@ public :
         /// \brief Set the value of a field
         ///
         /// The field is created if it doesn't exist. The name of
-        /// the field is case insensitive.
+        /// the field is case-insensitive.
         /// By default, a request doesn't contain any field (but the
         /// mandatory fields are added later by the HTTP client when
         /// sending the request).
@@ -141,7 +143,7 @@ public :
         ////////////////////////////////////////////////////////////
         void setBody(const std::string& body);
 
-    private :
+    private:
 
         friend class Http;
 
@@ -190,7 +192,7 @@ public :
     ////////////////////////////////////////////////////////////
     class SFML_NETWORK_API Response
     {
-    public :
+    public:
 
         ////////////////////////////////////////////////////////////
         /// \brief Enumerate all the valid status codes for a response
@@ -210,12 +212,12 @@ public :
             MultipleChoices  = 300, ///< The requested page can be accessed from several locations
             MovedPermanently = 301, ///< The requested page has permanently moved to a new location
             MovedTemporarily = 302, ///< The requested page has temporarily moved to a new location
-            NotModified      = 304, ///< For conditionnal requests, means the requested page hasn't changed and doesn't need to be refreshed
+            NotModified      = 304, ///< For conditional requests, means the requested page hasn't changed and doesn't need to be refreshed
 
             // 4xx: client error
             BadRequest          = 400, ///< The server couldn't understand the request (syntax error)
-            Unauthorized        = 401, ///< The requested page needs an authentification to be accessed
+            Unauthorized        = 401, ///< The requested page needs an authentication to be accessed
-            Forbidden           = 403, ///< The requested page cannot be accessed at all, even with authentification
+            Forbidden           = 403, ///< The requested page cannot be accessed at all, even with authentication
             NotFound            = 404, ///< The requested page doesn't exist
             RangeNotSatisfiable = 407, ///< The server can't satisfy the partial GET request (with a "Range" header field)
 
@@ -301,7 +303,7 @@ public :
         ////////////////////////////////////////////////////////////
         const std::string& getBody() const;
 
-    private :
+    private:
 
         friend class Http;
 
@@ -316,6 +318,18 @@ public :
         ////////////////////////////////////////////////////////////
         void parse(const std::string& data);
 
+
+        ////////////////////////////////////////////////////////////
+        /// \brief Read values passed in the answer header
+        ///
+        /// This function is used by Http to extract values passed
+        /// in the response.
+        ///
+        /// \param in String stream containing the header values
+        ///
+        ////////////////////////////////////////////////////////////
+        void parseFields(std::istream &in);
+
         ////////////////////////////////////////////////////////////
         // Types
         ////////////////////////////////////////////////////////////
@@ -343,9 +357,9 @@ public :
     /// This is equivalent to calling setHost(host, port).
     /// The port has a default value of 0, which means that the
     /// HTTP client will use the right port according to the
-    /// protocol used (80 for HTTP, 443 for HTTPS). You should
+    /// protocol used (80 for HTTP). You should leave it like
-    /// leave it like this unless you really need a port other
+    /// this unless you really need a port other than the
-    /// than the standard one, or use an unknown protocol.
+    /// standard one, or use an unknown protocol.
     ///
     /// \param host Web server to connect to
     /// \param port Port to use for connection
@@ -360,9 +374,9 @@ public :
     /// doesn't actually connect to it until you send a request.
     /// The port has a default value of 0, which means that the
     /// HTTP client will use the right port according to the
-    /// protocol used (80 for HTTP, 443 for HTTPS). You should
+    /// protocol used (80 for HTTP). You should leave it like
-    /// leave it like this unless you really need a port other
+    /// this unless you really need a port other than the
-    /// than the standard one, or use an unknown protocol.
+    /// standard one, or use an unknown protocol.
     ///
     /// \param host Web server to connect to
     /// \param port Port to use for connection
@@ -379,7 +393,7 @@ public :
     /// Warning: this function waits for the server's response and may
     /// not return instantly; use a thread if you don't want to block your
     /// application, or use a timeout to limit the time to wait. A value
-    /// of Time::Zero means that the client will use the system defaut timeout
+    /// of Time::Zero means that the client will use the system default timeout
     /// (which is usually pretty long).
     ///
     /// \param request Request to send
@@ -390,7 +404,7 @@ public :
     ////////////////////////////////////////////////////////////
     Response sendRequest(const Request& request, Time timeout = Time::Zero);
 
-private :
+private:
 
     ////////////////////////////////////////////////////////////
     // Member data
@@ -414,7 +428,8 @@ private :
 /// sf::Http is a very simple HTTP client that allows you
 /// to communicate with a web server. You can retrieve
 /// web pages, send data to an interactive resource,
-/// download a remote file, etc.
+/// download a remote file, etc. The HTTPS protocol is
+/// not supported.
 ///
 /// The HTTP client is split into 3 classes:
 /// \li sf::Http::Request

Externals/SFML/include/SFML/Network/IPAddress.hpp

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -43,7 +43,7 @@ namespace sf
 ////////////////////////////////////////////////////////////
 class SFML_NETWORK_API IpAddress
 {
-public :
+public:
 
     ////////////////////////////////////////////////////////////
     /// \brief Default constructor
@@ -99,7 +99,7 @@ public :
     /// This constructor uses the internal representation of
     /// the address directly. It should be used for optimization
     /// purposes, and only if you got that representation from
-    /// IpAddress::ToInteger().
+    /// IpAddress::toInteger().
     ///
     /// \param address 4 bytes of the address packed into a 32-bits integer
     ///
@@ -182,15 +182,27 @@ public :
     // Static member data
     ////////////////////////////////////////////////////////////
     static const IpAddress None;      ///< Value representing an empty/invalid address
+    static const IpAddress Any;       ///< Value representing any address (0.0.0.0)
     static const IpAddress LocalHost; ///< The "localhost" address (for connecting a computer to itself locally)
     static const IpAddress Broadcast; ///< The "broadcast" address (for sending UDP messages to everyone on a local network)
 
-private :
+private:
+
+    friend SFML_NETWORK_API bool operator <(const IpAddress& left, const IpAddress& right);
+
+    ////////////////////////////////////////////////////////////
+    /// \brief Resolve the given address string
+    ///
+    /// \param address Address string
+    ///
+    ////////////////////////////////////////////////////////////
+    void resolve(const std::string& address);
 
     ////////////////////////////////////////////////////////////
     // Member data
     ////////////////////////////////////////////////////////////
     Uint32 m_address; ///< Address stored as an unsigned 32 bits integer
+    bool   m_valid;   ///< Is the address valid?
 };
 
 ////////////////////////////////////////////////////////////

Externals/SFML/include/SFML/Network/Packet.hpp

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -49,7 +49,7 @@ class SFML_NETWORK_API Packet
     // A bool-like type that cannot be converted to integer or pointer types
     typedef bool (Packet::*BoolType)(std::size_t);
 
-public :
+public:
 
     ////////////////////////////////////////////////////////////
     /// \brief Default constructor
@@ -139,7 +139,7 @@ public:
     /// A packet will be in an invalid state if it has no more
     /// data to read.
     ///
-    /// This behaviour is the same as standard C++ streams.
+    /// This behavior is the same as standard C++ streams.
     ///
     /// Usage example:
     /// \code
@@ -171,41 +171,165 @@ public:
     operator BoolType() const;
 
     ////////////////////////////////////////////////////////////
-    /// Overloads of operator >> to read data from the packet
+    /// Overload of operator >> to read data from the packet
     ///
     ////////////////////////////////////////////////////////////
     Packet& operator >>(bool&         data);
+
+    ////////////////////////////////////////////////////////////
+    /// \overload
+    ////////////////////////////////////////////////////////////
     Packet& operator >>(Int8&         data);
+
+    ////////////////////////////////////////////////////////////
+    /// \overload
+    ////////////////////////////////////////////////////////////
     Packet& operator >>(Uint8&        data);
+
+    ////////////////////////////////////////////////////////////
+    /// \overload
+    ////////////////////////////////////////////////////////////
     Packet& operator >>(Int16&        data);
+
+    ////////////////////////////////////////////////////////////
+    /// \overload
+    ////////////////////////////////////////////////////////////
     Packet& operator >>(Uint16&       data);
+
+    ////////////////////////////////////////////////////////////
+    /// \overload
+    ////////////////////////////////////////////////////////////
     Packet& operator >>(Int32&        data);
+
+    ////////////////////////////////////////////////////////////
+    /// \overload
+    ////////////////////////////////////////////////////////////
     Packet& operator >>(Uint32&       data);
+
+    ////////////////////////////////////////////////////////////
+    /// \overload
+    ////////////////////////////////////////////////////////////
+    Packet& operator >>(Int64&        data);
+
+    ////////////////////////////////////////////////////////////
+    /// \overload
+    ////////////////////////////////////////////////////////////
+    Packet& operator >>(Uint64&       data);
+
+    ////////////////////////////////////////////////////////////
+    /// \overload
+    ////////////////////////////////////////////////////////////
     Packet& operator >>(float&        data);
+
+    ////////////////////////////////////////////////////////////
+    /// \overload
+    ////////////////////////////////////////////////////////////
     Packet& operator >>(double&       data);
+
+    ////////////////////////////////////////////////////////////
+    /// \overload
+    ////////////////////////////////////////////////////////////
     Packet& operator >>(char*         data);
+
+    ////////////////////////////////////////////////////////////
+    /// \overload
+    ////////////////////////////////////////////////////////////
     Packet& operator >>(std::string&  data);
+
+    ////////////////////////////////////////////////////////////
+    /// \overload
+    ////////////////////////////////////////////////////////////
     Packet& operator >>(wchar_t*      data);
+
+    ////////////////////////////////////////////////////////////
+    /// \overload
+    ////////////////////////////////////////////////////////////
     Packet& operator >>(std::wstring& data);
+
+    ////////////////////////////////////////////////////////////
+    /// \overload
+    ////////////////////////////////////////////////////////////
     Packet& operator >>(String&       data);
 
     ////////////////////////////////////////////////////////////
-    /// Overloads of operator << to write data into the packet
+    /// Overload of operator << to write data into the packet
     ///
     ////////////////////////////////////////////////////////////
     Packet& operator <<(bool                data);
+
+    ////////////////////////////////////////////////////////////
+    /// \overload
+    ////////////////////////////////////////////////////////////
     Packet& operator <<(Int8                data);
+
+    ////////////////////////////////////////////////////////////
+    /// \overload
+    ////////////////////////////////////////////////////////////
     Packet& operator <<(Uint8               data);
+
+    ////////////////////////////////////////////////////////////
+    /// \overload
+    ////////////////////////////////////////////////////////////
     Packet& operator <<(Int16               data);
+
+    ////////////////////////////////////////////////////////////
+    /// \overload
+    ////////////////////////////////////////////////////////////
     Packet& operator <<(Uint16              data);
+
+    ////////////////////////////////////////////////////////////
+    /// \overload
+    ////////////////////////////////////////////////////////////
     Packet& operator <<(Int32               data);
+
+    ////////////////////////////////////////////////////////////
+    /// \overload
+    ////////////////////////////////////////////////////////////
     Packet& operator <<(Uint32              data);
+
+    ////////////////////////////////////////////////////////////
+    /// \overload
+    ////////////////////////////////////////////////////////////
+    Packet& operator <<(Int64               data);
+
+    ////////////////////////////////////////////////////////////
+    /// \overload
+    ////////////////////////////////////////////////////////////
+    Packet& operator <<(Uint64              data);
+
+    ////////////////////////////////////////////////////////////
+    /// \overload
+    ////////////////////////////////////////////////////////////
     Packet& operator <<(float               data);
+
+    ////////////////////////////////////////////////////////////
+    /// \overload
+    ////////////////////////////////////////////////////////////
     Packet& operator <<(double              data);
+
+    ////////////////////////////////////////////////////////////
+    /// \overload
+    ////////////////////////////////////////////////////////////
     Packet& operator <<(const char*         data);
+
+    ////////////////////////////////////////////////////////////
+    /// \overload
+    ////////////////////////////////////////////////////////////
     Packet& operator <<(const std::string&  data);
+
+    ////////////////////////////////////////////////////////////
+    /// \overload
+    ////////////////////////////////////////////////////////////
     Packet& operator <<(const wchar_t*      data);
+
+    ////////////////////////////////////////////////////////////
+    /// \overload
+    ////////////////////////////////////////////////////////////
     Packet& operator <<(const std::wstring& data);
+
+    ////////////////////////////////////////////////////////////
+    /// \overload
+    ////////////////////////////////////////////////////////////
     Packet& operator <<(const String&       data);
 
 protected:
@@ -238,7 +362,7 @@ protected:
     ///
     /// This function can be defined by derived classes to
     /// transform the data after it is received; this can be
-    /// used for uncompression, decryption, etc.
+    /// used for decompression, decryption, etc.
     /// The function receives a pointer to the received data,
     /// and must fill the packet with the transformed bytes.
     /// The default implementation fills the packet directly
@@ -252,7 +376,7 @@ protected:
     ////////////////////////////////////////////////////////////
     virtual void onReceive(const void* data, std::size_t size);
 
-private :
+private:
 
     ////////////////////////////////////////////////////////////
     /// Disallow comparisons between packets
@@ -278,6 +402,7 @@ private :
     ////////////////////////////////////////////////////////////
     std::vector<char> m_data;    ///< Data stored in the packet
     std::size_t       m_readPos; ///< Current reading position in the packet
+    std::size_t       m_sendPos; ///< Current send position in the packet (for handling partial sends)
     bool              m_isValid; ///< Reading state of the packet
 };
 
@@ -296,12 +421,12 @@ private :
 /// (sf::TcpSocket, sf::UdpSocket).
 ///
 /// Packets solve 2 fundamental problems that arise when
-/// transfering data over the network:
+/// transferring data over the network:
 /// \li data is interpreted correctly according to the endianness
 /// \li the bounds of the packet are preserved (one send == one receive)
 ///
 /// The sf::Packet class provides both input and output modes.
-/// It is designed to follow the behaviour of standard C++ streams,
+/// It is designed to follow the behavior of standard C++ streams,
 /// using operators >> and << to extract and insert data.
 ///
 /// It is recommended to use only fixed-size types (like sf::Int32, etc.),

Externals/SFML/include/SFML/Network/Socket.hpp

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -44,7 +44,7 @@ class SocketSelector;
 ////////////////////////////////////////////////////////////
 class SFML_NETWORK_API Socket : NonCopyable
 {
-public :
+public:
 
     ////////////////////////////////////////////////////////////
     /// \brief Status codes that may be returned by socket functions
@@ -54,6 +54,7 @@ public :
     {
         Done,         ///< The socket has sent / received the data
         NotReady,     ///< The socket is not ready to send / receive data yet
+        Partial,      ///< The socket sent a part of the data
         Disconnected, ///< The TCP socket has been disconnected
         Error         ///< An unexpected error happened
     };
@@ -67,7 +68,7 @@ public :
         AnyPort = 0 ///< Special value that tells the system to pick any available port
     };
 
-public :
+public:
 
     ////////////////////////////////////////////////////////////
     /// \brief Destructor
@@ -104,7 +105,7 @@ public :
     ////////////////////////////////////////////////////////////
     bool isBlocking() const;
 
-protected :
+protected:
 
     ////////////////////////////////////////////////////////////
     /// \brief Types of protocols that the socket can use
@@ -165,7 +166,7 @@ protected :
     ////////////////////////////////////////////////////////////
     void close();
 
-private :
+private:
 
     friend class SocketSelector;
 

Externals/SFML/include/SFML/Network/SocketHandle.hpp

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.

Externals/SFML/include/SFML/Network/SocketSelector.hpp

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -42,7 +42,7 @@ class Socket;
 ////////////////////////////////////////////////////////////
 class SFML_NETWORK_API SocketSelector
 {
-public :
+public:
 
     ////////////////////////////////////////////////////////////
     /// \brief Default constructor
@@ -151,7 +151,7 @@ public :
     ////////////////////////////////////////////////////////////
     SocketSelector& operator =(const SocketSelector& right);
 
-private :
+private:
 
     struct SocketSelectorImpl;
 
@@ -188,7 +188,7 @@ private :
 /// (socket classes are not copyable anyway), it simply keeps
 /// a reference to the original sockets that you pass to the
 /// "add" function. Therefore, you can't use the selector as a
-/// socket container, you must store them oustide and make sure
+/// socket container, you must store them outside and make sure
 /// that they are alive as long as they are used in the selector.
 ///
 /// Using a selector is simple:

Externals/SFML/include/SFML/Network/TcpListener.hpp

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -30,6 +30,7 @@
 ////////////////////////////////////////////////////////////
 #include <SFML/Network/Export.hpp>
 #include <SFML/Network/Socket.hpp>
+#include <SFML/Network/IPAddress.hpp>
 
 
 namespace sf
@@ -42,7 +43,7 @@ class TcpSocket;
 ////////////////////////////////////////////////////////////
 class SFML_NETWORK_API TcpListener : public Socket
 {
-public :
+public:
 
     ////////////////////////////////////////////////////////////
     /// \brief Default constructor
@@ -64,21 +65,24 @@ public :
     unsigned short getLocalPort() const;
 
     ////////////////////////////////////////////////////////////
-    /// \brief Start listening for connections
+    /// \brief Start listening for incoming connection attempts
     ///
-    /// This functions makes the socket listen to the specified
+    /// This function makes the socket start listening on the
-    /// port, waiting for new connections.
+    /// specified port, waiting for incoming connection attempts.
-    /// If the socket was previously listening to another port,
-    /// it will be stopped first and bound to the new port.
     ///
-    /// \param port Port to listen for new connections
+    /// If the socket is already listening on a port when this
+    /// function is called, it will stop listening on the old
+    /// port before starting to listen on the new port.
+    ///
+    /// \param port    Port to listen on for incoming connection attempts
+    /// \param address Address of the interface to listen on
     ///
     /// \return Status code
     ///
     /// \see accept, close
     ///
     ////////////////////////////////////////////////////////////
-    Status listen(unsigned short port);
+    Status listen(unsigned short port, const IpAddress& address = IpAddress::Any);
 
     ////////////////////////////////////////////////////////////
     /// \brief Stop listening and close the socket

Externals/SFML/include/SFML/Network/TcpSocket.hpp

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -45,7 +45,7 @@ class Packet;
 ////////////////////////////////////////////////////////////
 class SFML_NETWORK_API TcpSocket : public Socket
 {
-public :
+public:
 
     ////////////////////////////////////////////////////////////
     /// \brief Default constructor
@@ -97,7 +97,8 @@ public :
     /// In blocking mode, this function may take a while, especially
     /// if the remote peer is not reachable. The last parameter allows
     /// you to stop trying to connect after a given timeout.
-    /// If the socket was previously connected, it is first disconnected.
+    /// If the socket is already connected, the connection is
+    /// forcibly disconnected before attempting to connect again.
     ///
     /// \param remoteAddress Address of the remote peer
     /// \param remotePort    Port of the remote peer
@@ -124,6 +125,9 @@ public :
     ////////////////////////////////////////////////////////////
     /// \brief Send raw data to the remote peer
     ///
+    /// To be able to handle partial sends over non-blocking
+    /// sockets, use the send(const void*, std::size_t, std::size_t&)
+    /// overload instead.
     /// This function will fail if the socket is not connected.
     ///
     /// \param data Pointer to the sequence of bytes to send
@@ -136,6 +140,22 @@ public :
     ////////////////////////////////////////////////////////////
     Status send(const void* data, std::size_t size);
 
+    ////////////////////////////////////////////////////////////
+    /// \brief Send raw data to the remote peer
+    ///
+    /// This function will fail if the socket is not connected.
+    ///
+    /// \param data Pointer to the sequence of bytes to send
+    /// \param size Number of bytes to send
+    /// \param sent The number of bytes sent will be written here
+    ///
+    /// \return Status code
+    ///
+    /// \see receive
+    ///
+    ////////////////////////////////////////////////////////////
+    Status send(const void* data, std::size_t size, std::size_t& sent);
+
     ////////////////////////////////////////////////////////////
     /// \brief Receive raw data from the remote peer
     ///
@@ -157,6 +177,10 @@ public :
     ////////////////////////////////////////////////////////////
     /// \brief Send a formatted packet of data to the remote peer
     ///
+    /// In non-blocking mode, if this function returns sf::Socket::Partial,
+    /// you \em must retry sending the same unmodified packet before sending
+    /// anything else in order to guarantee the packet arrives at the remote
+    /// peer uncorrupted.
     /// This function will fail if the socket is not connected.
     ///
     /// \param packet Packet to send
@@ -244,7 +268,7 @@ private:
 /// class to get more details about how they work.
 ///
 /// The socket is automatically disconnected when it is destroyed,
-/// but if you want to explicitely close the connection while
+/// but if you want to explicitly close the connection while
 /// the socket instance is still alive, you can call disconnect.
 ///
 /// Usage example:

Externals/SFML/include/SFML/Network/UdpSocket.hpp

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -30,12 +30,12 @@
 ////////////////////////////////////////////////////////////
 #include <SFML/Network/Export.hpp>
 #include <SFML/Network/Socket.hpp>
+#include <SFML/Network/IPAddress.hpp>
 #include <vector>
 
 
 namespace sf
 {
-class IpAddress;
 class Packet;
 
 ////////////////////////////////////////////////////////////
@@ -44,7 +44,7 @@ class Packet;
 ////////////////////////////////////////////////////////////
 class SFML_NETWORK_API UdpSocket : public Socket
 {
-public :
+public:
 
     ////////////////////////////////////////////////////////////
     // Constants
@@ -82,21 +82,29 @@ public :
     /// system to automatically pick an available port, and then
     /// call getLocalPort to retrieve the chosen port.
     ///
+    /// Since the socket can only be bound to a single port at
+    /// any given moment, if it is already bound when this
+    /// function is called, it will be unbound from the previous
+    /// port before being bound to the new one.
+    ///
     /// \param port    Port to bind the socket to
+    /// \param address Address of the interface to bind to
     ///
     /// \return Status code
     ///
     /// \see unbind, getLocalPort
     ///
     ////////////////////////////////////////////////////////////
-    Status bind(unsigned short port);
+    Status bind(unsigned short port, const IpAddress& address = IpAddress::Any);
 
     ////////////////////////////////////////////////////////////
     /// \brief Unbind the socket from the local port to which it is bound
     ///
-    /// The port that the socket was previously using is immediately
+    /// The port that the socket was previously bound to is immediately
-    /// available after this function is called. If the
+    /// made available to the operating system after this function is called.
-    /// socket is not bound to a port, this function has no effect.
+    /// This means that a subsequent call to bind() will be able to re-bind
+    /// the port if no other process has done so in the mean time.
+    /// If the socket is not bound to a port, this function has no effect.
     ///
     /// \see bind
     ///
@@ -235,7 +243,7 @@ private:
 ///
 /// If the socket is bound to a port, it is automatically
 /// unbound from it when the socket is destroyed. However,
-/// you can unbind the socket explicitely with the Unbind
+/// you can unbind the socket explicitly with the Unbind
 /// function if necessary, to stop receiving messages or
 /// make the port available for other sockets.
 ///

Externals/SFML/include/SFML/System.hpp

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -36,10 +36,12 @@
 //#include <SFML/System/Lock.hpp>
 //#include <SFML/System/Mutex.hpp>
 //#include <SFML/System/Sleep.hpp>
+#include <SFML/System/NonCopyable.hpp>
 #include <SFML/System/String.hpp>
 //#include <SFML/System/Thread.hpp>
 //#include <SFML/System/ThreadLocal.hpp>
 //#include <SFML/System/ThreadLocalPtr.hpp>
+#include <SFML/System/Time.hpp>
 #include <SFML/System/Utf.hpp>
 //#include <SFML/System/Vector2.hpp>
 //#include <SFML/System/Vector3.hpp>
@@ -50,7 +52,7 @@
 /// \defgroup system System module
 ///
 /// Base module of SFML, defining various utilities. It provides
-/// vector classes, unicode strings and conversion functions,
+/// vector classes, Unicode strings and conversion functions,
 /// threads and mutexes, timing classes.
 ///
 ////////////////////////////////////////////////////////////

Externals/SFML/include/SFML/System/Err.hpp

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -58,7 +58,7 @@ SFML_SYSTEM_API std::ostream& err();
 /// insertion operations defined by the STL
 /// (operator <<, manipulators, etc.).
 ///
-/// sf::err() can be redirected to write to another output, independantly
+/// sf::err() can be redirected to write to another output, independently
 /// of std::cerr, by using the rdbuf() function provided by the
 /// std::ostream class.
 ///
@@ -75,4 +75,6 @@ SFML_SYSTEM_API std::ostream& err();
 /// sf::err().rdbuf(previous);
 /// \endcode
 ///
+/// \return Reference to std::ostream representing the SFML error stream
+///
 ////////////////////////////////////////////////////////////

Externals/SFML/include/SFML/System/Export.hpp

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.

Externals/SFML/include/SFML/System/NonCopyable.hpp

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -40,19 +40,29 @@ namespace sf
 ////////////////////////////////////////////////////////////
 class SFML_SYSTEM_API NonCopyable
 {
-protected :
+protected:
 
     ////////////////////////////////////////////////////////////
     /// \brief Default constructor
     ///
     /// Because this class has a copy constructor, the compiler
     /// will not automatically generate the default constructor.
-    /// That's why we must define it explicitely.
+    /// That's why we must define it explicitly.
     ///
     ////////////////////////////////////////////////////////////
     NonCopyable() {}
     
-private :
+    ////////////////////////////////////////////////////////////
+    /// \brief Default destructor
+    ///
+    /// By declaring a protected destructor it's impossible to
+    /// call delete on a pointer of sf::NonCopyable, thus
+    /// preventing possible resource leaks.
+    ///
+    ////////////////////////////////////////////////////////////
+    ~NonCopyable() {}
+
+private:
 
     ////////////////////////////////////////////////////////////
     /// \brief Disabled copy constructor
@@ -89,7 +99,7 @@ private :
 /// \class sf::NonCopyable
 /// \ingroup system
 ///
-/// This class makes its instances non-copyable, by explicitely
+/// This class makes its instances non-copyable, by explicitly
 /// disabling its copy constructor and its assignment operator.
 ///
 /// To create a non-copyable class, simply inherit from

Externals/SFML/include/SFML/System/String.hpp

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -29,6 +29,8 @@
 // Headers
 ////////////////////////////////////////////////////////////
 #include <SFML/System/Export.hpp>
+#include <SFML/System/Utf.hpp>
+#include <iterator>
 #include <locale>
 #include <string>
 
@@ -42,13 +44,13 @@ namespace sf
 ////////////////////////////////////////////////////////////
 class SFML_SYSTEM_API String
 {
-public :
+public:
 
     ////////////////////////////////////////////////////////////
     // Types
     ////////////////////////////////////////////////////////////
     typedef std::basic_string<Uint32>::iterator       Iterator;      ///< Iterator type
-    typedef std::basic_string<Uint32>::const_iterator ConstIterator; ///< Constant iterator type
+    typedef std::basic_string<Uint32>::const_iterator ConstIterator; ///< Read-only iterator type
 
     ////////////////////////////////////////////////////////////
     // Static member data
@@ -156,10 +158,56 @@ public :
     String(const String& copy);
 
     ////////////////////////////////////////////////////////////
-    /// \brief Implicit cast operator to std::string (ANSI string)
+    /// \brief Create a new sf::String from a UTF-8 encoded string
+    ///
+    /// \param begin Forward iterator to the beginning of the UTF-8 sequence
+    /// \param end   Forward iterator to the end of the UTF-8 sequence
+    ///
+    /// \return A sf::String containing the source string
+    ///
+    /// \see fromUtf16, fromUtf32
+    ///
+    ////////////////////////////////////////////////////////////
+    template <typename T>
+    static String fromUtf8(T begin, T end);
+
+    ////////////////////////////////////////////////////////////
+    /// \brief Create a new sf::String from a UTF-16 encoded string
+    ///
+    /// \param begin Forward iterator to the beginning of the UTF-16 sequence
+    /// \param end   Forward iterator to the end of the UTF-16 sequence
+    ///
+    /// \return A sf::String containing the source string
+    ///
+    /// \see fromUtf8, fromUtf32
+    ///
+    ////////////////////////////////////////////////////////////
+    template <typename T>
+    static String fromUtf16(T begin, T end);
+
+    ////////////////////////////////////////////////////////////
+    /// \brief Create a new sf::String from a UTF-32 encoded string
+    ///
+    /// This function is provided for consistency, it is equivalent to
+    /// using the constructors that takes a const sf::Uint32* or
+    /// a std::basic_string<sf::Uint32>.
+    ///
+    /// \param begin Forward iterator to the beginning of the UTF-32 sequence
+    /// \param end   Forward iterator to the end of the UTF-32 sequence
+    ///
+    /// \return A sf::String containing the source string
+    ///
+    /// \see fromUtf8, fromUtf16
+    ///
+    ////////////////////////////////////////////////////////////
+    template <typename T>
+    static String fromUtf32(T begin, T end);
+
+    ////////////////////////////////////////////////////////////
+    /// \brief Implicit conversion operator to std::string (ANSI string)
     ///
     /// The current global locale is used for conversion. If you
-    /// want to explicitely specify a locale, see toAnsiString.
+    /// want to explicitly specify a locale, see toAnsiString.
     /// Characters that do not fit in the target encoding are
     /// discarded from the returned string.
     /// This operator is defined for convenience, and is equivalent
@@ -173,7 +221,7 @@ public :
     operator std::string() const;
 
     ////////////////////////////////////////////////////////////
-    /// \brief Implicit cast operator to std::wstring (wide string)
+    /// \brief Implicit conversion operator to std::wstring (wide string)
     ///
     /// Characters that do not fit in the target encoding are
     /// discarded from the returned string.
@@ -188,7 +236,7 @@ public :
     operator std::wstring() const;
 
     ////////////////////////////////////////////////////////////
-    /// \brief Convert the unicode string to an ANSI string
+    /// \brief Convert the Unicode string to an ANSI string
     ///
     /// The UTF-32 string is converted to an ANSI string in
     /// the encoding defined by \a locale.
@@ -205,7 +253,7 @@ public :
     std::string toAnsiString(const std::locale& locale = std::locale()) const;
 
     ////////////////////////////////////////////////////////////
-    /// \brief Convert the unicode string to a wide string
+    /// \brief Convert the Unicode string to a wide string
     ///
     /// Characters that do not fit in the target encoding are
     /// discarded from the returned string.
@@ -217,6 +265,39 @@ public :
     ////////////////////////////////////////////////////////////
     std::wstring toWideString() const;
 
+    ////////////////////////////////////////////////////////////
+    /// \brief Convert the Unicode string to a UTF-8 string
+    ///
+    /// \return Converted UTF-8 string
+    ///
+    /// \see toUtf16, toUtf32
+    ///
+    ////////////////////////////////////////////////////////////
+    std::basic_string<Uint8> toUtf8() const;
+
+    ////////////////////////////////////////////////////////////
+    /// \brief Convert the Unicode string to a UTF-16 string
+    ///
+    /// \return Converted UTF-16 string
+    ///
+    /// \see toUtf8, toUtf32
+    ///
+    ////////////////////////////////////////////////////////////
+    std::basic_string<Uint16> toUtf16() const;
+
+    ////////////////////////////////////////////////////////////
+    /// \brief Convert the Unicode string to a UTF-32 string
+    ///
+    /// This function doesn't perform any conversion, since the
+    /// string is already stored as UTF-32 internally.
+    ///
+    /// \return Converted UTF-32 string
+    ///
+    /// \see toUtf8, toUtf16
+    ///
+    ////////////////////////////////////////////////////////////
+    std::basic_string<Uint32> toUtf32() const;
+
     ////////////////////////////////////////////////////////////
     /// \brief Overload of assignment operator
     ///
@@ -241,7 +322,7 @@ public :
     /// \brief Overload of [] operator to access a character by its position
     ///
     /// This function provides read-only access to characters.
-    /// Note: this function doesn't throw if \a index is out of range.
+    /// Note: the behavior is undefined if \a index is out of range.
     ///
     /// \param index Index of the character to get
     ///
@@ -254,7 +335,7 @@ public :
     /// \brief Overload of [] operator to access a character by its position
     ///
     /// This function provides read and write access to characters.
-    /// Note: this function doesn't throw if \a index is out of range.
+    /// Note: the behavior is undefined if \a index is out of range.
     ///
     /// \param index Index of the character to get
     ///
@@ -321,7 +402,7 @@ public :
     /// \brief Find a sequence of one or more characters in the string
     ///
     /// This function searches for the characters of \a str
-    /// into the string, starting from \a start.
+    /// in the string, starting from \a start.
     ///
     /// \param str   Characters to find
     /// \param start Where to begin searching
@@ -331,6 +412,49 @@ public :
     ////////////////////////////////////////////////////////////
     std::size_t find(const String& str, std::size_t start = 0) const;
 
+    ////////////////////////////////////////////////////////////
+    /// \brief Replace a substring with another string
+    ///
+    /// This function replaces the substring that starts at index \a position
+    /// and spans \a length characters with the string \a replaceWith.
+    ///
+    /// \param position    Index of the first character to be replaced
+    /// \param length      Number of characters to replace. You can pass InvalidPos to
+    ///                    replace all characters until the end of the string.
+    /// \param replaceWith String that replaces the given substring.
+    ///
+    ////////////////////////////////////////////////////////////
+    void replace(std::size_t position, std::size_t length, const String& replaceWith);
+
+    ////////////////////////////////////////////////////////////
+    /// \brief Replace all occurrences of a substring with a replacement string
+    ///
+    /// This function replaces all occurrences of \a searchFor in this string
+    /// with the string \a replaceWith.
+    ///
+    /// \param searchFor   The value being searched for
+    /// \param replaceWith The value that replaces found \a searchFor values
+    ///
+    ////////////////////////////////////////////////////////////
+    void replace(const String& searchFor, const String& replaceWith);
+
+    ////////////////////////////////////////////////////////////
+    /// \brief Return a part of the string
+    ///
+    /// This function returns the substring that starts at index \a position
+    /// and spans \a length characters.
+    ///
+    /// \param position Index of the first character
+    /// \param length   Number of characters to include in the substring (if
+    ///                 the string is shorter, as many characters as possible
+    ///                 are included). \ref InvalidPos can be used to include all
+    ///                 characters until the end of the string.
+    ///
+    /// \return String object containing a substring of this object
+    ///
+    ////////////////////////////////////////////////////////////
+    String substring(std::size_t position, std::size_t length = InvalidPos) const;
+
     ////////////////////////////////////////////////////////////
     /// \brief Get a pointer to the C-style array of characters
     ///
@@ -365,7 +489,7 @@ public :
     ConstIterator begin() const;
 
     ////////////////////////////////////////////////////////////
-    /// \brief Return an iterator to the beginning of the string
+    /// \brief Return an iterator to the end of the string
     ///
     /// The end iterator refers to 1 position past the last character;
     /// thus it represents an invalid character and should never be
@@ -379,7 +503,7 @@ public :
     Iterator end();
 
     ////////////////////////////////////////////////////////////
-    /// \brief Return an iterator to the beginning of the string
+    /// \brief Return an iterator to the end of the string
     ///
     /// The end iterator refers to 1 position past the last character;
     /// thus it represents an invalid character and should never be
@@ -392,7 +516,7 @@ public :
     ////////////////////////////////////////////////////////////
     ConstIterator end() const;
 
-private :
+private:
 
     friend SFML_SYSTEM_API bool operator ==(const String& left, const String& right);
     friend SFML_SYSTEM_API bool operator <(const String& left, const String& right);
@@ -434,7 +558,7 @@ SFML_SYSTEM_API bool operator !=(const String& left, const String& right);
 /// \param left  Left operand (a string)
 /// \param right Right operand (a string)
 ///
-/// \return True if \a left is alphabetically lesser than \a right
+/// \return True if \a left is lexicographically before \a right
 ///
 ////////////////////////////////////////////////////////////
 SFML_SYSTEM_API bool operator <(const String& left, const String& right);
@@ -446,7 +570,7 @@ SFML_SYSTEM_API bool operator <(const String& left, const String& right);
 /// \param left  Left operand (a string)
 /// \param right Right operand (a string)
 ///
-/// \return True if \a left is alphabetically greater than \a right
+/// \return True if \a left is lexicographically after \a right
 ///
 ////////////////////////////////////////////////////////////
 SFML_SYSTEM_API bool operator >(const String& left, const String& right);
@@ -458,7 +582,7 @@ SFML_SYSTEM_API bool operator >(const String& left, const String& right);
 /// \param left  Left operand (a string)
 /// \param right Right operand (a string)
 ///
-/// \return True if \a left is alphabetically lesser or equal than \a right
+/// \return True if \a left is lexicographically before or equivalent to \a right
 ///
 ////////////////////////////////////////////////////////////
 SFML_SYSTEM_API bool operator <=(const String& left, const String& right);
@@ -470,7 +594,7 @@ SFML_SYSTEM_API bool operator <=(const String& left, const String& right);
 /// \param left  Left operand (a string)
 /// \param right Right operand (a string)
 ///
-/// \return True if \a left is alphabetically greater or equal than \a right
+/// \return True if \a left is lexicographically after or equivalent to \a right
 ///
 ////////////////////////////////////////////////////////////
 SFML_SYSTEM_API bool operator >=(const String& left, const String& right);
@@ -487,6 +611,8 @@ SFML_SYSTEM_API bool operator >=(const String& left, const String& right);
 ////////////////////////////////////////////////////////////
 SFML_SYSTEM_API String operator +(const String& left, const String& right);
 
+#include <SFML/System/String.inl>
+
 } // namespace sf
 
 
@@ -500,7 +626,7 @@ SFML_SYSTEM_API String operator +(const String& left, const String& right);
 /// sf::String is a utility string class defined mainly for
 /// convenience. It is a Unicode string (implemented using
 /// UTF-32), thus it can store any character in the world
-/// (european, chinese, arabic, hebrew, etc.).
+/// (European, Chinese, Arabic, Hebrew, etc.).
 ///
 /// It automatically handles conversions from/to ANSI and
 /// wide strings, so that you can work with standard string

Externals/SFML/include/SFML/System/String.inl

@@ -0,0 +1,53 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org)
+//
+// This software is provided 'as-is', without any express or implied warranty.
+// In no event will the authors be held liable for any damages arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it freely,
+// subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented;
+//    you must not claim that you wrote the original software.
+//    If you use this software in a product, an acknowledgment
+//    in the product documentation would be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such,
+//    and must not be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source distribution.
+//
+////////////////////////////////////////////////////////////
+
+
+////////////////////////////////////////////////////////////
+template <typename T>
+String String::fromUtf8(T begin, T end)
+{
+    String string;
+    Utf8::toUtf32(begin, end, std::back_inserter(string.m_string));
+    return string;
+}
+
+
+////////////////////////////////////////////////////////////
+template <typename T>
+String String::fromUtf16(T begin, T end)
+{
+    String string;
+    Utf16::toUtf32(begin, end, std::back_inserter(string.m_string));
+    return string;
+}
+
+
+////////////////////////////////////////////////////////////
+template <typename T>
+String String::fromUtf32(T begin, T end)
+{
+    String string;
+    string.m_string.assign(begin, end);
+    return string;
+}

Externals/SFML/include/SFML/System/Time.hpp

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -39,7 +39,7 @@ namespace sf
 ////////////////////////////////////////////////////////////
 class SFML_SYSTEM_API Time
 {
-public :
+public:
 
     ////////////////////////////////////////////////////////////
     /// \brief Default constructor
@@ -84,7 +84,7 @@ public :
     ////////////////////////////////////////////////////////////
     static const Time Zero; ///< Predefined "zero" time value
 
-private :
+private:
 
     friend SFML_SYSTEM_API Time seconds(float);
     friend SFML_SYSTEM_API Time milliseconds(Int32);
@@ -101,7 +101,7 @@ private :
     ////////////////////////////////////////////////////////////
     explicit Time(Int64 microseconds);
 
-private :
+private:
 
     ////////////////////////////////////////////////////////////
     // Member data
@@ -399,6 +399,42 @@ SFML_SYSTEM_API Time& operator /=(Time& left, float right);
 ////////////////////////////////////////////////////////////
 SFML_SYSTEM_API Time& operator /=(Time& left, Int64 right);
 
+////////////////////////////////////////////////////////////
+/// \relates Time
+/// \brief Overload of binary / operator to compute the ratio of two time values
+///
+/// \param left  Left operand (a time)
+/// \param right Right operand (a time)
+///
+/// \return \a left divided by \a right
+///
+////////////////////////////////////////////////////////////
+SFML_SYSTEM_API float operator /(Time left, Time right);
+
+////////////////////////////////////////////////////////////
+/// \relates Time
+/// \brief Overload of binary % operator to compute remainder of a time value
+///
+/// \param left  Left operand (a time)
+/// \param right Right operand (a time)
+///
+/// \return \a left modulo \a right
+///
+////////////////////////////////////////////////////////////
+SFML_SYSTEM_API Time operator %(Time left, Time right);
+
+////////////////////////////////////////////////////////////
+/// \relates Time
+/// \brief Overload of binary %= operator to compute/assign remainder of a time value
+///
+/// \param left  Left operand (a time)
+/// \param right Right operand (a time)
+///
+/// \return \a left modulo \a right
+///
+////////////////////////////////////////////////////////////
+SFML_SYSTEM_API Time& operator %=(Time& left, Time right);
+
 } // namespace sf
 
 

Externals/SFML/include/SFML/System/Utf.hpp

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -47,7 +47,7 @@ class Utf;
 template <>
 class Utf<8>
 {
-public :
+public:
 
     ////////////////////////////////////////////////////////////
     /// \brief Decode a single UTF-8 character
@@ -254,7 +254,7 @@ public :
 template <>
 class Utf<16>
 {
-public :
+public:
 
     ////////////////////////////////////////////////////////////
     /// \brief Decode a single UTF-16 character
@@ -461,7 +461,7 @@ public :
 template <>
 class Utf<32>
 {
-public :
+public:
 
     ////////////////////////////////////////////////////////////
     /// \brief Decode a single UTF-32 character
@@ -752,7 +752,7 @@ typedef Utf<32> Utf32;
 /// to handle ANSI, wide, latin-1, UTF-8, UTF-16 and UTF-32 encodings.
 ///
 /// sf::Utf<X> functions are all static, these classes are not meant to
-/// be instanciated. All the functions are template, so that you
+/// be instantiated. All the functions are template, so that you
 /// can use any character / string type for a given encoding.
 ///
 /// It has 3 specializations:

Externals/SFML/include/SFML/System/Utf.inl

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2012 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -24,12 +24,12 @@
 
 
 ////////////////////////////////////////////////////////////
-// References :
+// References:
 //
-// http://www.unicode.org/
+// https://www.unicode.org/
-// http://www.unicode.org/Public/PROGRAMS/CVTUTF/ConvertUTF.c
+// https://www.unicode.org/Public/PROGRAMS/CVTUTF/ConvertUTF.c
-// http://www.unicode.org/Public/PROGRAMS/CVTUTF/ConvertUTF.h
+// https://www.unicode.org/Public/PROGRAMS/CVTUTF/ConvertUTF.h
-// http://people.w3.org/rishida/scripts/uniview/conversion
+// https://people.w3.org/rishida/scripts/uniview/conversion
 //
 ////////////////////////////////////////////////////////////
 
@@ -62,12 +62,12 @@ In Utf<8>::decode(In begin, In end, Uint32& output, Uint32 replacement)
         output = 0;
         switch (trailingBytes)
         {
-            case 5 : output += static_cast<Uint8>(*begin++); output <<= 6;
+            case 5: output += static_cast<Uint8>(*begin++); output <<= 6;
-            case 4 : output += static_cast<Uint8>(*begin++); output <<= 6;
+            case 4: output += static_cast<Uint8>(*begin++); output <<= 6;
-            case 3 : output += static_cast<Uint8>(*begin++); output <<= 6;
+            case 3: output += static_cast<Uint8>(*begin++); output <<= 6;
-            case 2 : output += static_cast<Uint8>(*begin++); output <<= 6;
+            case 2: output += static_cast<Uint8>(*begin++); output <<= 6;
-            case 1 : output += static_cast<Uint8>(*begin++); output <<= 6;
+            case 1: output += static_cast<Uint8>(*begin++); output <<= 6;
-            case 0 : output += static_cast<Uint8>(*begin++);
+            case 0: output += static_cast<Uint8>(*begin++);
         }
         output -= offsets[trailingBytes];
     }
@@ -114,10 +114,10 @@ Out Utf<8>::encode(Uint32 input, Out output, Uint8 replacement)
         Uint8 bytes[4];
         switch (bytestoWrite)
         {
-            case 4 : bytes[3] = static_cast<Uint8>((input | 0x80) & 0xBF); input >>= 6;
+            case 4: bytes[3] = static_cast<Uint8>((input | 0x80) & 0xBF); input >>= 6;
-            case 3 : bytes[2] = static_cast<Uint8>((input | 0x80) & 0xBF); input >>= 6;
+            case 3: bytes[2] = static_cast<Uint8>((input | 0x80) & 0xBF); input >>= 6;
-            case 2 : bytes[1] = static_cast<Uint8>((input | 0x80) & 0xBF); input >>= 6;
+            case 2: bytes[1] = static_cast<Uint8>((input | 0x80) & 0xBF); input >>= 6;
-            case 1 : bytes[0] = static_cast<Uint8> (input | firstBytes[bytestoWrite]);
+            case 1: bytes[0] = static_cast<Uint8> (input | firstBytes[bytestoWrite]);
         }
 
         // Add them to the output
@@ -322,7 +322,7 @@ In Utf<16>::decode(In begin, In end, Uint32& output, Uint32 replacement)
 template <typename Out>
 Out Utf<16>::encode(Uint32 input, Out output, Uint16 replacement)
 {
-    if (input < 0xFFFF)
+    if (input <= 0xFFFF)
     {
         // The character can be copied directly, we just need to check if it's in the valid range
         if ((input >= 0xD800) && (input <= 0xDFFF))
@@ -339,7 +339,7 @@ Out Utf<16>::encode(Uint32 input, Out output, Uint16 replacement)
     }
     else if (input > 0x0010FFFF)
     {
-        // Invalid character (greater than the maximum unicode value)
+        // Invalid character (greater than the maximum Unicode value)
         if (replacement)
             *output++ = replacement;
     }
@@ -638,7 +638,7 @@ Out Utf<32>::toUtf32(In begin, In end, Out output)
 template <typename In>
 Uint32 Utf<32>::decodeAnsi(In input, const std::locale& locale)
 {
-    // On Windows, gcc's standard library (glibc++) has almost
+    // On Windows, GCC's standard library (glibc++) has almost
     // no support for Unicode stuff. As a consequence, in this
     // context we can only use the default locale and ignore
     // the one passed as parameter.

Externals/SFML/src/SFML/Network/Http.cpp

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -26,10 +26,12 @@
 // Headers
 ////////////////////////////////////////////////////////////
 #include <SFML/Network/Http.hpp>
+#include <SFML/System/Err.hpp>
 #include <cctype>
 #include <algorithm>
 #include <iterator>
 #include <sstream>
+#include <limits>
 
 
 namespace
@@ -105,10 +107,11 @@ std::string Http::Request::prepare() const
     std::string method;
     switch (m_method)
     {
-        default :
+        case Get:    method = "GET";    break;
-        case Get :  method = "GET";  break;
+        case Post:   method = "POST";   break;
-        case Post : method = "POST"; break;
+        case Head:   method = "HEAD";   break;
-        case Head : method = "HEAD"; break;
+        case Put:    method = "PUT";    break;
+        case Delete: method = "DELETE"; break;
     }
 
     // Write the first line containing the request type
@@ -230,9 +233,49 @@ void Http::Response::parse(const std::string& data)
     }
 
     // Ignore the end of the first line
-    in.ignore(10000, '\n');
+    in.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
 
     // Parse the other lines, which contain fields, one by one
+    parseFields(in);
+
+    m_body.clear();
+
+    // Determine whether the transfer is chunked
+    if (toLower(getField("transfer-encoding")) != "chunked")
+    {
+        // Not chunked - just read everything at once
+        std::copy(std::istreambuf_iterator<char>(in), std::istreambuf_iterator<char>(), std::back_inserter(m_body));
+    }
+    else
+    {
+        // Chunked - have to read chunk by chunk
+        std::size_t length;
+
+        // Read all chunks, identified by a chunk-size not being 0
+        while (in >> std::hex >> length)
+        {
+            // Drop the rest of the line (chunk-extension)
+            in.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
+
+            // Copy the actual content data
+            std::istreambuf_iterator<char> it(in);
+            std::istreambuf_iterator<char> itEnd;
+            for (std::size_t i = 0; ((i < length) && (it != itEnd)); i++)
+                m_body.push_back(*it++);
+        }
+
+        // Drop the rest of the line (chunk-extension)
+        in.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
+
+        // Read all trailers (if present)
+        parseFields(in);
+    }
+}
+
+
+////////////////////////////////////////////////////////////
+void Http::Response::parseFields(std::istream &in)
+{
     std::string line;
     while (std::getline(in, line) && (line.size() > 2))
     {
@@ -251,10 +294,6 @@ void Http::Response::parse(const std::string& data)
             m_fields[toLower(field)] = value;
         }
     }
-
-    // Finally extract the body
-    m_body.clear();
-    std::copy(std::istreambuf_iterator<char>(in), std::istreambuf_iterator<char>(), std::back_inserter(m_body));
 }
 
 
@@ -277,19 +316,19 @@ Http::Http(const std::string& host, unsigned short port)
 ////////////////////////////////////////////////////////////
 void Http::setHost(const std::string& host, unsigned short port)
 {
-    // Detect the protocol used
+    // Check the protocol
-    std::string protocol = toLower(host.substr(0, 8));
+    if (toLower(host.substr(0, 7)) == "http://")
-    if (protocol.substr(0, 7) == "http://")
     {
         // HTTP protocol
         m_hostName = host.substr(7);
         m_port     = (port != 0 ? port : 80);
     }
-    else if (protocol == "https://")
+    else if (toLower(host.substr(0, 8)) == "https://")
     {
-        // HTTPS protocol
+        // HTTPS protocol -- unsupported (requires encryption and certificates and stuff...)
-        m_hostName = host.substr(8);
+        err() << "HTTPS protocol is not supported by sf::Http" << std::endl;
-        m_port     = (port != 0 ? port : 443);
+        m_hostName = "";
+        m_port     = 0;
     }
     else
     {

Externals/SFML/src/SFML/Network/IPAddress.cpp

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -29,89 +29,56 @@
 #include <SFML/Network/Http.hpp>
 #include <SFML/Network/SocketImpl.hpp>
 #include <cstring>
-
+#include <utility>
-
-namespace
-{
-    sf::Uint32 resolve(const std::string& address)
-    {
-        if (address == "255.255.255.255")
-        {
-            // The broadcast address needs to be handled explicitely,
-            // because it is also the value returned by inet_addr on error
-            return INADDR_BROADCAST;
-        }
-        else
-        {
-            // Try to convert the address as a byte representation ("xxx.xxx.xxx.xxx")
-            sf::Uint32 ip = inet_addr(address.c_str());
-            if (ip != INADDR_NONE)
-                return ip;
-
-            // Not a valid address, try to convert it as a host name
-            addrinfo hints;
-            std::memset(&hints, 0, sizeof(hints));
-            hints.ai_family = AF_INET;
-            addrinfo* result = NULL;
-            if (getaddrinfo(address.c_str(), NULL, &hints, &result) == 0)
-            {
-                if (result)
-                {
-                    ip = reinterpret_cast<sockaddr_in*>(result->ai_addr)->sin_addr.s_addr;
-                    freeaddrinfo(result);
-                    return ip;
-                }
-            }
-
-            // Not a valid address nor a host name
-            return 0;
-        }
-    }
-}
 
 
 namespace sf
 {
 ////////////////////////////////////////////////////////////
 const IpAddress IpAddress::None;
+const IpAddress IpAddress::Any(0, 0, 0, 0);
 const IpAddress IpAddress::LocalHost(127, 0, 0, 1);
 const IpAddress IpAddress::Broadcast(255, 255, 255, 255);
 
 
 ////////////////////////////////////////////////////////////
 IpAddress::IpAddress() :
-m_address(0)
+m_address(0),
+m_valid  (false)
 {
-    // We're using 0 (INADDR_ANY) instead of INADDR_NONE to represent the invalid address,
-    // because the latter is also the broadcast address (255.255.255.255); it's ok because
-    // SFML doesn't publicly use INADDR_ANY (it is always used implicitely)
 }
 
 
 ////////////////////////////////////////////////////////////
 IpAddress::IpAddress(const std::string& address) :
-m_address(resolve(address))
+m_address(0),
+m_valid  (false)
 {
+    resolve(address);
 }
 
 
 ////////////////////////////////////////////////////////////
 IpAddress::IpAddress(const char* address) :
-m_address(resolve(address))
+m_address(0),
+m_valid  (false)
 {
+    resolve(address);
 }
 
 
 ////////////////////////////////////////////////////////////
 IpAddress::IpAddress(Uint8 byte0, Uint8 byte1, Uint8 byte2, Uint8 byte3) :
-m_address(htonl((byte0 << 24) | (byte1 << 16) | (byte2 << 8) | byte3))
+m_address(htonl((byte0 << 24) | (byte1 << 16) | (byte2 << 8) | byte3)),
+m_valid  (true)
 {
 }
 
 
 ////////////////////////////////////////////////////////////
 IpAddress::IpAddress(Uint32 address) :
-m_address(htonl(address))
+m_address(htonl(address)),
+m_valid  (true)
 {
 }
 
@@ -148,7 +115,7 @@ IpAddress IpAddress::getLocalAddress()
         return localAddress;
 
     // Connect the socket to localhost on any port
-    sockaddr_in address = priv::SocketImpl::createAddress(ntohl(INADDR_LOOPBACK), 0);
+    sockaddr_in address = priv::SocketImpl::createAddress(ntohl(INADDR_LOOPBACK), 9);
     if (connect(sock, reinterpret_cast<sockaddr*>(&address), sizeof(address)) == -1)
     {
         priv::SocketImpl::close(sock);
@@ -193,10 +160,59 @@ IpAddress IpAddress::getPublicAddress(Time timeout)
 }
 
 
+////////////////////////////////////////////////////////////
+void IpAddress::resolve(const std::string& address)
+{
+    m_address = 0;
+    m_valid = false;
+
+    if (address == "255.255.255.255")
+    {
+        // The broadcast address needs to be handled explicitly,
+        // because it is also the value returned by inet_addr on error
+        m_address = INADDR_BROADCAST;
+        m_valid = true;
+    }
+    else if (address == "0.0.0.0")
+    {
+        m_address = INADDR_ANY;
+        m_valid = true;
+    }
+    else
+    {
+        // Try to convert the address as a byte representation ("xxx.xxx.xxx.xxx")
+        Uint32 ip = inet_addr(address.c_str());
+        if (ip != INADDR_NONE)
+        {
+            m_address = ip;
+            m_valid = true;
+        }
+        else
+        {
+            // Not a valid address, try to convert it as a host name
+            addrinfo hints;
+            std::memset(&hints, 0, sizeof(hints));
+            hints.ai_family = AF_INET;
+            addrinfo* result = NULL;
+            if (getaddrinfo(address.c_str(), NULL, &hints, &result) == 0)
+            {
+                if (result)
+                {
+                    ip = reinterpret_cast<sockaddr_in*>(result->ai_addr)->sin_addr.s_addr;
+                    freeaddrinfo(result);
+                    m_address = ip;
+                    m_valid = true;
+                }
+            }
+        }
+    }
+}
+
+
 ////////////////////////////////////////////////////////////
 bool operator ==(const IpAddress& left, const IpAddress& right)
 {
-    return left.toInteger() == right.toInteger();
+    return !(left < right) && !(right < left);
 }
 
 
@@ -210,7 +226,7 @@ bool operator !=(const IpAddress& left, const IpAddress& right)
 ////////////////////////////////////////////////////////////
 bool operator <(const IpAddress& left, const IpAddress& right)
 {
-    return left.toInteger() < right.toInteger();
+    return std::make_pair(left.m_valid, left.m_address) < std::make_pair(right.m_valid, right.m_address);
 }
 
 

Externals/SFML/src/SFML/Network/Packet.cpp

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -37,6 +37,7 @@ namespace sf
 ////////////////////////////////////////////////////////////
 Packet::Packet() :
 m_readPos(0),
+m_sendPos(0),
 m_isValid(true)
 {
 
@@ -188,6 +189,52 @@ Packet& Packet::operator >>(Uint32& data)
 }
 
 
+////////////////////////////////////////////////////////////
+Packet& Packet::operator >>(Int64& data)
+{
+    if (checkSize(sizeof(data)))
+    {
+        // Since ntohll is not available everywhere, we have to convert
+        // to network byte order (big endian) manually
+        const Uint8* bytes = reinterpret_cast<const Uint8*>(&m_data[m_readPos]);
+        data = (static_cast<Int64>(bytes[0]) << 56) |
+               (static_cast<Int64>(bytes[1]) << 48) |
+               (static_cast<Int64>(bytes[2]) << 40) |
+               (static_cast<Int64>(bytes[3]) << 32) |
+               (static_cast<Int64>(bytes[4]) << 24) |
+               (static_cast<Int64>(bytes[5]) << 16) |
+               (static_cast<Int64>(bytes[6]) <<  8) |
+               (static_cast<Int64>(bytes[7])      );
+        m_readPos += sizeof(data);
+    }
+
+    return *this;
+}
+
+
+////////////////////////////////////////////////////////////
+Packet& Packet::operator >>(Uint64& data)
+{
+    if (checkSize(sizeof(data)))
+    {
+        // Since ntohll is not available everywhere, we have to convert
+        // to network byte order (big endian) manually
+        const Uint8* bytes = reinterpret_cast<const Uint8*>(&m_data[m_readPos]);
+        data = (static_cast<Uint64>(bytes[0]) << 56) |
+               (static_cast<Uint64>(bytes[1]) << 48) |
+               (static_cast<Uint64>(bytes[2]) << 40) |
+               (static_cast<Uint64>(bytes[3]) << 32) |
+               (static_cast<Uint64>(bytes[4]) << 24) |
+               (static_cast<Uint64>(bytes[5]) << 16) |
+               (static_cast<Uint64>(bytes[6]) <<  8) |
+               (static_cast<Uint64>(bytes[7])      );
+        m_readPos += sizeof(data);
+    }
+
+    return *this;
+}
+
+
 ////////////////////////////////////////////////////////////
 Packet& Packet::operator >>(float& data)
 {
@@ -385,6 +432,48 @@ Packet& Packet::operator <<(Uint32 data)
 }
 
 
+////////////////////////////////////////////////////////////
+Packet& Packet::operator <<(Int64 data)
+{
+    // Since htonll is not available everywhere, we have to convert
+    // to network byte order (big endian) manually
+    Uint8 toWrite[] =
+    {
+        static_cast<Uint8>((data >> 56) & 0xFF),
+        static_cast<Uint8>((data >> 48) & 0xFF),
+        static_cast<Uint8>((data >> 40) & 0xFF),
+        static_cast<Uint8>((data >> 32) & 0xFF),
+        static_cast<Uint8>((data >> 24) & 0xFF),
+        static_cast<Uint8>((data >> 16) & 0xFF),
+        static_cast<Uint8>((data >>  8) & 0xFF),
+        static_cast<Uint8>((data      ) & 0xFF)
+    };
+    append(&toWrite, sizeof(toWrite));
+    return *this;
+}
+
+
+////////////////////////////////////////////////////////////
+Packet& Packet::operator <<(Uint64 data)
+{
+    // Since htonll is not available everywhere, we have to convert
+    // to network byte order (big endian) manually
+    Uint8 toWrite[] =
+    {
+        static_cast<Uint8>((data >> 56) & 0xFF),
+        static_cast<Uint8>((data >> 48) & 0xFF),
+        static_cast<Uint8>((data >> 40) & 0xFF),
+        static_cast<Uint8>((data >> 32) & 0xFF),
+        static_cast<Uint8>((data >> 24) & 0xFF),
+        static_cast<Uint8>((data >> 16) & 0xFF),
+        static_cast<Uint8>((data >>  8) & 0xFF),
+        static_cast<Uint8>((data      ) & 0xFF)
+    };
+    append(&toWrite, sizeof(toWrite));
+    return *this;
+}
+
+
 ////////////////////////////////////////////////////////////
 Packet& Packet::operator <<(float data)
 {
@@ -405,7 +494,7 @@ Packet& Packet::operator <<(double data)
 Packet& Packet::operator <<(const char* data)
 {
     // First insert string length
-    Uint32 length = std::strlen(data);
+    Uint32 length = static_cast<Uint32>(std::strlen(data));
     *this << length;
 
     // Then insert characters
@@ -434,7 +523,7 @@ Packet& Packet::operator <<(const std::string& data)
 Packet& Packet::operator <<(const wchar_t* data)
 {
     // First insert string length
-    Uint32 length = std::wcslen(data);
+    Uint32 length = static_cast<Uint32>(std::wcslen(data));
     *this << length;
 
     // Then insert characters

Externals/SFML/src/SFML/Network/Socket.cpp

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -82,6 +82,13 @@ void Socket::create()
     if (m_socket == priv::SocketImpl::invalidSocket())
     {
         SocketHandle handle = socket(PF_INET, m_type == Tcp ? SOCK_STREAM : SOCK_DGRAM, 0);
+
+        if (handle == priv::SocketImpl::invalidSocket())
+        {
+            err() << "Failed to create socket" << std::endl;
+            return;
+        }
+
         create(handle);
     }
 }
@@ -101,7 +108,7 @@ void Socket::create(SocketHandle handle)
 
         if (m_type == Tcp)
         {
-            // Disable the Nagle algorithm (ie. removes buffering of TCP packets)
+            // Disable the Nagle algorithm (i.e. removes buffering of TCP packets)
             int yes = 1;
             if (setsockopt(m_socket, IPPROTO_TCP, TCP_NODELAY, reinterpret_cast<char*>(&yes), sizeof(yes)) == -1)
             {

Externals/SFML/src/SFML/Network/SocketImpl.hpp

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.

Externals/SFML/src/SFML/Network/SocketSelector.cpp

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -29,10 +29,11 @@
 #include <SFML/Network/Socket.hpp>
 #include <SFML/Network/SocketImpl.hpp>
 #include <SFML/System/Err.hpp>
+#include <algorithm>
 #include <utility>
 
 #ifdef _MSC_VER
-    #pragma warning(disable : 4127) // "conditional expression is constant" generated by the FD_SET macro
+    #pragma warning(disable: 4127) // "conditional expression is constant" generated by the FD_SET macro
 #endif
 
 
@@ -41,9 +42,10 @@ namespace sf
 ////////////////////////////////////////////////////////////
 struct SocketSelector::SocketSelectorImpl
 {
-    fd_set AllSockets;   ///< Set containing all the sockets handles
+    fd_set allSockets;   ///< Set containing all the sockets handles
-    fd_set SocketsReady; ///< Set containing handles of the sockets that are ready
+    fd_set socketsReady; ///< Set containing handles of the sockets that are ready
-    int    MaxSocket;    ///< Maximum socket handle
+    int    maxSocket;    ///< Maximum socket handle
+    int    socketCount;  ///< Number of socket handles
 };
 
 
@@ -76,11 +78,38 @@ void SocketSelector::add(Socket& socket)
     SocketHandle handle = socket.getHandle();
     if (handle != priv::SocketImpl::invalidSocket())
     {
-        FD_SET(handle, &m_impl->AllSockets);
 
-        int size = static_cast<int>(handle);
+#if defined(SFML_SYSTEM_WINDOWS)
-        if (size > m_impl->MaxSocket)
+
-            m_impl->MaxSocket = size;
+        if (m_impl->socketCount >= FD_SETSIZE)
+        {
+            err() << "The socket can't be added to the selector because the "
+                  << "selector is full. This is a limitation of your operating "
+                  << "system's FD_SETSIZE setting.";
+            return;
+        }
+
+        if (FD_ISSET(handle, &m_impl->allSockets))
+            return;
+
+        m_impl->socketCount++;
+
+#else
+
+        if (handle >= FD_SETSIZE)
+        {
+            err() << "The socket can't be added to the selector because its "
+                  << "ID is too high. This is a limitation of your operating "
+                  << "system's FD_SETSIZE setting.";
+            return;
+        }
+
+        // SocketHandle is an int in POSIX
+        m_impl->maxSocket = std::max(m_impl->maxSocket, handle);
+
+#endif
+
+        FD_SET(handle, &m_impl->allSockets);
     }
 }
 
@@ -88,18 +117,38 @@ void SocketSelector::add(Socket& socket)
 ////////////////////////////////////////////////////////////
 void SocketSelector::remove(Socket& socket)
 {
-    FD_CLR(socket.getHandle(), &m_impl->AllSockets);
+    SocketHandle handle = socket.getHandle();
-    FD_CLR(socket.getHandle(), &m_impl->SocketsReady);
+    if (handle != priv::SocketImpl::invalidSocket())
+    {
+
+#if defined(SFML_SYSTEM_WINDOWS)
+
+        if (!FD_ISSET(handle, &m_impl->allSockets))
+            return;
+
+        m_impl->socketCount--;
+
+#else
+
+        if (handle >= FD_SETSIZE)
+            return;
+
+#endif
+
+        FD_CLR(handle, &m_impl->allSockets);
+        FD_CLR(handle, &m_impl->socketsReady);
+    }
 }
 
 
 ////////////////////////////////////////////////////////////
 void SocketSelector::clear()
 {
-    FD_ZERO(&m_impl->AllSockets);
+    FD_ZERO(&m_impl->allSockets);
-    FD_ZERO(&m_impl->SocketsReady);
+    FD_ZERO(&m_impl->socketsReady);
 
-    m_impl->MaxSocket = 0;
+    m_impl->maxSocket = 0;
+    m_impl->socketCount = 0;
 }
 
 
@@ -112,10 +161,11 @@ bool SocketSelector::wait(Time timeout)
     time.tv_usec = static_cast<long>(timeout.asMicroseconds() % 1000000);
 
     // Initialize the set that will contain the sockets that are ready
-    m_impl->SocketsReady = m_impl->AllSockets;
+    m_impl->socketsReady = m_impl->allSockets;
 
     // Wait until one of the sockets is ready for reading, or timeout is reached
-    int count = select(m_impl->MaxSocket + 1, &m_impl->SocketsReady, NULL, NULL, timeout != Time::Zero ? &time : NULL);
+    // The first parameter is ignored on Windows
+    int count = select(m_impl->maxSocket + 1, &m_impl->socketsReady, NULL, NULL, timeout != Time::Zero ? &time : NULL);
 
     return count > 0;
 }
@@ -124,7 +174,21 @@ bool SocketSelector::wait(Time timeout)
 ////////////////////////////////////////////////////////////
 bool SocketSelector::isReady(Socket& socket) const
 {
-    return FD_ISSET(socket.getHandle(), &m_impl->SocketsReady) != 0;
+    SocketHandle handle = socket.getHandle();
+    if (handle != priv::SocketImpl::invalidSocket())
+    {
+
+#if !defined(SFML_SYSTEM_WINDOWS)
+
+        if (handle >= FD_SETSIZE)
+            return false;
+
+#endif
+
+        return FD_ISSET(handle, &m_impl->socketsReady) != 0;
+    }
+
+    return false;
 }
 
 

Externals/SFML/src/SFML/Network/TcpListener.cpp

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -61,14 +61,21 @@ unsigned short TcpListener::getLocalPort() const
 
 
 ////////////////////////////////////////////////////////////
-Socket::Status TcpListener::listen(unsigned short port)
+Socket::Status TcpListener::listen(unsigned short port, const IpAddress& address)
 {
+    // Close the socket if it is already bound
+    close();
+
     // Create the internal socket if it doesn't exist
     create();
 
+    // Check if the address is valid
+    if ((address == IpAddress::None) || (address == IpAddress::Broadcast))
+        return Error;
+
     // Bind the socket to the specified port
-    sockaddr_in address = priv::SocketImpl::createAddress(INADDR_ANY, port);
+    sockaddr_in addr = priv::SocketImpl::createAddress(address.toInteger(), port);
-    if (bind(getHandle(), reinterpret_cast<sockaddr*>(&address), sizeof(address)) == -1)
+    if (bind(getHandle(), reinterpret_cast<sockaddr*>(&addr), sizeof(addr)) == -1)
     {
         // Not likely to happen, but...
         err() << "Failed to bind listener socket to port " << port << std::endl;
@@ -76,7 +83,7 @@ Socket::Status TcpListener::listen(unsigned short port)
     }
 
     // Listen to the bound port
-    if (::listen(getHandle(), 0) == -1)
+    if (::listen(getHandle(), SOMAXCONN) == -1)
     {
         // Oops, socket is deaf
         err() << "Failed to listen to port " << port << std::endl;

Externals/SFML/src/SFML/Network/TcpSocket.cpp

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -34,7 +34,7 @@
 #include <cstring>
 
 #ifdef _MSC_VER
-    #pragma warning(disable : 4127) // "conditional expression is constant" generated by the FD_SET macro
+    #pragma warning(disable: 4127) // "conditional expression is constant" generated by the FD_SET macro
 #endif
 
 
@@ -118,6 +118,9 @@ unsigned short TcpSocket::getRemotePort() const
 ////////////////////////////////////////////////////////////
 Socket::Status TcpSocket::connect(const IpAddress& remoteAddress, unsigned short remotePort, Time timeout)
 {
+    // Disconnect the socket if it is already connected
+    disconnect();
+
     // Create the internal socket if it doesn't exist
     create();
 
@@ -150,13 +153,14 @@ Socket::Status TcpSocket::connect(const IpAddress& remoteAddress, unsigned short
         if (::connect(getHandle(), reinterpret_cast<sockaddr*>(&address), sizeof(address)) >= 0)
         {
             // We got instantly connected! (it may no happen a lot...)
+            setBlocking(blocking);
             return Done;
         }
 
         // Get the error status
         Status status = priv::SocketImpl::getErrorStatus();
 
-        // If we were in non-blocking mode, return immediatly
+        // If we were in non-blocking mode, return immediately
         if (!blocking)
             return status;
 
@@ -178,7 +182,7 @@ Socket::Status TcpSocket::connect(const IpAddress& remoteAddress, unsigned short
             {
                 // At this point the connection may have been either accepted or refused.
                 // To know whether it's a success or a failure, we must check the address of the connected peer
-                if (getRemoteAddress() != sf::IpAddress::None)
+                if (getRemoteAddress() != IpAddress::None)
                 {
                     // Connection accepted
                     status = Done;
@@ -217,6 +221,18 @@ void TcpSocket::disconnect()
 
 ////////////////////////////////////////////////////////////
 Socket::Status TcpSocket::send(const void* data, std::size_t size)
+{
+    if (!isBlocking())
+        err() << "Warning: Partial sends might not be handled properly." << std::endl;
+
+    std::size_t sent;
+
+    return send(data, size, sent);
+}
+
+
+////////////////////////////////////////////////////////////
+Socket::Status TcpSocket::send(const void* data, std::size_t size, std::size_t& sent)
 {
     // Check the parameters
     if (!data || (size == 0))
@@ -226,16 +242,22 @@ Socket::Status TcpSocket::send(const void* data, std::size_t size)
     }
 
     // Loop until every byte has been sent
-    int sent = 0;
+    int result = 0;
-    int sizeToSend = static_cast<int>(size);
+    for (sent = 0; sent < size; sent += result)
-    for (int length = 0; length < sizeToSend; length += sent)
     {
         // Send a chunk of data
-        sent = ::send(getHandle(), static_cast<const char*>(data) + length, sizeToSend - length, flags);
+        result = ::send(getHandle(), static_cast<const char*>(data) + sent, size - sent, flags);
 
         // Check for errors
-        if (sent < 0)
+        if (result < 0)
-            return priv::SocketImpl::getErrorStatus();
+        {
+            Status status = priv::SocketImpl::getErrorStatus();
+
+            if ((status == NotReady) && sent)
+                return Partial;
+
+            return status;
+        }
     }
 
     return Done;
@@ -303,7 +325,20 @@ Socket::Status TcpSocket::send(Packet& packet)
         std::memcpy(&blockToSend[0] + sizeof(packetSize), data, size);
 
     // Send the data block
-    return send(&blockToSend[0], blockToSend.size());
+    std::size_t sent;
+    Status status = send(&blockToSend[0] + packet.m_sendPos, blockToSend.size() - packet.m_sendPos, sent);
+
+    // In the case of a partial send, record the location to resume from
+    if (status == Partial)
+    {
+        packet.m_sendPos += sent;
+    }
+    else if (status == Done)
+    {
+        packet.m_sendPos = 0;
+    }
+
+    return status;
 }
 
 

Externals/SFML/src/SFML/Network/UdpSocket.cpp

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -64,14 +64,21 @@ unsigned short UdpSocket::getLocalPort() const
 
 
 ////////////////////////////////////////////////////////////
-Socket::Status UdpSocket::bind(unsigned short port)
+Socket::Status UdpSocket::bind(unsigned short port, const IpAddress& address)
 {
+    // Close the socket if it is already bound
+    close();
+
     // Create the internal socket if it doesn't exist
     create();
 
+    // Check if the address is valid
+    if ((address == IpAddress::None) || (address == IpAddress::Broadcast))
+        return Error;
+
     // Bind the socket
-    sockaddr_in address = priv::SocketImpl::createAddress(INADDR_ANY, port);
+    sockaddr_in addr = priv::SocketImpl::createAddress(address.toInteger(), port);
-    if (::bind(getHandle(), reinterpret_cast<sockaddr*>(&address), sizeof(address)) == -1)
+    if (::bind(getHandle(), reinterpret_cast<sockaddr*>(&addr), sizeof(addr)) == -1)
     {
         err() << "Failed to bind socket to port " << port << std::endl;
         return Error;

Externals/SFML/src/SFML/Network/Unix/SocketImpl.cpp

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -26,6 +26,7 @@
 // Headers
 ////////////////////////////////////////////////////////////
 #include <SFML/Network/Unix/SocketImpl.hpp>
+#include <SFML/System/Err.hpp>
 #include <errno.h>
 #include <fcntl.h>
 #include <cstring>
@@ -39,11 +40,15 @@ namespace priv
 sockaddr_in SocketImpl::createAddress(Uint32 address, unsigned short port)
 {
     sockaddr_in addr;
-    std::memset(addr.sin_zero, 0, sizeof(addr.sin_zero));
+    std::memset(&addr, 0, sizeof(addr));
     addr.sin_addr.s_addr = htonl(address);
     addr.sin_family      = AF_INET;
     addr.sin_port        = htons(port);
 
+#if defined(SFML_SYSTEM_MACOS)
+    addr.sin_len = sizeof(addr);
+#endif
+
     return addr;
 }
 
@@ -67,9 +72,16 @@ void SocketImpl::setBlocking(SocketHandle sock, bool block)
 {
     int status = fcntl(sock, F_GETFL);
     if (block)
-        fcntl(sock, F_SETFL, status & ~O_NONBLOCK);
+    {
+        if (fcntl(sock, F_SETFL, status & ~O_NONBLOCK) == -1)
+            err() << "Failed to set file status flags: " << errno << std::endl;
+    }
     else
-        fcntl(sock, F_SETFL, status | O_NONBLOCK);
+    {
+        if (fcntl(sock, F_SETFL, status | O_NONBLOCK) == -1)
+            err() << "Failed to set file status flags: " << errno << std::endl;
+
+    }
 }
 
 
@@ -84,14 +96,14 @@ Socket::Status SocketImpl::getErrorStatus()
 
     switch (errno)
     {
-        case EWOULDBLOCK :  return Socket::NotReady;
+        case EWOULDBLOCK:  return Socket::NotReady;
-        case ECONNABORTED : return Socket::Disconnected;
+        case ECONNABORTED: return Socket::Disconnected;
-        case ECONNRESET :   return Socket::Disconnected;
+        case ECONNRESET:   return Socket::Disconnected;
-        case ETIMEDOUT :    return Socket::Disconnected;
+        case ETIMEDOUT:    return Socket::Disconnected;
-        case ENETRESET :    return Socket::Disconnected;
+        case ENETRESET:    return Socket::Disconnected;
-        case ENOTCONN :     return Socket::Disconnected;
+        case ENOTCONN:     return Socket::Disconnected;
-        case EPIPE :        return Socket::Disconnected;
+        case EPIPE:        return Socket::Disconnected;
-        default :           return Socket::Error;
+        default:           return Socket::Error;
     }
 }
 

Externals/SFML/src/SFML/Network/Unix/SocketImpl.hpp

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -49,7 +49,7 @@ namespace priv
 ////////////////////////////////////////////////////////////
 class SocketImpl
 {
-public :
+public:
 
     ////////////////////////////////////////////////////////////
     // Types

Externals/SFML/src/SFML/Network/Win32/SocketImpl.cpp

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -37,7 +37,7 @@ namespace priv
 sockaddr_in SocketImpl::createAddress(Uint32 address, unsigned short port)
 {
     sockaddr_in addr;
-    std::memset(addr.sin_zero, 0, sizeof(addr.sin_zero));
+    std::memset(&addr, 0, sizeof(addr));
     addr.sin_addr.s_addr = htonl(address);
     addr.sin_family      = AF_INET;
     addr.sin_port        = htons(port);
@@ -73,15 +73,15 @@ Socket::Status SocketImpl::getErrorStatus()
 {
     switch (WSAGetLastError())
     {
-        case WSAEWOULDBLOCK :  return Socket::NotReady;
+        case WSAEWOULDBLOCK:  return Socket::NotReady;
-        case WSAEALREADY :     return Socket::NotReady;
+        case WSAEALREADY:     return Socket::NotReady;
-        case WSAECONNABORTED : return Socket::Disconnected;
+        case WSAECONNABORTED: return Socket::Disconnected;
-        case WSAECONNRESET :   return Socket::Disconnected;
+        case WSAECONNRESET:   return Socket::Disconnected;
-        case WSAETIMEDOUT :    return Socket::Disconnected;
+        case WSAETIMEDOUT:    return Socket::Disconnected;
-        case WSAENETRESET :    return Socket::Disconnected;
+        case WSAENETRESET:    return Socket::Disconnected;
-        case WSAENOTCONN :     return Socket::Disconnected;
+        case WSAENOTCONN:     return Socket::Disconnected;
-        case WSAEISCONN :      return Socket::Done; // when connecting a non-blocking socket
+        case WSAEISCONN:      return Socket::Done; // when connecting a non-blocking socket
-        default :              return Socket::Error;
+        default:              return Socket::Error;
     }
 }
 

Externals/SFML/src/SFML/Network/Win32/SocketImpl.hpp

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -52,7 +52,7 @@ namespace priv
 ////////////////////////////////////////////////////////////
 class SocketImpl
 {
-public :
+public:
 
     ////////////////////////////////////////////////////////////
     // Types

Externals/SFML/src/SFML/System/Err.cpp

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -33,10 +33,10 @@
 namespace
 {
 // This class will be used as the default streambuf of sf::Err,
-// it outputs to stderr by default (to keep the default behaviour)
+// it outputs to stderr by default (to keep the default behavior)
 class DefaultErrStreamBuf : public std::streambuf
 {
-public :
+public:
 
     DefaultErrStreamBuf()
     {
@@ -55,7 +55,7 @@ public :
         delete[] pbase();
     }
 
-private :
+private:
 
     virtual int overflow(int character)
     {

Externals/SFML/src/SFML/System/String.cpp

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -174,6 +174,41 @@ std::wstring String::toWideString() const
 }
 
 
+////////////////////////////////////////////////////////////
+std::basic_string<Uint8> String::toUtf8() const
+{
+    // Prepare the output string
+    std::basic_string<Uint8> output;
+    output.reserve(m_string.length());
+
+    // Convert
+    Utf32::toUtf8(m_string.begin(), m_string.end(), std::back_inserter(output));
+
+    return output;
+}
+
+
+////////////////////////////////////////////////////////////
+std::basic_string<Uint16> String::toUtf16() const
+{
+    // Prepare the output string
+    std::basic_string<Uint16> output;
+    output.reserve(m_string.length());
+
+    // Convert
+    Utf32::toUtf16(m_string.begin(), m_string.end(), std::back_inserter(output));
+
+    return output;
+}
+
+
+////////////////////////////////////////////////////////////
+std::basic_string<Uint32> String::toUtf32() const
+{
+    return m_string;
+}
+
+
 ////////////////////////////////////////////////////////////
 String& String::operator =(const String& right)
 {
@@ -246,6 +281,36 @@ std::size_t String::find(const String& str, std::size_t start) const
 }
 
 
+////////////////////////////////////////////////////////////
+void String::replace(std::size_t position, std::size_t length, const String& replaceWith)
+{
+    m_string.replace(position, length, replaceWith.m_string);
+}
+
+
+////////////////////////////////////////////////////////////
+void String::replace(const String& searchFor, const String& replaceWith)
+{
+    std::size_t step = replaceWith.getSize();
+    std::size_t len = searchFor.getSize();
+    std::size_t pos = find(searchFor);
+
+    // Replace each occurrence of search
+    while (pos != InvalidPos)
+    {
+        replace(pos, len, replaceWith);
+        pos = find(searchFor, pos + step);
+    }
+}
+
+
+////////////////////////////////////////////////////////////
+String String::substring(std::size_t position, std::size_t length) const
+{
+    return m_string.substr(position, length);
+}
+
+
 ////////////////////////////////////////////////////////////
 const Uint32* String::getData() const
 {

Externals/SFML/src/SFML/System/Time.cpp

@@ -1,7 +1,7 @@
 ////////////////////////////////////////////////////////////
 //
 // SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org)
 //
 // This software is provided 'as-is', without any express or implied warranty.
 // In no event will the authors be held liable for any damages arising from the use of this software.
@@ -236,4 +236,25 @@ Time& operator /=(Time& left, Int64 right)
     return left = left / right;
 }
 
+
+////////////////////////////////////////////////////////////
+float operator /(Time left, Time right)
+{
+    return left.asSeconds() / right.asSeconds();
+}
+
+
+////////////////////////////////////////////////////////////
+Time operator %(Time left, Time right)
+{
+    return microseconds(left.asMicroseconds() % right.asMicroseconds());
+}
+
+
+////////////////////////////////////////////////////////////
+Time& operator %=(Time& left, Time right)
+{
+    return left = left % right;
+}
+
 } // namespace sf