Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Partially applied patch #8618848 ("adjustment of bombs demo to wxBombsCE"). Applied the source changes only, not the project changes; (wx-)modernized the demo.

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@24919 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Dimitri Schoolwerth
2003-12-19 01:34:40 +00:00
parent 02a0c28d96
commit 0c65afdb45
5 changed files with 746 additions and 508 deletions
Download Patch File Download Diff File Expand all files Collapse all files

362
demos/bombs/bombs.cpp
View File

@@ -2,7 +2,7 @@
// Name: bombs.cpp // Name: bombs.cpp
// Purpose: Bombs game // Purpose: Bombs game
// Author: P. Foggia 1996 // Author: P. Foggia 1996
// Modified by: // Modified by: Wlodzimierz Skiba (ABX) 2003
// Created: 1996 // Created: 1996
// RCS-ID: $Id$ // RCS-ID: $Id$
// Copyright: (c) 1996 P. Foggia // Copyright: (c) 1996 P. Foggia
@@ -10,243 +10,275 @@
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__ #ifdef __GNUG__
#pragma implementation # pragma implementation
#endif #endif
#include "wx/wxprec.h" #include "wx/wxprec.h"
#ifdef __BORLANDC__
# pragma hdrstop
#endif
#ifndef WX_PRECOMP #ifndef WX_PRECOMP
#include "wx/wx.h" # include "wx/wx.h"
#endif //precompiled headers #endif //precompiled headers
#include "bombs.h" #include "bombs.h"
#include <time.h>
#include <stdlib.h> #include <stdlib.h>
#if defined(__WXGTK__) || defined(__WXX11__) || defined(__WXMOTIF__) || defined(__WXMAC__) || defined(__WXMGL__) #ifndef __WXWINCE__
#include "bombs.xpm" # include <time.h>
#endif #endif
IMPLEMENT_APP(AppClass) #if defined(__WXGTK__) || defined(__WXX11__) || defined(__WXMOTIF__) \
|| defined(__WXMAC__) || defined(__WXMGL__)
# include "bombs.xpm"
#endif
IMPLEMENT_APP(BombsApp)
#ifdef __WXWINCE__
STDAPI_(__int64) CeGetRandomSeed();
#endif
// Called to initialize the program // Called to initialize the program
bool AppClass::OnInit() bool BombsApp::OnInit()
{ {
srand((unsigned)time(NULL)); #ifdef __WXWINCE__
srand((unsigned) CeGetRandomSeed());
#else
srand((unsigned) time(NULL));
#endif
// Initialize all the top-level window members to NULL. m_frame = new BombsFrame(&m_game);
BombsFrame = NULL;
level=IDM_EASY;
BombsFrame = m_frame->NewGame(bombsID_EASY);
new BombsFrameClass(NULL, _T("wxBombs"), wxPoint(155, 165), wxSize(300, 300), wxMINIMIZE_BOX | wxSYSTEM_MENU | wxCAPTION | wxCLOSE_BOX );
int xmax=BombsFrame->BombsCanvas->field_width*BombsFrame->BombsCanvas->x_cell*X_UNIT; return true;
int ymax=BombsFrame->BombsCanvas->field_height*BombsFrame->BombsCanvas->y_cell*Y_UNIT;
BombsFrame->SetClientSize(xmax, ymax);
return TRUE;
} }
BEGIN_EVENT_TABLE(BombsFrameClass, wxFrame) BEGIN_EVENT_TABLE(BombsFrame, wxFrame)
EVT_MENU(IDM_EASY, BombsFrameClass::OnEasy) EVT_MENU(bombsID_EASY, BombsFrame::OnNewEasyGame)
EVT_MENU(IDM_MEDIUM, BombsFrameClass::OnMedium) EVT_MENU(bombsID_MEDIUM, BombsFrame::OnNewMediumGame)
EVT_MENU(IDM_DIFFICULT, BombsFrameClass::OnDifficult) EVT_MENU(bombsID_HARD, BombsFrame::OnNewHardGame)
EVT_MENU(IDM_EXIT, BombsFrameClass::OnExit) EVT_MENU(wxID_EXIT, BombsFrame::OnExit)
EVT_MENU(IDM_ABOUT, BombsFrameClass::OnAbout) EVT_MENU(wxID_ABOUT, BombsFrame::OnAbout)
EVT_MENU(IDM_RESTART, BombsFrameClass::OnRestart)
EVT_CLOSE(BombsFrameClass::OnCloseWindow)
END_EVENT_TABLE() END_EVENT_TABLE()
BombsFrameClass::BombsFrameClass(wxFrame *parent, const wxString& title, const wxPoint& pos, const wxSize& size, long style): BombsFrame::BombsFrame(BombsGame *game)
wxFrame(parent, -1, title, pos, size, style) : wxFrame(NULL, wxID_ANY, wxT("wxBombs"), wxDefaultPosition,
wxSize(300, 300), wxDEFAULT_DIALOG_STYLE|wxMINIMIZE_BOX)
{ {
// Initialize child subwindow members. m_game = game;
BombsCanvas = NULL;
SetIcon(wxICON(bombs)); SetIcon(wxICON(bombs));
CreateStatusBar(); #if wxUSE_STATUSBAR
CreateStatusBar();
// Create a menu bar for the frame #endif
wxMenuBar *menuBar1 = new wxMenuBar;
wxMenu *menu1 = new wxMenu;
menu1->Append(IDM_EXIT, _T("E&xit")); // , "Quit the program");
menu1->AppendSeparator();
menu1->Append(IDM_ABOUT, _T("&About...")); // , "Infos on wxBombs");
menuBar1->Append(menu1, _T("&File"));
wxMenu *menu2 = new wxMenu;
menu2->Append(IDM_RESTART, _T("&Restart")); // , "Clear the play field");
menu2->AppendSeparator();
menu2->Append(IDM_EASY, _T("&Easy"), wxEmptyString, TRUE); // "10x10 play field", TRUE);
menu2->Append(IDM_MEDIUM, _T("&Medium"), wxEmptyString, TRUE); // "15x15 play field", TRUE);
menu2->Append(IDM_DIFFICULT, _T("&Difficult"), wxEmptyString, TRUE); // "25x20 play field", TRUE);
menuBar1->Append(menu2, _T("&Game"));
SetMenuBar(menuBar1);
menuBar=menuBar1;
menuBar->Check(wxGetApp().level, TRUE);
// Create child subwindows. // Create a menu bar for the frame
BombsCanvas = new BombsCanvasClass(this); wxMenuBar *menuBar = new wxMenuBar;
wxMenu *menuFile = new wxMenu;
wxMenu *menuLevel = new wxMenu;
menuLevel->AppendRadioItem(bombsID_EASY, wxT("&Easy (10x10)\tCtrl-1"));
menuLevel->AppendRadioItem(bombsID_MEDIUM, wxT("&Medium (15x15)\tCtrl-2"));
menuLevel->AppendRadioItem(bombsID_HARD, wxT("&Hard (25x20)\tCtrl-3"));
// Ensure the subwindows get resized o.k. menuFile->Append(bombsID_NEWGAME, wxT("&New Game"),
// OnSize(width, height); menuLevel, wxT("Starts a new game"));
// Centre frame on the screen. menuFile->AppendSeparator();
Centre(wxBOTH); menuFile->Append(wxID_EXIT, wxT("E&xit"), wxT("Quits the application"));
// Show the frame. menuBar->Append(menuFile, wxT("&File"));
Show(TRUE);
wxMenu *menuHelp = new wxMenu;
menuHelp->Append(wxID_ABOUT, wxT("&About"),
wxT("Displays the program information") );
menuBar->Append(menuHelp, wxT("&Help"));
SetMenuBar(menuBar);
// Create child subwindows.
m_canvas = new BombsCanvas(this, m_game);
// Ensure the subwindows get resized o.k.
// OnSize(width, height);
// Centre frame on the screen.
Centre(wxBOTH);
// Show the frame.
Show();
} }
BombsFrameClass::~BombsFrameClass(void) void BombsFrame::OnExit(wxCommandEvent& WXUNUSED(event))
{ {
Close();
} }
void BombsFrameClass::OnCloseWindow(wxCloseEvent& WXUNUSED(event)) void BombsFrame::NewGame(int level)
{ {
this->Destroy();
int numHorzCells = 20, numVertCells = 20;
switch(level)
{
case bombsID_EASY:
numHorzCells = numVertCells = 10;
break;
case bombsID_MEDIUM:
numHorzCells = numVertCells = 15;
break;
case bombsID_HARD:
numHorzCells = 25; numVertCells = 20;
break;
default :
wxFAIL_MSG(wxT("Invalid level"));
break;
}
m_game->Init(numHorzCells, numVertCells);
GetMenuBar()->Check(level, true);
m_canvas->UpdateGridSize();
SetClientSize(m_canvas->GetGridSizeInPixels());
} }
void BombsFrameClass::OnExit(wxCommandEvent& WXUNUSED(event)) void BombsFrame::OnAbout(wxCommandEvent& WXUNUSED(event))
{ {
this->Destroy(); wxMessageBox(
wxT("wxBombs (c) 1996 by P. Foggia\n<foggia@amalfi.dis.unina.it>"),
wxT("About wxBombs") );
} }
void BombsFrameClass::OnRestart(wxCommandEvent& WXUNUSED(event)) void BombsFrame::OnNewEasyGame(wxCommandEvent& WXUNUSED(event))
{ {
BombsCanvas->UpdateFieldSize(); NewGame(bombsID_EASY);
int xmax=BombsCanvas->field_width*BombsCanvas->x_cell*X_UNIT;
int ymax=BombsCanvas->field_height*BombsCanvas->y_cell*Y_UNIT;
wxGetApp().BombsFrame->SetClientSize(xmax, ymax);
} }
void BombsFrameClass::OnAbout(wxCommandEvent& WXUNUSED(event)) void BombsFrame::OnNewMediumGame(wxCommandEvent& WXUNUSED(event))
{ {
wxMessageBox(_T("wxBombs (c) 1996 by P. Foggia\n<foggia@amalfi.dis.unina.it>"), _T("About wxBombs")); NewGame(bombsID_MEDIUM);
} }
void BombsFrameClass::OnEasy(wxCommandEvent& WXUNUSED(event)) void BombsFrame::OnNewHardGame(wxCommandEvent& WXUNUSED(event))
{ {
menuBar->Check(wxGetApp().level, FALSE); NewGame(bombsID_HARD);
wxGetApp().level=IDM_EASY;
menuBar->Check(wxGetApp().level, TRUE);
} }
void BombsFrameClass::OnMedium(wxCommandEvent& WXUNUSED(event)) BEGIN_EVENT_TABLE(BombsCanvas, wxPanel)
{ EVT_PAINT(BombsCanvas::OnPaint)
menuBar->Check(wxGetApp().level, FALSE); EVT_MOUSE_EVENTS(BombsCanvas::OnMouseEvent)
wxGetApp().level=IDM_MEDIUM; EVT_CHAR(BombsCanvas::OnChar)
menuBar->Check(wxGetApp().level, TRUE);
}
void BombsFrameClass::OnDifficult(wxCommandEvent& WXUNUSED(event))
{
menuBar->Check(wxGetApp().level, FALSE);
wxGetApp().level=IDM_DIFFICULT;
menuBar->Check(wxGetApp().level, TRUE);
}
BEGIN_EVENT_TABLE(BombsCanvasClass, wxWindow)
EVT_PAINT(BombsCanvasClass::OnPaint)
EVT_MOUSE_EVENTS(BombsCanvasClass::OnEvent)
END_EVENT_TABLE() END_EVENT_TABLE()
BombsCanvasClass::BombsCanvasClass(wxFrame *parent, const wxPoint& pos, const wxSize& size, long style): BombsCanvas::BombsCanvas(wxFrame *parent, BombsGame *game)
wxWindow(parent, -1, pos, size, style) : wxPanel(parent, wxID_ANY)
{ {
int sx, sy; m_game = game;
wxClientDC dc(this); int sx, sy;
wxFont font= BOMBS_FONT; wxClientDC dc(this);
dc.SetFont(font); wxFont font= BOMBS_FONT;
dc.SetFont(font);
long chw, chh; long chw, chh;
wxChar buf[]=_T("M"); wxString buf = wxT("M");
dc.GetTextExtent(buf, &chw, &chh); dc.GetTextExtent(buf, &chw, &chh);
dc.SetFont(wxNullFont); dc.SetFont(wxNullFont);
dc.SetMapMode(wxMM_METRIC); dc.SetMapMode(wxMM_METRIC);
int xcm = dc.LogicalToDeviceX(10); int xcm = dc.LogicalToDeviceX(10);
int ycm = dc.LogicalToDeviceY(10); int ycm = dc.LogicalToDeviceY(10);
// To have a square cell, there must be : // To have a square cell, there must be :
// sx*ycm == sy*xcm // sx*ycm == sy*xcm
if (chw*ycm < chh*xcm) if (chw*ycm < chh*xcm)
{ sy=chh; {
sx=chh*xcm/ycm; sy = chh;
sx = chh*xcm/ycm;
} }
else else
{ sx=chw; {
sy=chw*ycm/xcm; sx = chw;
sy = chw*ycm/xcm;
} }
x_cell = (sx+3+X_UNIT)/X_UNIT;
y_cell = (sy+3+Y_UNIT)/Y_UNIT; m_cellWidth = (sx+3+X_UNIT)/X_UNIT;
dc.SetMapMode(wxMM_TEXT); m_cellHeight = (sy+3+Y_UNIT)/Y_UNIT;
bmp=NULL; dc.SetMapMode(wxMM_TEXT);
UpdateFieldSize(); m_bmp = NULL;
} }
BombsCanvasClass::~BombsCanvasClass(void) BombsCanvas::~BombsCanvas()
{ {
if (bmp) if (m_bmp)
delete bmp; {
delete m_bmp;
m_bmp = NULL;
}
} }
// Called when canvas needs to be repainted. // Called when canvas needs to be repainted.
void BombsCanvasClass::OnPaint(wxPaintEvent& WXUNUSED(event)) void BombsCanvas::OnPaint(wxPaintEvent& WXUNUSED(event))
{ {
wxPaintDC dc(this); wxPaintDC dc(this);
// Insert your drawing code here. const int numHorzCells = m_game->GetWidth();
if (!bmp) const int numVertCells = m_game->GetHeight();
{ bmp=new wxBitmap(field_width*x_cell*X_UNIT+1, // Insert your drawing code here.
field_height*y_cell*Y_UNIT+1); if (!m_bmp)
if (bmp) {
{ wxMemoryDC memDC; wxSize size = dc.GetSize();
memDC.SelectObject(* bmp); m_bmp = new wxBitmap(size.GetWidth(), size.GetHeight());
DrawField(&memDC, 0, 0, field_width-1, field_height-1); if (m_bmp)
memDC.SelectObject(wxNullBitmap); {
wxMemoryDC memDC;
memDC.SelectObject(*m_bmp);
DrawField(&memDC, 0, 0, numHorzCells-1, numVertCells-1);
memDC.SelectObject(wxNullBitmap);
} }
} }
if (bmp)
{ wxMemoryDC memDC; if (m_bmp)
memDC.SelectObject(* bmp); {
dc.Blit(0, 0, field_width*x_cell*X_UNIT+1, wxMemoryDC memDC;
field_height*y_cell*Y_UNIT+1, memDC.SelectObject(*m_bmp);
&memDC, 0, 0, wxCOPY); wxSize size = dc.GetSize();
dc.Blit(0, 0, size.GetWidth(), size.GetHeight(),
&memDC, 0, 0, wxCOPY);
memDC.SelectObject(wxNullBitmap); memDC.SelectObject(wxNullBitmap);
} }
else else
DrawField(& dc, 0, 0, field_width-1, field_height-1); {
DrawField(&dc, 0, 0, numHorzCells-1, numVertCells-1);
}
} }
// Updates the field size depending on wxGetApp().level and void BombsCanvas::UpdateGridSize()
// redraws the canvas {
void BombsCanvasClass::UpdateFieldSize()
{ field_width=20;
field_height=20;
switch(wxGetApp().level) if (m_bmp)
{ case IDM_EASY: {
field_width=10; delete m_bmp;
field_height=10; m_bmp = NULL;
break; }
case IDM_MEDIUM:
field_width=15; Refresh();
field_height=15; }
break;
case IDM_DIFFICULT: wxSize BombsCanvas::GetGridSizeInPixels() const
field_width=25; {
field_height=20; return wxSize(m_cellWidth*X_UNIT*m_game->GetWidth(),
break; m_cellHeight*Y_UNIT*m_game->GetHeight());
} }
wxGetApp().Game.Init(field_width, field_height);
if (bmp)
delete bmp;
bmp=NULL;
wxWindow::Refresh();
}

