Added new boost timer. Prepared fixes for removing players.

docs/net_protocol.txt

@@ -62,7 +62,7 @@ Server Reply: Join Game ACK
 	+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 	|       Number of Players       |          Small Blind          |
 	+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-	|       Hands before raise      |            Reserved           |
+	|       Hands before raise      |       Proposed GUI Speed      |
 	+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 	|                          Start Cash                           |
 	+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
@@ -71,7 +71,8 @@ Player Number:
 	0 to (NumberOfPlayers - 1), "position".
 Player ID:
 	Unique Player ID
-
+Proposed GUI Speed:
+	1-11
 
 
 Server Notification: Player Joined

src/core/boost/timer.hpp

@@ -0,0 +1,22 @@
+#ifndef BOOST_TIMER_HPP
+#define BOOST_TIMER_HPP
+
+// (C) Copyright Vaucher Philippe 2006
+
+// Use, modification and distribution is subject to the 
+// Boost Software License, Version 1.0. (See accompanying
+// file LICENSE-1.0 or http://www.boost.org/LICENSE-1.0)
+// Author: Vaucher Philippe 2006
+
+// Speeds up compilation a bit on msvc
+#if (defined _MSC_VER) && (_MSC_VER >= 1200)
+#pragma once
+#endif
+
+// -------------------------- Includes --------------------------
+
+#include "boost/timer/implementation.hpp"
+#include "boost/timer/devices.hpp"
+#include "boost/timer/typedefs.hpp"
+
+#endif // BOOST_TIMER_HPP

src/core/boost/timer/devices.hpp

@@ -0,0 +1,31 @@
+#ifndef BOOST_TIMER_DEVICES_HPP
+#define BOOST_TIMER_DEVICES_HPP
+
+// (C) Copyright Vaucher Philippe 2006
+
+// Use, modification and distribution is subject to the 
+// Boost Software License, Version 1.0. (See accompanying
+// file LICENSE-1.0 or http://www.boost.org/LICENSE-1.0)
+// Author: Vaucher Philippe 2006
+
+
+// -------------------------- Devices --------------------------
+
+//! A device has 3 main member functions: start(), elapsed() & reset().
+
+
+// -------------------------- Includes --------------------------
+
+#include "boost/timer/devices/clock.hpp"
+#include "boost/timer/devices/date_time.hpp"
+
+#ifndef BOOST_WINDOWS
+    #include "boost/timer/devices/gettimeofday.hpp"
+#else
+    #include "boost/timer/devices/QueryPerformanceCounter.hpp"
+    #include "boost/timer/devices/timeGetTime.hpp"
+    #include "boost/timer/devices/GetSystemTimeAsFileTime.hpp"
+    #include "boost/timer/devices/GetTickCount.hpp"
+#endif
+
+#endif // BOOST_TIMER_DEVICES_HPP

src/core/boost/timer/devices/GetSystemTimeAsFileTime.hpp

@@ -0,0 +1,96 @@
+#ifndef BOOST_TIMER_DEVICES_GSTAFT_HPP
+#define BOOST_TIMER_DEVICES_GSTAFT_HPP
+
+// (C) Copyright Vaucher Philippe 2006
+
+// Use, modification and distribution is subject to the 
+// Boost Software License, Version 1.0. (See accompanying
+// file LICENSE-1.0 or http://www.boost.org/LICENSE-1.0)
+// Author: Vaucher Philippe 2006
+
+
+// -------------------------- GetSystemTimeAsFileTime() --------------------------
+
+// Properties:
+//   - ??? ns resolution.
+//   - ??? ns overhead (6 clocks (64-bit load/store + synchronization (4))).
+//
+// Pros:
+//   - Low overhead.
+//
+// Cons:
+//   - Low resolution.
+
+
+// -------------------------- Includes --------------------------
+
+#ifndef BOOST_WINDOWS
+    #error "GetSystemTimeAsFileTime() can only be used on windows"
+#else
+
+// Boost headers
+#include <boost/cstdint.hpp>
+#include <boost/date_time/posix_time/posix_time.hpp>
+
+// Windows headers
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+
+
+// -------------------------- Code --------------------------
+
+namespace boost
+{
+
+//! The gstaft_device class is based on GetSystemTimeAsFileTime() to compute the time
+class gstaft_device
+{
+
+  public:
+
+    typedef posix_time::ptime               time_type;
+    typedef time_type::time_duration_type   time_duration_type;
+
+    explicit gstaft_device() : m_elapsed(0, 0, 0)
+    {
+        std::memset(&m_start, 0, sizeof(ULARGE_INTEGER));
+    }
+
+    void start() 
+    {
+        if(!m_start.QuadPart)
+            GetSystemTimeAsFileTime(reinterpret_cast<LPFILETIME>(&m_start));
+    }
+
+    const time_duration_type& elapsed() const
+    {
+        if(m_start.QuadPart)
+        {
+            ULARGE_INTEGER current;
+            GetSystemTimeAsFileTime(reinterpret_cast<LPFILETIME>(&current));
+            uint64_t tmp = current.QuadPart - m_start.QuadPart;
+            m_elapsed += posix_time::milliseconds(tmp / 10000.0);
+            m_start = current;
+        }
+        return m_elapsed;
+    }
+
+    void reset()
+    {
+        m_elapsed = time_duration_type(0,0,0);
+        std::memset(&m_start, 0, sizeof(ULARGE_INTEGER));
+    }
+
+
+  private:
+
+    mutable ULARGE_INTEGER     m_start;
+    mutable time_duration_type m_elapsed;
+
+};
+
+} // namespace boost
+
+#endif // BOOST_WINDOWS
+
+#endif // BOOST_TIMER_DEVICES_GSTAFT_HPP

