Создание событий

class Timer{
  //Здесь необходимо объявить событие onTick 
};
 
 
class Clock{
  
  Timer timer;  
 
public:
  Clock(){
    //Здесь необходимо подписаться на событие в timer.onTick с обработчиком timer_tick
  }
 
  void timer_tick(){
  }
};

#include <stdio.h>
 
// КЛАСС 1 (источник события)
[event_source(native)]
class Timer{
public:
   __event void onTick();
};
 
// КЛАСС 2 (получатель события)
[event_receiver(native)]
class Clock{
public:
   void timer_tick(int nValue) {
   }
 
   void hookEvent(Timer* timer) {
      __hook(&Timer::onTick, timer, &Clock::timer_tick);
    }
 
   void unhookEvent(Timer* timer) {
      __unhook(&Timer::onTick, timer, &Clock::timer_tick);
   }
};
 
// КЛАСС 3 (связывает 2 класса по событию)
int main() {
   Timer timer;
   Clock clock;
 
   clock.hookEvent(&timer);
   __raise timer.onTick();
   clock.unhookEvent(&timer);
}

// КЛАСС 1
class Timer{
  void (*onTick)();
}
 
// КЛАСС 2
class Clock{
  void onTick(){
  }
}
 
//КЛАСС 3 (ну или главная процедура)
int main(){
  Timer timer;
  Clock clock;
 
  timer.onTick=clock.onTick;
  
  return 0;
}

///----------------------------------------------------------------------------|
/// Делегаты почти, как в шарпе ...
///----------------------------------------------------------------------------:
#include <map>
#include <vector>
#include <iostream>
#include <functional>
#include <string_view>
#include <windows.h>
 
///----------------------------------------------------------------------------|
/// Работа с временными интервалами.
///----------------------------------------------------------------------------:
///--------------------------|
/// Event.                   |
///--------------------------:
struct  Event
{       Event(std::function<void()> cb, float s) : callback(cb), sec(s)
        {       id++;
        }
       ~Event(){id--;}
 
private:
    std::function<void()> callback;
    float                      sec;
    size_t                      id; ///<<<---В этом месте тонко ...
    float                     when;
    static size_t              cnt;
 
    friend struct Count_tick;
};
size_t Event::cnt = 0;
 
///--------------------------|
/// Глобальный тикер.        |
///--------------------------:
struct Count_tick
{
    void operator++(int)
    {   ++tick.ll;
 
        for(auto&[id, e] : events)
        {   if(e->when <= static_cast<float>(tick.ll))
            {   e->callback();
                e->when += e->sec;
            }
        }
    }
    int get() {return tick.i;}
 
    void operator+=(Event* e)
    {   events[e->id] = e;
        e->when = static_cast<float>(tick.ll) + e->sec;
    }
 
    void operator-=(Event* e)
    {   if(auto p = events.find(e->id); p != events.end())
        {   events.erase(p);
        }
    }
 
private:
    union
    {   int        i;
        long long ll;
    }tick{0};
 
    std::map<size_t, Event*> events;
}CNT_tick;
 
static void foo1()
{   std::cout << "start Gun-01\n";
}
 
static void foo2()
{   std::cout << "start Gun-02\n";
}
 
static void del(Event* e)
{   CNT_tick -= e;
    std::cout << "del--------------\n";
}
 
Event* E;
 
///--------------------------|
/// Тест.                    |
///--------------------------:
inline void testclass_Timer_tick()
{
    ///----------------------------------|
    /// Какие нам нужны события?         |
    ///----------------------------------:
    Event e1(foo1, 10); /// Повторять foo1 через каждую секунду.
    Event e2(foo2, 15); /// Повторять foo2 через каждые 1.5 секунд.
 
    E = &e1;
    Event e3([=](){del(E);}, 70); /// Через 7 секунд отписываемся от e1.
 
    ///----------------------------------|
    /// Подписка на события.             |
    ///----------------------------------:
    CNT_tick += &e1;
    CNT_tick += &e2;
    CNT_tick += &e3;
 
    ///----------------------------------|
    /// Игровой цикл.                    |
    ///----------------------------------:
    while(true)
    {   CNT_tick++;
 
        /// ...
 
        Sleep(100);
    }
}
 
