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

302
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,159 +10,188 @@
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
#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));
#if wxUSE_STATUSBAR
CreateStatusBar(); CreateStatusBar();
#endif
// Create a menu bar for the frame // Create a menu bar for the frame
wxMenuBar *menuBar1 = new wxMenuBar; wxMenuBar *menuBar = new wxMenuBar;
wxMenu *menu1 = new wxMenu; wxMenu *menuFile = new wxMenu;
menu1->Append(IDM_EXIT, _T("E&xit")); // , "Quit the program"); wxMenu *menuLevel = new wxMenu;
menu1->AppendSeparator(); menuLevel->AppendRadioItem(bombsID_EASY, wxT("&Easy (10x10)\tCtrl-1"));
menu1->Append(IDM_ABOUT, _T("&About...")); // , "Infos on wxBombs"); menuLevel->AppendRadioItem(bombsID_MEDIUM, wxT("&Medium (15x15)\tCtrl-2"));
menuBar1->Append(menu1, _T("&File")); menuLevel->AppendRadioItem(bombsID_HARD, wxT("&Hard (25x20)\tCtrl-3"));
wxMenu *menu2 = new wxMenu;
menu2->Append(IDM_RESTART, _T("&Restart")); // , "Clear the play field"); menuFile->Append(bombsID_NEWGAME, wxT("&New Game"),
menu2->AppendSeparator(); menuLevel, wxT("Starts a new game"));
menu2->Append(IDM_EASY, _T("&Easy"), wxEmptyString, TRUE); // "10x10 play field", TRUE);
menu2->Append(IDM_MEDIUM, _T("&Medium"), wxEmptyString, TRUE); // "15x15 play field", TRUE); menuFile->AppendSeparator();
menu2->Append(IDM_DIFFICULT, _T("&Difficult"), wxEmptyString, TRUE); // "25x20 play field", TRUE); menuFile->Append(wxID_EXIT, wxT("E&xit"), wxT("Quits the application"));
menuBar1->Append(menu2, _T("&Game"));
SetMenuBar(menuBar1); menuBar->Append(menuFile, wxT("&File"));
menuBar=menuBar1;
menuBar->Check(wxGetApp().level, 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. // Create child subwindows.
BombsCanvas = new BombsCanvasClass(this); m_canvas = new BombsCanvas(this, m_game);
// Ensure the subwindows get resized o.k. // Ensure the subwindows get resized o.k.
// OnSize(width, height); // OnSize(width, height);
// Centre frame on the screen. // Centre frame on the screen.
Centre(wxBOTH); Centre(wxBOTH);
// Show the frame. // Show the frame.
Show(TRUE); 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)
{ {
m_game = game;
int sx, sy; int sx, sy;
wxClientDC dc(this); wxClientDC dc(this);
wxFont font= BOMBS_FONT; wxFont font= BOMBS_FONT;
dc.SetFont(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);
@@ -174,79 +203,82 @@ BombsCanvasClass::BombsCanvasClass(wxFrame *parent, const wxPoint& pos, const wx
// 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;
m_cellHeight = (sy+3+Y_UNIT)/Y_UNIT;
dc.SetMapMode(wxMM_TEXT); dc.SetMapMode(wxMM_TEXT);
bmp=NULL; m_bmp = NULL;
UpdateFieldSize();
} }
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);
const int numHorzCells = m_game->GetWidth();
const int numVertCells = m_game->GetHeight();
// Insert your drawing code here. // Insert your drawing code here.
if (!bmp) if (!m_bmp)
{ bmp=new wxBitmap(field_width*x_cell*X_UNIT+1, {
field_height*y_cell*Y_UNIT+1); wxSize size = dc.GetSize();
if (bmp) m_bmp = new wxBitmap(size.GetWidth(), size.GetHeight());
{ wxMemoryDC memDC; if (m_bmp)
memDC.SelectObject(* bmp); {
DrawField(&memDC, 0, 0, field_width-1, field_height-1); wxMemoryDC memDC;
memDC.SelectObject(*m_bmp);
DrawField(&memDC, 0, 0, numHorzCells-1, numVertCells-1);
memDC.SelectObject(wxNullBitmap); 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);
wxSize size = dc.GetSize();
dc.Blit(0, 0, size.GetWidth(), size.GetHeight(),
&memDC, 0, 0, wxCOPY); &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;
field_height=15;
break;
case IDM_DIFFICULT:
field_width=25;
field_height=20;
break;
} }
wxGetApp().Game.Init(field_width, field_height);
if (bmp) Refresh();
delete bmp; }
bmp=NULL;
wxSize BombsCanvas::GetGridSizeInPixels() const
{
return wxSize(m_cellWidth*X_UNIT*m_game->GetWidth(),
m_cellHeight*Y_UNIT*m_game->GetHeight());
}
wxWindow::Refresh();
}