155
demos/bombs/bombs.h
View File

@@ -2,108 +2,107 @@
// Name: bombs.h // Name: bombs.h
// Purpose: Bombs game // Purpose: Bombs game
// Author: P. Foggia 1996 // Author: P. Foggia 1996
// Modified by: // Modified by: Wlodzimierz Skiba (ABX) 2003
// Created: 1996 // Created: 1996
// RCS-ID: $Id$ // RCS-ID: $Id$
// Copyright: (c) 1996 P. Foggia // Copyright: (c) 1996 P. Foggia
// Licence: wxWindows licence // Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
#ifndef _INC_BOMBS_H #ifndef _WX_DEMOS_BOMBS_BOMBS_H_
#define _INC_BOMBS_H #define _WX_DEMOS_BOMBS_BOMBS_H_
#include "game.h" #include "game.h"
/* class BombsFrame;
* Forward declarations of all top-level window classes.
*/
class BombsFrameClass;
class AboutFrameClass;
/* /*
* Class representing the entire Application * Class representing the entire Application
*/ */
class AppClass: public wxApp class BombsApp: public wxApp
{ {
public: public:
BombsFrameClass *BombsFrame; virtual bool OnInit();
int level;
BombsGame Game; private :
BombsFrame *m_frame;
BombsGame m_game;
bool OnInit();
}; };
DECLARE_APP(AppClass) DECLARE_APP(BombsApp)
class BombsCanvasClass; class BombsCanvas;
class BombsFrameClass: public wxFrame class BombsFrame : public wxFrame
{ {
private: public:
protected:
public:
// Subwindows for reference within the program.
BombsCanvasClass *BombsCanvas;
wxMenuBar *menuBar;
// Constructor and destructor BombsFrame(BombsGame *bombsGame);
BombsFrameClass(wxFrame *parent, const wxString& title, const wxPoint& pos, const wxSize& size, long style);
~BombsFrameClass(void);
void OnCloseWindow(wxCloseEvent& event); void NewGame(int level);
void OnExit(wxCommandEvent& event);
void OnRestart(wxCommandEvent& event);
void OnAbout(wxCommandEvent& event);
void OnEasy(wxCommandEvent& event);
void OnMedium(wxCommandEvent& event);
void OnDifficult(wxCommandEvent& event);
DECLARE_EVENT_TABLE() private:
void OnNewEasyGame(wxCommandEvent& event);
void OnNewMediumGame(wxCommandEvent& event);
void OnNewHardGame(wxCommandEvent& event);
void OnExit(wxCommandEvent& event);
void OnAbout(wxCommandEvent& event);
BombsGame *m_game;
// Subwindows for reference within the program.
BombsCanvas *m_canvas;
DECLARE_EVENT_TABLE()
}; };
/* Menu identifiers // App specific menu identifiers
*/ enum
// File
#define BOMBSFRAMECLASS_FILE 1
// E&xit
#define IDM_EXIT 2
// About...
#define IDM_ABOUT 3
// Game
#define BOMBSFRAMECLASS_GAME 4
// &Restart
#define IDM_RESTART 5
// &Easy
#define IDM_EASY 6
// &Medium
#define IDM_MEDIUM 7
// &Difficult
#define IDM_DIFFICULT 8
class BombsCanvasClass: public wxWindow
{ {
private: bombsID_NEWGAME = wxID_HIGHEST,
protected: bombsID_EASY,
public: bombsID_MEDIUM,
int field_width, field_height; bombsID_HARD
int x_cell, y_cell;
wxBitmap *bmp;
// Constructor and destructor
BombsCanvasClass(wxFrame *parent, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = 0);
~BombsCanvasClass(void);
void OnPaint(wxPaintEvent& event);
void DrawField(wxDC *, int xc1, int yc1, int xc2, int yc2);
void RefreshField(int xc1, int yc1, int xc2, int yc2);
void Uncover(int x, int y);
void OnEvent(wxMouseEvent& event);
void UpdateFieldSize();
DECLARE_EVENT_TABLE()
}; };
/* Menu identifiers class BombsCanvas : public wxPanel
*/ {
public:
// Constructor and destructor
BombsCanvas(wxFrame *parent, BombsGame *game);
void UpdateGridSize();
wxSize GetGridSizeInPixels() const;
~BombsCanvas();
private:
void OnPaint(wxPaintEvent& event);
void DrawField(wxDC *, int xc1, int yc1, int xc2, int yc2);
void RefreshField(int xc1, int yc1, int xc2, int yc2);
void Uncover(int x, int y);
void OnMouseEvent(wxMouseEvent& event);
void OnChar(wxKeyEvent& event);
BombsGame *m_game;
wxBitmap *m_bmp;
// Cell size in pixels
int m_cellWidth;
int m_cellHeight;
DECLARE_EVENT_TABLE()
};
/* The following sizes should probably be redefined */ /* The following sizes should probably be redefined */
/* dimensions of a scroll unit, in pixels */ /* dimensions of a scroll unit, in pixels */
@@ -111,10 +110,14 @@ DECLARE_EVENT_TABLE()
#define Y_UNIT 4 #define Y_UNIT 4
/* the dimensions of a cell, in scroll units are in /* the dimensions of a cell, in scroll units are in
* BombsCanvasClass::x_cell and y_cell * BombsCanvas::x_cell and y_cell
*/ */
#ifdef __WXWINCE__
#define BOMBS_FONT wxFont(12, wxSWISS, wxNORMAL, wxNORMAL)
#else
#define BOMBS_FONT wxFont(14, wxROMAN, wxNORMAL, wxNORMAL) #define BOMBS_FONT wxFont(14, wxROMAN, wxNORMAL, wxNORMAL)
#endif
#endif /* mutual exclusion */ #endif // #ifndef _WX_DEMOS_BOMBS_BOMBS_H_