int main()
{   testclass_Timer_tick();
}

/// C++17
///----------------------------------------------------------------------------|
/// DEMO.
///
/// Делегаты: почти, как в шарпе ... (на примере работы с таймером)
/// version(2021.08.31)
///
/// Модель применения:
///     1. определить событие Event и  действие Delegate.
///     2. подписать Delegate на выполнение на заданный временной интервал.
///     3. возможно два варианта: в цикле или только один раз.
///     4. при необходимости можно отписаться от выполнения.
///
///----------------------------------------------------------------------------:
#include <map>
#include <thread>
#include <vector>
#include <chrono>
#include <iostream>
#include <functional>
#include <string_view>
 
#define  l(v) std::cout << #v << " = " << v << "\n";
 
/// #include "myl.h"
///----------------------------------------------------------------------------|
/// Май библа.                                                                 |
///----------------------------------------------------------------------------:
namespace myl
{
    void pause(float seconds)
    {   const size_t ms = static_cast<size_t>(seconds * 1000);
        std::this_thread::sleep_for(std::chrono::milliseconds {ms});
    }
 
    struct  Eventtime;
    typedef std::chrono::high_resolution_clock::time_point tmpoint_t;
    ///------------------------------------------------------------------------|
    /// а-ля шарповский Делегат.
    ///------------------------------------------------------------------------:
    struct  Delegate
    {
        enum eREPEAT { ONCE, LOOP, NONE };
 
            Delegate(std::function<void()> cb, float s, eREPEAT r = ONCE)
                :   callback(cb), 
                    sec     (s ), 
                    repeat  (r )
 
            {   id  = ++cnt;
            }
           ~Delegate()
            {   tick_delete(); --cnt;
            }
 
        Eventtime* get_host_event() const { return count_tick; }
 
    private:
        std::function<void()> callback  ;
        float                 sec       ;
        eREPEAT               repeat    ;
 
        tmpoint_t             point_when;
        static size_t         cnt       ;
        size_t                id        ;
 
        Eventtime*            count_tick;
        void               tick_delete();
        friend struct          Eventtime;
    };
    size_t Delegate::cnt = 0;
 
    ///------------------------------------------------------------------------|
    /// а-ля шарповский Ивент.
    ///------------------------------------------------------------------------:
    struct  Eventtime
    {       Eventtime(const char* nm = "noname") : name(nm)
            {
            }
 
        void operator()()
        {   std::vector<Delegate*> del;
 
            for(auto&[id, e] : delegates)
            {   if(e->point_when <= look())
                {   std::cout << "[Eventtime " << name << "]: ";
                    e->callback();
 
                    if(e->repeat == Delegate::ONCE) del.push_back(e);
                    else                         e->point_when = future(e->sec);
                }
            }
 
            for(auto& i : del) (*this) -= i;
        }
        auto get()
        {   return look();
        }
 
        void operator+=(Delegate* e)
        {   e->count_tick = this;
            delegates[e->id] = e   ;
            e->point_when = future(e->sec);
        }
 
        bool operator-=(const Delegate* e)
        {   if(auto p = delegates.find(e->id); p != delegates.end())
            {   delegates.erase(p);
                return true;
            }
            return false;
        }
 
        size_t size_delegates()
        {   return delegates.size();
        }
 
private:
        const char* name;
        std::map<size_t, Delegate*> delegates;
 
        tmpoint_t look()
        {   return std::chrono::high_resolution_clock::now();
        }
        tmpoint_t future(float fsec)
        {   std::chrono::milliseconds ms {static_cast<size_t>(fsec * 1000)};
            return look() + ms;
        }
 
    } GLOBAL_Eventtime("GLOBAL");
 
    void Delegate::tick_delete()
    {   std::cout << "Destructor id = ";
        (*count_tick) -= this;
        std::cout << id << '\n';
    }
 
}; // end namespace myl
 