141
demos/bombs/bombs.h
View File

@@ -2,119 +2,122 @@
// 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 NewGame(int level);
private:
void OnNewEasyGame(wxCommandEvent& event);
void OnNewMediumGame(wxCommandEvent& event);
void OnNewHardGame(wxCommandEvent& event);
void OnCloseWindow(wxCloseEvent& event);
void OnExit(wxCommandEvent& event); 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() 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;
class BombsCanvas : public wxPanel
{
public:
// Constructor and destructor // Constructor and destructor
BombsCanvasClass(wxFrame *parent, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = 0);
~BombsCanvasClass(void); BombsCanvas(wxFrame *parent, BombsGame *game);
void UpdateGridSize();
wxSize GetGridSizeInPixels() const;
~BombsCanvas();
private:
void OnPaint(wxPaintEvent& event); void OnPaint(wxPaintEvent& event);
void DrawField(wxDC *, int xc1, int yc1, int xc2, int yc2); void DrawField(wxDC *, int xc1, int yc1, int xc2, int yc2);
void RefreshField(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 Uncover(int x, int y);
void OnEvent(wxMouseEvent& event); void OnMouseEvent(wxMouseEvent& event);
void UpdateFieldSize(); void OnChar(wxKeyEvent& event);
DECLARE_EVENT_TABLE() BombsGame *m_game;
wxBitmap *m_bmp;
// Cell size in pixels
int m_cellWidth;
int m_cellHeight;
DECLARE_EVENT_TABLE()
}; };
/* Menu identifiers
*/
/* 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 */
#define X_UNIT 4 #define X_UNIT 4
#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_

