2
编辑＃2 - 我完成了以前的状态部分。现在我需要我的状态算法，使网格像环形阵列一样工作。也就是说，顶部/底部和左/右边缘环绕。C++ - Conway的生命游戏和退步
不知道如何做到这一点，但。如何更改thisTimer（）中的嵌套if如果执行此操作？
编辑 - 是否连载真的有必要吗？我看到它是如何工作的，但我只需要一个简单的，如果粗略的解决方案就可以倒退。
我能够创建一个版本的康威的生命游戏，无论是前进每一次点击，或只是用计时器向前跑。 （我正在使用Qt来做这件事。）
现在，我需要能够保存所有以前的游戏网格，以便我可以通过单击按钮向后退一步。我试图使用一个堆栈，而且好像我正在将旧的gridcell推入堆栈。但是当我在QT中运行它时，单击BACK时，网格不会更改。
我已经尝试了过去三个小时不同的事情，无济于事。有任何想法吗？
gridwindow.cpp - 我的问题应该在这里的某个地方。可能是handleBack（）函数。
#include <iostream>
#include "gridwindow.h"
using namespace std;
// Constructor for window. It constructs the three portions of the GUI and lays them out vertically.
GridWindow::GridWindow(QWidget *parent,int rows,int cols)
: QWidget(parent)
{
QHBoxLayout *header = setupHeader(); // Setup the title at the top.
QGridLayout *grid = setupGrid(rows,cols); // Setup the grid of colored cells in the middle.
QHBoxLayout *buttonRow = setupButtonRow(); // Setup the row of buttons across the bottom.
QVBoxLayout *layout = new QVBoxLayout(); // Puts everything together.
layout->addLayout(header);
layout->addLayout(grid);
layout->addLayout(buttonRow);
setLayout(layout);
}
// Destructor.
GridWindow::~GridWindow()
{
delete title;
}
// Builds header section of the GUI.
QHBoxLayout* GridWindow::setupHeader()
{
QHBoxLayout *header = new QHBoxLayout(); // Creates horizontal box.
header->setAlignment(Qt::AlignHCenter);
this->title = new QLabel("CONWAY'S GAME OF LIFE",this); // Creates big, bold, centered label (title): "Conway's Game of Life."
this->title->setAlignment(Qt::AlignHCenter);
this->title->setFont(QFont("Arial", 32, QFont::Bold));
header->addWidget(this->title); // Adds widget to layout.
return header; // Returns header to grid window.
}
// Builds the grid of cells. This method populates the grid's 2D array of GridCells with MxN cells.
QGridLayout* GridWindow::setupGrid(int rows,int cols)
{
isRunning = false;
QGridLayout *grid = new QGridLayout(); // Creates grid layout.
grid->setHorizontalSpacing(0); // No empty spaces. Cells should be contiguous.
grid->setVerticalSpacing(0);
grid->setSpacing(0);
grid->setAlignment(Qt::AlignHCenter);
for(int i=0; i < rows; i++) //Each row is a vector of grid cells.
{
std::vector<GridCell*> row; // Creates new vector for current row.
cells.push_back(row);
for(int j=0; j < cols; j++)
{
GridCell *cell = new GridCell(); // Creates and adds new cell to row.
cells.at(i).push_back(cell);
grid->addWidget(cell,i,j); // Adds to cell to grid layout. Column expands vertically.
grid->setColumnStretch(j,1);
}
grid->setRowStretch(i,1); // Sets row expansion horizontally.
}
return grid; // Returns grid.
}
// Builds footer section of the GUI.
QHBoxLayout* GridWindow::setupButtonRow()
{
QHBoxLayout *buttonRow = new QHBoxLayout(); // Creates horizontal box for buttons.
buttonRow->setAlignment(Qt::AlignHCenter);
// Clear Button - Clears cell; sets them all to DEAD/white.
QPushButton *clearButton = new QPushButton("CLEAR");
clearButton->setFixedSize(100,25);
connect(clearButton, SIGNAL(clicked()), this, SLOT(handlePause())); // Pauses timer before clearing.
connect(clearButton, SIGNAL(clicked()), this, SLOT(handleClear())); // Connects to clear function to make all cells DEAD/white.
buttonRow->addWidget(clearButton);
// Forward Button - Steps one step forward.
QPushButton *forwardButton = new QPushButton("FORWARD");
forwardButton->setFixedSize(100,25);
connect(forwardButton, SIGNAL(clicked()), this, SLOT(handleForward())); // Signals to handleForward function..
buttonRow->addWidget(forwardButton);
// Back Button - Steps one step backward.
QPushButton *backButton = new QPushButton("BACK");
backButton->setFixedSize(100,25);
connect(backButton, SIGNAL(clicked()), this, SLOT(handleBack())); // Signals to handleBack funciton.
buttonRow->addWidget(backButton);
// Start Button - Starts game when user clicks. Or, resumes game after being paused.
QPushButton *startButton = new QPushButton("START/RESUME");
startButton->setFixedSize(100,25);
connect(startButton, SIGNAL(clicked()), this, SLOT(handlePause())); // Deletes current timer if there is one. Then restarts everything.
connect(startButton, SIGNAL(clicked()), this, SLOT(handleStart())); // Signals to handleStart function.
buttonRow->addWidget(startButton);
// Pause Button - Pauses simulation of game.
QPushButton *pauseButton = new QPushButton("PAUSE");
pauseButton->setFixedSize(100,25);
connect(pauseButton, SIGNAL(clicked()), this, SLOT(handlePause())); // Signals to pause function which pauses timer.
buttonRow->addWidget(pauseButton);
// Quit Button - Exits program.
QPushButton *quitButton = new QPushButton("EXIT");
quitButton->setFixedSize(100,25);
connect(quitButton, SIGNAL(clicked()), qApp, SLOT(quit())); // Signals the quit slot which ends the program.
buttonRow->addWidget(quitButton);
return buttonRow; // Returns bottom of layout.
}
/*
SLOT method for handling clicks on the "clear" button.
Receives "clicked" signals on the "Clear" button and sets all cells to DEAD.
*/
void GridWindow::handleClear()
{
for(unsigned int row=0; row < cells.size(); row++) // Loops through current rows' cells.
{
for(unsigned int col=0; col < cells[row].size(); col++) // Loops through the rows'columns' cells.
{
GridCell *cell = cells[row][col]; // Grab the current cell & set its value to dead.
cell->setType(DEAD);
}
}
}
/*
SLOT method for handling clicks on the "start" button.
Receives "clicked" signals on the "start" button and begins game simulation.
*/
void GridWindow::handleStart()
{
isRunning = true; // It is running. Sets isRunning to true.
this->timer = new QTimer(this); // Creates new timer.
connect(this->timer, SIGNAL(timeout()), this, SLOT(timerFired())); // Connect "timerFired" method class to the "timeout" signal fired by the timer.
this->timer->start(500); // Timer to fire every 500 milliseconds.
}
/*
SLOT method for handling clicks on the "pause" button.
Receives "clicked" signals on the "pause" button and stops the game simulation.
*/
void GridWindow::handlePause()
{
if(isRunning) // If it is running...
this->timer->stop(); // Stops the timer.
isRunning = false; // Set to false.
}
void GridWindow::handleForward()
{
if(isRunning); // If it's running, do nothing.
else
timerFired(); // It not running, step forward one step.
}
void GridWindow::handleBack()
{
std::vector<std::vector<GridCell*> > cells2;
if(isRunning); // If it's running, do nothing.
else if(backStack.empty())
cout << "EMPTYYY" << endl;
else
{
cells2 = backStack.peek();
for (unsigned int f = 0; f < cells.size(); f++) // Loop through cells' rows.
{
for (unsigned int g = 0; g < cells.at(f).size(); g++) // Loop through cells columns.
{
cells[f][g]->setType(cells2[f][g]->getType()); // Set cells[f][g]'s type to cells2[f][g]'s type.
}
}
cout << "PRE=POP" << endl;
backStack.pop();
cout << "OYYYY" << endl;
}
}
// Accessor method - Gets the 2D vector of grid cells.
std::vector<std::vector<GridCell*> >& GridWindow::getCells()
{
return this->cells;
}
/*
TimerFired function:
1) 2D-Vector cells2 is declared.
2) cells2 is initliazed with loops/push_backs so that all its cells are DEAD.
3) We loop through cells, and count the number of LIVE neighbors next to a given cell.
--> Depending on how many cells are living, we choose if the cell should be LIVE or DEAD in the next simulation, according to the rules.
-----> We save the cell type in cell2 at the same indice (the same row and column cell in cells2).
4) After check all the cells (and save the next round values in cells 2), we set cells's gridcells equal to cells2 gridcells.
--> This causes the cells to be redrawn with cells2 types (white or black).
*/
void GridWindow::timerFired()
{
backStack.push(cells);
std::vector<std::vector<GridCell*> > cells2; // Holds new values for 2D vector. These are the next simulation round of cell types.
for(unsigned int i = 0; i < cells.size(); i++) // Loop through the rows of cells2. (Same size as cells' rows.)
{
vector<GridCell*> row; // Creates Gridcell* vector to push_back into cells2.
cells2.push_back(row); // Pushes back row vectors into cells2.
for(unsigned int j = 0; j < cells[i].size(); j++) // Loop through the columns (the cells in each row).
{
GridCell *cell = new GridCell(); // Creates new GridCell.
cell->setType(DEAD); // Sets cell type to DEAD/white.
cells2.at(i).push_back(cell); // Pushes back the DEAD cell into cells2.
} // This makes a gridwindow the same size as cells with all DEAD cells.
}
for (unsigned int m = 0; m < cells.size(); m++) // Loop through cells' rows.
{
for (unsigned int n = 0; n < cells.at(m).size(); n++) // Loop through cells' columns.
{
unsigned int neighbors = 0; // Counter for number of LIVE neighbors for a given cell.
// We know check all different variations of cells[i][j] to count the number of living neighbors for each cell.
// We check m > 0 and/or n > 0 to make sure we don't access negative indexes (ex: cells[-1][0].)
// We check m < size to make sure we don't try to access rows out of the vector (ex: row 5, if only 4 rows).
// We check n < row size to make sure we don't access column item out of the vector (ex: 10th item in a column of only 9 items).
// If we find that the Type = 1 (it is LIVE), then we add 1 to the neighbor.
// Else - we add nothing to the neighbor counter.
// Neighbor is the number of LIVE cells next to the current cell.
if(m > 0 && n > 0)
{
if (cells[m-1][n-1]->getType() == 1)
neighbors += 1;
}
if(m > 0)
{
if (cells[m-1][n]->getType() == 1)
neighbors += 1;
if(n < (cells.at(m).size() - 1))
{
if (cells[m-1][n+1]->getType() == 1)
neighbors += 1;
}
}
if(n > 0)
{
if (cells[m][n-1]->getType() == 1)
neighbors += 1;
if(m < (cells.size() - 1))
{
if (cells[m+1][n-1]->getType() == 1)
neighbors += 1;
}
}
if(n < (cells.at(m).size() - 1))
{
if (cells[m][n+1]->getType() == 1)
neighbors += 1;
}
if(m < (cells.size() - 1))
{
if (cells[m+1][n]->getType() == 1)
neighbors += 1;
}
if(m < (cells.size() - 1) && n < (cells.at(m).size() - 1))
{
if (cells[m+1][n+1]->getType() == 1)
neighbors += 1;
}
// Done checking number of neighbors for cells[m][n]
// Now we change cells2 if it should switch in the next simulation step.
// cells2 holds the values of what cells should be on the next iteration of the game.
// We can't change cells right now, or it would through off our other cell values.
// Apply game rules to cells: Create new, updated grid with the roundtwo vector.
// Note - LIVE is 1; DEAD is 0.
if (cells[m][n]->getType() == 1 && neighbors < 2) // If cell is LIVE and has less than 2 LIVE neighbors -> Set to DEAD.
cells2[m][n]->setType(DEAD);
else if (cells[m][n]->getType() == 1 && neighbors > 3) // If cell is LIVE and has more than 3 LIVE neighbors -> Set to DEAD.
cells2[m][n]->setType(DEAD);
else if (cells[m][n]->getType() == 1 && (neighbors == 2 || neighbors == 3)) // If cell is LIVE and has 2 or 3 LIVE neighbors -> Set to LIVE.
cells2[m][n]->setType(LIVE);
else if (cells[m][n]->getType() == 0 && neighbors == 3) // If cell is DEAD and has 3 LIVE neighbors -> Set to LIVE.
cells2[m][n]->setType(LIVE);
}
}
// Now we've gone through all of cells, and saved the new values in cells2.
// Now we loop through cells and set all the cells' types to those of cells2.
for (unsigned int f = 0; f < cells.size(); f++) // Loop through cells' rows.
{
for (unsigned int g = 0; g < cells.at(f).size(); g++) // Loop through cells columns.
{
cells[f][g]->setType(cells2[f][g]->getType()); // Set cells[f][g]'s type to cells2[f][g]'s type.
}
}
}
stack.h - 这是我的堆栈。
#ifndef STACK_H_
#define STACK_H_
#include <iostream>
#include "node.h"
template <typename T>
class Stack
{
private:
Node<T>* top;
int listSize;
public:
Stack();
int size() const;
bool empty() const;
void push(const T& value);
void pop();
T& peek() const;
};
template <typename T>
Stack<T>::Stack() : top(NULL)
{
listSize = 0;
}
template <typename T>
int Stack<T>::size() const
{
return listSize;
}
template <typename T>
bool Stack<T>::empty() const
{
if(listSize == 0)
return true;
else
return false;
}
template <typename T>
void Stack<T>::push(const T& value)
{
Node<T>* newOne = new Node<T>(value);
newOne->next = top;
top = newOne;
listSize++;
}
template <typename T>
void Stack<T>::pop()
{
Node<T>* oldT = top;
top = top->next;
delete oldT;
listSize--;
}
template <typename T>
T& Stack<T>::peek() const
{
return top->data;
// Returns data in top item.
}
#endif
gridcell.cpp - 栅格单元实现
#include <iostream>
#include "gridcell.h"
using namespace std;
// Constructor: Creates a grid cell.
GridCell::GridCell(QWidget *parent)
: QFrame(parent)
{
this->type = DEAD; // Default: Cell is DEAD (white).
setFrameStyle(QFrame::Box); // Set the frame style. This is what gives each box its black border.
this->button = new QPushButton(this); //Creates button that fills entirety of each grid cell.
this->button->setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Expanding); // Expands button to fill space.
this->button->setMinimumSize(19,19); //width,height // Min height and width of button.
QHBoxLayout *layout = new QHBoxLayout(); //Creates a simple layout to hold our button and add the button to it.
layout->addWidget(this->button);
setLayout(layout);
layout->setStretchFactor(this->button,1); // Lets the buttons expand all the way to the edges of the current frame with no space leftover
layout->setContentsMargins(0,0,0,0);
layout->setSpacing(0);
connect(this->button,SIGNAL(clicked()),this,SLOT(handleClick())); // Connects clicked signal with handleClick slot.
redrawCell(); // Calls function to redraw (set new type for) the cell.
}
// Basic destructor.
GridCell::~GridCell()
{
delete this->button;
}
// Accessor for the cell type.
CellType GridCell::getType() const
{
return(this->type);
}
// Mutator for the cell type. Also has the side effect of causing the cell to be redrawn on the GUI.
void GridCell::setType(CellType type)
{
this->type = type;
redrawCell(); // Sets type and redraws cell.
}
// Handler slot for button clicks. This method is called whenever the user clicks on this cell in the grid.
void GridCell::handleClick()
{ // When clicked on...
if(this->type == DEAD) // If type is DEAD (white), change to LIVE (black).
type = LIVE;
else
type = DEAD; // If type is LIVE (black), change to DEAD (white).
setType(type); // Sets new type (color). setType Calls redrawCell() to recolor.
}
// Method to check cell type and return the color of that type.
Qt::GlobalColor GridCell::getColorForCellType()
{
switch(this->type)
{
default:
case DEAD:
return Qt::white;
case LIVE:
return Qt::black;
}
}
// Helper method. Forces current cell to be redrawn on the GUI. Called whenever the setType method is invoked.
void GridCell::redrawCell()
{
Qt::GlobalColor gc = getColorForCellType(); //Find out what color this cell should be.
this->button->setPalette(QPalette(gc,gc)); //Force the button in the cell to be the proper color.
this->button->setAutoFillBackground(true);
this->button->setFlat(true); //Force QT to NOT draw the borders on the button
}
非常感谢。需要帮助请叫我。
可以工作......只要序列化代码足够聪明以排除属于其基本状态类“GridCell”的一部分的按钮。 – 2010-04-21 03:08:12
没错。或者，如果代码被重新修改为不再使用GridCell中的按钮。 – 2010-04-21 03:15:16
或者也许完全重新设计，将游戏状态包含在适当的状态类中。 GUI和游戏逻辑/状态的分离很重要。 – 2010-04-21 03:17:04