Змейка

    m_coord +=
        wxGetKeyState(WXK_UP)? wxPoint(0, -10) : wxGetKeyState(WXK_DOWN) ? wxPoint(0, 10) : 
        wxGetKeyState(WXK_LEFT)? wxPoint(-10, 0) : wxGetKeyState(WXK_RIGHT)? wxPoint(10, 0) : wxPoint(10, 0);

    void DoMotion()
    {
        //for(size_t i=Sections.size()-2; i>-1; --i)
        //{
        //  std::swap(Sections[i].GetCoord(), Sections[i+1].GetCoord());
        //}
        Sections[Sections.size()-1].GetCoord()+=
            currSnakeDir==UP ? wxPoint(0, -10) : currSnakeDir==DOWN ? wxPoint(0, 10) :
            currSnakeDir==LEFT ? wxPoint(-10, 0) : currSnakeDir==RIGHT ? wxPoint(10, 0) : wxPoint(0, 0);
    }

    void DoMotion()
    {
        for(size_t i=Sections.size()-2; i>0; --i)
        {
            std::swap(Sections[i].GetCoord(), Sections[i+1].GetCoord());
        }
        Sections[1].SetCoord(Sections[0].GetCoord());
        Sections[0].GetCoord()+=
            currSnakeDir==UP ? wxPoint(0, -10) : currSnakeDir==DOWN ? wxPoint(0, 10) :
            currSnakeDir==LEFT ? wxPoint(-10, 0) : currSnakeDir==RIGHT ? wxPoint(10, 0) : wxPoint(0, 0);
    }

//Food.h
#include "wx/wx.h"
 
class MyFood
{
public:
    MyFood(MyCanvas* Canv, const int rad_=10)
    {
        canv=Canv;
        rad=rad_;
    }
 
    ~MyFood()
    {
    }
 
    void SetCoord(const wxPoint& s)
    {
        food_coord.x=s.x;
        food_coord.y=s.y;
    }
 
    const wxPoint GetCoord() const
    {
        return food_coord;
    }
    
    void DrawFood(wxDC& dc)
    {
        dc.SetBrush(wxColour("Red"));
        dc.DrawCircle(GetCoord(), rad);
    }
private:
    wxPoint food_coord;
    MyCanvas* canv;
    int rad;
};

//Snake.h
#include <wx/wx.h>
 
#include <vector>
 
class MyCanvas;
 
enum Direction
{
    UP,
    RIGHT, 
    LEFT,
    DOWN,
    NONE
};
 
class MySection
{
public:
    MySection(const size_t radius=5, const wxPoint& point=wxPoint(0, 0)):
      sect_coord(point), 
          rad(radius)
    {
    }
 
    wxPoint& GetCoord()
    {
        return sect_coord;
    }
 
    void SetCoord(const wxPoint& c)
    {
        sect_coord.x=c.x;
        sect_coord.y=c.y;
    }
 
    void Draw (wxDC& dc)
    {
        dc.DrawCircle(sect_coord, rad);
    }
 
private:
    wxPoint sect_coord;
    size_t rad;
};
 
class MySnake
{
public:
    MySnake(MyCanvas* c, size_t sect_count=1)
    {
        canv=c;
        Sections.resize(sect_count);
    }
 
    bool DoMotion(const wxSize& size, const int one_c=10)
    {
        static size_t cnt=0;
        if(Sections.size()>1)
        {
            for(size_t i=Sections.size()-2; i>0; --i)
            {
                std::swap(Sections[i].GetCoord(), Sections[i+1].GetCoord());
            }
            Sections[1].SetCoord(Sections[0].GetCoord());
        }
        Sections[0].GetCoord()+=
            currSnakeDir==UP ? wxPoint(0, -one_c) : currSnakeDir==DOWN ? wxPoint(0, one_c) :
            currSnakeDir==LEFT ? wxPoint(-one_c, 0) : currSnakeDir==RIGHT ? wxPoint(one_c, 0) : wxPoint(0, 0);
        if(!isNotWall(size)||(cnt>=Sections.size()&&!isNotBroke()))
            return false;
        ++cnt;
        return true;
    }
    