394
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;
wxChar buf[2];
long chw, chh; 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 *redPen = wxThePenList->FindOrCreatePen(*wxRed, 1, wxSOLID);
wxPen *bluePen = wxThePenList->FindOrCreatePen(*wxBlue, 1, wxSOLID);
wxBrush *whiteBrush = wxTheBrushList->FindOrCreateBrush(*wxWhite, wxSOLID);
wxBrush *greyBrush = wxTheBrushList->FindOrCreateBrush(*wxGrey, wxSOLID);
wxBrush *redBrush = wxTheBrushList->FindOrCreateBrush(*wxRed, wxSOLID);
xmax=field_width*x_cell*X_UNIT;
ymax=field_height*y_cell*Y_UNIT;
wxPen *blackPen = wxThePenList->FindOrCreatePen(wxBlack, 1, wxSOLID);
wxPen *redPen = wxThePenList->FindOrCreatePen(wxRed, 1, wxSOLID);
wxPen *bluePen = wxThePenList->FindOrCreatePen(wxBlue, 1, wxSOLID);
wxBrush *whiteBrush = wxTheBrushList->FindOrCreateBrush(wxWhite, wxSOLID);
wxBrush *greyBrush = wxTheBrushList->FindOrCreateBrush(wxGrey, wxSOLID);
wxBrush *focusedBrush = wxTheBrushList->FindOrCreateBrush(wxFocused, wxSOLID);
wxBrush *redBrush = wxTheBrushList->FindOrCreateBrush(wxRed, wxSOLID);
dc->SetPen(* blackPen); dc->SetPen(* blackPen);
int x, y;
int xMax = this->GetGridSizeInPixels().GetWidth();
int yMax = this->GetGridSizeInPixels().GetHeight();
for(x=xc1; x<=xc2; x++) for(x=xc1; x<=xc2; x++)
dc->DrawLine(x*x_cell*X_UNIT, 0, x*x_cell*X_UNIT, ymax); dc->DrawLine(x*m_cellWidth*X_UNIT, 0, x*m_cellWidth*X_UNIT, yMax);
for(y=xc1; y<=yc2; y++) for(y=xc1; y<=yc2; y++)
dc->DrawLine(0, y*y_cell*Y_UNIT, xmax, y*y_cell*Y_UNIT); dc->DrawLine(0, y*m_cellHeight*Y_UNIT, xMax, y*m_cellHeight*Y_UNIT);
wxFont font= BOMBS_FONT; wxFont font= BOMBS_FONT;
dc->SetFont(font); dc->SetFont(font);
buf[1]=_T('\0');
for(x=xc1; x<=xc2; x++) for(x=xc1; x<=xc2; x++)
for(y=yc1; y<=yc2; y++) for(y=yc1; y<=yc2; y++)
{ if (wxGetApp().Game.IsMarked(x,y)) {
{ dc->SetPen(* blackPen); if (m_game->IsMarked(x,y))
dc->SetBrush(* greyBrush); {
dc->DrawRectangle( x*x_cell*X_UNIT, y*y_cell*Y_UNIT, dc->SetPen(* blackPen);
x_cell*X_UNIT+1, y_cell*Y_UNIT+1);
*buf=_T('M'); if (m_game->IsFocussed(x, y))
if (!wxGetApp().Game.IsHidden(x,y) && wxGetApp().Game.IsBomb(x,y)) dc->SetBrush(* focusedBrush);
dc->SetTextForeground(*wxBlue);
else else
dc->SetTextForeground(*wxRed); dc->SetBrush(* greyBrush);
dc->SetTextBackground(*wxGrey);
dc->DrawRectangle( x*m_cellWidth*X_UNIT, y*m_cellHeight*Y_UNIT,
m_cellWidth*X_UNIT+1, m_cellHeight*Y_UNIT+1);
buf = wxT("M");
if (!m_game->IsHidden(x,y) && m_game->IsBomb(x,y))
dc->SetTextForeground(wxBlue);
else
dc->SetTextForeground(wxRed);
dc->SetTextBackground(wxGrey);
dc->GetTextExtent(buf, &chw, &chh); dc->GetTextExtent(buf, &chw, &chh);
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)) if (!m_game->IsHidden(x,y) && m_game->IsBomb(x,y))
{ dc->SetPen(*redPen); {
dc->DrawLine(x*x_cell*X_UNIT, y*y_cell*Y_UNIT, dc->SetPen(*redPen);
(x+1)*x_cell*X_UNIT, (y+1)*y_cell*Y_UNIT); dc->DrawLine(x*m_cellWidth*X_UNIT, y*m_cellHeight*Y_UNIT,
dc->DrawLine(x*x_cell*X_UNIT, (y+1)*y_cell*Y_UNIT, (x+1)*m_cellWidth*X_UNIT, (y+1)*m_cellHeight*Y_UNIT);
(x+1)*x_cell*X_UNIT, y*y_cell*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 (wxGetApp().Game.IsHidden(x,y)) else if (m_game->IsHidden(x,y))
{ dc->SetPen(*blackPen); {
dc->SetPen(*blackPen);
if (m_game->IsFocussed(x, y))
dc->SetBrush(* focusedBrush);
else
dc->SetBrush(*greyBrush); 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); dc->DrawRectangle( x*m_cellWidth*X_UNIT, y*m_cellHeight*Y_UNIT,
m_cellWidth*X_UNIT+1, m_cellHeight*Y_UNIT+1);
} }
else if (wxGetApp().Game.IsBomb(x,y)) else if (m_game->IsBomb(x,y))
{ dc->SetPen(* blackPen); {
dc->SetPen(* blackPen);
dc->SetBrush(* redBrush); dc->SetBrush(* redBrush);
dc->DrawRectangle( x*x_cell*X_UNIT, y*y_cell*Y_UNIT, dc->DrawRectangle( x*m_cellWidth*X_UNIT, y*m_cellHeight*Y_UNIT,
x_cell*X_UNIT+1, y_cell*Y_UNIT+1); m_cellWidth*X_UNIT+1, m_cellHeight*Y_UNIT+1);
*buf=_T('B'); buf = wxT("B");
dc->SetTextForeground(* wxBlack); dc->SetTextForeground(wxBlack);
dc->SetTextBackground(* wxRed); dc->SetTextBackground(wxRed);
dc->GetTextExtent(buf, &chw, &chh); dc->GetTextExtent(buf, &chw, &chh);
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 (m_game->IsExploded(x,y))
if (wxGetApp().Game.IsExploded(x,y)) {
{ dc->SetPen(* bluePen); dc->SetPen(* bluePen);
dc->DrawLine(x*x_cell*X_UNIT, y*y_cell*Y_UNIT, dc->DrawLine(x*m_cellWidth*X_UNIT, y*m_cellHeight*Y_UNIT,
(x+1)*x_cell*X_UNIT, (y+1)*y_cell*Y_UNIT); (x+1)*m_cellWidth*X_UNIT, (y+1)*m_cellHeight*Y_UNIT);
dc->DrawLine(x*x_cell*X_UNIT, (y+1)*y_cell*Y_UNIT, dc->DrawLine(x*m_cellWidth*X_UNIT, (y+1)*m_cellHeight*Y_UNIT,
(x+1)*x_cell*X_UNIT, y*y_cell*Y_UNIT); (x+1)*m_cellWidth*X_UNIT, y*m_cellHeight*Y_UNIT);
} }
} }
else // Display a digit else // Display a digit
{ dc->SetPen(* blackPen); {
dc->SetPen(* blackPen);
if (m_game->IsFocussed(x, y))
dc->SetBrush(* focusedBrush);
else
dc->SetBrush(* whiteBrush); dc->SetBrush(* whiteBrush);
dc->DrawRectangle( x*x_cell*X_UNIT, y*y_cell*Y_UNIT, dc->DrawRectangle( x*m_cellWidth*X_UNIT, y*m_cellHeight*Y_UNIT,
x_cell*X_UNIT+1, y_cell*Y_UNIT+1); m_cellWidth*X_UNIT+1, m_cellHeight*Y_UNIT+1);
*buf = (wxGetApp().Game.Get(x,y) & BG_MASK) + _T('0');
dc->GetTextExtent(buf, &chw, &chh); int digit_value = m_game->Get(x,y) & BG_MASK;
switch(*buf) switch(digit_value)
{ case _T('0'): dc->SetTextForeground(* wxGreen); break; {
case _T('1'): dc->SetTextForeground(* wxBlue); break; case 0:
default: dc->SetTextForeground(* wxBlack); break; 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->SetTextBackground(* wxWhite); 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);
);
} }
} }
dc->SetFont(wxNullFont); 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);
}
} }
/*-------- BombCanvasClass::RefreshField(xc1, yc1, xc2, yc2) --------*/ // Refreshes the field image
/* Refreshes the field image */ // 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::RefreshField(int xc1, int yc1, int xc2, int yc2)
/*---------------------------------------------------------------------*/ {
void BombsCanvasClass::RefreshField(int xc1, int yc1, int xc2, int yc2)
{
wxClientDC dc(this); wxClientDC dc(this);
DrawField(& dc, xc1, yc1, xc2, yc2); DrawField(& dc, xc1, yc1, xc2, yc2);
if (bmp) if (m_bmp)
{ wxMemoryDC memDC; {
memDC.SelectObject(* bmp); wxMemoryDC memDC;
memDC.SelectObject(*m_bmp);
DrawField(&memDC, xc1, yc1, xc2, yc2); DrawField(&memDC, xc1, yc1, xc2, yc2);
memDC.SelectObject(wxNullBitmap); 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)
{
wxBell();
if (hasWon)
{
wxMessageBox(wxT("Nice! You found all the bombs!"),
wxT("wxWin Bombs"), wxOK|wxCENTRE);
} }
else // x,y is a bomb else // x,y is a bomb
{ wxGetApp().Game.Explode(x, y); {
m_game->Explode(x, y);
} }
for(x=0; x<field_width; x++)
for(y=0; y<field_height; y++) for(x=0; x<gridWidth; x++)
wxGetApp().Game.Unhide(x,y); for(y=0; y<gridHeight; y++)
RefreshField(0, 0, field_width-1, field_height-1); 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 )
? x+1
: gridWidth - 1;
int top = ( y > 0 ) ? y-1 : 0; int top = ( y > 0 ) ? y-1 : 0;
int bottom = ( y < wxGetApp().Game.GetHeight() - 1 )? int bottom = ( y < gridHeight - 1 )
y+1 : wxGetApp().Game.GetHeight() - 1; ? y+1
int i,j; : gridHeight - 1;
for (j = top; j <= bottom; j++)
for (i=left; i <= right; i++) int i, j;
if ((i != x || j != y) && wxGetApp().Game.IsHidden(i,j) for (j=top; j<=bottom; j++)
&& !wxGetApp().Game.IsMarked(i,j)) for (i=left; i<=right; i++)
Uncover(i,j); 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)
{ {
const int gridWidth = m_game->GetWidth();
const int gridHeight = m_game->GetHeight();
wxCoord fx, fy; wxCoord fx, fy;
event.GetPosition(&fx, &fy); event.GetPosition(&fx, &fy);
int x = fx/(x_cell*X_UNIT); int x = fx/(m_cellWidth*X_UNIT);
int y = fy/(y_cell*Y_UNIT); int y = fy/(m_cellHeight*Y_UNIT);
if (x<field_width && y<field_height) if (x<gridWidth && y<gridHeight)
{ if ( (event.RightDown() || (event.LeftDown() && event.ShiftDown())) {
&& (wxGetApp().Game.IsHidden(x,y) if ( (event.RightDown() || (event.LeftDown() && event.ShiftDown()))
|| wxGetApp().Game.GetRemainingCells()==0)) && (m_game->IsHidden(x,y)
{ wxGetApp().Game.Mark(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); RefreshField(x, y, x, y);
return; 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); {
// 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; 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);
}
}

138
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++)
for(y=0; y<height; y++)
{ field[x+y*width] = ((float)rand()/RAND_MAX <PROB)?
BG_HIDDEN | BG_BOMB :
BG_HIDDEN;
} }
bombs=0; m_field = new short[aWidth*aHeight];
for(x=0; x<width; x++) if (!m_field)
for(y=0; y<height; y++) {
if (field[x+y*width] & BG_BOMB) m_width = m_height = 0;
{ bombs++; 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;
}
}
m_numBombCells = 0;
for(x=0; x<m_width; x++)
for(y=0; y<m_height; y++)
if (m_field[x+y*m_width] & BG_BOMB)
{
m_numBombCells++;
for(xx=x-1; xx<=x+1; xx++) for(xx=x-1; xx<=x+1; xx++)
if (xx>=0 && xx<width) if (xx>=0 && xx<m_width)
for(yy=y-1; yy<=y+1; yy++) for(yy=y-1; yy<=y+1; yy++)
if (yy>=0 && yy<height && (yy!=y || xx!=x)) if (yy>=0 && yy<m_height && (yy!=y || xx!=x))
field[xx+yy*width]++; m_field[xx+yy*m_width]++;
}
normal_cells=height*width-bombs;
return 1;
} }
/*---------------------- BombsGame::Mark(x,y) -------------------------*/ m_numRemainingCells = m_height*m_width-m_numBombCells;
/* Marks/unmarks a cell */
/*-----------------------------------------------------------------------*/ return true;
}
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;
if (!IsBomb(x,y))
normal_cells--;
}
/*------------------- BombsGame::Explode(x,y) ------------------------*/
/* Makes a cell exploded */
/*----------------------------------------------------------------------*/
void BombsGame::Explode(int x, int y)
{ {
field[x+y*width] |= BG_EXPLODED; return;
} }
m_field[x+y*m_width] &= ~BG_HIDDEN;
if (!IsBomb(x,y))
{
m_numRemainingCells--;
}
}
void BombsGame::Explode(int x, int y)
{
m_field[x+y*m_width] |= BG_EXPLODED;
}

121
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_