Змейка

//Food.h
#include "wx/wx.h"
 
class MyFood
{
public:
    MyFood(MyCanvas* Canv)
    {
    }
 
    ~MyFood()
    {
    }
 
    void SetFoodCoord(const wxPoint& s)
    {
        food_coord.x=s.x;
        food_coord.y=s.y;
    }
 
    const wxPoint GetFoodCoord() const
    {
        return food_coord;
    }
 
private:
    wxPoint food_coord;
};

//Snake.h
#include "wx/wx.h"
 
#include <deque>
 
class MyCanvas;
 
class MySection
{
public:
    MySection(MyCanvas* Canv)
    {
        sect_coord.x=0;
        sect_coord.y=0;
    }
 
    ~MySection()
    {
    }
    
    const wxPoint GetSectCoord() const
    {
        return sect_coord;
    }
 
    void SetSectCoord(const wxPoint& s)
    {
        sect_coord.x=s.x;
        sect_coord.y=s.y;
    }
 
    void Draw(wxDC& dc, const wxPoint& coord, const wxPoint& old_c);
 
protected:
    wxPoint sect_coord;
};
 
class MySnake
{
public:
    MySnake(MyCanvas* Canv)
    {
    }
 
    ~MySnake()
    {
    }
 
    std::deque<MySection>& GetSnake()
    {
        return Snake;
    }
 
    const size_t GetSnakeSize() const
    {
        return Snake.size();
    }
 
    MySection& operator [](int i)
    {
        return Snake[i];
    }
    
    void Draw(wxDC& dc, const wxPoint& coord, const wxPoint& old_c);
    
    void Redraw(wxDC& dc, const wxPoint& coord, const wxPoint& old_c);
private:
    std::deque<MySection> Snake;
};

//Snake.cpp
#include <wx/wx.h>
 
#include "Snake.h"
 
void MySection::Draw(wxDC& dc, const wxPoint& coord, const wxPoint& old_c)
{
    dc.DrawCircle(coord, 5);
}
 
void MySnake::Draw(wxDC& dc, const wxPoint& coord, const wxPoint& old_c)
{
    dc.SetBrush(wxColour("White"));
    for(size_t i=0; i<Snake.size(); ++i)
    {
        Snake[i].Draw(dc, old_c+wxPoint(i*10, 0), coord);
    }
    Redraw(dc, coord, old_c);
}
 
void MySnake::Redraw(wxDC& dc, const wxPoint& coord, const wxPoint& old_c)
{
    dc.SetBrush(wxColour("Gree"));
    Snake.begin()->Draw(dc, old_c, coord);
    Snake.insert(Snake.end(), Snake.front());
    Snake.pop_front();
    //Snake.erase(Snake.begin());
    //Snake.resize(Snake.size()+1);
    dc.SetBrush(wxColour("White"));
    Snake[Snake.size()-1].Draw(dc, coord+wxSize(30, 0), old_c);
}

//minimal.cpp
class MyFrame : public wxFrame
{
public:
    // ctor(s)
    MyFrame(const wxString& title);
 
    // event handlers (these functions should _not_ be virtual)
    void OnQuit(wxCommandEvent& event);
    void OnAbout(wxCommandEvent& event);
private:
    // any class wishing to process wxWidgets events must use this macro
    DECLARE_EVENT_TABLE()
};
 
class MyCanvas : public wxScrolledWindow
{
public:
    MyCanvas(MyFrame* POb):
      wxScrolledWindow(POb, wxID_ANY, wxDefaultPosition,
        wxSize(640, 480)),Sn(new MySnake(this)), Food(new MyFood(this))
    {
        m_timer.SetOwner(this);
        m_timer.Start(1000);
        Sn->GetSnake().resize(4, this);
    }
      ~MyCanvas()
      {
          delete Sn;
      }
protected:
    void OnTimer(wxTimerEvent& event);
    void OnPaint(wxPaintEvent& event);
    void OnKeyboard(wxKeyEvent& event);
    void Invalidate()
    {
        Refresh();
    }
 