    void Draw(wxDC& dc)
    {
        dc.SetBrush(wxColour("White"));
        for(size_t i=0; i<Sections.size(); ++i)
        {
            Sections[i].SetCoord(Sections[i].GetCoord());
            Sections[i].Draw(dc);
        }
    }
 
    void SetDir(const Direction& New)
    {
        currSnakeDir=New;
    }
 
    void add()
    {
        Sections.push_back(MySection(5, wxPoint(Sections[0].GetCoord())));
    }
 
    bool isNotWall(const wxSize& sz)
    {
        if(((Sections[0].GetCoord().x>=sz.x)||(Sections[0].GetCoord().y>=sz.y)) ||
            ((Sections[0].GetCoord().x<0)||(Sections[0].GetCoord().y<0)))
        {
            return false;
        }
        return true;
    }
 
    bool isNotBroke()
    {
        for(size_t j=1; j<Sections.size(); ++j)
        {
            if(Sections[0].GetCoord()==Sections[j].GetCoord())
            {
                return false;
            }
        }
        return true;
    }
 
    MySection& operator [](const size_t idx)
    {
        return Sections[idx];
    }
 
    const std::vector<MySection>& GetVec() const
    {
        return Sections;
    }
private:
    std::vector<MySection> Sections;
    MyCanvas* canv;
    Direction currSnakeDir;
};

//Minimal.cpp
class MyCanvas : public wxScrolledWindow
{
public:
    MyCanvas(MyFrame* POb):
      wxScrolledWindow(POb, wxID_ANY, wxDefaultPosition,
        wxSize(640, 480)),Sn(new MySnake(this)), Food(new MyFood(this)), points(0)
    {
        m_timer.SetOwner(this);
        m_timer.Start(500);
    }
    ~MyCanvas()
    {
       delete Sn;
       delete Food;
    }
 
    size_t points;
protected:
    void OnTimer(wxTimerEvent& event);
    void OnPaint(wxPaintEvent& event);
    void OnKeyboard(wxKeyEvent& event);
    void Invalidate()
    {
        Refresh();
    }
 
    wxTimer m_timer;
 
private:
    void DoDraw(wxDC& dc, const wxPoint& pt, const wxPoint& old_pt);
    void DoMotion(const Direction& curr);
    void DrawFood(wxDC& dc);
    bool CheckCoord();
    bool IsEaten(const size_t point=10);
 
    MySnake* Sn;
    MyFood* Food;
 
    DECLARE_EVENT_TABLE()
};
//
void MyFrame::OnAbout(wxCommandEvent& WXUNUSED(event))
{
    wxMessageBox(wxString::Format(
                    _T("Hello, this is Snake Game\n"
                 )),
                 _T("About Application"),
                 wxOK | wxICON_INFORMATION,
                 this);
}
 
void MyCanvas::OnPaint(wxPaintEvent& WXUNUSED(event))
{
    wxPaintDC dc(this);
}
 
void MyCanvas::OnTimer(wxTimerEvent& WXUNUSED(event))
{
    wxSize CS = GetClientRect().GetSize();
    if(!Sn->DoMotion(CS))
    {
        m_timer.Stop();
        wxMessageBox(_T("Game over!\nYou lose!\n"), wxString::Format("You have %d points\n", points), wxOK | wxICON_ERROR, this);
        this->GetParent()->Close();
    }
    wxMemoryDC dc;
    dc.SelectObject(wxBitmap(CS.GetHeight(), CS.GetWidth()));
    Sn->Draw(dc);
    DrawFood(dc);
    wxClientDC clientDC(this);
    clientDC.Blit(wxPoint(0, 0), CS, &dc, wxPoint(0, 0));
}
 
void MyCanvas::OnKeyboard(wxKeyEvent& WXUNUSED(event))
{
    wxGetKeyState(WXK_UP) ? Sn->SetDir(UP) :
        wxGetKeyState(WXK_DOWN) ? Sn->SetDir(DOWN) :
        wxGetKeyState(WXK_RIGHT) ? Sn->SetDir(RIGHT) :
        wxGetKeyState(WXK_LEFT) ? Sn->SetDir(LEFT) :
        Sn->SetDir(NONE);
}
 
