135 lines
3.1 KiB
C++
135 lines
3.1 KiB
C++
/* ScummVM - Graphic Adventure Engine
|
|
*
|
|
* ScummVM is the legal property of its developers, whose names
|
|
* are too numerous to list here. Please refer to the COPYRIGHT
|
|
* file distributed with this source distribution.
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
*/
|
|
|
|
#include "bagel/hodjnpodj/hnplibs/stdafx.h"
|
|
#include "bagel/hodjnpodj/life/grid.h"
|
|
|
|
namespace Bagel {
|
|
namespace HodjNPodj {
|
|
namespace Life {
|
|
|
|
colony::colony(int r, int c) {
|
|
int i, j; // indicies
|
|
|
|
rows = r;
|
|
cols = c;
|
|
m_nColony_count = 0;
|
|
|
|
/*
|
|
* Set up initial city. All cells on the
|
|
* grid are set to NO_LIFE
|
|
*/
|
|
|
|
for (i = 0; i < rows; i++)
|
|
for (j = 0; j < cols; j++)
|
|
grid[i][j] = NO_LIFE;
|
|
}
|
|
|
|
colony::~colony() {
|
|
}
|
|
|
|
colony &colony::operator=(const colony& c) {
|
|
int i, j;
|
|
|
|
for (i = 0; i < this->rows; i++)
|
|
for (j = 0; j < this->cols; j++)
|
|
this->grid[i][j] = c.grid[i][j];
|
|
this->m_nColony_count = c.m_nColony_count;
|
|
|
|
return *this;
|
|
}
|
|
|
|
bool colony::operator==(const colony& c) {
|
|
int i, j;
|
|
|
|
if (this->m_nColony_count != c.m_nColony_count)
|
|
return 0;
|
|
|
|
for (i = 0; i < this->rows; i++)
|
|
for (j = 0; j < this->cols; j++)
|
|
if (this->grid[i][j] != c.grid[i][j])
|
|
return 0;
|
|
return 1;
|
|
}
|
|
|
|
bool colony::operator!=(const colony& c) {
|
|
return !(*this == c);
|
|
}
|
|
|
|
void colony::evolve(const colony &clny) {
|
|
int r, c; // for local cell check
|
|
int neighbors; // # of neighbors in local area
|
|
int pos_r, pos_c; // will step across every part of board
|
|
|
|
/*
|
|
* apply evolve conditions centered at pos_r, pos_c
|
|
*/
|
|
|
|
for (pos_r = 0; pos_r < rows; pos_r++)
|
|
for (pos_c = 0; pos_c < cols; pos_c++) {
|
|
neighbors = 0;
|
|
for (r = pos_r - 1; r <= pos_r + 1; r++) {
|
|
/*
|
|
* make sure it's not out of bounds of grid
|
|
*/
|
|
if (r < 0)
|
|
continue;
|
|
if (r >= rows)
|
|
break;
|
|
|
|
for (c = pos_c - 1; c <= pos_c + 1; c++) {
|
|
if (c < 0)
|
|
continue;
|
|
if (c >= cols)
|
|
break;
|
|
/* don't count center as neighbor */
|
|
if ((r == pos_r) && (c == pos_c))
|
|
continue;
|
|
if (clny.grid[r][c] == LIFE)
|
|
neighbors++;
|
|
}
|
|
}
|
|
|
|
/* game of life conditions! */
|
|
if ((neighbors < 2 || neighbors > 3) &&
|
|
clny.grid[pos_r][pos_c] == LIFE)
|
|
flip(pos_r, pos_c);
|
|
else if (neighbors == 3 &&
|
|
clny.grid[pos_r][pos_c] == NO_LIFE)
|
|
flip(pos_r, pos_c);
|
|
}
|
|
}
|
|
|
|
|
|
void colony::flip(int r, int c) {
|
|
if (grid[r][c] == LIFE) {
|
|
grid[r][c] = NO_LIFE;
|
|
m_nColony_count--;
|
|
} else {
|
|
grid[r][c] = LIFE;
|
|
m_nColony_count++;
|
|
}
|
|
}
|
|
|
|
} // namespace Life
|
|
} // namespace HodjNPodj
|
|
} // namespace Bagel
|