Okay, after this poor theoretical stuff, I want to have some more fun and start coding. I wanted to have this algorithm first, to make the programing easier later on, so that I can focus absolutely on coding and learning the syntax, instead of thinking about program logics while learning C++.
So the first thing I realized was the main game class. My first steps reminded me of the pictures of new born cows: They are able to walk from the first minute of their life, but their legs are shaking heavily and they hit the dirt a lot. =)
Some programming details, that I learned and find very useful to know:
I'm using the this. keyword a lot in Actionscript 3. It gives me a lot of control over the Class variables, separation them from variables with the same name, that are just available in a class method. ( -> There can be a difference between this.var and var)
What was new for me is the syntax: this->var. Let me see if I got this right: Everytime, we address something via a pointer, we use the arrow ->. "this", in this case is a pointer to the class itself. If we had created a class directly as a variable, we'd use the point syntax.
Another very cool thing, that I learned is the initialization list:
When create a constructor, you often have the case, that you pass an argument, that you have to pass to a member variable of the class. So the first lines of your constructor will probably look like this:
MyClass::MyClass(int var1, int var2, int var3){
this->var1 = var1;
this->var2 = var2;
this->var3 = var3;
(...)
And so on. But C++ comes with a very handy feature, that makes this procedure a lot slimmer.
MyClass::MyClass(int var1, int var2, int var3):var1(var1), var2(var2), var3(var3){
(...)
Just put the variables into the constructor line directly next to a colon after the parameters. I think the syntax is kind of self-explaining.
Note that the member variables have to be initiated in the header file for reasons of memory calculation.
Another note: I intentionally avoided the usage of the "namespace" command. It makes coding a lot more comfortable, because I don't have to write things like "std::cout" all the time. But I wanted to code it as detailed as possible to get a feeling for where the most important methods are to find.
So, here's the Class:
Minesweeper.h
/*
* Minesweeper.h
* MineSweeper++
*
* Created by Felix Ullrich on 10/18/08.
* Copyright 2008 fuX. All rights reserved.
*
* This class represents a Minesweeper API
*
*/
#ifndef MINESWEEPER_H
#define MINESWEEPER_H
#include
#include
class MineSweeper{
public:
//public member variables
int mineCount;
bool initiated;
//public member methods
MineSweeper(int width, int height, int mineCount);
~MineSweeper();
int revolveField(int x, int y);
bool markItem(int x, int y);
bool revolveAdjacentFields(int x, int y);
std::vector< std::vector > getFieldVector();
private:
//private member variables
std::vector< std::vector > queue;
std::vector< std::vector > minefield;
std::vector< std::vector > revolvedfield;
std::vector< std::vector > flagfield;
//private member methods
int getAdjacentMineCount(int x, int y);
int getAdjacentFlagCount(int x, int y);
int getAdjacentCount(std::vector< std::vector > field, int x, int y);
void revolveNextQueueItem();
void addNecessaryItemsToQueue(std::vector< std::vector > adjacentArray);
bool MineSweeper::isItemMarked(std::vector item);
bool MineSweeper::isItemInQueue(std::vector item);
void fillMineField(int clickedX, int clickedY);
std::vector< std::vector > getAdjacentFields(int x, int y);
};
#endif /* MINESWEEPER_H */
Minesweeper.cpp
/*
* Minesweeper.cpp
* MineSweeper++
*
* Created by Felix Ullrich on 10/18/08.
* Copyright 2008 fuX. All rights reserved.
*
*/
#include "Minesweeper.h"
#include
#include
#include
MineSweeper::MineSweeper(int width, int height, int mineCount):
//Initializations
mineCount(mineCount){
//Constructor
this->minefield.assign(width, std::vector(height));
this->revolvedfield.assign(width, std::vector(height));
this->flagfield.assign(width, std::vector(height));
/** TODO: Event Empty mine field created **/
}
MineSweeper::~MineSweeper(){
//Destructor
std::cout << "Program End" << std::endl;
}
int MineSweeper::revolveField(int x, int y){
if (!this->flagfield[x][y]){
if (!this->revolvedfield[x][y]){
this->revolvedfield[x][y] = true;
if (!this->initiated){
std::cout << "First mine" << std::endl;
this->fillMineField(x, y);
this->initiated = true;
/** TODO: Event -> Mine field filled **/
}
//If the field is a mine
if (this->minefield[x][y]){
/** TODO: Event -> Mine exploded (x, y, 9) **/
std::cout << "Mine Exploded." << std::endl;
return 9;
} else {
std::cout << "No Mine at this field." << std::endl;
int adjacentMines = this->getAdjacentMineCount(x, y);
//If the mine count is larger than 0
if (adjacentMines > 0){
/** TODO: Event -> Field has adjacentMines count (x, y, adjacentMines) **/
return adjacentMines;
} else {
/** TODO: Event -> Field has 0 adjacent mines (x, y, 0) **/
std::vector< std::vector > adjacentFields = this->getAdjacentFields(x, y);
this->addNecessaryItemsToQueue(adjacentFields);
this->revolveNextQueueItem();
return 0;
}
}
}
}
}
std::vector< std::vector > MineSweeper::getFieldVector(){
std::vector< std::vector > field;
field.assign(this->minefield.size(), std::vector(this->minefield[0].size()));
for (int i = 0; i < this->minefield.size(); i++){
for (int j = 0; j < this->minefield[0].size(); j++){
if (!this->revolvedfield[i][j]){
if (this->flagfield[i][j]){
field[i][j] = 11;
} else {
field[i][j] = 10;
}
} else {
if (this->minefield[i][j]){
field[i][j] = 9;
} else {
field[i][j] = this->getAdjacentMineCount(i, j);
}
}
}
}
return field;
}
int MineSweeper::getAdjacentMineCount(int x, int y){
std::cout << "Get Adjacent Mine Count." << std::endl;
return this->getAdjacentCount(this->minefield, x, y);
}
int MineSweeper::getAdjacentFlagCount(int x, int y){
std::cout << "Get Adjacent Flag Count." << std::endl;
return this->getAdjacentCount(this->flagfield, x, y);
}
int MineSweeper::getAdjacentCount(std::vector< std::vector > field, int x, int y){
int adjacentItems = 0;
//Iterate each field around the selected field
for (int i = x - 1; i <= x + 1; i++){
for (int j = y - 1; j <= y + 1; j++){
//If the checked field is not out of bounds
if (i != -1 && j != -1 && i != field.size() && j != field[0].size()){
//If the field is filled
if(i != 0 || j != 0){
if (field[i][j]){
adjacentItems++;
}
}
}
}
}
std::cout << "Adjacent Items: " << adjacentItems << std::endl;
return adjacentItems;
}
void MineSweeper::revolveNextQueueItem(){
if (this->queue.size() > 0){
std::vector item = this->queue[this->queue.size() - 1];
std::cout << "Queue: " << this->queue.size() << " - ";
this->queue.pop_back();
std::cout << this->queue.size() << std::endl;
this->revolveField(item[0], item[1]);
}
if (this->queue.size() > 0){
this->revolveNextQueueItem();
}
}
void MineSweeper::addNecessaryItemsToQueue(std::vector< std::vector > adjacentArray){
for (int i = 0; i < adjacentArray.size(); i++){
if (!this->isItemInQueue(adjacentArray[i]) && !isItemMarked(adjacentArray[i])){
this->queue.push_back(adjacentArray[i]);
}
}
}
bool MineSweeper::isItemMarked(std::vector item){
if (this->flagfield[item[0]][item[1]]){
return true;
}
return false;
}
bool MineSweeper::isItemInQueue(std::vector item){
for (int i = 0; i < this->queue.size(); i++){
if (item[0] == this->queue[i][0] && item[1] == this->queue[i][1]){
return true;
}
}
return false;
}
bool MineSweeper::markItem(int x, int y){
if (!this->revolvedfield[x][y]){
this->flagfield[x][y] = this->flagfield[x][y] == false;
}
return this->flagfield[x][y];
}
void MineSweeper::fillMineField(int clickedX, int clickedY){
std::srand( (unsigned)std::time( NULL ) );
std::cout << "Mine Field filled; " << clickedX << " and " << clickedY << " ignored." << std::endl;
int addedMines = 0;
while (addedMines < this->mineCount){
int rndX = std::rand() % this->minefield.size();
int rndY = std::rand() % this->minefield[0].size();
if (!this->minefield[rndX][rndY]){
if (clickedX != rndX || clickedY != rndY){
this->minefield[rndX][rndY] = true;
std::cout << "Field: " << rndX << " - " << rndY << std::endl;
addedMines++;
}
}
}
}
std::vector< std::vector > MineSweeper::getAdjacentFields(int x, int y){
std::vector< std::vector > adjacentFields;
for (int i = x - 1; i <= x + 1; i++){
for (int j = y - 1; j <= y + 1; j++){
//If the checked field is not out of bounds
if (i != -1 && j != -1 && i != this->minefield.size() && j != this->minefield[0].size()){
if (i != x || j != y){
std::vector field;
field.push_back(i);
field.push_back(j);
adjacentFields.push_back(field);
}
}
}
}
return adjacentFields;
}
bool MineSweeper::revolveAdjacentFields(int x, int y){
if (this->getAdjacentFlagCount(x, y) == this->getAdjacentMineCount(x, y)){
this->addNecessaryItemsToQueue(this->getAdjacentFields(x, y));
this->revolveNextQueueItem();
return true;
}
return false;
}