    wxTimer m_timer;
    wxPoint m_coord;
    wxTimer food_timer;
    wxPoint old_m_coord;
 
private:
    enum Direction {UP, DOWN, RIGHT, LEFT} currDirection;
    void DoDraw(wxDC& dc, const wxPoint& pt, const wxPoint& old_pt);
    void DoMotion(const Direction& curr);
    void DrawFood(wxDC& dc);
    bool IsNotExist();
    bool IsAlive();
    //void RedrawSect(wxDC& dc, const wxPoint& pt);
 
    MySnake* Sn;
    MyFood* Food;
 
    DECLARE_EVENT_TABLE()
};
 
enum
{
    Minimal_Quit = wxID_EXIT,
 
    Minimal_About = wxID_ABOUT,
 
    Minimal_Hello = 1
};
 
 
BEGIN_EVENT_TABLE(MyFrame, wxFrame)
    EVT_MENU(Minimal_Quit,  MyFrame::OnQuit)
    EVT_MENU(Minimal_About, MyFrame::OnAbout)
END_EVENT_TABLE()
 
BEGIN_EVENT_TABLE(MyCanvas, wxScrolledWindow)
    EVT_PAINT(MyCanvas::OnPaint)
    EVT_TIMER(wxID_ANY, MyCanvas::OnTimer)
    EVT_KEY_DOWN(MyCanvas::OnKeyboard)
END_EVENT_TABLE()
 
IMPLEMENT_APP(MyApp)
 
bool MyApp::OnInit()
{
    if ( !wxApp::OnInit() )
        return false;
 
    // create the main application window
    MyFrame *frame = new MyFrame(_T("Draw line App"));
    frame->Show(true);
    return true;
}
 
MyFrame::MyFrame(const wxString& title)
       : wxFrame(NULL, wxID_ANY, title)
{
    SetIcon(wxICON(sample));
 
#if wxUSE_MENUS
    wxMenu *fileMenu = new wxMenu;
 
    wxMenu *helpMenu = new wxMenu;
 
    helpMenu->Append(Minimal_About, _T("&About...\tF1"), _T("Show about dialog"));
 
    fileMenu->Append(Minimal_Quit, _T("E&xit\tAlt-X"), _T("Quit this program"));
 
    wxMenuBar *menuBar = new wxMenuBar();
    menuBar->Append(fileMenu, _T("&File"));
    menuBar->Append(helpMenu, _T("&Help"));
 
    SetMenuBar(menuBar);
#endif 
 
#if wxUSE_STATUSBAR
    CreateStatusBar(2);
    SetStatusText(_T("Welcome to wxWidgets!"));
#endif 
    MyCanvas* Ob= new MyCanvas(this);
}
 
void MyFrame::OnQuit(wxCommandEvent& WXUNUSED(event))
{
    Close(true);
}
 
void MyFrame::OnAbout(wxCommandEvent& WXUNUSED(event))
{
    wxMessageBox(wxString::Format(
                    _T("Welcome to %s!\n")
                    _T("\n")
                    _T("This is the minimal wxWidgets sample\n")
                    _T("running under %s."),
                    wxVERSION_STRING,
                    wxGetOsDescription().c_str()
                 ),
                 _T("About wxWidgets minimal sample"),
                 wxOK | wxICON_INFORMATION,
                 this);
}
 