src/core/boost/timer/devices/GetTickCount.hpp

@@ -0,0 +1,92 @@
+#ifndef BOOST_TIMER_DEVICES_GTC_HPP
+#define BOOST_TIMER_DEVICES_GTC_HPP
+
+// (C) Copyright Vaucher Philippe 2006
+
+// Use, modification and distribution is subject to the 
+// Boost Software License, Version 1.0. (See accompanying
+// file LICENSE-1.0 or http://www.boost.org/LICENSE-1.0)
+// Author: Vaucher Philippe 2006
+
+// -------------------------- GetTickCount() --------------------------
+
+// Properties:
+//   - 5 to 55 ms resolution.
+//   - ??? ns overhead (8 clock (load, mul, shift)).
+//
+// Pros:
+//   - Very low overhead.
+//
+// Cons:
+//   - Very low resolution.
+
+
+// -------------------------- Includes --------------------------
+
+#ifndef BOOST_WINDOWS
+    #error "GetTickCount() can only be used on windows"
+#else
+
+// Boost headers
+#include <boost/cstdint.hpp>
+#include <boost/date_time/posix_time/posix_time.hpp>
+
+// Windows headers
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+
+
+// -------------------------- Code --------------------------
+
+namespace boost
+{
+
+//! The gtc_device class is based on GetTickCount() to compute the time
+class gtc_device
+{
+
+  public:
+
+    typedef posix_time::ptime               time_type;
+    typedef time_type::time_duration_type   time_duration_type;
+
+    explicit gtc_device() : m_start(0), m_elapsed(0, 0, 0)
+    {
+    }
+
+    void start() 
+    {
+        if(!m_start)
+            m_start = GetTickCount();
+    }
+
+    const time_duration_type& elapsed() const
+    {
+        if(m_start)
+        {
+            uint32_t current = GetTickCount();
+            m_elapsed += posix_time::milliseconds(current - m_start);
+            m_start = current;
+        }
+        return m_elapsed;
+    }
+
+    void reset()
+    {
+        m_elapsed = time_duration_type(0,0,0);
+        m_start = 0;
+    }
+
+
+  private:
+
+    mutable uint32_t m_start;
+    mutable time_duration_type m_elapsed;
+
+};
+
+} // namespace boost
+
+#endif // BOOST_WINDOWS
+
+#endif // BOOST_TIMER_DEVICES_GTC_HPP

src/core/boost/timer/devices/QueryPerformanceCounter.hpp

