Mirrors_UI_SDK/wxWidgets
1
0
Fork 0
mirror of https://github.com/wxWidgets/wxWidgets.git synced 2025-12-19 10:50:17 +08:00
Code Issues Actions 1 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
// Purpose: Bombs game
// Author: P. Foggia 1996
// Modified by:
// Modified by: Wlodzimierz Skiba (ABX) 2003
// Created: 1996
// RCS-ID: $Id$
// Copyright: (c) 1996 P. Foggia
@@ -10,243 +10,275 @@
///////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__
#pragma implementation
# pragma implementation
#endif
#include "wx/wxprec.h"
#ifdef __BORLANDC__
# pragma hdrstop
#endif
#ifndef WX_PRECOMP
#include "wx/wx.h"
# include "wx/wx.h"
#endif //precompiled headers
#include "bombs.h"
#include <time.h>
#include <stdlib.h>
#if defined(__WXGTK__) || defined(__WXX11__) || defined(__WXMOTIF__) || defined(__WXMAC__) || defined(__WXMGL__)
#include "bombs.xpm"
#ifndef __WXWINCE__
# include <time.h>
#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
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.
BombsFrame = NULL;
level=IDM_EASY;
m_frame = new BombsFrame(&m_game);
BombsFrame =
new BombsFrameClass(NULL, _T("wxBombs"), wxPoint(155, 165), wxSize(300, 300), wxMINIMIZE_BOX | wxSYSTEM_MENU | wxCAPTION | wxCLOSE_BOX );
m_frame->NewGame(bombsID_EASY);
int xmax=BombsFrame->BombsCanvas->field_width*BombsFrame->BombsCanvas->x_cell*X_UNIT;
int ymax=BombsFrame->BombsCanvas->field_height*BombsFrame->BombsCanvas->y_cell*Y_UNIT;
BombsFrame->SetClientSize(xmax, ymax);
return TRUE;
return true;
}
BEGIN_EVENT_TABLE(BombsFrameClass, wxFrame)
EVT_MENU(IDM_EASY, BombsFrameClass::OnEasy)
EVT_MENU(IDM_MEDIUM, BombsFrameClass::OnMedium)
EVT_MENU(IDM_DIFFICULT, BombsFrameClass::OnDifficult)
EVT_MENU(IDM_EXIT, BombsFrameClass::OnExit)
EVT_MENU(IDM_ABOUT, BombsFrameClass::OnAbout)
EVT_MENU(IDM_RESTART, BombsFrameClass::OnRestart)
EVT_CLOSE(BombsFrameClass::OnCloseWindow)
BEGIN_EVENT_TABLE(BombsFrame, wxFrame)
EVT_MENU(bombsID_EASY, BombsFrame::OnNewEasyGame)
EVT_MENU(bombsID_MEDIUM, BombsFrame::OnNewMediumGame)
EVT_MENU(bombsID_HARD, BombsFrame::OnNewHardGame)
EVT_MENU(wxID_EXIT, BombsFrame::OnExit)
EVT_MENU(wxID_ABOUT, BombsFrame::OnAbout)
END_EVENT_TABLE()
BombsFrameClass::BombsFrameClass(wxFrame *parent, const wxString& title, const wxPoint& pos, const wxSize& size, long style):
wxFrame(parent, -1, title, pos, size, style)
BombsFrame::BombsFrame(BombsGame *game)
: wxFrame(NULL, wxID_ANY, wxT("wxBombs"), wxDefaultPosition,
wxSize(300, 300), wxDEFAULT_DIALOG_STYLE|wxMINIMIZE_BOX)
{
// Initialize child subwindow members.
BombsCanvas = NULL;
m_game = game;
SetIcon(wxICON(bombs));
SetIcon(wxICON(bombs));
CreateStatusBar();
// Create a menu bar for the frame
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);
#if wxUSE_STATUSBAR
CreateStatusBar();
#endif
// Create child subwindows.
BombsCanvas = new BombsCanvasClass(this);
// Create a menu bar for the frame
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.
// OnSize(width, height);
menuFile->Append(bombsID_NEWGAME, wxT("&New Game"),
menuLevel, wxT("Starts a new game"));
// Centre frame on the screen.
Centre(wxBOTH);
menuFile->AppendSeparator();
menuFile->Append(wxID_EXIT, wxT("E&xit"), wxT("Quits the application"));
// Show the frame.
Show(TRUE);
menuBar->Append(menuFile, wxT("&File"));
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();
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);
NewGame(bombsID_EASY);
}
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);
wxGetApp().level=IDM_EASY;
menuBar->Check(wxGetApp().level, TRUE);
NewGame(bombsID_HARD);
}
void BombsFrameClass::OnMedium(wxCommandEvent& WXUNUSED(event))
{
menuBar->Check(wxGetApp().level, FALSE);
wxGetApp().level=IDM_MEDIUM;
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)
BEGIN_EVENT_TABLE(BombsCanvas, wxPanel)
EVT_PAINT(BombsCanvas::OnPaint)
EVT_MOUSE_EVENTS(BombsCanvas::OnMouseEvent)
EVT_CHAR(BombsCanvas::OnChar)
END_EVENT_TABLE()
BombsCanvasClass::BombsCanvasClass(wxFrame *parent, const wxPoint& pos, const wxSize& size, long style):
wxWindow(parent, -1, pos, size, style)
{
int sx, sy;
wxClientDC dc(this);
wxFont font= BOMBS_FONT;
dc.SetFont(font);
BombsCanvas::BombsCanvas(wxFrame *parent, BombsGame *game)
: wxPanel(parent, wxID_ANY)
{
m_game = game;
int sx, sy;
wxClientDC dc(this);
wxFont font= BOMBS_FONT;
dc.SetFont(font);
long chw, chh;
wxChar buf[]=_T("M");
long chw, chh;
wxString buf = wxT("M");
dc.GetTextExtent(buf, &chw, &chh);
dc.SetFont(wxNullFont);
dc.GetTextExtent(buf, &chw, &chh);
dc.SetFont(wxNullFont);
dc.SetMapMode(wxMM_METRIC);
dc.SetMapMode(wxMM_METRIC);
int xcm = dc.LogicalToDeviceX(10);
int ycm = dc.LogicalToDeviceY(10);
int xcm = dc.LogicalToDeviceX(10);
int ycm = dc.LogicalToDeviceY(10);
// To have a square cell, there must be :
// sx*ycm == sy*xcm
if (chw*ycm < chh*xcm)
{ sy=chh;
sx=chh*xcm/ycm;
if (chw*ycm < chh*xcm)
{
sy = chh;
sx = chh*xcm/ycm;
}
else
{ sx=chw;
sy=chw*ycm/xcm;
else
{
sx = chw;
sy = chw*ycm/xcm;
}
x_cell = (sx+3+X_UNIT)/X_UNIT;
y_cell = (sy+3+Y_UNIT)/Y_UNIT;
dc.SetMapMode(wxMM_TEXT);
bmp=NULL;
UpdateFieldSize();
m_cellWidth = (sx+3+X_UNIT)/X_UNIT;
m_cellHeight = (sy+3+Y_UNIT)/Y_UNIT;
dc.SetMapMode(wxMM_TEXT);
m_bmp = NULL;
}
BombsCanvasClass::~BombsCanvasClass(void)
BombsCanvas::~BombsCanvas()
{
if (bmp)
delete bmp;
if (m_bmp)
{
delete m_bmp;
m_bmp = NULL;
}
}
// 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.
if (!bmp)
{ bmp=new wxBitmap(field_width*x_cell*X_UNIT+1,
field_height*y_cell*Y_UNIT+1);
if (bmp)
{ wxMemoryDC memDC;
memDC.SelectObject(* bmp);
DrawField(&memDC, 0, 0, field_width-1, field_height-1);
memDC.SelectObject(wxNullBitmap);
const int numHorzCells = m_game->GetWidth();
const int numVertCells = m_game->GetHeight();
// Insert your drawing code here.
if (!m_bmp)
{
wxSize size = dc.GetSize();
m_bmp = new wxBitmap(size.GetWidth(), size.GetHeight());
if (m_bmp)
{
wxMemoryDC memDC;
memDC.SelectObject(*m_bmp);
DrawField(&memDC, 0, 0, numHorzCells-1, numVertCells-1);
memDC.SelectObject(wxNullBitmap);
}
}
if (bmp)
{ wxMemoryDC memDC;
memDC.SelectObject(* bmp);
dc.Blit(0, 0, field_width*x_cell*X_UNIT+1,
field_height*y_cell*Y_UNIT+1,
&memDC, 0, 0, wxCOPY);
if (m_bmp)
{
wxMemoryDC memDC;
memDC.SelectObject(*m_bmp);
wxSize size = dc.GetSize();
dc.Blit(0, 0, size.GetWidth(), size.GetHeight(),
&memDC, 0, 0, wxCOPY);
memDC.SelectObject(wxNullBitmap);
}
else
DrawField(& dc, 0, 0, field_width-1, field_height-1);
else
{
DrawField(&dc, 0, 0, numHorzCells-1, numVertCells-1);
}
}
// Updates the field size depending on wxGetApp().level and
// redraws the canvas
void BombsCanvasClass::UpdateFieldSize()
{ field_width=20;
field_height=20;
void BombsCanvas::UpdateGridSize()
{
switch(wxGetApp().level)
{ case IDM_EASY:
field_width=10;
field_height=10;
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 (m_bmp)
{
delete m_bmp;
m_bmp = NULL;
}
Refresh();
}
wxSize BombsCanvas::GetGridSizeInPixels() const
{
return wxSize(m_cellWidth*X_UNIT*m_game->GetWidth(),
m_cellHeight*Y_UNIT*m_game->GetHeight());
}
if (bmp)
delete bmp;
bmp=NULL;
wxWindow::Refresh();
}

155
demos/bombs/bombs.h
View File

@@ -2,108 +2,107 @@
// Name: bombs.h
// Purpose: Bombs game
// Author: P. Foggia 1996
// Modified by:
// Modified by: Wlodzimierz Skiba (ABX) 2003
// Created: 1996
// RCS-ID: $Id$
// Copyright: (c) 1996 P. Foggia
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _INC_BOMBS_H
#define _INC_BOMBS_H
#ifndef _WX_DEMOS_BOMBS_BOMBS_H_
#define _WX_DEMOS_BOMBS_BOMBS_H_
#include "game.h"
/*
* Forward declarations of all top-level window classes.
*/
class BombsFrameClass;
class AboutFrameClass;
class BombsFrame;
/*
* Class representing the entire Application
*/
class AppClass: public wxApp
class BombsApp: public wxApp
{
public:
BombsFrameClass *BombsFrame;
int level;
BombsGame Game;
public:
virtual bool OnInit();
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:
protected:
public:
// Subwindows for reference within the program.
BombsCanvasClass *BombsCanvas;
wxMenuBar *menuBar;
public:
// Constructor and destructor
BombsFrameClass(wxFrame *parent, const wxString& title, const wxPoint& pos, const wxSize& size, long style);
~BombsFrameClass(void);
BombsFrame(BombsGame *bombsGame);
void OnCloseWindow(wxCloseEvent& 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);
void NewGame(int level);
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
*/
// 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
// App specific menu identifiers
enum
{
private:
protected:
public:
int field_width, field_height;
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()
bombsID_NEWGAME = wxID_HIGHEST,
bombsID_EASY,
bombsID_MEDIUM,
bombsID_HARD
};
/* 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 */
/* dimensions of a scroll unit, in pixels */
@@ -111,10 +110,14 @@ DECLARE_EVENT_TABLE()
#define Y_UNIT 4
/* 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)
#endif
#endif /* mutual exclusion */
#endif // #ifndef _WX_DEMOS_BOMBS_BOMBS_H_

470
demos/bombs/bombs1.cpp
View File

File diff suppressed because it is too large Load Diff

144
demos/bombs/game.cpp
View File

@@ -2,7 +2,7 @@
// Name: bombs1.cpp
// Purpose: Implementation of the class BombsGame
// Author: P. Foggia 1996
// Modified by:
// Modified by: Wlodzimierz Skiba (ABX) 2003
// Created: 1996
// RCS-ID: $Id$
// Copyright: (c) 1996 P. Foggia
@@ -10,14 +10,18 @@
///////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__
#pragma implementation
# pragma implementation
#endif
#include "wx/wxprec.h"
#ifdef __BORLANDC__
#pragma hdrstop
#endif
#ifndef WX_PRECOMP
#include "wx/wx.h"
#endif //precompiled headers
# include "wx/wx.h"
#endif
#include "game.h"
#include <stdlib.h>
@@ -26,80 +30,92 @@
#define PROB 0.2
#ifndef RAND_MAX
#define RAND_MAX INT_MAX
# define RAND_MAX INT_MAX
#endif
/*-------------------- BombsGame::~BombsGame() ---------------------*/
/*--------------------------------------------------------------------*/
BombsGame::~BombsGame()
{ if (field)
free(field);
}
{
if (m_field)
{
delete[] m_field;
}
}
/*------------------ int BombsGame::Init(width,height) -------------------*/
/* Initialize the play field. Returns 0 on failure */
/*--------------------------------------------------------------------------*/
int BombsGame::Init(int aWidth, int aHeight)
{ int x, y;
// Initialize the play field. Returns false on failure
bool BombsGame::Init(int aWidth, int aHeight)
{
m_gridFocusX = m_gridFocusY = -1;
int x, y;
int xx, yy;
if (field)
free(field);
field=(short *)malloc(aWidth*aHeight*sizeof(short));
if (!field)
{ width=height=0;
return 0;
}
width=aWidth;
height=aHeight;
if (m_field)
{
delete[] m_field;
}
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;
m_field = new short[aWidth*aHeight];
if (!m_field)
{
m_width = m_height = 0;
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;
for(x=0; x<width; x++)
for(y=0; y<height; y++)
if (field[x+y*width] & BG_BOMB)
{ bombs++;
for(xx=x-1; xx<=x+1; xx++)
if (xx>=0 && xx<width)
for(yy=y-1; yy<=y+1; yy++)
if (yy>=0 && yy<height && (yy!=y || xx!=x))
field[xx+yy*width]++;
}
normal_cells=height*width-bombs;
return 1;
}
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++)
if (xx>=0 && xx<m_width)
for(yy=y-1; yy<=y+1; yy++)
if (yy>=0 && yy<m_height && (yy!=y || xx!=x))
m_field[xx+yy*m_width]++;
}
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)
{
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)
{ if (!IsHidden(x,y))
return;
field[x+y*width] &= ~BG_HIDDEN;
{
if (!IsHidden(x,y))
{
return;
}
m_field[x+y*m_width] &= ~BG_HIDDEN;
if (!IsBomb(x,y))
normal_cells--;
}
{
m_numRemainingCells--;
}
}
/*------------------- BombsGame::Explode(x,y) ------------------------*/
/* Makes a cell exploded */
/*----------------------------------------------------------------------*/
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
// Definition of the class BombsGame, containing the data for a
// playfield
//---------------------------------------------------------------
#ifndef GAME_H
#define GAME_H
///////////////////////////////////////////////////////////////////////////////
// Name: game.h
// Purpose: Bombs game
// Author: P. Foggia 1996
// Modified by: Wlodzimierz Skiba (ABX) 2003
// Created: 1996
// 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_BOMB 0x200
@@ -12,31 +18,88 @@
#define BG_EXPLODED 0x800
#define BG_MASK 0x0FF
#include <stddef.h>
class BombsGame
{ protected:
int width,height;
short *field;
int bombs,normal_cells;
public:
BombsGame() { width=height=0; 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; };
};
{
public:
BombsGame()
{
m_width = m_height = 0;
m_field = NULL;
};
#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_