///----------------------------------------------------------------------------|
/// Тест Game.
///     - два события
///     - на них можно подписаться - подписать делегатов.
///     - можно подписанные делегаты отписать.
///----------------------------------------------------------------------------:
struct Game
{   void go()
    {   ///----------------------------------|
        /// Готовим делегаты с поведением.   |
        ///----------------------------------:
                      // Повторять foo1 через каждую секунду.
        myl::Delegate e1 (               foo1,      1.0f, myl::Delegate::LOOP);
        
                      // Повторять foo2 через каждые 2 секунды.
        myl::Delegate e2 ([this]     (){ foo2();},  2.0f, myl::Delegate::LOOP);
        
                      // Через 7 секунд отписываемся от e2.
        myl::Delegate e3 ([this, &e2](){ del(&e2);     },  7.f);
        
                      // Завершаем цикл через 12 секунд.
        myl::Delegate fin([this]     (){ finish_game();}, 12.f);
 
        ///----------------------------------|
        /// Подписка                         |
        /// на события в ГЛОБАЛЬНОМ ивенте.  |
        ///----------------------------------:
        myl::GLOBAL_Eventtime += &e1;
        myl::GLOBAL_Eventtime += &e2;
      //myl::GLOBAL_Eventtime += &e3;
        myl::GLOBAL_Eventtime += &fin;
 
        ///----------------------------------|
        /// Подписка                         |
        /// на события в ЛОКАЛЬНОМ ивенте.   |
        ///----------------------------------:
        myl::Eventtime LOCAL__Eventtime("LOCAL ");
                       LOCAL__Eventtime += &e3;
 
        ///==================================|
        ///                                  |
        ///        Игровой цикл.             |
        ///                                  |
        ///==================================:
        while(done)
        {   myl::GLOBAL_Eventtime();
                 LOCAL__Eventtime();
 
            /// ...
 
            myl::pause(0.05f); /// (50ms) Холодный проц это хорошо.
        }
        ///==================================.
    }
 
private:
    bool done = true;
 
private:
    ///----------------------------------|
    /// Набор глаголов для подписок.     |
    ///----------------------------------:
    static void foo1(){   std::cout << "start Gun-01\n"; }
           void foo2(){   std::cout << "start Gun-02\n"; }
           
    void finish_game()
    {   std::cout << "finish_game ...\n\n";
        done = false;
    }
 
    void del(const myl::Delegate* e)
    {   bool b = (*(e->get_host_event()) -= e);
        std::cout << "delete -------------- "
                  << (b ? "GOOD!" : "No..") << "\n";
    }
};
 
///----------------------------------------------------------------------------|
/// Старт тест.
///----------------------------------------------------------------------------:
int main()
{
    {   Game game;
             game.go();
    }
    l(myl::GLOBAL_Eventtime.size_delegates())
 
    {   Game game;
             game.go();
    }
    l(myl::GLOBAL_Eventtime.size_delegates())
 
    std::cout << "\nPROGRAM FINISH.\n";
    std::cin.get();
}

           ~Delegate()
            {   tick_delete(); --cnt;
            }

/// C++17
///----------------------------------------------------------------------------|
/// DEMO.
/// Шаблонный паттерн Delegate + Event.
///----------------------------------------------------------------------------:
#include <vector>
#include <string>
#include <iomanip>
#include <iostream>
#include <functional>
 
#define  l(v) std::cout<< std::setw(6) << (v) << " = "<< #v << "\n";
 
template<typename U, typename ... E>
using FX_t = std::function<U (E ...)>;
 
using F0_t = std::function<void (void)>;
 
template<typename U, typename ... E>
struct ITest
{   virtual U go(E ...) = 0;
};
 
template<>
struct ITest<void, void>
{   virtual void go() = 0;
};
 
///----------------------------------------------------------------------------|
/// Делегаты.
///----------------------------------------------------------------------------:
template<typename U, typename ... E>
struct  Delegate : public ITest<U, E ...>
{       Delegate(FX_t<U,E ...> f) { callback = f; }
 
    U   go(E ... x) { return callback(x ...  ); }
 
    FX_t<U,E ...> callback;
};
 