@@ -0,0 +1,130 @@
+#ifndef BOOST_TIMER_DEVICES_QPC_HPP
+#define BOOST_TIMER_DEVICES_QPC_HPP
+
+// (C) Copyright Vaucher Philippe 2006
+
+// Use, modification and distribution is subject to the 
+// Boost Software License, Version 1.0. (See accompanying
+// file LICENSE-1.0 or http://www.boost.org/LICENSE-1.0)
+// Author: Vaucher Philippe 2006
+
+
+// -------------------------- QueryPerformanceCounter() --------------------------
+
+// Properties:
+//   Win2k (PIT):
+//     - 838 ns resolution.
+//     - ~3000 ns overhead.
+//   WinXP (PMT):
+//     - 279 ns resolution.
+//     - 700 ns overhead.
+//
+// Pros:
+//   - High resolution (usually the best one).
+//
+// Cons:
+//   - High overhead.
+//   - Not thread safe.
+//   - Multi core problems. To solve the issue you can #define BOOST_QPC_SET_AFFINITY which will call SetThreadAffinityMask() for you.
+//
+// Issues:
+//   1) Q274323: may jump several seconds under heavy PCI bus load.
+//      not a problem, because the older systems on which this occurs
+//      have safe TSCs, so that is used instead.
+//   2) "System clock problem can inflate benchmark scores":
+//      incorrect value if not polled every 4.5 seconds?
+
+
+// -------------------------- Includes --------------------------
+
+#ifndef BOOST_WINDOWS
+    #error "QueryPerformanceCounter() can only be used on windows"
+#else
+
+// Boost headers
+#include <boost/throw_exception.hpp>
+#include <boost/date_time/posix_time/posix_time.hpp>
+
+// Windows headers
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+
+
+// -------------------------- Code --------------------------
+
+namespace boost
+{
+
+class qpc_device
+{
+
+  public:
+
+    typedef posix_time::ptime               time_type;
+    typedef time_type::time_duration_type   time_duration_type;
+
+    explicit qpc_device() : m_elapsed(0, 0, 0)
+    {
+        #ifdef BOOST_QPC_SET_AFFINITY
+        m_affinity = SetThreadAffinityMask(GetCurrentThread(), 1);
+        #endif
+
+        m_start.QuadPart = 0;
+        if(!QueryPerformanceFrequency(&m_frequency))
+            throw_exception(std::runtime_error("qpc_device: QueryPerformanceFrequency() indicated there's no high-resolution performance counter"));
+
+        // Make it so we have the future results directly in milliseconds
+        m_frequency.QuadPart /= 1000;
+    }
+
+    ~qpc_device()
+    {
+        #ifdef BOOST_QPC_SET_AFFINITY
+        SetThreadAffinityMask(GetCurrentThread(), m_affinity);
+        #endif
+    }
+
+    void start() 
+    {
+        if(!m_start.QuadPart && !QueryPerformanceCounter(&m_start))
+            throw_exception(std::runtime_error("qpc_device: QueryPerformanceCounter() failed"));
+    }
+
+    const time_duration_type& elapsed() const
+    {
+        if(m_start.QuadPart)
+        {
+            LARGE_INTEGER current;
+            if(!QueryPerformanceCounter(&current))
+                throw_exception(std::runtime_error("qpc_device: QueryPerformanceCounter() failed"));
+            uint64_t milliseconds = (current.QuadPart - m_start.QuadPart) / m_frequency.QuadPart;
+            m_elapsed += posix_time::milliseconds(milliseconds);
+            m_start = current;
+        }
+        return m_elapsed;
+    }
+
+    void reset()
+    {
+        m_elapsed = time_duration_type(0,0,0);
+        m_start.QuadPart = 0;
+    }
+
+
+  private:
+
+    LARGE_INTEGER               m_frequency;
+    mutable LARGE_INTEGER       m_start;
+    mutable time_duration_type  m_elapsed;
+
+    #ifdef BOOST_QPC_SET_AFFINITY
+    DWORD_PTR                   m_affinity;
+    #endif
+
+};
+
+} // namespace boost
+
+#endif // BOOST_WINDOWS
+
+#endif // BOOST_TIMER_DEVICES_QPC_HPP

src/core/boost/timer/devices/clock.hpp

@@ -0,0 +1,85 @@
+#ifndef BOOST_TIMER_DEVICES_CLOCK_HPP
+#define BOOST_TIMER_DEVICES_CLOCK_HPP
+
+// (C) Copyright Vaucher Philippe 2006
+
+// Use, modification and distribution is subject to the 
+// Boost Software License, Version 1.0. (See accompanying
+// file LICENSE-1.0 or http://www.boost.org/LICENSE-1.0)
+// Author: Vaucher Philippe 2006
+
+// -------------------------- std::clock() --------------------------
+
+// Properties:
+//   - ??? ns resolution.
+//   - ??? ns overhead.
+//   - Is implemented with GetSystemTimeAsFileTime on windows.
+//
+// Pros:
+//   - Portable.
+//
+// Cons:
+//   - High resolution.
+
+
+// -------------------------- Includes --------------------------
+
+// Standard headers
+#include <ctime>
+
+// Boost headers
+#include <boost/date_time/posix_time/posix_time.hpp>
+
+
+// -------------------------- Code --------------------------
+
+namespace boost
+{
+
+//! The clock_device class is based on std::clock() to compute the time
+class clock_device
+{
+
+  public:
+
+    typedef posix_time::ptime               time_type;
+    typedef time_type::time_duration_type   time_duration_type;
+
+    explicit clock_device() : m_start(0), m_elapsed(0, 0, 0)
+    {
+    }
+
+    void start() 
+    {
+        if(!m_start)
+            m_start = std::clock();
+    }
+
+    const time_duration_type& elapsed() const
+    {
+        if(m_start)
+        {
+            std::clock_t current = std::clock();
+            m_elapsed += posix_time::milliseconds(static_cast<double>(current-m_start) / CLOCKS_PER_SEC * 1000.0);
+            m_start = current;
+        }
+        return m_elapsed;
+    }
+
+    void reset()
+    {
+        m_elapsed = time_duration_type(0,0,0);
+        m_start = 0;
+    }
+
+
+  private:
+
+    mutable std::clock_t        m_start;
+    mutable time_duration_type  m_elapsed;
+
+};
+
+} // namespace boost
+
+#endif // BOOST_TIMER_DEVICES_CLOCK_HPP

src/core/boost/timer/devices/date_time.hpp

