Совместное создание игры

#ifndef GATE_H
#define GATE_H
///----------------------------------------------------------------------------|
/// "gate.h"
///----------------------------------------------------------------------------:
#include <SFML/Network.hpp>
 
#include <functional>
#include <iostream>
#include <map>
 
#include "model.h"
 
inline std::string cutStr(std::string s)
{   auto p = s.rfind("sources"); return s.substr(p, s.size() - p);
}
 
#define ASSERT(a) if(!(a)) \
{   std::cout << "ASSERT_ERROR: " \
              << "FILE: \"" << cutStr(__FILE__)  << "\", " \
              << "LINE: "   << __LINE__ \
              << "\n"; throw(-1); }
 
inline void showTestResult(const char* test, const bool result)
{   std::cout   << "  " << test << "::test() ---> "
                << (result ? "GOOD!" : "FAIL") << std::endl;
}
 
namespace minesweeper
{
    struct Game;
 
    ///------------------------------------------------------------------------|
    /// Парсер команд с аргументами.
    ///------------------------------------------------------------------------:
    struct  RPCParser
    {       RPCParser()
            {
            }
 
        ///----------------------------|
        /// Приём пакета.              |
        ///----------------------------:
        void operator<<(sf::Packet& p)
        {
            packet = &p;
 
            p >> command;
 
            sf::Uint32 Size; p >> Size;
 
            a.resize(Size);
 
            for(sf::Uint32 i = 0; i < Size; ++i) p >> a[i];
 
            packet->clear();
        }
 
        const Arr1d& getArgs() const { return a; }
 
        ///----------------------------|
        /// - команда.                 |
        /// - аргументы.               |
        /// - пакет входной/выходной.  |
        ///----------------------------:
        std::string             command;
        std::vector<unsigned>         a;
        sf::Packet*     packet{nullptr};
 
        ///----------------------------|
        /// Включить дебаг.            |
        ///----------------------------:
        inline static bool ISDEBUG{true};
 
        ///----------------------------|
        /// Дебаг.                     |
        ///----------------------------:
        std::string debug() const
        {
            if(!ISDEBUG) return "";
 
            std::stringstream   ss;
            {   ss << "command: \"" << command << ' ';
                for(const auto  e : a) ss << e << ' ';
            }
 
            std::string s(ss.str()); s.pop_back(); s += "\"\n";
            return      s;
        }
 
        bool isAnswer() const
        {   return packet != nullptr && 0 != packet->getDataSize();
        }
 
        ///----------------------------|
        /// Тест.                      |
        ///----------------------------:
        static void test()
        {
            bool result{true};
 
            RPCParser rpcParser;
 
            sf::Packet   p; p   << "inputPlot"
                                << sf::Uint32(2)
                                << sf::Uint32(20)
                                << sf::Uint32(25);
            rpcParser << p;
 
            ASSERT(rpcParser.command  == "inputPlot")
            ASSERT(rpcParser.a.size() ==  2)
            ASSERT(rpcParser.a[0]     == 20)
            ASSERT(rpcParser.a[1]     == 25)
 
            l(rpcParser.debug())
 
            showTestResult("RPCParser", result);
        }
    };
 
 
    namespace mns = minesweeper ;
    using  CArr1d = const Arr1d&;
    using  VobFoo = std::map<std::string, std::function<void()>>;
 
    ///------------------------------------------------------------------------|
    /// Все команды Сапёра.
    ///     -   "getVisual"         ответ массив : поле.
    ///     -   "startGame"         ответ "H W"  : Размер поля.
    ///     -   "inputPlot Y X "    ответ "E"    : Собщение(см.в model.h).
    ///     -   "setFlag Y X"       ответа_нет   : .
    ///------------------------------------------------------------------------:
    struct  HolderCommands : private VobFoo
    {       HolderCommands ( RPCParser& rpc);
 
        ///----------------------------|
        /// Вызов командной функции.   |
        ///----------------------------:
        void doCommand()
        {   if(const auto it = find(rpcParser.command); it != end())
            {   it->second();
            }
            else  throw("Command is absent!");
        }
 
        void reCreateGame(const unsigned W, const unsigned H);
 
    private:
        std::unique_ptr<Game> game;
        RPCParser&       rpcParser;
 
        void checkAmountArgs(CArr1d a, unsigned n)
        {   if(a.size() != n) throw("checkAmountArgs failed!");
        }
 
        bool isExistGame() const;
 