//void MyCanvas::DoDraw(wxDC& dc, const wxPoint& pt, const wxPoint& old_pt)
//{
//    dc.SetBrush(wxBrush(wxColour("White")));
//  static int cnt=0;
//  size_t i=0;
//  static wxPoint Coords;
//  for(i=0; i<Sn->GetSnakeSize(); ++i)
//  {
//      (*Sn)[i].SetSectCoord(old_pt+wxPoint(i*10, 0));
//      //if(cnt!=0&&i==Sn->GetSnakeSize()-1)
//      //  (*Sn)[Sn->GetSnakeSize()-1].SetSectCoord(Coords);
//      dc.DrawCircle((*Sn)[i].GetSectCoord(), 5);
//  }
//  dc.SetBrush(wxColour("GREE"));
//  dc.DrawCircle((*Sn)[0].GetSectCoord(), 5);
//  
//  //Sn->GetSnake().insert(Sn->GetSnake().begin(), Sn->GetSnake().front());
//  //Sn->GetSnake().pop_back();
//  DoMotion(currDirection);
//  Sn->GetSnake().erase(Sn->GetSnake().begin());
//  Sn->GetSnake().resize(Sn->GetSnakeSize()+1, MySection(this));
//  dc.SetBrush(wxColour("White"));
//  (*Sn)[Sn->GetSnakeSize()-1].SetSectCoord(pt+wxPoint(i*10, 0));
//  dc.DrawCircle((*Sn)[Sn->GetSnakeSize()-1].GetSectCoord(), 5);
//  //Coords=((*Sn)[Sn->GetSnakeSize()-1].GetSectCoord());
//  //cnt=1;
//}
 
void MyCanvas::OnPaint(wxPaintEvent& WXUNUSED(event))
{
    wxPaintDC dc(this);
    //DoDraw(dc, wxPoint(20, 20), wxPoint(20, 20));
}
 
void MyCanvas::OnTimer(wxTimerEvent& WXUNUSED(event))
{
    DoMotion(currDirection);
    wxMemoryDC dc;
    wxSize CS = GetClientRect().GetSize();
    dc.SelectObject(wxBitmap(CS.GetHeight(), CS.GetWidth()));
    //DoDraw(dc, m_coord, old_m_coord);
    Sn->Draw(dc, m_coord, old_m_coord);
    wxClientDC clientDC(this);
    clientDC.Blit(wxPoint(0, 0), CS, &dc, wxPoint(0, 0));
}
 
void MyCanvas::DoMotion(const Direction& curr)
{
    old_m_coord=m_coord;
    m_coord+=
        curr==UP ? wxPoint(0, -15) : curr==DOWN ? wxPoint(0, 15) :
        curr==LEFT ? wxPoint(-15, 0) : curr==RIGHT ? wxPoint(15, 0) : wxPoint(0, 0);
    //if (!IsAlive())
    //      exit(0);
}
 
void MyCanvas::OnKeyboard(wxKeyEvent& WXUNUSED(event))
{
    wxGetKeyState(WXK_UP) ? currDirection=UP :
        wxGetKeyState(WXK_DOWN) ? currDirection=DOWN :
        wxGetKeyState(WXK_RIGHT) ? currDirection=RIGHT :
        wxGetKeyState(WXK_LEFT) ? currDirection=LEFT :
        0;
}
 
void MyCanvas::DrawFood(wxDC& dc)
{
    const wxSize sz=GetClientRect().GetSize();
    dc.SetBrush(wxBrush(wxColour("Green")));
    Food->SetFoodCoord(wxPoint(rand()%sz.x, rand()%sz.y));
    dc.DrawCircle(Food->GetFoodCoord(), 15);
}
 
bool MyCanvas::IsNotExist()
{
    for(size_t i=0; i<Sn->GetSnakeSize(); ++i)
    {
        if(((*Sn)[i].GetSectCoord().x==(*Food).GetFoodCoord().x) &&
            ((*Sn)[i].GetSectCoord().y==(*Food).GetFoodCoord().y))
        {
            return false;
        }
    }
    return true;
}
 
bool MyCanvas::IsAlive()
{
    const wxSize sz=GetClientRect().GetSize();
    if(((*Sn)[0].GetSectCoord().x>=sz.x||(*Sn)[0].GetSectCoord().y>=sz.y) ||
        (((*Sn)[0].GetSectCoord().x<0)||(*Sn)[0].GetSectCoord().y<0))
    {
        wxMessageBox(_T("Game over!\nYou lose!\n"), _T("\n"), wxOK | wxICON_ERROR, this);
        return false;
    }
    return true;
}