@@ -0,0 +1,84 @@
+#ifndef BOOST_TIMER_DEVICES_DATE_TIME_HPP
+#define BOOST_TIMER_DEVICES_DATE_TIME_HPP
+
+// (C) Copyright Vaucher Philippe 2006
+
+// Use, modification and distribution is subject to the 
+// Boost Software License, Version 1.0. (See accompanying
+// file LICENSE-1.0 or http://www.boost.org/LICENSE-1.0)
+// Author: Vaucher Philippe 2006
+
+
+// -------------------------- date_time devices --------------------------
+
+// Properties:
+//   - windows: uses GetSystemTimeAsFileTime()
+//   - POSIX: uses gettimeofday()
+//
+// Pros:
+//   - Portable.
+
+
+// -------------------------- Includes --------------------------
+
+#include <boost/date_time/posix_time/posix_time.hpp>
+
+
+// -------------------------- Code --------------------------
+
+namespace boost
+{
+
+//! The date_time device
+template <class Clock, class Time = posix_time::ptime>
+class date_time_device
+{
+
+  public:
+
+    typedef Clock clock_type;
+    typedef Time  time_type;
+    typedef typename clock_type::time_duration_type time_duration_type;
+
+    explicit date_time_device() : m_start(date_time::not_a_date_time), m_elapsed(0, 0, 0)
+    {
+    }
+
+    void start()
+    {
+        if(m_start.is_not_a_date_time())
+            m_start = clock_type::local_time();
+    }
+
+    const time_duration_type& elapsed() const
+    {
+        if(!m_start.is_not_a_date_time())
+        {
+            time_type current(clock_type::local_time());
+            m_elapsed += (current - m_start);
+            m_start = current;
+        }
+        return m_elapsed;
+    }
+
+    void reset()
+    {
+        m_start   = date_time::not_a_date_time;
+        m_elapsed = time_duration_type(0,0,0);
+    }
+
+
+  private:
+
+    mutable time_type           m_start;
+    mutable time_duration_type  m_elapsed;
+
+};
+
+// Convenience typedefs
+typedef date_time_device<posix_time::microsec_clock>    microsec_device;
+typedef date_time_device<posix_time::second_clock>      second_device;
+
+} // namespace boost
+
+#endif // BOOST_TIMER_DEVICES_DATE_TIME_HPP

src/core/boost/timer/devices/gettimeofday.hpp

@@ -0,0 +1,98 @@
+#ifndef BOOST_TIMER_DEVICES_GTOD_HPP
+#define BOOST_TIMER_DEVICES_GTOD_HPP
+
+// (C) Copyright Vaucher Philippe 2006
+
+// Use, modification and distribution is subject to the 
+// Boost Software License, Version 1.0. (See accompanying
+// file LICENSE-1.0 or http://www.boost.org/LICENSE-1.0)
+// Author: Vaucher Philippe 2006
+
+// -------------------------- gettimeofday() --------------------------
+
+// Properties:
+//   - ??? ns resolution.
+//   - ??? ns overhead.
+//
+// Pros:
+//   - Low overhead.
+//   - High resolution.
+
+
+// -------------------------- Includes --------------------------
+
+// Get config
+#include <boost/config.hpp>
+
+// Check we have gettimeofday()
+#ifndef BOOST_HAS_GETTIMEOFDAY
+    #error "gettimeofday() can only be used on POSIX systems"
+#else
+
+// Boost headers
+#include <boost/date_time/posix_time/posix_time.hpp>
+
+// Linux headers
+#include <sys/time.h>
+
+// -------------------------- Code --------------------------
+
+namespace boost
+{
+
+//! The gtod_device class is based on gettimeofday() to compute the time
+class gtod_device
+{
+
+  public:
+
+    typedef posix_time::ptime               time_type;
+    typedef time_type::time_duration_type   time_duration_type;
+
+    explicit gtod_device() : m_elapsed(0, 0, 0)
+    {
+        std::memset(&m_start, 0, sizeof(timeval));
+    }
+
+    void start() 
+    {
+        if(!is_time(m_start))
+            gettimeofday(&m_start, 0);
+    }
+
+    const time_duration_type& elapsed() const
+    {
+        if(is_time(m_start))
+        {
+            timeval current;
+            gettimeofday(&current, 0);
+            m_elapsed += posix_time::milliseconds((current.tv_sec-m_start.tv_sec) * 1000 + ((current.tv_usec-m_start.tv_usec) / 1000.0));
+            m_start = current;
+        }
+        return m_elapsed;
+    }
+
+    void reset()
+    {
+        m_elapsed = time_duration_type(0,0,0);
+        std::memset(&m_start, 0, sizeof(timeval));
+    }
+
+
+  private:
+
+    bool is_time(const timeval& value) const
+    {
+        return value.tv_sec || value.tv_usec;
+    }
+
+    mutable timeval m_start;
+    mutable time_duration_type m_elapsed;
+
+};
+
+} // namespace boost
+
+#endif // BOOST_HAS_GETTIMEOFDAY
+
+#endif // BOOST_TIMER_DEVICES_GTOD_HPP

src/core/boost/timer/devices/timeGetTime.hpp

