// Koło Informatyczne
// I LO w Tarnowie
// Plik nagłówkowy
//--------------------

#define RMIN 10
#define RMAX 40
#define CMIN 10
#define CMAX 60
#define MMIN 10

#define SSIZE 100
#define SGROW

// Struktura komórki planszy
//--------------------------
struct Cell
{
  bool open;      // Pole odkryte
  bool flag;      // Flaga na polu
  bool mine;      // Mina w polu
  bool exploded;  // Mina wybuchła
  int  count;     // Liczba min w sąsiedztwie
};

// Klasa planszy pola minowego
//----------------------------
class Minefield
{
  protected:
    Cell ** T;    // Macierz dynamiczna
    int r,c;      // Liczba wierszy r i kolumn c
    int mc;       // Liczba min na polu
  public:
    Minefield(int m, int n, int mn); // Konstruktor
    ~Minefield();                    // Destruktor
    int RowCount();                  // Zwraca liczbę wierszy
    int ColCount();                  // Zwraca liczbę kolumn
    int MinCount();                  // Zwraca liczbę min
    Cell & At(int rr,int cc);        // Zwraca referencję do komórki
};

// Klasa stosu
//------------

class Stack
{
  protected:
    int * S;                    // Stos dynamiczny
    int sp;                     // Wskaźnik stosu
    int n;                      // Rozmiar stosu
  public:
    Stack();                    // Konstruktor
    ~Stack();                   // Destruktor
    bool notEmpty();            // Zwraca true, gdy stos nie jest pusty
    void push(int a, int b);    // Umieszcza a i b na stosie
    void pop(int & a, int & b); // Pobiera a i b ze stosu
};

#define RMIN 10
#define RMAX 40
#define CMIN 10
#define CMAX 60
#define MMIN 10

#define SSIZE 100
#define SGROW 50

#define FSIZE 20

struct Cell
{
  bool open;
  bool flag;
  bool mine;
  bool exploded;
  int  count;
};

class Minefield
{
  protected:
    Cell ** T;
    int r,c;
    int mc;
  public:
    Minefield(int m, int n, int mn);
    ~Minefield();
    int RowCount();
    int ColCount();
    int MinCount();
    Cell & At(int rr,int cc);
};

Sekcja publiczna definiuje kilka metod klasy:

W sumie metody RowCount(), ColCount(), MinCount() i At() nie są niezbędne – moglibyśmy się w programie odwoływać do odpowiednich pól klasy, gdyby uczynić je publicznymi. Ale tak jest bardziej czytelnie i elegancko.

class Stack
{
  protected:
    int * S;
    int sp;
    int n;
  public:
    Stack();
    ~Stack();
    bool notEmpty();
    void push(int a, int b);
    void pop(int & a, int & b);
};

W sekcji chronionej mamy następujące pola:

W sekcji publicznej mamy następujące metody:

#include "myclasses.h"
#include <stdlib.h>

// Klasa planszy gry
//------------------

// Konstruktor planszy
//--------------------
Minefield::Minefield(int m, int n, int mn)
{
  // Ustalamy liczbę wierszy
  r = m;
  if(r < RMIN) r = RMIN;  // Jeśli r nie mieści się w zakresie,
  if(r > RMAX) r = RMAX;  // to je odpowiednio dopasowujemy

  // Ustalamy liczbę kolumn
  c = n;
  if(c < CMIN) c = CMIN;  // Jeśli c nie mieści się w zakresie,
  if(c > CMAX) c = CMAX;  // to je odpowiednio dopasowujemy

  // Tworzymy macierz pól
  T = new Cell * [r];
  for(int i = 0; i < r; i++)
  {
    T[i] = new Cell [c];

    // Każdą komórkę pola inicjujemy zerami

    for(int j = 0; j < c; j++)
    {
      T[i][j].open = T[i][j].flag = T[i][j].mine = T[i][j].exploded = false;
      T[i][j].count = 0;
    }
  }

  // Ustalamy liczbę min na polu, dopasowując ją do zakresu

  if(mn < MMIN) mn = MMIN;
  if(mn > (r * c) / 3) mn = (r * c) / 3;

  // Wstawiamy miny na pole do komórek
  // W mc będzie ostateczna liczba min

  mc = 0;

  while(mc < mn)
  {
    int rr = rand() % r;         // Generujemy losowe pole planszy
    int cc = rand() % c;
    if(T[rr][cc].mine) continue; // Jeśli zawiera minę, to powtarzamy
    T[rr][cc].mine = true;       // Wstawiamy minę w pole
    mc++;                        // Zwiększamy licznik min
  }

  // Zliczamy miny w sąsiedztwie każdego pola

  for(int i = 0; i < r; i++)
    for(int j = 0; j < c; j++)
      for(int ii = i - 1; ii <= i + 1; ii++)
        if((ii >= 0) && (ii < r))
          for(int jj = j - 1; jj <= j + 1; jj++)
            if((jj >= 0) && (jj < c) && T[ii][jj].mine)
              T[i][j].count++;

}