void testclass_Delegate()
{   auto lambda([](auto ... x){ return (x + ...);});
 
    ///----------------------------:
    Delegate<bool, bool>*
        ptest0 = new Delegate<bool, bool>([](bool b){ return 2 == 1;});
      l(ptest0->go(true))
 
    ///----------------------------:
    Delegate<int, int>*
        ptest1 = new Delegate<int, int>(lambda);
      l(ptest1->go(7))
 
    ///----------------------------:
    auto
        ptest2 = new Delegate<float, float, float>(lambda);
      l(ptest2->go(7.4f, 8.f))
 
    ///----------------------------:
    using S = std::string;
    ITest<S, S, S>*
        ptest3 = new Delegate<S, S, S>(lambda);
      l(ptest3->go("asd", "+qwe"))
 
    ///----------------------------:
    ptest3 = dynamic_cast<ITest<S, S, S>*>(ptest2);
 
    std::cout << "\nTEST: testclass_Delegate() FINISH.\n";
    std::cin.get();
}
 
///----------------------------------------------------|
/// Специализация с возвращаемым void.                 |
///----------------------------------------------------:
template<typename ... E>
struct Delegate<void, E ...> : public ITest<void, E ...>
{      Delegate(FX_t<void,E ...> f) { callback = f; }
 
    void    go(E ... x) { callback(x ...  ); }
 
    FX_t<void,E ...> callback;
};
 
///----------------------------------------------------|
/// Специализация без аргументов.                      |
///----------------------------------------------------:
template<>
struct Delegate<void, void> : public ITest<void>
{      Delegate(F0_t f) { callback = f; }
 
    void go(void) { callback(); }
 
    F0_t callback;
};
 
///----------------------------------------------------------------------------|
/// События.
///----------------------------------------------------------------------------:
#define DD Delegate<U,E ...>
template<typename U, typename ... E>
struct Event
{   std::vector<DD*> m;
    void operator+=(DD* p)
    {   m.push_back(p);
    }
 
    U run(E ... x)
    {   return m.back()->callback(x ...);
    }
};
#undef DD
 
///----------------------------------------------------|
/// Специализация с возвращаемым void.                 |
///----------------------------------------------------:
template<typename ... E>
struct Event<void, E ...>
{   std::vector<Delegate<void, E ...>*> m;
    void operator+=(Delegate<void, E ...>* p)
    {   m.push_back(p);
    }
 
    void run(E ... x)
    {   m.back()->callback(x ...);
    }
};
 
///----------------------------------------------------|
/// Специализация без аргументов.                      |
///----------------------------------------------------:
template<>
struct Event<void>
{   std::vector<Delegate<void>*> m;
    void operator+=(Delegate<void>* p)
    {   m.push_back(p);
    }
 
    void run()
    {   m.back()->callback();
    }
};
 
void testclass_Event()
{
    Delegate<int, int>          d1([](int x){ return x + 1;});
    Event   <int, int>          e1;
                                e1 += &d1;
                              l(e1.run(5));
 
    Delegate<float, float, int> d2([](float y, int x){ return y * x;});
    Event   <float, float, int> e2;
                                e2 += &d2;
                              l(e2.run(2.3f, 5));
 
    ///-----------------------------------------------------|
    /// Uses the partial specialization с возвращаемым void.|
    ///-----------------------------------------------------:
    auto lambda1([](float y, int x){ std::cout << "Spec: " << y * x << '\n';});
    Delegate<void, float, int>  d3(lambda1);
    Event   <void, float, int>  e3;
                                e3 += &d3;
                                e3.run(200.3f, 5);
 
    ///-----------------------------------------------------|
    /// Uses the partial specialization                     |
    ///     с возвращаемым void + без аргументов.           |
    ///-----------------------------------------------------:
    auto lambda2([](){ std::cout << "Spec: without args\n";});
    Delegate<void>              d4(lambda2);
    Event   <void>              e4;
                                e4 += &d4;
                                e4.run();
 
    std::cout << "\nTEST: testclass_Event() FINISH.\n";
    std::cin.get();
}
 
///----------------------------------------------------------------------------|
/// Старт тест.
///----------------------------------------------------------------------------:
int main()
{
    testclass_Delegate();
    testclass_Event   ();
 
    std::cout << "\nTESTS FINISH.\n";
    std::cin.get();
}