@@ -0,0 +1,94 @@
+#ifndef BOOST_TIMER_DEVICES_TGT_HPP
+#define BOOST_TIMER_DEVICES_TGT_HPP
+
+// (C) Copyright Vaucher Philippe 2006
+
+// Use, modification and distribution is subject to the 
+// Boost Software License, Version 1.0. (See accompanying
+// file LICENSE-1.0 or http://www.boost.org/LICENSE-1.0)
+// Author: Vaucher Philippe 2006
+
+// -------------------------- std::clock() --------------------------
+
+// Properties:
+//   - 1 ms resolution.
+//   - ??? ns overhead.
+//
+// Pros:
+//   - Low overhead.
+//
+// Cons:
+//   - Low resolution.
+
+// -------------------------- Includes --------------------------
+
+#ifndef BOOST_WINDOWS
+    #error "timeGetTime() can only be used on windows"
+#else
+
+// Boost headers
+#include <boost/cstdint.hpp>
+#include <boost/date_time/posix_time/posix_time.hpp>
+
+// Windows headers
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+
+// Automagically link winmm.lib if we can
+#pragma comment(lib, "winmm.lib")
+
+
+// -------------------------- Code --------------------------
+
+namespace boost
+{
+
+//! The tgt_device class is based on timeGetTime() to compute the time
+class tgt_device
+{
+
+  public:
+
+    typedef posix_time::ptime               time_type;
+    typedef time_type::time_duration_type   time_duration_type;
+
+    explicit tgt_device() : m_start(0), m_elapsed(0, 0, 0)
+    {
+    }
+
+    void start() 
+    {
+        if(!m_start)
+            m_start = timeGetTime();
+    }
+
+    const time_duration_type& elapsed() const
+    {
+        if(m_start)
+        {
+            uint32_t current = timeGetTime();
+            m_elapsed += posix_time::milliseconds(current - m_start);
+            m_start = current;
+        }
+        return m_elapsed;
+    }
+
+    void reset()
+    {
+        m_elapsed = time_duration_type(0,0,0);
+        m_start = 0;
+    }
+
+
+  private:
+
+    mutable uint32_t m_start;
+    mutable time_duration_type m_elapsed;
+
+};
+
+} // namespace boost
+
+#endif // BOOST_WINDOWS
+
+#endif // BOOST_TIMER_DEVICES_TGT_HPP

src/core/boost/timer/implementation.hpp

@@ -0,0 +1,107 @@
+#ifndef BOOST_TIMER_IMPLEMENTATION_HPP
+#define BOOST_TIMER_IMPLEMENTATION_HPP
+
+// (C) Copyright Vaucher Philippe 2006
+
+// Use, modification and distribution is subject to the 
+// Boost Software License, Version 1.0. (See accompanying
+// file LICENSE-1.0 or http://www.boost.org/LICENSE-1.0)
+// Author: Vaucher Philippe 2006
+
+
+// -------------------------- Code --------------------------
+
+namespace boost
+{
+
+    //! The timer class takes a device type that's used for the elapsed time computation.
+    //! Calling start(), pause() or resume() twice has no special effects.
+    template<class Device>
+    class timer
+    {
+
+    public:
+
+        typedef Device device_type;
+        typedef typename device_type::time_duration_type time_duration_type;
+
+        enum start_options { auto_start = 1, manual_start };
+
+        //! By default, start the timer without any time offset
+        explicit timer(time_duration_type initial_duration = time_duration_type(0, 0, 0), start_options start_op = auto_start)
+            : m_elapsed(initial_duration), m_running(false)
+        {
+            if(start_op == auto_start)
+                start();
+        }
+
+        //! Starts the timer
+        void start() 
+        {
+            if(!m_running)
+            {
+                m_device.start();
+                m_running = true;
+            }
+        }
+
+        //! Restarts the timer
+        void restart()
+        {
+            reset();
+            start();
+        }
+
+        //! Returns the elapsed time
+        time_duration_type elapsed() const
+        {
+            return m_running ? (m_device.elapsed() + m_elapsed) : m_elapsed;
+        }
+
+        //! Pauses the timer
+        void pause()
+        {
+            if(m_running)
+            {
+                m_elapsed += m_device.elapsed();
+                m_device.reset();
+                m_running = false;
+            }
+        }
+
+        //! Resumes the timer
+        void resume()
+        {
+            if(!m_running)
+            {
+                m_device.start();
+                m_running = true;
+            }
+        }
+
+        //! Resets the timer
+        void reset()
+        {
+            m_elapsed = time_duration_type(0,0,0);
+            m_device.reset();
+            m_running = false;
+        }
+
+        //! Tells wether the timer is currently running or not
+        bool is_running() const
+        {
+            return m_running;
+        }
+
+
+    private:
+
+        mutable device_type         m_device;
+        mutable time_duration_type  m_elapsed;
+        bool                        m_running;
+
+    };
+
+} // namespace boost
+
+#endif // BOOST_TIMER_IMPLEMENTATION_HPP

src/core/boost/timer/typedefs.hpp