470
demos/bombs/bombs1.cpp
View File

@@ -2,7 +2,7 @@
// Name: bombs1.cpp // Name: bombs1.cpp
// Purpose: Bombs game // Purpose: Bombs game
// Author: P. Foggia 1996 // Author: P. Foggia 1996
// Modified by: // Modified by: Wlodzimierz Skiba (ABX) 2003
// Created: 1996 // Created: 1996
// RCS-ID: $Id$ // RCS-ID: $Id$
// Copyright: (c) 1996 P. Foggia // Copyright: (c) 1996 P. Foggia
@@ -15,211 +15,335 @@
*/ */
#ifdef __GNUG__ #ifdef __GNUG__
#pragma implementation # pragma implementation
#endif #endif
#include "wx/wxprec.h" #include "wx/wxprec.h"
#ifdef __BORLANDC__
# pragma hdrstop
#endif
#ifndef WX_PRECOMP #ifndef WX_PRECOMP
#include "wx/wx.h" # include "wx/wx.h"
#endif //precompiled headers #endif //precompiled headers
#include "bombs.h" #include "bombs.h"
/*-------- BombCanvasClass::DrawField(dc, xc1, yc1, xc2, yc2) -------*/ // Draws the field on the device context dc
/* Draws the field on the device context dc */ // xc1,yc1 etc. are the (inclusive) limits of the area to be drawn,
/* xc1,yc1 etc. are the (inclusive) limits of the area to be drawn, */ // expressed in cells.
/* expressed in cells. */ void BombsCanvas::DrawField(wxDC *dc, int xc1, int yc1, int xc2, int yc2)
/*---------------------------------------------------------------------*/ {
void BombsCanvasClass::DrawField(wxDC *dc, int xc1, int yc1, int xc2, int yc2) wxString buf;
{ int x,y,xmax,ymax; long chw, chh;
wxChar buf[2];
long chw, chh;
wxColour *wxBlack = wxTheColourDatabase->FindColour(_T("BLACK")); wxColour wxBlack = wxTheColourDatabase->Find(wxT("BLACK"));
wxColour *wxWhite = wxTheColourDatabase->FindColour(_T("WHITE")); wxColour wxWhite = wxTheColourDatabase->Find(wxT("WHITE"));
wxColour *wxRed = wxTheColourDatabase->FindColour(_T("RED")); wxColour wxRed = wxTheColourDatabase->Find(wxT("RED"));
wxColour *wxBlue = wxTheColourDatabase->FindColour(_T("BLUE")); wxColour wxBlue = wxTheColourDatabase->Find(wxT("BLUE"));
wxColour *wxGrey = wxTheColourDatabase->FindColour(_T("LIGHT GREY")); wxColour wxGrey = wxTheColourDatabase->Find(wxT("LIGHT GREY"));
wxColour *wxGreen = wxTheColourDatabase->FindColour(_T("GREEN")); wxColour wxFocused = wxTheColourDatabase->Find(wxT("GREY"));
wxColour wxGreen = wxTheColourDatabase->Find(wxT("GREEN"));
wxPen *blackPen = wxThePenList->FindOrCreatePen(*wxBlack, 1, wxSOLID); wxPen *blackPen = wxThePenList->FindOrCreatePen(wxBlack, 1, wxSOLID);
wxPen *redPen = wxThePenList->FindOrCreatePen(*wxRed, 1, wxSOLID); wxPen *redPen = wxThePenList->FindOrCreatePen(wxRed, 1, wxSOLID);
wxPen *bluePen = wxThePenList->FindOrCreatePen(*wxBlue, 1, wxSOLID); wxPen *bluePen = wxThePenList->FindOrCreatePen(wxBlue, 1, wxSOLID);
wxBrush *whiteBrush = wxTheBrushList->FindOrCreateBrush(*wxWhite, wxSOLID); wxBrush *whiteBrush = wxTheBrushList->FindOrCreateBrush(wxWhite, wxSOLID);
wxBrush *greyBrush = wxTheBrushList->FindOrCreateBrush(*wxGrey, wxSOLID); wxBrush *greyBrush = wxTheBrushList->FindOrCreateBrush(wxGrey, wxSOLID);
wxBrush *redBrush = wxTheBrushList->FindOrCreateBrush(*wxRed, wxSOLID); wxBrush *focusedBrush = wxTheBrushList->FindOrCreateBrush(wxFocused, wxSOLID);
wxBrush *redBrush = wxTheBrushList->FindOrCreateBrush(wxRed, wxSOLID);
xmax=field_width*x_cell*X_UNIT; dc->SetPen(* blackPen);
ymax=field_height*y_cell*Y_UNIT;
int x, y;
int xMax = this->GetGridSizeInPixels().GetWidth();
int yMax = this->GetGridSizeInPixels().GetHeight();
for(x=xc1; x<=xc2; x++)
dc->DrawLine(x*m_cellWidth*X_UNIT, 0, x*m_cellWidth*X_UNIT, yMax);
for(y=xc1; y<=yc2; y++)
dc->DrawLine(0, y*m_cellHeight*Y_UNIT, xMax, y*m_cellHeight*Y_UNIT);
dc->SetPen(* blackPen); wxFont font= BOMBS_FONT;
for(x=xc1; x<=xc2; x++) dc->SetFont(font);
dc->DrawLine(x*x_cell*X_UNIT, 0, x*x_cell*X_UNIT, ymax);
for(y=xc1; y<=yc2; y++)
dc->DrawLine(0, y*y_cell*Y_UNIT, xmax, y*y_cell*Y_UNIT);
for(x=xc1; x<=xc2; x++)
for(y=yc1; y<=yc2; y++)
{
if (m_game->IsMarked(x,y))
{
dc->SetPen(* blackPen);
wxFont font= BOMBS_FONT; if (m_game->IsFocussed(x, y))
dc->SetFont(font); dc->SetBrush(* focusedBrush);
else
dc->SetBrush(* greyBrush);
buf[1]=_T('\0'); dc->DrawRectangle( x*m_cellWidth*X_UNIT, y*m_cellHeight*Y_UNIT,
for(x=xc1; x<=xc2; x++) m_cellWidth*X_UNIT+1, m_cellHeight*Y_UNIT+1);
for(y=yc1; y<=yc2; y++) buf = wxT("M");
{ if (wxGetApp().Game.IsMarked(x,y)) if (!m_game->IsHidden(x,y) && m_game->IsBomb(x,y))
{ dc->SetPen(* blackPen); dc->SetTextForeground(wxBlue);
dc->SetBrush(* greyBrush); else
dc->DrawRectangle( x*x_cell*X_UNIT, y*y_cell*Y_UNIT, dc->SetTextForeground(wxRed);
x_cell*X_UNIT+1, y_cell*Y_UNIT+1);
*buf=_T('M'); dc->SetTextBackground(wxGrey);
if (!wxGetApp().Game.IsHidden(x,y) && wxGetApp().Game.IsBomb(x,y)) dc->GetTextExtent(buf, &chw, &chh);
dc->SetTextForeground(*wxBlue); dc->DrawText( buf,
else x*m_cellWidth*X_UNIT + (m_cellWidth*X_UNIT-chw)/2,
dc->SetTextForeground(*wxRed); y*m_cellHeight*Y_UNIT + (m_cellHeight*Y_UNIT-chh)/2 );
dc->SetTextBackground(*wxGrey);
if (!m_game->IsHidden(x,y) && m_game->IsBomb(x,y))
{
dc->SetPen(*redPen);
dc->DrawLine(x*m_cellWidth*X_UNIT, y*m_cellHeight*Y_UNIT,
(x+1)*m_cellWidth*X_UNIT, (y+1)*m_cellHeight*Y_UNIT);
dc->DrawLine(x*m_cellWidth*X_UNIT, (y+1)*m_cellHeight*Y_UNIT,
(x+1)*m_cellWidth*X_UNIT, y*m_cellHeight*Y_UNIT);
}
}
else if (m_game->IsHidden(x,y))
{
dc->SetPen(*blackPen);
if (m_game->IsFocussed(x, y))
dc->SetBrush(* focusedBrush);
else
dc->SetBrush(*greyBrush);
dc->DrawRectangle( x*m_cellWidth*X_UNIT, y*m_cellHeight*Y_UNIT,
m_cellWidth*X_UNIT+1, m_cellHeight*Y_UNIT+1);
}
else if (m_game->IsBomb(x,y))
{
dc->SetPen(* blackPen);
dc->SetBrush(* redBrush);
dc->DrawRectangle( x*m_cellWidth*X_UNIT, y*m_cellHeight*Y_UNIT,
m_cellWidth*X_UNIT+1, m_cellHeight*Y_UNIT+1);
buf = wxT("B");
dc->SetTextForeground(wxBlack);
dc->SetTextBackground(wxRed);
dc->GetTextExtent(buf, &chw, &chh);
dc->DrawText( buf,
x*m_cellWidth*X_UNIT + (m_cellWidth*X_UNIT-chw)/2,
y*m_cellHeight*Y_UNIT + (m_cellHeight*Y_UNIT-chh)/2);
if (m_game->IsExploded(x,y))
{
dc->SetPen(* bluePen);
dc->DrawLine(x*m_cellWidth*X_UNIT, y*m_cellHeight*Y_UNIT,
(x+1)*m_cellWidth*X_UNIT, (y+1)*m_cellHeight*Y_UNIT);
dc->DrawLine(x*m_cellWidth*X_UNIT, (y+1)*m_cellHeight*Y_UNIT,
(x+1)*m_cellWidth*X_UNIT, y*m_cellHeight*Y_UNIT);
}
}
else // Display a digit
{
dc->SetPen(* blackPen);
if (m_game->IsFocussed(x, y))
dc->SetBrush(* focusedBrush);
else
dc->SetBrush(* whiteBrush);
dc->DrawRectangle( x*m_cellWidth*X_UNIT, y*m_cellHeight*Y_UNIT,
m_cellWidth*X_UNIT+1, m_cellHeight*Y_UNIT+1);
int digit_value = m_game->Get(x,y) & BG_MASK;
switch(digit_value)
{
case 0:
buf = wxT("0");
dc->SetTextForeground(wxGreen);
break;
case 1:
buf = wxT("1");
dc->SetTextForeground(wxBlue);
break;
default:
buf.Printf(wxT("%d"),digit_value);
dc->SetTextForeground(wxBlack);
break;
}
dc->GetTextExtent(buf, &chw, &chh); dc->GetTextExtent(buf, &chw, &chh);
dc->SetTextBackground(wxWhite);
dc->DrawText( buf, dc->DrawText( buf,
x*x_cell*X_UNIT + (x_cell*X_UNIT-chw)/2, x*m_cellWidth*X_UNIT + (m_cellWidth*X_UNIT-chw)/2,
y*y_cell*Y_UNIT + (y_cell*Y_UNIT-chh)/2 y*m_cellHeight*Y_UNIT + (m_cellHeight*Y_UNIT-chh)/2);
); }
if (!wxGetApp().Game.IsHidden(x,y) && wxGetApp().Game.IsBomb(x,y)) }
{ dc->SetPen(*redPen); dc->SetFont(wxNullFont);
dc->DrawLine(x*x_cell*X_UNIT, y*y_cell*Y_UNIT,
(x+1)*x_cell*X_UNIT, (y+1)*y_cell*Y_UNIT);
dc->DrawLine(x*x_cell*X_UNIT, (y+1)*y_cell*Y_UNIT,
(x+1)*x_cell*X_UNIT, y*y_cell*Y_UNIT);
}
}
else if (wxGetApp().Game.IsHidden(x,y))
{ dc->SetPen(*blackPen);
dc->SetBrush(*greyBrush);
dc->DrawRectangle( x*x_cell*X_UNIT, y*y_cell*Y_UNIT,
x_cell*X_UNIT+1, y_cell*Y_UNIT+1);
}
else if (wxGetApp().Game.IsBomb(x,y))
{ dc->SetPen(* blackPen);
dc->SetBrush(* redBrush);
dc->DrawRectangle( x*x_cell*X_UNIT, y*y_cell*Y_UNIT,
x_cell*X_UNIT+1, y_cell*Y_UNIT+1);
*buf=_T('B');
dc->SetTextForeground(* wxBlack);
dc->SetTextBackground(* wxRed);
dc->GetTextExtent(buf, &chw, &chh);
dc->DrawText( buf,
x*x_cell*X_UNIT + (x_cell*X_UNIT-chw)/2,
y*y_cell*Y_UNIT + (y_cell*Y_UNIT-chh)/2
);
if (wxGetApp().Game.IsExploded(x,y))
{ dc->SetPen(* bluePen);
dc->DrawLine(x*x_cell*X_UNIT, y*y_cell*Y_UNIT,
(x+1)*x_cell*X_UNIT, (y+1)*y_cell*Y_UNIT);
dc->DrawLine(x*x_cell*X_UNIT, (y+1)*y_cell*Y_UNIT,
(x+1)*x_cell*X_UNIT, y*y_cell*Y_UNIT);
}
}
else // Display a digit
{ dc->SetPen(* blackPen);
dc->SetBrush(* whiteBrush);
dc->DrawRectangle( x*x_cell*X_UNIT, y*y_cell*Y_UNIT,
x_cell*X_UNIT+1, y_cell*Y_UNIT+1);
*buf = (wxGetApp().Game.Get(x,y) & BG_MASK) + _T('0');
dc->GetTextExtent(buf, &chw, &chh);
switch(*buf)
{ case _T('0'): dc->SetTextForeground(* wxGreen); break;
case _T('1'): dc->SetTextForeground(* wxBlue); break;
default: dc->SetTextForeground(* wxBlack); break;
}
dc->SetTextBackground(* wxWhite);
dc->DrawText( buf,
x*x_cell*X_UNIT + (x_cell*X_UNIT-chw)/2,
y*y_cell*Y_UNIT + (y_cell*Y_UNIT-chh)/2
);
}
}
dc->SetFont(wxNullFont);
if (wxGetApp().BombsFrame) #if wxUSE_LOG
{ wxString buf; wxLogStatus(wxT("%d bombs %d remaining cells"),
buf.Printf(_T("%d bombs %d remaining cells"), m_game->GetNumBombs(), m_game->GetNumRemainingCells() );
wxGetApp().Game.GetBombs(), #endif
wxGetApp().Game.GetRemainingCells()); }
wxGetApp().BombsFrame->SetStatusText(buf, 0);
// Refreshes the field image
// xc1,yc1 etc. are the (inclusive) limits of the area to be drawn,
// expressed in cells.
void BombsCanvas::RefreshField(int xc1, int yc1, int xc2, int yc2)
{
wxClientDC dc(this);
DrawField(& dc, xc1, yc1, xc2, yc2);
if (m_bmp)
{
wxMemoryDC memDC;
memDC.SelectObject(*m_bmp);
DrawField(&memDC, xc1, yc1, xc2, yc2);
memDC.SelectObject(wxNullBitmap);
} }
} }
/*-------- BombCanvasClass::RefreshField(xc1, yc1, xc2, yc2) --------*/
/* Refreshes the field image */
/* xc1,yc1 etc. are the (inclusive) limits of the area to be drawn, */
/* expressed in cells. */
/*---------------------------------------------------------------------*/
void BombsCanvasClass::RefreshField(int xc1, int yc1, int xc2, int yc2)
{
wxClientDC dc(this);
DrawField(& dc, xc1, yc1, xc2, yc2);
if (bmp)
{ wxMemoryDC memDC;
memDC.SelectObject(* bmp);
DrawField(&memDC, xc1, yc1, xc2, yc2);
memDC.SelectObject(wxNullBitmap);
}
}
// Called when uncovering a cell. // Called when uncovering a cell.
void BombsCanvasClass::Uncover(int x, int y) void BombsCanvas::Uncover(int x, int y)
{ {
wxGetApp().Game.Unhide(x,y); m_game->Unhide(x,y);
RefreshField(x, y, x, y); RefreshField(x, y, x, y);
if (wxGetApp().Game.IsBomb(x,y) || wxGetApp().Game.GetRemainingCells()==0)
{ wxBell(); const int gridWidth = m_game->GetWidth();
if (!wxGetApp().Game.IsBomb(x,y)) const int gridHeight = m_game->GetHeight();
{ wxMessageBox(_T("Nice! You found all the bombs!"), _T("wxWin Bombs"),
wxOK|wxCENTRE, wxGetApp().BombsFrame); const bool hasWon = m_game->GetNumRemainingCells() == 0;
} if (m_game->IsBomb(x,y) || hasWon)
else // x,y is a bomb {
{ wxGetApp().Game.Explode(x, y); wxBell();
} if (hasWon)
for(x=0; x<field_width; x++) {
for(y=0; y<field_height; y++) wxMessageBox(wxT("Nice! You found all the bombs!"),
wxGetApp().Game.Unhide(x,y); wxT("wxWin Bombs"), wxOK|wxCENTRE);
RefreshField(0, 0, field_width-1, field_height-1); }
else // x,y is a bomb
{
m_game->Explode(x, y);
}
for(x=0; x<gridWidth; x++)
for(y=0; y<gridHeight; y++)
m_game->Unhide(x,y);
RefreshField(0, 0, gridWidth-1, gridHeight-1);
} }
else if (!wxGetApp().Game.Get(x, y)) else if (!m_game->Get(x, y))
{ int left = ( x > 0 ) ? x-1 : 0; {
int right = ( x < wxGetApp().Game.GetWidth() - 1 )? int left = ( x > 0 ) ? x-1 : 0;
x+1 : wxGetApp().Game.GetWidth() - 1; int right = ( x < gridWidth - 1 )
int top = ( y > 0 ) ? y-1 : 0; ? x+1
int bottom = ( y < wxGetApp().Game.GetHeight() - 1 )? : gridWidth - 1;
y+1 : wxGetApp().Game.GetHeight() - 1; int top = ( y > 0 ) ? y-1 : 0;
int i,j; int bottom = ( y < gridHeight - 1 )
for (j = top; j <= bottom; j++) ? y+1
for (i=left; i <= right; i++) : gridHeight - 1;
if ((i != x || j != y) && wxGetApp().Game.IsHidden(i,j)
&& !wxGetApp().Game.IsMarked(i,j)) int i, j;
Uncover(i,j); for (j=top; j<=bottom; j++)
for (i=left; i<=right; i++)
if ( (i != x || j != y) && m_game->IsHidden(i, j)
&& !m_game->IsMarked(i, j) )
{
Uncover(i, j);
}
} }
} }
// Called when the canvas receives a mouse event. // Called when the canvas receives a mouse event.
void BombsCanvasClass::OnEvent(wxMouseEvent& event) void BombsCanvas::OnMouseEvent(wxMouseEvent& event)
{ {
wxCoord fx, fy; const int gridWidth = m_game->GetWidth();
event.GetPosition(&fx, &fy); const int gridHeight = m_game->GetHeight();
int x = fx/(x_cell*X_UNIT);
int y = fy/(y_cell*Y_UNIT); wxCoord fx, fy;
if (x<field_width && y<field_height) event.GetPosition(&fx, &fy);
{ if ( (event.RightDown() || (event.LeftDown() && event.ShiftDown())) int x = fx/(m_cellWidth*X_UNIT);
&& (wxGetApp().Game.IsHidden(x,y) int y = fy/(m_cellHeight*Y_UNIT);
|| wxGetApp().Game.GetRemainingCells()==0)) if (x<gridWidth && y<gridHeight)
{ wxGetApp().Game.Mark(x,y); {
RefreshField(x, y, x, y); if ( (event.RightDown() || (event.LeftDown() && event.ShiftDown()))
return; && (m_game->IsHidden(x,y)
|| !m_game->GetNumRemainingCells() ) )
{
// store previous and current field
int prevFocusX = m_game->m_gridFocusX;
int prevFocusY = m_game->m_gridFocusY;
m_game->m_gridFocusX = x;
m_game->m_gridFocusY = y;
RefreshField(prevFocusX, prevFocusY, prevFocusX, prevFocusY);
m_game->Mark(x, y);
RefreshField(x, y, x, y);
return;
} }
else if (event.LeftDown() && wxGetApp().Game.IsHidden(x,y) else if (event.LeftDown() && m_game->IsHidden(x,y)
&& !wxGetApp().Game.IsMarked(x,y)) && !m_game->IsMarked(x,y))
{ Uncover(x,y); {
return; // store previous and current field
int prevGridFocusX = m_game->m_gridFocusX;
int prevGridFocusY = m_game->m_gridFocusY;
m_game->m_gridFocusX = x;
m_game->m_gridFocusY = y;
RefreshField(prevGridFocusX, prevGridFocusY,
prevGridFocusX, prevGridFocusY);
Uncover(x, y);
return;
} }
} }
} }
void BombsCanvas::OnChar(wxKeyEvent& event)
{
int keyCode = event.GetKeyCode();
int prevGridFocusX = m_game->m_gridFocusX;
int prevGridFocusY = m_game->m_gridFocusY;
const int gridWidth = m_game->GetWidth();
const int gridHeight = m_game->GetHeight();
switch(keyCode)
{
case WXK_RIGHT:
m_game->m_gridFocusX++;
if (m_game->m_gridFocusX >= gridWidth) m_game->m_gridFocusX = 0;
break;
case WXK_LEFT:
m_game->m_gridFocusX--;
if (m_game->m_gridFocusX<0) m_game->m_gridFocusX = gridWidth-1;
break;
case WXK_DOWN:
m_game->m_gridFocusY++;
if (m_game->m_gridFocusY >= gridHeight) m_game->m_gridFocusY = 0;
break;
case WXK_UP:
m_game->m_gridFocusY--;
if (m_game->m_gridFocusY<0) m_game->m_gridFocusY = gridHeight-1;
break;
case WXK_RETURN:
if ( (prevGridFocusX == m_game->m_gridFocusX)
&& (prevGridFocusY == m_game->m_gridFocusY)
&& (m_game->IsHidden(m_game->m_gridFocusX, m_game->m_gridFocusY)) )
{
m_game->Mark(m_game->m_gridFocusX, m_game->m_gridFocusY);
if (!m_game->IsMarked(m_game->m_gridFocusX, m_game->m_gridFocusY))
{
Uncover(m_game->m_gridFocusX, m_game->m_gridFocusY);
}
RefreshField(m_game->m_gridFocusX, m_game->m_gridFocusY,
m_game->m_gridFocusX, m_game->m_gridFocusY);
}
break;
default:
event.Skip();
}
if ((prevGridFocusX != m_game->m_gridFocusX)
|| (prevGridFocusY != m_game->m_gridFocusY))
{
// refresh previous field and focused field
RefreshField(prevGridFocusX, prevGridFocusY,
prevGridFocusX, prevGridFocusY);
RefreshField(m_game->m_gridFocusX, m_game->m_gridFocusY,
m_game->m_gridFocusX, m_game->m_gridFocusY);
}
}