/// C++17
///----------------------------------------------------------------------------|
/// DEMO.
///
/// Делегаты: почти, как в шарпе ... (на примере работы с таймером)
/// version(2021.03.09)
///
/// Модель применения:
///     1. определить событие Delegate.
///     2. подписать событие на выполнение на заданный временной интервал.
///     3. возможно два варианта: в цикле или только один раз.
///     4. при необходимости можно отписаться от выполнения.
///
/// Update: ( + namespace Advanced)
///     5. теперь делегаты можно с любым количество аргументов,
///     6. и с любыми типами этих аргументов.
///     7. также Event умеет возвращает значения в векторе:
///     8. все подписанные делегаты сбрасывают значения в возвращаемый вектор.
///
///----------------------------------------------------------------------------:
#include <map>
#include <thread>
#include <vector>
#include <chrono>
#include <memory>
#include <iostream>
#include <functional>
#include <string_view>
 
#define  l(v) std::cout << #v << " = " << v << "\n";
 
template<class T>
inline void logm(const T& m, const char* mess = "")
{   if(m.empty()) return;
    std::cout << mess << ": ";
    for(const auto e : m) std::cout << e << ' ';
    std::cout << '\n';
}
 
/// #include "myl.h"
///----------------------------------------------------------------------------|
/// Май библа.                                                                 |
///----------------------------------------------------------------------------:
typedef std::chrono::high_resolution_clock::time_point tmpoint_t;
namespace Advanced
{
    template<typename U, typename ... E>
    using FL_t = std::function<U (E ...)>;
 
    enum eREPEAT { ONCE, LOOP, NONE };
    template<typename U, typename ... E> struct  Event;
    template<typename U, typename ... E>
    struct  Delegate
    {
            Delegate(FL_t<U,E ...> cb, float s, eREPEAT r = ONCE)
                :   callback(cb),
                    sec     (s ),
                    repeat  (r )
 
            {   id  = ++cnt;
            }
           ~Delegate()
            {   remove(); --cnt;
            }
 
        U operator()(E ... x) { return callback(x ...  ); }
        Event<U, E ...>* get_host_event() const { return pevent;}
 
    private:
        FL_t<U,E ...>    callback  ;
        float            sec       ;
        eREPEAT          repeat    ;
 
        tmpoint_t        point_when;
        static size_t    cnt       ;
        size_t           id        ;
 
        Event<U, E ...>* pevent    ;
        void             remove()  ;
 
        friend struct    Event<U, E ...>;
    };
 
    template<typename U, typename ... E>
    size_t Delegate<U, E ...>::cnt = 0;
 
    template<typename U, typename ... E>
    struct  Event
    {       Event(const char* nm = "noname") : name(nm)
            {
            }
 
        std::vector<U> operator()(E ... x)
        {   std::vector<Delegate<U, E ...>* > del;
            std::vector<U>                    res;
            for(auto&[id, e] : delegates)
            {   if(e->point_when <= look())
                {   std::cout << "[Eventtime " << name << "]: ";
 
                    res.push_back(e->callback(x ...));
 
                    if(e->repeat == ONCE) del.push_back(e);
                    else                  e->point_when = future(e->sec);
                }
            }
 
            for(auto& i : del) (*this) -= i;
            return res;
        }
 
        auto get(){ return look(); }
 
        void operator+=(Delegate<U, E ...>* e)
        {   e->pevent        = this          ;
            delegates[e->id] = e             ;
            e->point_when    = future(e->sec);
        }
 
        bool operator-=(const Delegate<U, E ...>* e)
        {   if(auto p = delegates.find(e->id); p != delegates.end())
            {   delegates.erase(p);
                return true;
            }
            return false;
        }
 
        size_t size_delegates()
        {   return delegates.size();
        }
 
    private:
        const char* name;
        std::map<size_t, Delegate<U, E ...>* > delegates;
 
        tmpoint_t look()
        {   return std::chrono::high_resolution_clock::now();
        }
        tmpoint_t future(float fsec)
        {   std::chrono::milliseconds ms {static_cast<size_t>(fsec * 1000)};
            return look() + ms;
        }
    };
 
    template<typename U, typename ... E>
    void Delegate<U, E ...>::remove()
    {   std::cout << "Destructor id = ";
        (*pevent) -= this              ;
        std::cout << id << '\n'        ;
    }
 
}; // end namespace Advanced
 