@@ -0,0 +1,55 @@
+#ifndef BOOST_TIMER_TYPEDEFS_HPP
+#define BOOST_TIMER_TYPEDEFS_HPP
+
+// (C) Copyright Vaucher Philippe 2006
+
+// Use, modification and distribution is subject to the 
+// Boost Software License, Version 1.0. (See accompanying
+// file LICENSE-1.0 or http://www.boost.org/LICENSE-1.0)
+// Author: Vaucher Philippe 2006
+
+
+// -------------------------- Includes --------------------------
+
+#include <boost/date_time/posix_time/posix_time.hpp>
+
+#include "boost/timer/implementation.hpp"
+#include "boost/timer/devices.hpp"
+
+
+// -------------------------- Devices --------------------------
+
+namespace boost
+{
+
+// boost::date_time devices
+typedef timer<microsec_device>   microsec_timer;
+typedef timer<second_device>     second_timer;
+
+// std::clock() device
+typedef timer<clock_device> clock_timer;
+
+#ifndef BOOST_WINDOWS
+
+    // gettimeofday() device
+    typedef timer<gtod_device> gtod_timer;
+
+#else
+
+    // QueryPerformanceCounter() device
+    typedef timer<qpc_device> qpc_timer;
+
+    // timeGetTime() device
+    typedef timer<tgt_device> tgt_timer;
+
+    // GetSystemTimeAsFileTime() device
+    typedef timer<gstaft_device> gstaft_timer;
+
+    // GetTickCount() device
+    typedef timer<gtc_device> gtc_timer;
+
+#endif
+
+} // namespace boost
+
+#endif // BOOST_TIMER_TYPEDEFS_HPP

src/net/common/netpacket.cpp

@@ -80,7 +80,7 @@ struct NetPacketJoinGameAckData
 	u_int16_t			numberOfPlayers;
 	u_int16_t			smallBlind;
 	u_int16_t			handsBeforeRaise;
-	u_int16_t			reserved;
+	u_int16_t			proposedGuiSpeed;
 	u_int32_t			startCash;
 };
 
@@ -443,6 +443,7 @@ NetPacketJoinGameAck::SetData(const NetPacketJoinGameAck::Data &inData)
 	tmpData->numberOfPlayers	= htons(inData.gameData.numberOfPlayers);
 	tmpData->smallBlind			= htons(inData.gameData.smallBlind);
 	tmpData->handsBeforeRaise	= htons(inData.gameData.handsBeforeRaise);
+	tmpData->proposedGuiSpeed	= htons(inData.gameData.guiSpeed);
 	tmpData->startCash			= htonl(inData.gameData.startCash);
 }
 
@@ -458,6 +459,7 @@ NetPacketJoinGameAck::GetData(NetPacketJoinGameAck::Data &outData) const
 	outData.gameData.numberOfPlayers	= ntohs(tmpData->numberOfPlayers);
 	outData.gameData.smallBlind			= ntohs(tmpData->smallBlind);
 	outData.gameData.handsBeforeRaise	= ntohs(tmpData->handsBeforeRaise);
+	outData.gameData.guiSpeed			= ntohs(tmpData->proposedGuiSpeed);
 	outData.gameData.startCash			= ntohl(tmpData->startCash);
 }
 

src/net/common/serverrecvstate.cpp

@@ -23,9 +23,12 @@
 #include <net/senderthread.h>
 #include <net/netpacket.h>
 #include <net/socket_msg.h>
+#include <net/netexception.h>
 #include <core/rand.h>
 #include <gamedata.h>
 
+#include <core/boost/timer.hpp>
+
 using namespace std;
 
 #define SERVER_WAIT_TIMEOUT_MSEC	50
@@ -47,6 +50,9 @@ ServerRecvStateInit::Instance()
 ServerRecvStateInit::ServerRecvStateInit()
 : m_curUniquePlayerId(0)
 {
+	boost::microsec_timer::time_duration_type dur;
+	boost::microsec_timer t(dur);
+	t.start();
 }
 
 ServerRecvStateInit::~ServerRecvStateInit()
@@ -62,8 +68,8 @@ ServerRecvStateInit::HandleNewConnection(ServerRecvThread &server, boost::shared
 	RandomBytes((unsigned char *)&sessionId, sizeof(sessionId)); // TODO: check for collisions.
 
 	// Create a new session.
-	boost::shared_ptr<SessionData> sessionData(new SessionData(sessionId));
-	server.AddSession(connData, sessionData);
+	boost::shared_ptr<SessionData> sessionData(new SessionData(connData->ReleaseSocket(), sessionId));
+	server.AddSession(sessionData);
 }
 
 int