144
demos/bombs/game.cpp
View File

@@ -2,7 +2,7 @@
// Name: bombs1.cpp // Name: bombs1.cpp
// Purpose: Implementation of the class BombsGame // Purpose: Implementation of the class BombsGame
// Author: P. Foggia 1996 // Author: P. Foggia 1996
// Modified by: // Modified by: Wlodzimierz Skiba (ABX) 2003
// Created: 1996 // Created: 1996
// RCS-ID: $Id$ // RCS-ID: $Id$
// Copyright: (c) 1996 P. Foggia // Copyright: (c) 1996 P. Foggia
@@ -10,14 +10,18 @@
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__ #ifdef __GNUG__
#pragma implementation # pragma implementation
#endif #endif
#include "wx/wxprec.h" #include "wx/wxprec.h"
#ifdef __BORLANDC__
#pragma hdrstop
#endif
#ifndef WX_PRECOMP #ifndef WX_PRECOMP
#include "wx/wx.h" # include "wx/wx.h"
#endif //precompiled headers #endif
#include "game.h" #include "game.h"
#include <stdlib.h> #include <stdlib.h>
@@ -26,80 +30,92 @@
#define PROB 0.2 #define PROB 0.2
#ifndef RAND_MAX #ifndef RAND_MAX
#define RAND_MAX INT_MAX # define RAND_MAX INT_MAX
#endif #endif
/*-------------------- BombsGame::~BombsGame() ---------------------*/
/*--------------------------------------------------------------------*/
BombsGame::~BombsGame() BombsGame::~BombsGame()
{ if (field) {
free(field); if (m_field)
} {
delete[] m_field;
}
}
/*------------------ int BombsGame::Init(width,height) -------------------*/ // Initialize the play field. Returns false on failure
/* Initialize the play field. Returns 0 on failure */ bool BombsGame::Init(int aWidth, int aHeight)
/*--------------------------------------------------------------------------*/ {
int BombsGame::Init(int aWidth, int aHeight) m_gridFocusX = m_gridFocusY = -1;
{ int x, y;
int x, y;
int xx, yy; int xx, yy;
if (field) if (m_field)
free(field); {
field=(short *)malloc(aWidth*aHeight*sizeof(short)); delete[] m_field;
if (!field) }
{ width=height=0;
return 0;
}
width=aWidth;
height=aHeight;
for(x=0; x<width; x++) m_field = new short[aWidth*aHeight];
for(y=0; y<height; y++) if (!m_field)
{ field[x+y*width] = ((float)rand()/RAND_MAX <PROB)? {
BG_HIDDEN | BG_BOMB : m_width = m_height = 0;
BG_HIDDEN; return false;
}
m_width = aWidth;
m_height = aHeight;
for(x=0; x<m_width; x++)
{
for(y=0; y<m_height; y++)
{
m_field[x+y*m_width] = ((float)rand()/RAND_MAX <PROB)
? BG_HIDDEN | BG_BOMB
: BG_HIDDEN;
} }
}
bombs=0; m_numBombCells = 0;
for(x=0; x<width; x++) for(x=0; x<m_width; x++)
for(y=0; y<height; y++) for(y=0; y<m_height; y++)
if (field[x+y*width] & BG_BOMB) if (m_field[x+y*m_width] & BG_BOMB)
{ bombs++; {
for(xx=x-1; xx<=x+1; xx++) m_numBombCells++;
if (xx>=0 && xx<width)
for(yy=y-1; yy<=y+1; yy++) for(xx=x-1; xx<=x+1; xx++)
if (yy>=0 && yy<height && (yy!=y || xx!=x)) if (xx>=0 && xx<m_width)
field[xx+yy*width]++; for(yy=y-1; yy<=y+1; yy++)
} if (yy>=0 && yy<m_height && (yy!=y || xx!=x))
normal_cells=height*width-bombs; m_field[xx+yy*m_width]++;
return 1; }
}
m_numRemainingCells = m_height*m_width-m_numBombCells;
return true;
}
/*---------------------- BombsGame::Mark(x,y) -------------------------*/
/* Marks/unmarks a cell */
/*-----------------------------------------------------------------------*/
void BombsGame::Mark(int x, int y) void BombsGame::Mark(int x, int y)
{ {
field[x+y*width] ^= BG_MARKED; m_field[x+y*m_width] ^= BG_MARKED;
} }
/*------------------- BombsGame::Unhide(x,y) ------------------------*/
/* Unhides a cell */
/*---------------------------------------------------------------------*/
void BombsGame::Unhide(int x, int y) void BombsGame::Unhide(int x, int y)
{ if (!IsHidden(x,y)) {
return; if (!IsHidden(x,y))
field[x+y*width] &= ~BG_HIDDEN; {
return;
}
m_field[x+y*m_width] &= ~BG_HIDDEN;
if (!IsBomb(x,y)) if (!IsBomb(x,y))
normal_cells--; {
} m_numRemainingCells--;
}
}
/*------------------- BombsGame::Explode(x,y) ------------------------*/
/* Makes a cell exploded */
/*----------------------------------------------------------------------*/
void BombsGame::Explode(int x, int y) void BombsGame::Explode(int x, int y)
{ {
field[x+y*width] |= BG_EXPLODED; m_field[x+y*m_width] |= BG_EXPLODED;
} }