namespace myl
{
    void pause(float seconds)
    {   std::this_thread::sleep_for(std::chrono::milliseconds
        {   static_cast<size_t>(seconds * 1000)
        });
    }
 
    enum    eREPEAT { ONCE, LOOP, NONE };
    struct  Eventtime;
    ///------------------------------------------------------------------------|
    /// а-ля шарповский Делегат.
    ///------------------------------------------------------------------------:
    struct  Delegate
    {       Delegate(std::function<void()> cb, float s, eREPEAT r = ONCE)
                :   callback(cb),
                    sec     (s ),
                    repeat  (r )
 
            {   id  = ++cnt;
            }
           ~Delegate()
            {   remove(); --cnt;
            }
 
        Eventtime* get_host_event() const { return pevent; }
 
    private:
        std::function<void()> callback  ;
        float                 sec       ;
        eREPEAT               repeat    ;
 
        tmpoint_t             point_when;
        static size_t         cnt       ;
        size_t                id        ;
 
        Eventtime*            pevent    ;
        void                  remove()  ;
        friend struct         Eventtime ;
    };
    size_t Delegate::cnt = 0;
 
    ///------------------------------------------------------------------------|
    /// а-ля шарповский Ивент.
    ///------------------------------------------------------------------------:
    struct  Eventtime
    {       Eventtime(const char* nm = "noname") : name(nm)
            {
            }
 
        void operator()()
        {   std::vector<Delegate*> del;
 
            for(auto&[id, e] : delegates)
            {   if(e->point_when <= look())
                {   std::cout << "[Eventtime " << name << "]: ";
                    e->callback();
 
                    if(e->repeat == ONCE) del.push_back(e);
                    else                  e->point_when = future(e->sec);
                }
            }
 
            for(auto& i : del) (*this) -= i;
        }
 
        auto get()
        {   return look();
        }
 
        void operator+=(Delegate* e)
        {   e->pevent = this;
            delegates[e->id] = e   ;
            e->point_when = future(e->sec);
        }
 
        bool operator-=(const Delegate* e)
        {   if(auto p = delegates.find(e->id); p != delegates.end())
            {   delegates.erase(p);
                return true;
            }
            return false;
        }
 
        size_t size_delegates()
        {   return delegates.size();
        }
 
private:
        const char* name;
        std::map<size_t, Delegate*> delegates;
 
        tmpoint_t look()
        {   return std::chrono::high_resolution_clock::now();
        }
        tmpoint_t future(float fsec)
        {   std::chrono::milliseconds ms {static_cast<size_t>(fsec * 1000)};
            return look() + ms;
        }
 
    } GLOBAL_Eventtime("GLOBAL");
 
    void Delegate::remove()
    {   std::cout << "Destructor id = ";
        (*pevent) -= this;
        std::cout << id << '\n';
    }
 
}; // end namespace myl
 