    public:
        ///----------------------------|
        /// Тест.                      |
        ///----------------------------:
        static void test();
 
        friend struct  Gate;
    };
 
 
    ///------------------------------------------------------------------------|
    /// Gate.
    ///------------------------------------------------------------------- Gate:
    struct  Gate
    {       Gate();
           ~Gate();
 
        ///----------------------------|
        /// Приём пакета.              |
        /// Ответ в этом же пакете!    |
        ///----------------------------:
        void operator<<(sf::Packet& p)
        {   try
            {   rpcParser << p;
                holderCommands.doCommand();
            }
            catch(const char* error)
            {   std::cout << "ERROR: " << error << std::endl;
                p.clear();
                return;
            }
        }
 
    private:
        RPCParser      rpcParser     ;
        HolderCommands holderCommands;
 
        std::string debugView() const;
 
    public:
        ///----------------------------|
        /// Тест.                      |
        ///----------------------------:
        static void test();
    };
}
 
#endif // header guard

    struct HolderCommands;
    using  CArr1d  = const Arr1d&;
    using  VobFoos = std::map<std::string, std::function<void(HolderCommands*)>>;
 
    ///------------------------------------------------------------------------|
    /// Все команды Сапёра.
    ///     -   "startGame"         ответ "H W"    : Размер поля.
    ///     -   "getVisual"         ответ "массив" : Поле.
    ///     -   "inputPlot X Y"     ответ "EVENT"  : Собщение(см.в model.h).
    ///     -   "setFlag   X Y"     ответа_нет     : .
    ///------------------------------------------------------------------------:
    struct  HolderCommands
    {       HolderCommands ( RPCParser& rpc);
 
        ///----------------------------|
        /// Вызов командной функции.   |
        ///----------------------------:
        void doCommand()
        {   if(const auto it = foo.find(rpcParser.command); it != foo.end())
            {   it->second(this);
            }
            else  throw("Command is absent!");
        }
 
        void reCreateGame(const unsigned W, const unsigned H);
 
    private:
        std::unique_ptr<Game> game;
        RPCParser&       rpcParser;
 
        ///----------------------------|
        /// Коллекция команд.          |
        ///----------------------------:
        static VobFoos foo;
 
        void checkAmountArgs(CArr1d a, unsigned n)
        {   if(a.size() != n) throw("checkAmountArgs failed!");
        }
 
        bool isExistGame() const;
 
    public:
        ///----------------------------|
        /// Тест.                      |
        ///----------------------------:
        static void  test();
        
        friend struct  Gate;
    };

  const w = 6, h = 4, w_val = ImageSource->Width / w, h_val = ImageSource->Height / h, w_dif = (ImageSandbox->Width - ImageSource->Width) / (w-1), h_dif = (ImageSandbox->Height - ImageSource->Height) / (h-1);
  double w_koef = ImageSource->Picture->Bitmap->Width / ImageSource->Width;
  double h_koef = ImageSource->Picture->Bitmap->Height / ImageSource->Height;
  int i, j;
  for (i = 0; i <= h; i++)
  {
    ImageDest->Canvas->MoveTo(0, ImageDest->Height*i/h-0.1);
    ImageDest->Canvas->LineTo(ImageDest->Width, ImageDest->Height*i/h-0.1);
  }
 
  for (i = 0; i <= w; i++)
  {
    ImageDest->Canvas->MoveTo(ImageDest->Width*i/w-0.1, 0);
    ImageDest->Canvas->LineTo(ImageDest->Width*i/w-0.1, ImageDest->Height);
  }
 
  for (i = 0; i < w; i++)
    for (j = 0; j < h; j++)
    {
      ImageDest->Canvas->TextOutW(ImageDest->Left + i * w_val, ImageDest->Top + j * h_val, j*w+i+1);
      ImageSandbox->Canvas->CopyRect(Rect(i*(w_val+w_dif), j*(h_val+h_dif), i*(w_val+w_dif)+w_val, j*(h_val+h_dif)+h_val), ImageSource->Canvas, Rect(i*w_val*w_koef, j*h_val*h_koef, (i+1)*w_val*w_koef, (j+1)*h_val*h_koef));
//    BitBlt(ImageSandbox->Canvas->Handle, i*(w_val+w_dif), j*(h_val+h_dif), i*(w_val+w_dif)+w_val, j*(h_val+h_dif)+h_val, ImageSource->Canvas->Handle, i*w_val*w_koef, j*h_val*h_koef, SRCCOPY);
    }