@@ -74,8 +80,19 @@ ServerRecvStateInit::Process(ServerRecvThread &server)
 
 	if (recvSock != INVALID_SOCKET)
 	{
-		boost::shared_ptr<NetPacket> packet = server.GetReceiver().Recv(recvSock);
 		boost::shared_ptr<SessionData> session = server.GetSession(recvSock);
+		boost::shared_ptr<NetPacket> packet;
+		try
+		{
+			packet = server.GetReceiver().Recv(recvSock);
+		} catch (const NetException &e)
+		{
+			if (session.get())
+			{
+				//server.CloseSessionDelayed(session);
+				return retVal;
+			}
+		}
 
 		// Ignore if no session / no packet.
 		if (packet.get() && session.get())
@@ -83,7 +100,7 @@ ServerRecvStateInit::Process(ServerRecvThread &server)
 			// Session should be in initial state.
 			if (session->GetState() != SessionData::Init)
 			{
-				server.SendError(ERR_SOCK_INVALID_STATE, recvSock);
+				//server.SessionError(session, ERR_SOCK_INVALID_STATE);
 				return retVal;
 			}
 
@@ -91,7 +108,7 @@ ServerRecvStateInit::Process(ServerRecvThread &server)
 			const NetPacketJoinGame *tmpPacket = packet->ToNetPacketJoinGame();
 			if (!tmpPacket)
 			{
-				server.SendError(ERR_SOCK_INVALID_PACKET, recvSock);
+				//server.SessionError(session, ERR_SOCK_INVALID_PACKET);
 				return retVal;
 			}
 
@@ -101,38 +118,30 @@ ServerRecvStateInit::Process(ServerRecvThread &server)
 			// Check the protocol version.
 			if (joinGameData.versionMajor != NET_VERSION_MAJOR)
 			{
-				server.SendError(ERR_NET_VERSION_NOT_SUPPORTED, recvSock);
+				//server.SessionError(session, ERR_NET_VERSION_NOT_SUPPORTED);
 				return retVal;
 			}
 
 			// Check the server password.
 			if (!server.CheckPassword(joinGameData.password))
 			{
-				server.SendError(ERR_NET_INVALID_PASSWORD, recvSock);
+				//server.SessionError(session, ERR_NET_INVALID_PASSWORD);
 				return retVal;
 			}
 
-			PlayerDataList &playerDataList = server.GetPlayerDataList();
+			size_t curNumPlayers = server.GetCurNumberOfPlayers();
 
 			// Check the number of players.
-			if (playerDataList.size() >= (size_t)server.GetGameData().numberOfPlayers)
+			if (curNumPlayers >= (size_t)server.GetGameData().numberOfPlayers)
 			{
-				server.SendError(ERR_NET_SERVER_FULL, recvSock);
+				//server.SessionError(session, ERR_NET_SERVER_FULL);
 				return retVal;
 			}
 
 			// Check whether this player is already connected.
-			PlayerDataList::const_iterator player_i = playerDataList.begin();
-			PlayerDataList::const_iterator player_end = playerDataList.end();
-			while (player_i != player_end)
+			if (server.IsPlayerConnected(joinGameData.playerName))
 			{
-				if ((*player_i)->GetName() == joinGameData.playerName)
-					break;
-				++player_i;
-			}
-			if (player_i != player_end)
-			{
-				server.SendError(ERR_NET_PLAYER_NAME_IN_USE, recvSock);
+				//server.SessionError(session, ERR_NET_PLAYER_NAME_IN_USE);
 				return retVal;
 			}
 
@@ -148,7 +157,7 @@ ServerRecvStateInit::Process(ServerRecvThread &server)
 			boost::shared_ptr<NetPacket> answer(new NetPacketJoinGameAck);
 			NetPacketJoinGameAck::Data joinGameAckData;
 			joinGameAckData.playerId = tmpPlayerData->GetUniqueId();
-			joinGameAckData.playerNumber = playerDataList.size();
+			joinGameAckData.playerNumber = 0;//playerDataList.size();
 			joinGameAckData.sessionId = session->GetId(); // TODO: currently unused.
 			joinGameAckData.gameData = server.GetGameData();
 			static_cast<NetPacketJoinGameAck *>(answer.get())->SetData(joinGameAckData);
@@ -156,7 +165,7 @@ ServerRecvStateInit::Process(ServerRecvThread &server)
 			session->SetState(SessionData::Established);
 
 			// Store player data in list.
-			playerDataList.push_back(tmpPlayerData);
+			//playerDataList.push_back(tmpPlayerData);
 		}
 	}
 	return retVal;

src/net/common/serverrecvthread.cpp

@@ -36,7 +36,9 @@ public:
 
 	virtual void SignalNetError(SOCKET sock, int errorID, int osErrorID)
 	{
-		// TODO
+		// We just ignore send errors for now, on server side.
+		// A send error should trigger a read error or a read
+		// returning 0 afterwards, and we will handle this error.
 	}
 
 private:
@@ -247,17 +249,7 @@ ServerRecvThread::CleanupSessionMap()
 {
 	boost::mutex::scoped_lock lock(m_sessionMapMutex);
 
-	// We need to manually close all sockets for the sessions.
-	// This is "not great", but there are some issues when
-	// automatically closing them.
-	SocketSessionMap::iterator i = m_sessionMap.begin();
-	SocketSessionMap::iterator end = m_sessionMap.end();
-
-	while (i != end)
-	{
-		CLOSESOCKET(i->first);
-		++i;
-	}
+	// Sockets will be closed automatically.
 	m_sessionMap.clear();
 }
 
@@ -289,19 +281,19 @@ ServerRecvThread::GetSession(SOCKET sock)
 }
 
 void
-ServerRecvThread::AddSession(boost::shared_ptr<ConnectData> connData, boost::shared_ptr<SessionData> sessionData)
+ServerRecvThread::AddSession(boost::shared_ptr<SessionData> sessionData)
 {
 	boost::mutex::scoped_lock lock(m_sessionMapMutex);
 
-	SocketSessionMap::iterator pos = m_sessionMap.lower_bound(connData->GetSocket());
+	SocketSessionMap::iterator pos = m_sessionMap.lower_bound(sessionData->GetSocket());
 
 	// If pos points to a pair whose key is equivalent to the socket, this handle
 	// already exists within the list.
-	if (pos != m_sessionMap.end() && connData->GetSocket() == pos->first)
+	if (pos != m_sessionMap.end() && sessionData->GetSocket() == pos->first)
 	{
 		throw ServerException(ERR_SOCK_CONN_EXISTS, 0);
 	}
-	m_sessionMap.insert(pos, SocketSessionMap::value_type(connData->ReleaseSocket(), sessionData));
+	m_sessionMap.insert(pos, SocketSessionMap::value_type(sessionData->GetSocket(), sessionData));
 }
 
 SenderThread &