// Destruktor planszy
//-------------------
Minefield::~Minefield()
{
  for(int i = 0; i < r; i++) delete [] T[i]; // Usuwamy wiersze
  delete [] T;                               // Usuwamy tablicę wierszy
}

// Zwraca liczbę wierszy
//----------------------
int Minefield::RowCount()
{
  return r;
}

// Zwraca liczbę kolumn
//---------------------
int Minefield::ColCount()
{
  return c;
}

// Zwraca liczbę min
//------------------
int Minefield::MinCount()
{
  return mc;
}

// Zwraca referencję do komórki planszy
// rr - numer wiersza
// cc - numer kolumny
//-------------------------------------
Cell & Minefield::At(int rr,int cc)
{
  return T[rr][cc];
}

// Klasa Stosu
//------------

// Konstruktor
//------------
Stack::Stack()
{
  n  = SSIZE;         // Zapamiętujemy rozmiar
  S  = new int [n];   // Tworzymy stos
  sp = 0;             // Zerujemy wskaźnik stosu
}

// Destruktor
//-----------
Stack::~Stack()
{
  delete [] S;
}

// Zwraca true, jeśli stos nie jest pusty
//---------------------------------------
bool Stack::notEmpty()
{
  return sp;
}

// Umieszcza na stosie a i b
//--------------------------
void Stack::push(int a, int b)
{
  if(sp == n)                   // Sprawdzamy, czy na stosie jest miejsce
  {                             // Jeśli nie, to
    n += SGROW;                 // Powiększamy rozmiar
    int * T = new int[n];       // Tworzymy nowy stos
    for(int i = 0; i < sp; i++)
      T[i] = S[i];              // Kopiujemy stary stos do nowego
    delete [] S;                // Stary stos usuwamy
    S = T;                      // Nowy stos przydzielamy S
  }

  S[sp++] = a;                  // Na stosie umieszczamy a i b
  S[sp++] = b;
}

// Pobiera ze stosu a i b
//-----------------------
void Stack::pop(int & a, int & b)
{
  b = S[--sp];                  // Pobieramy ze stosu najpierw b 
  a = S[--sp];                  // a następnie a
}

#include "myclasses.h"

Dzięki dołączeniu tego pliku nasz program "zna" budowę zdefiniowanych tam elementów.

#include <stdlib.h>

Plik stdlib.h definiuje funkcje standardowej biblioteki. Potrzebujemy go do generacji liczb pseudolosowych w funkcji rand(), która właśnie jest tam zdefiniowana. O liczbach pseudolosowych możesz przeczytać tutaj.