///----------------------------------------------------------------------------|
/// Тест Game.
///     - два события
///     - на них можно подписаться - подписать делегатов.
///     - можно подписанные делегаты отписать.
///     ...
///     + Advanced.
///----------------------------------------------------------------------------:
struct Game
{   void go()
    {   ///----------------------------------|
        /// Какие нам нужны события?         |
        ///----------------------------------:
        // e1  - Повторять foo1 через каждую секунду.
        // e2  - Повторять foo2 через каждые 2 секунды.
        // e3  - Через 7 секунд отписываемся от e2.
        // fin - Завершаем цикл через 12 секунд.
 
        myl::Delegate e1 (          foo1,      1.0f, myl::LOOP);
        myl::Delegate e2 ([this](){ foo2(); }, 2.0f, myl::LOOP);
        myl::Delegate e3 ([this, &e2](){ del(&e2); },  7.f);
        myl::Delegate fin([this](){ finish_game(); }, 12.f);
 
        ///----------------------------------|
        /// Подписка на события              |
        /// в ГЛОБАЛЬНОМ ивенте.             |
        ///----------------------------------:
        myl::GLOBAL_Eventtime += &e1;
        myl::GLOBAL_Eventtime += &e2;
      //myl::GLOBAL_Eventtime += &e3;
        myl::GLOBAL_Eventtime += &fin;
 
        ///----------------------------------|
        /// Подписка на события              |
        /// в ЛОКАЛЬНОМ ивенте.              |
        ///----------------------------------:
        myl::Eventtime LOCAL__Eventtime("LOCAL ");
                       LOCAL__Eventtime += &e3;
 
    ///--------------------------------------|
    /// Advanced.                            |
    ///     Во избежании краша:              |
    ///     порядок создания(на стеке):      |
    ///     сначала Event, а затем Delegate. |
    ///--------------------------------------|
    /// ae-1 |
    ///------:
    auto lymbda1([](int x){ return x + 1;});
 
    Advanced::Event   <int, int> ae1("Advanced::event-1");
    Advanced::Delegate<int, int> d1 ( lymbda1, 2.f, Advanced::LOOP);
    ae1 += &d1;
 
    ///------|
    /// ae-2 |
    ///------:
    auto lymbda2([](float y, int x)->float{ return y * x    ;});
    auto lymbda3([](float y, int x)->float{ return y * x * 2;});
 
    using E = Advanced::Event   <float, float, int>;
    using D = Advanced::Delegate<float, float, int>;
 
    E ae2("Advanced::event-2");
    std::unique_ptr<D> d2(new D (lymbda2, 2.0f, Advanced::LOOP));
    std::unique_ptr<D> d3(new D (lymbda3, 4.0f, Advanced::LOOP));
    ae2 += d2.get();
    ae2 += d3.get();
 
        ///==================================|
        ///                                  |
        ///          Игровой цикл.           |
        ///                                  |
        ///==================================:
        while(done)
        {   myl::GLOBAL_Eventtime();
                 LOCAL__Eventtime();
 
            ///--------------|
            /// Advanced.    |
            ///--------------:
            logm(ae1(      5));
            logm(ae2(2.3f, 5));
 
            /// ...
 
            myl::pause(0.05f); /// (50ms) Холодный проц это хорошо.
        }
        ///==================================.
    }
 
private:
    bool done = true;
 
private:
    ///----------------------------------|
    /// Набор глаголов для подписок.     |
    ///----------------------------------:
    static void foo1(){   std::cout << "start Gun-01\n"; }
           void foo2(){   std::cout << "start Gun-02\n"; }
 
    void finish_game()
    {   std::cout << "finish_game ...\n\n";
        done = false;
    }
 
    void del(const myl::Delegate* e)
    {   bool b = (*(e->get_host_event()) -= e);
        std::cout << "delete -------------- "
                  << (b ? "GOOD!" : "No..") << "\n";
    }
};
 
///----------------------------------------------------------------------------|
/// Старт тест.
///----------------------------------------------------------------------------:
int main()
{
    {   Game game;
             game.go();
    }
    l(myl::GLOBAL_Eventtime.size_delegates())
 
    {   Game game;
             game.go();
    }
    l(myl::GLOBAL_Eventtime.size_delegates())
 
    std::cout << "\nPROGRAMM FINISH.\n";
    std::cin.get();
}

//Класс делегата (общий для всех событий)
template <class Arg>
class Delegate {
    class Owner {};
    typedef void (Owner::* Func)(Arg arg);
    Func func;
    Owner* classptr;
public:
    template <class T>
    Delegate(T* owner, void (T::* func)(Arg arg)) {
        this->classptr = reinterpret_cast<Owner*>(owner);
        this->func = reinterpret_cast<Func>(func);
    }
 
    void operator () (Arg arg) {
        if (classptr && func) (classptr->*func)(arg);
    }
};
 
 
//Класс параметра события
struct onTickArg {
    int arg1;
    float arg2;
 
    onTickArg (int arg1, float arg2) {
        this->arg1 = arg1;
        this->arg2 = arg2;
    }
};
 
//Таймер
class Timer{
public :
    //Объявляем событие
    Delegate<onTickArg*>* onTick = NULL;
 
    void tick(){
        //Вызов события
        if (onTick) (*onTick)(new onTickArg(10, 20.5f));
    }
}
 
//Часы
class Clock{
    Timer timer;
public:
    Clock{
        //Подписываемся на событие таймера
        timer.onTick = new Delegate<onTickArg*>(this, &Clock::timer_tick);
    }
 
    //Обработчик события
    void    timer_tick(){
    }
}