void MyCanvas::DrawFood(wxDC& dc)
{
    const int coord=10;
    static int cnt=0;
    const wxSize sz=GetClientRect().GetSize();
    if(cnt==0)
    {
        (*Food).SetCoord(wxPoint(coord*(rand()%(sz.x/coord)), coord*(rand()%(sz.y/coord))));
        while(!CheckCoord())
            (*Food).SetCoord(wxPoint(coord*(rand()%(sz.x/coord)), coord*(rand()%(sz.y/coord))));
    }
    if(IsEaten())
    {
        while(!CheckCoord())
            (*Food).SetCoord(wxPoint(coord*(rand()%(sz.x/coord)), coord*(rand()%(sz.y/coord))));
    }
    (*Food).DrawFood(dc);
    cnt++;
}
 
bool MyCanvas::CheckCoord()
{
    for(size_t i=0; i<Sn->GetVec().size(); ++i)
    {
        if(((*Sn)[i].GetCoord().x==(*Food).GetCoord().x)
            && ((*Sn)[i].GetCoord().y==(*Food).GetCoord().y))
            return false;
    }
    return true;
}
 
bool MyCanvas::IsEaten(const size_t point)
{
    if(((*Sn)[0].GetCoord().x==(*Food).GetCoord().x)
        && ((*Sn)[0].GetCoord().y==(*Food).GetCoord().y))
    {
        Sn->add();
        points+=point;
        return true;
    }
    return false;
}

// в конструкторе
Connect( wxEVT_PAINT, wxPaintEventHandler(MyCanvas::OnPaint) );
Connect( wxEVT_KEY_DOWN, wxKeyEventHandler(MyCanvas::OnKeyboard) );
Connect( wxEVT_TIMER, wxTimerEventHandler(MyCanvas::OnTimer) );

...
/*for(size_t i=Sections.size()-2; i>0; --i)
{
    std::swap(Sections[i].GetCoord(), Sections[i+1].GetCoord());
}
Sections[1].SetCoord(Sections[0].GetCoord());*/
Sections.insert( Sections.begin(), Sections.front() ); // !!!
Sections.pop_back();                                   // !!!
...

    case WXK_SPACE:
        {
            static int cnt=0;
            if(cnt%2==0)
            {
                m_timer.Stop();
                wxMessageBox(_T("Пауза!"), _T("\n"), wxOK, this);
            }
            else
            {
                m_timer.Start();
            }
            cnt++;
        }
        break;

// это вывод сообщения(какого угодно) на канве по середине окна
void MyCanvas::showMessage(const wxString& message)
{
    wxPaintDC dc(this);
    dc.SetFont( wxFont(16, wxFONTFAMILY_MODERN, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_LIGHT) );
    dc.SetTextForeground(wxColour("White"));
    wxSize ts = dc.GetTextExtent(message);
    dc.DrawText(message, (GetClientSize().x - ts.x)/2, (GetClientSize().y - ts.y)/2);
}
 
// установка паузы
void MyCanvas::Pause()
{
    if(pause_) m_timer.Start();
    else m_timer.Stop();
    pause_ = !pause_;
}

        case WXK_SPACE:
            Pause();
            Refresh();
        break;

if(pause_) showMessage("PAUSE");

    void SetDir(const Direction& New)
    {
        if((currSnakeDir==UP&&New==DOWN)||
            (currSnakeDir==DOWN&&New==UP)||
            (currSnakeDir==RIGHT&&New==LEFT)||
            (currSnakeDir==LEFT&&New==RIGHT))
            currSnakeDir=currSnakeDir;
        else
            currSnakeDir=New;
    }

    MyCanvas* Ob= new MyCanvas(this, wxPoint(0, 0), wxSize(1, 1));

    MyCanvas(MyFrame* POb):
      wxScrolledWindow(POb), Sn(new MySnake(this)), Food(new MyFood(this)), points(0), Sizer(new wxBoxSizer(0))
    {
        Sizer->Add(400, 400, 0, wxEXPAND);
        SetSizer(Sizer);
        m_timer.SetOwner(this);
        m_timer.Start(500);
    }