Minefield::Minefield(int m, int n, int mn)
{

m  – liczbę wierszy planszy pola minowego
n  – liczbę kolumn
mn – liczbę min

  r = m;
  if(r < RMIN) r = RMIN;
  if(r > RMAX) r = RMAX;

  c = n;
  if(c < CMIN) c = CMIN;
  if(c > CMAX) c = CMAX;

Liczba wierszy zostaje zapamiętana w polu r klasy, a liczba kolumn w polu c.

  T = new Cell * [r];

  for(int i = 0; i < r; i++)
  {
    T[i] = new Cell [c];

    for(int j = 0; j < c; j++)
    {
      T[i][j].open = 
      T[i][j].flag = 
      T[i][j].mine = 
      T[i][j].exploded = false;

      T[i][j].count = 0;
    }
  }

Następnie w pętli tworzymy poszczególne wiersze macierzy. Wiersz zbudowany jest z c komórek typu Cell. Adres wiersza zapamiętujemy w komórce tablicy T.

Po utworzeniu wiersza inicjujemy wszystkie komórki. W polach open, flag, mine i exploded umieszczamy wartość logiczną false.

W polu count umieszczamy zero.

  if(mn < MMIN) mn = MMIN;
  if(mn > (r * c) / 3) mn = (r * c) / 3;

  mc = 0;

  while(mc < mn)
  {
    int rr = rand() % r;
    int cc = rand() % c;
    if(T[rr][cc].mine) continue;
    T[rr][cc].mine = true;
    mc++;
  }

Następnie w pętli umieszczamy na planszy mn min. Najpierw losujemy jedno z pól planszy. Zmienna rr jest numerem wiersza, a cc jest numerem kolumny tego pola. Po wylosowaniu pola, sprawdzamy, czy zawiera już minę. Jeśli tak, to losujemy inne pole – polecenie continue powoduje powrót na początek pętli while.

Jeśli pole nie zawiera miny, to ustawiamy jego składnik mine na true i zwiększamy licznik min mc. Pętla while wykonuje się dotąd, aż mc osiągnie pożądaną wartość mn.

  for(int i = 0; i < r; i++)
    for(int j = 0; j < c; j++)
      for(int ii = i - 1; ii <= i + 1; ii++)
        if((ii >= 0) && (ii < r))
          for(int jj = j - 1; jj <= j + 1; jj++)
            if((jj >= 0) && (jj < c) && T[ii][jj].mine)
              T[i][j].count++;

}

Jeśli w którymś z tych 9 pól znajdzie się mina, to licznik count środkowego pola zostaje zwiększony o 1. Komplikacja pętli jest spowodowana tym, że pole środkowe może leżeć na krawędzi planszy, a w takim przypadku należy część pól pominąć, ponieważ plansza ich nie zawiera.

Minefield::~Minefield()
{
  for(int i = 0; i < r; i++) delete [] T[i];
  delete [] T;
}

int Minefield::RowCount()
{
  return r;
}

int Minefield::ColCount()
{
  return c;
}

int Minefield::MinCount()
{
  return mc;
}

Cell & Minefield::At(int rr,int cc)
{
  return T[rr][cc];
}

Stack::Stack()
{
  n  = SSIZE;
  S  = new int [n];
  sp = 0;
}

Stack::~Stack()
{
  delete [] S;
}

bool Stack::notEmpty()
{
  return sp;
}

void Stack::push(int a, int b)
{
  if(sp == n)
  {
    n += SGROW;
    int * T = new int[n];
    for(int i = 0; i < sp; i++) T[i] = S[i];
    delete [] S;
    S = T;
  }

  S[sp++] = a;
  S[sp++] = b;
}

Na końcu umieszczamy kolejno na stosie a i b. Zwróć uwagę na zwiększanie wskaźnika stosu sp po każdej operacji zapisu.

void Stack::pop(int & a, int & b)
{
  b = S[--sp];
  a = S[--sp];
}

//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"
#include "myclasses.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
}
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"
#include "myclasses.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TfrmSaper *frmSaper;

Minefield * mf = NULL;         // Plansza gry
bool Playing = false;          // Jeśli gra się toczy, to true
Graphics::TBitmap * bm = NULL; // Wskaźnik bitmapy planszy
int MinesCount;                // Liczba pozostałych min do odkrycia

