Первый Pattern, первый квест

#include <SDL3/SDL.h>
#include <SDL3/SDL_main.h>
#include "SDL3/SDL_keycode.h"
#include "SDL3/SDL_render.h"
#include <functional>
#include <vector>
#include <cstdlib>
#include <iostream>

class Number
{
private:
  int N;
public:
  Number(int n){ N=n; }
  Number(Number& n){N=n.getNumber();}
  Number(Number&& n){N=n.getNumber();}
  int getNumber(){ return N; }
};

template<typename T>
class Component
{
private:
  std::vector<T> c;
  int ID;
public:
  virtual void Add(T t)
  {
    c.push_back(std::move(t));
  }
  void Del()
  {
    if(c.size()>0)
      {
	c.pop_back();
      }
  }
  int getSize()
  {
    return c.size();
  }
  typename std::vector<T>::iterator GetBegin()
  {
    return c.begin();
  }
  typename std::vector<T>::iterator GetEEnd()
  {
    return c.end();
  }
  typename std::vector<T>::reverse_iterator GetRBegin()
  {
    return c.rbegin();
  }
  typename std::vector<T>::reverse_iterator GetREnd()
  {
    return c.rend();
  }
  T GetEnd()
  {
    return c.back();
  }
  T GetI(int i)
  {
    return c[i];
  }
  int GetID()
  {
    return ID;
  }
  void SetID(int i)
  {
    ID=i;
  }
  virtual void Show()
  {
  }
  void Clear()
  {
    for(int i=0;i<c.size();i++)
      {
        delete c[i];
      }
    c.clear();
  }
};


template<typename T>
class Collection:public Component<T>
{
private:
  std::vector<T*> test;
public:
  Collection()
  {
  }
  void Insert(int p,T* t)
  {
    test.push_back(std::move(t));
    test[p]->SetID(p);
  }
  void GetEnd(int p)
  {
    test.pop_back();
  }
  T* GetI(int i)
  {
    return test[i];
  }
  void Show()
  {
    for(int i=0;i<test.size();i++)
      {
	test[i]->Show();
      }
  }
  void Clear()
  {
    for(int i=0;i<test.size();i++)
      {
        test[i]->Clear();
      }
    
    test.clear();
  }
  ///////////////for-range-based
  auto begin()
  {
    return test.begin();
  }
  auto end()
  {
    return test.end();
  }
  auto cbegin() const
  {
    return test.begin();
  }
  auto cend() const
  {
    return test.end();
  }
  auto begin() const
  {
    return test.begin();
  }
  auto end() const
  {
    return test.end();
  }
  ////////////////
};



template<typename T>
class Command
{
protected:
  Collection<T>* doc; 
public:
  virtual ~Command() {}
  virtual void Execute() = 0; 
  virtual void unExecute() = 0;

  void setDocument(  Collection<T>* _doc )
  {
    doc = _doc; 
  }
};

template<typename T>
class InsertCommand : public Command<T>
{
  int line; 
  T* str;
public:
  InsertCommand( int _line, T* _str ): line( _line )
  {
    str = new T;
      str->Add(_str->GetEnd());
  }
  void Execute()
  {
    Command<T>::doc->GetI(line)->Add( str->GetEnd() );
  }

  void unExecute()
  {
    Command<T>::doc->GetI( line )->Del();
    delete str;
  }
};


template<typename T>
class DeleteCommand : public Command<T>
{
  int line; 
  T* str;
public:
  DeleteCommand( int _line,T* _str ): line( _line )
  {
    str = new T;
  }
  void Execute()
  {
	str->Add( Command<T>::doc->GetI(line)->GetEnd() );
	Command<T>::doc->GetI(line)->Del();
  }
  void unExecute()
  {
    Command<T>::doc->GetI(line)->Add( str->GetEnd() );

    delete str;
  }
};


template<typename T>
class Invoker
{
  std::vector<Command<T>*> DoneCommands; 
  Collection<T>* doc; 
  Command<T>* command; 
public:
  void Insert( int line, T* str )
  {
    command = new InsertCommand( line, str); 
      
    command->setDocument( doc ); 

    command->Execute(); 
    DoneCommands.push_back( command ); 
  }
  void Delete(int line, T* str)
  {
    command = new DeleteCommand(line,str); 
      
    command->setDocument( doc ); 

    command->Execute(); 
    DoneCommands.push_back( command ); 
  }
  void Undo()
  {
    if( DoneCommands.size() == 0 )
      {
	//std::cout << "There is nothing to undo!" << std::endl; 
      }
    else
      {
	command = DoneCommands.back(); 
	DoneCommands.pop_back(); 
	command->unExecute();
	delete command;
      }
  }
  void SetDoc( Collection<T> *_doc )
  {
    doc=_doc;
  }
  void Show()     
  {
    doc->Show();
  }
  void Clear()
  {
    for(auto& e: DoneCommands)
      {
	delete e;
      }
    DoneCommands.clear();
    doc->Clear();
  }
};