@@ -331,10 +323,34 @@ ServerRecvThread::CheckPassword(const std::string &password) const
 	return (password == m_password);
 }
 
-PlayerDataList &
-ServerRecvThread::GetPlayerDataList()
+size_t
+ServerRecvThread::GetCurNumberOfPlayers() const
 {
-	return m_playerDataList;
+	boost::mutex::scoped_lock lock(m_sessionMapMutex);
+	return m_sessionMap.size();
+}
+
+bool
+ServerRecvThread::IsPlayerConnected(const std::string &playerName) const
+{
+	bool retVal = false;
+	boost::mutex::scoped_lock lock(m_sessionMapMutex);
+
+	SocketSessionMap::const_iterator session_i = m_sessionMap.begin();
+	SocketSessionMap::const_iterator session_end = m_sessionMap.end();
+
+	while (session_i != session_end)
+	{
+		const boost::shared_ptr<PlayerData> tmpPlayerData = session_i->second->GetPlayerData();
+		if (tmpPlayerData.get() && tmpPlayerData->GetName() == playerName)
+		{
+			retVal = true;
+			break;
+		}
+
+		++session_i;
+	}
+	return retVal;
 }
 
 ServerSenderCallback &

src/net/common/sessiondata.cpp

@@ -19,12 +19,14 @@
 
 #include <net/sessiondata.h>
 
-SessionData::SessionData(unsigned id)
-: m_id(id), m_state(SessionData::Init)
+SessionData::SessionData(SOCKET sockfd, unsigned id)
+: m_sockfd(sockfd), m_id(id), m_state(SessionData::Init)
 {
 }
 
 SessionData::~SessionData()
 {
+	if (m_sockfd != INVALID_SOCKET)
+		CLOSESOCKET(m_sockfd);
 }
 

src/net/serverrecvthread.h

@@ -30,7 +30,6 @@
 #include <net/connectdata.h>
 #include <net/sessiondata.h>
 #include <net/servercallback.h>
-#include <playerdata.h>
 
 #define RECEIVER_THREAD_TERMINATE_TIMEOUT	200
 
@@ -79,7 +78,7 @@ protected:
 	void SetState(ServerRecvState &newState);
 
 	boost::shared_ptr<SessionData> GetSession(SOCKET sock);
-	void AddSession(boost::shared_ptr<ConnectData> connData, boost::shared_ptr<SessionData> sessionData);
+	void AddSession(boost::shared_ptr<SessionData> sessionData);
 
 	SenderThread &GetSender();
 	ReceiverHelper &GetReceiver();
@@ -87,7 +86,8 @@ protected:
 	const GameData &GetGameData() const;
 	bool CheckPassword(const std::string &password) const;
 
-	PlayerDataList &GetPlayerDataList();
+	size_t GetCurNumberOfPlayers() const;
+	bool IsPlayerConnected(const std::string &playerName) const;
 
 	ServerSenderCallback &GetSenderCallback();
 
@@ -109,7 +109,6 @@ private:
 	std::auto_ptr<ServerSenderCallback> m_senderCallback;
 	std::auto_ptr<GameData> m_gameData;
 
-	PlayerDataList m_playerDataList;
 	std::string m_password;
 
 	ServerCallback &m_callback;

src/net/sessiondata.h

@@ -21,6 +21,8 @@
 #ifndef _SESSIONDATA_H_
 #define _SESSIONDATA_H_
 
+#include <playerdata.h>
+#include <net/socket_helper.h>
 #include <string>
 
 #define SESSION_ID_INIT			0
@@ -30,7 +32,7 @@ class SessionData
 public:
 	enum State { Init, Established };
 
-	SessionData(unsigned id);
+	SessionData(SOCKET sockfd, unsigned id);
 	~SessionData();
 
 	unsigned GetId() const
@@ -40,15 +42,25 @@ public:
 	void SetState(State state)
 	{m_state = state;}
 
+	const boost::shared_ptr<PlayerData> GetPlayerData() const
+	{return m_playerData;}
+	void SetPlayerData(boost::shared_ptr<PlayerData> playerData)
+	{m_playerData = playerData;}
+
+	SOCKET GetSocket() const
+	{return m_sockfd;}
+
 	const std::string &GetClientAddr() const
 	{return m_clientAddr;}
 	void SetClientAddr(const std::string &addr)
 	{m_clientAddr = addr;}
 
 private:
-	unsigned			m_id;
-	State				m_state;
-	std::string			m_clientAddr;
+	SOCKET							m_sockfd;
+	unsigned						m_id;
+	State							m_state;
+	std::string						m_clientAddr;
+	boost::shared_ptr<PlayerData>	m_playerData;
 };
 
 #endif