//---------------------------------------------------------------------------
__fastcall TfrmSaper::TfrmSaper(TComponent* Owner)
        : TForm(Owner)
{
}
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
void DrawMFCell(int r,int c)
{
  int x = FSIZE * c;               // Obliczamy współrzędne komórki na bitmapie
  int y = FSIZE * r;

  TRect cell(x,y,x+FSIZE,y+FSIZE); // Tworzymy prostokąt obejmujący komórkę

  // W zależności od zawartości komórki rysujemy różne treści
  // w obrębie prostokąta komórki

  if(mf->At(r,c).open)                      // Jeśli komórka jest odkryta
  {
    bm->Canvas->Brush->Color = clWhite;     // To rysujemy białe tło
    bm->Canvas->FillRect(cell);
    if(mf->At(r,c).mine)                    // Teraz sprawdzamy, czy w komórce jest mina
    {
      if(mf->At(r,c).exploded)              // A jeśli jest, to czy wybuchła
      {
        bm->Canvas->Pen->Color = clYellow;  // Tak, linia żółta, pędzel czerwony
        bm->Canvas->Brush->Color = clRed;
      }
      else
      {
        bm->Canvas->Pen->Color = clGray;    // Nie, linia szara, pędzel czarny
        bm->Canvas->Brush->Color = clBlack;
      }
      bm->Canvas->Ellipse(x+3,y+3,x+FSIZE-3,y+FSIZE-3); // Rysujemy minę
    }
    else if(mf->At(r,c).count > 0)
    {
      // Komórka odkryta bez miny - jeśli liczba min ją otaczających jest
      // większa od 0, to w komórce zostanie wyświetlona ta liczba

      AnsiString s = IntToStr(mf->At(r,c).count);           // Pobieramy tekst liczby
      int sx = x + (FSIZE - bm->Canvas->TextWidth(s)) / 2;  // Obliczamy położenie tekstu
      int sy = y + (FSIZE - bm->Canvas->TextHeight(s)) / 2; // na środku komórki
      bm->Canvas->TextOutA(sx,sy,s);                        // Rysujemy tekst
    }
  }
  else
  {
    // Komórka zakryta

    bm->Canvas->Brush->Color = clGray;    // Tło szare

    if(mf->At(r,c).flag)                  // Sprawdzamy, czy komórka jest oflagowana
      bm->Canvas->Brush->Color = clGreen; // Jeśli tak, to tło zielone

    bm->Canvas->FillRect(cell);           // Wypełniamy komórkę wybranym tłem
  }

  // Na koniec rysujemy kratkę

  bm->Canvas->Pen->Color = clMaroon;      // Kolor linii
  bm->Canvas->MoveTo(x,y);                // Punkt startowy
  bm->Canvas->LineTo(x+FSIZE-1,y);        // Linia pozioma
  bm->Canvas->LineTo(x+FSIZE-1,y+FSIZE);  // Linia pionowa
}
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
void DrawMF()
{
  for(int i = 0; i < mf->RowCount(); i++)
    for(int j = 0; j < mf->ColCount(); j++)
      DrawMFCell(i,j);                      // Rysujemy kolejne komórki planszy
}
//---------------------------------------------------------------------------

void __fastcall TfrmSaper::FormPaint(TObject *Sender)
{

}

void __fastcall TfrmSaper::FormPaint(TObject *Sender)
{
  Canvas->Draw(0,pnlSetting->Height,bm); 
}

void __fastcall TfrmSaper::btnStartClick(TObject *Sender)
{

}

void __fastcall TfrmSaper::btnStartClick(TObject *Sender)
{
  if(mf) delete mf;  // Usuwamy poprzednią planszę gry
  if(bm) delete bm;  // oraz jej bitmapę

  int r = edtRows->Text.ToInt();   // Odczytujemy rozmiar planszy
  int c = edtCols->Text.ToInt();   // z pól edycyjnych
  int m = edtMines->Text.ToInt();  // oraz liczbę min

  mf = new Minefield(r,c,m);       // Tworzymy nową planszę

  r = mf->RowCount();              // Odczytujemy faktyczne rozmiary
  c = mf->ColCount();              // planszy pola minowego
  MinesCount = m = mf->MinCount(); // oraz rzeczywistą liczbę min

  edtRows->Text  = IntToStr(r);    // Korygujemy pola edycyjne
  edtCols->Text  = IntToStr(c);
  edtMines->Text = IntToStr(m);

  ClientWidth = FSIZE * c;         // Obliczamy wymiary okna
  ClientHeight = pnlSetting->Height + FSIZE * r;

  bm = new Graphics::TBitmap;      // Tworzymy nową bitmapę dla planszy
  bm->Width = FSIZE * c;           // Obliczamy rozmiar jej płótna Canvas
  bm->Height = FSIZE * r;

  DrawMF();                        // Rysujemy całe pole minowe na bitmapie

  lblMines->Caption = "miny = " + IntToStr(MinesCount);

  Invalidate();                    // Unieważniamy okno, co spowoduje
                                   // przerysowanie jego treści
  Playing = true;                  // Oznaczamy grę jako aktywną
}