123
demos/bombs/game.h
View File

@@ -1,10 +1,16 @@
//--------------------------------------------------------------- ///////////////////////////////////////////////////////////////////////////////
// game.h // Name: game.h
// Definition of the class BombsGame, containing the data for a // Purpose: Bombs game
// playfield // Author: P. Foggia 1996
//--------------------------------------------------------------- // Modified by: Wlodzimierz Skiba (ABX) 2003
#ifndef GAME_H // Created: 1996
#define GAME_H // RCS-ID: $Id$
// Copyright: (c) 1996 P. Foggia
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DEMOS_BOMBS_GAME_H_
#define _WX_DEMOS_BOMBS_GAME_H_
#define BG_HIDDEN 0x100 #define BG_HIDDEN 0x100
#define BG_BOMB 0x200 #define BG_BOMB 0x200
@@ -12,31 +18,88 @@
#define BG_EXPLODED 0x800 #define BG_EXPLODED 0x800
#define BG_MASK 0x0FF #define BG_MASK 0x0FF
#include <stddef.h> #include <stddef.h>
class BombsGame class BombsGame
{ protected: {
int width,height; public:
short *field; BombsGame()
int bombs,normal_cells; {
public: m_width = m_height = 0;
BombsGame() { width=height=0; field=NULL; }; m_field = NULL;
~BombsGame(); };
int Init(int width, int height);
int GetWidth() { return width; };
int GetHeight() { return height; };
int Get(int x, int y) { return field[x+y*width]; };
void Mark(int x, int y);
void Unhide(int x, int y);
void Explode(int x, int y);
int IsHidden(int x, int y) { return Get(x,y) & BG_HIDDEN; };
int IsMarked(int x, int y) { return Get(x,y) & BG_MARKED; };
int IsBomb(int x, int y) { return Get(x,y) & BG_BOMB; };
int IsExploded(int x, int y) { return Get(x,y) & BG_EXPLODED; };
int GetBombs() { return bombs; };
int GetRemainingCells() { return normal_cells; };
};
#endif /* def GAME_H */ ~BombsGame();
int GetWidth() const { return m_width; };
int GetHeight() const { return m_height; };
int Get(int x, int y) const
{
return m_field[x+y*m_width];
};
int IsFocussed(int x, int y) const
{
return (m_gridFocusX == x) && (m_gridFocusY == y);
}
int IsHidden(int x, int y) const
{
return Get(x,y) & BG_HIDDEN;
};
int IsMarked(int x, int y) const
{
return Get(x,y) & BG_MARKED;
};
int IsBomb(int x, int y) const
{
return Get(x,y) & BG_BOMB;
};
int IsExploded(int x, int y) const
{
return Get(x,y) & BG_EXPLODED;
};
int GetNumBombs() const
{
return m_numBombCells;
};
int GetNumRemainingCells() const
{
return m_numRemainingCells;
};
bool Init(int width, int height);
// Marks/unmarks a cell
void Mark(int x, int y);
// Unhides a cell
void Unhide(int x, int y);
// Makes a cell exploded
void Explode(int x, int y);
int m_gridFocusX;
int m_gridFocusY;
private:
// Current difficulty level (Determines grid size).
//int m_level;
int m_width, m_height;
short *m_field;
int m_numBombCells, m_numRemainingCells;
};
#endif // #ifndef _WX_DEMOS_BOMBS_GAME_H_