template<typename T>
class One:public Component<T>
{
private:
  
public:
  One()
  {

  }
  void Show() override {
    typename std::vector<T>::iterator it=this->GetBegin();
    for(;it<this->GetEEnd();it++)
      {
	//SDL_Log("%d",(*it)->getNumber());
	std::cout << (*it)->getNumber();
      }
    std::cout<<std::endl;
  }
  ~One()
  {
   
  }
};

template<typename T>
class Two:public Component<T>
{
private:
  
public:
  Two()
  {

  }
  void Show() override {
    typename std::vector<T>::iterator it=this->GetBegin();
    for(;it<this->GetEEnd();it++)
      {
	std::cout << (*it)->getNumber();
      }
    std::cout<<std::endl;
  }
  ~Two()
  {
   
  }
};

class ValidationEntry {
public:
  int id;
  std::function<Number*()> getNumber;//every
  const char* message;
};


class ValidRules {
public:
  int id;
  std::function<bool()> getRule;//everyRule/everyQuest
  const char* message;
};

void setAction(Invoker<Component<Number*>>& inv,std::vector<int> pT,Component<Number*>* cG);

bool Iteration(Collection<Component<Number*>> coll)
{
  return (coll.GetI(0)->getSize()==5&&coll.GetI(1)->getSize()==5);
}

Number* getEnd(Collection<Component<Number*>> coll,int i)
{
  return  coll.GetI(i)->GetEnd();
}

int main(int argc, char const *argv[])
{
  SDL_Init(SDL_INIT_EVENTS|SDL_INIT_VIDEO);
  SDL_Event e;
  bool run=false;
  SDL_Window* win;
  SDL_Renderer* ren;
  SDL_CreateWindowAndRenderer(0,1200,900,0,&win,&ren);

  One<Number*>* one=new One<Number*>();
  Two<Number*>* two=new Two<Number*>();
  
  one->Add(new Number(rand()%6));
  two->Add(new Number(rand()%6));
		      
  Collection<Component<Number*>> collection;
  Invoker<Component<Number*>> inv;
  
  std::vector<int> pT={0,1};
  
  collection.Insert(0,one);
  collection.Insert(1,two);
  
  inv.SetDoc(&collection);

  std::vector< ValidationEntry > validations = {//justvalidation
    {0,[&]() -> Number* { return getEnd(collection,0); },""},
    {1,[&]() -> Number* { return getEnd(collection,1); },""}
  };

  std::vector< ValidRules > validQuests = {//quest
    {0, [&]() -> bool { return Iteration(collection); }, "For check questEnd"}
  };
  ////
  int counter=0;
  srand(time(NULL));
  while(!run)
    {
      while(SDL_PollEvent(&e))
	{
	  switch(e.type)
	    {
	    case SDL_EVENT_QUIT:
	      run = true;
	      break;
	    case SDL_EVENT_KEY_DOWN:
	      switch(e.key.key)
		{
		case SDLK_LEFT:
		  //SDL_Log("Left");
		  if(!Iteration(collection)&&counter<5)
		    {
		      one->Add(new Number(rand()%6));
		      two->Add(new Number(rand()%6));
		      counter++;
		    }
		  
		  inv.Show();
	      	  break;
		case SDLK_UP:
		  //SDL_Log("UP");
		  break;
		case SDLK_DOWN:
		  //SDL_Log("DOWN");
		  inv.Undo();
		  inv.Undo();
		  inv.Show();
		  break;
		case SDLK_RIGHT:
		  //SDL_Log("RIGHT");
		  setAction(inv,pT,one);
		  inv.Show();
		  break;
		}
	      break;
	    }
	}
      SDL_RenderClear(ren);
      SDL_SetRenderDrawColor(ren, 10, 10, 10, 255);
      
      SDL_RenderPresent(ren);
      SDL_Delay(60);
    }

  inv.Clear();
  SDL_Quit();
  delete one;
  delete two;
  return 0;
}

void setAction(Invoker<Component<Number*>>& inv,std::vector<int> pT,Component<Number*>* cG) {
  inv.Insert(pT[1],cG);//second-to
  inv.Delete(pT[0],cG);//first-from
}