void __fastcall TfrmSaper::FormCreate(TObject *Sender)
{
  srand(time(NULL));       // Inicjujemy generator pseudolosowy
  DoubleBuffered = true;   // Okno podwójnie buforowane - nie będzie migotać
  btnStartClick(Sender);   // Inicjujemy planszę poprzez onClick dla przycisku START
}

void __fastcall TfrmSaper::FormMouseDown(TObject *Sender,
      TMouseButton Button, TShiftState Shift, int X, int Y)
{
  if(Playing)                                 // Sprawdzamy, czy gra jest w toku
  {
    int r = (Y - pnlSetting->Height) / FSIZE; // Obliczamy współrzędne komórki
    int c =  X / FSIZE;                       // klikniętej przez gracza

    if(Button == mbRight)                     // Prawy przycisk myszki?
    {
      if(mf->At(r,c).open == false)           // Komórka zakryta?
      {
        mf->At(r,c).flag = !mf->At(r,c).flag; // Ustaw lub usuń flagę oraz zmodyfikuj licznik min
        if(mf->At(r,c).flag && MinesCount) MinesCount--; else MinesCount++;
      }
    }
    else if((Button == mbLeft) && !mf->At(r,c).flag)
    {                                         // Lewy przycisk myszki, a komórka bez flagi
      mf->At(r,c).open = true;                // Odkrywamy komórkę
      if(mf->At(r,c).mine)                    // Komórka z miną?
      {
        mf->At(r,c).exploded = true;          // Jeśli tak, to gra się kończy
        Playing = false;
      }
      else if(mf->At(r,c).count == 0)         // Sprawdzamy, czy liczba otaczających min jest równa 0
      {                                       // Jeśli tak, to za pomocą DFS odkrywamy przyległe komórki bez min
        Stack * S = new Stack;                // Tworzymy stos

        mf->At(r,c).open = false;             // Chwilowo zakrywamy komórkę - wymaga tego DFS

        S->push(r,c);                         // Pozycja komórki startowej na stos

        while(S->notEmpty())                  // W pętli wykonujemy przejście DFS
        {
          int xr,xc;
          S->pop(xr,xc);                      // Pobieramy ze stosu pozycję komórki
          if(mf->At(xr,xc).open) continue;    // Jeśli przetworzona, to wracamy na początek pętli
          mf->At(xr,xc).open = true;          // Otwieramy komórkę
          if(mf->At(xr,xc).flag) MinesCount++;// Jeśli komórka była oflagowana, to zwiększamy licznik min
          DrawMFCell(xr,xc);                  // Rysujemy komórkę na płótnie mapy bitowej bm
          if(mf->At(xr,xc).count == 0)        // Jeśli jest to komórka bez otaczających ją min, to na stosie
          {                                   // umieszczamy wszystkich jej nieotwartych sąsiadów 
            for(int i = xr - 1; i <= xr + 1; i++)
              if((i >= 0) && (i < mf->RowCount()))
                for(int j = xc - 1; j <= xc + 1; j++)
                  if((j >=0) && (j < mf->ColCount()) &&
                    (mf->At(i,j).open == false))
                  {
                    S->push(i,j);
                  }
          }
        }
        delete S;                             // Koniec DFS. Usuwamy stos
      }
    }
    DrawMFCell(r,c);                          // Rysujemy na bitmapie bm klikniętą komórkę

    // Sprawdzamy koniec gry.

    bool test = true;

    for(int i = 0; i < mf->RowCount(); i++)   // Sprawdzamy, czy na planszy pozostały jeszcze nieodkryte komórki
      for(int j = 0; j < mf->ColCount(); j++) // bez min. Jeśli tak, to test jest zerowany na false.
        if((mf->At(i,j).open == false) && (mf->At(i,j).mine == false))
          test = false;                       // Gra jeszcze nie jest skończona

    if(test) Playing = false;                 // Przerywamy grę, jeśli test jest pozytywny  

    if(!Playing)                              // Jeśli gra się zakończyła, to odkrywamy wszystkie komórki
    {
      for(int i = 0; i < mf->RowCount(); i++)
        for(int j = 0; j < mf->ColCount(); j++)
          mf->At(i,j).open = true;

      DrawMF();                               // Rysujemy całą planszę gry
    }

    lblMines->Caption = "miny = " + IntToStr(MinesCount);

    Invalidate();                             // To powoduje przekopiowanie bitmapy bm do okna gry
  }        
}