B
Falls Du Windows benutzt, hast Du hier etwas zum spielen:
#include <windows.h>
#include <array>
using namespace std;
// Spielfeld
const int zeilen = 5;
const int spalten = 7;
using spielfeldTyp = array<int, zeilen * spalten>;
//Regeln
const int minAnzFuerNeu = 2;
const int minAnzFuerErhalt = 2;
const int maxAnzFuerErhalt = 3;
//Ausgabeoffset
const int spielfeldOffX = 3;
const int spielfeldOffY = 15;
const int nextOffX = 25;
const int nextOffY = spielfeldOffY;
// n paar Konsolefunktionen
void SetCursorVisible(BOOL v)
{
CONSOLE_CURSOR_INFO ci;
GetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &ci);
ci.bVisible = v;
SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &ci);
}
void SetWindowExt(int x, int y, int yMulti = 1)
{
SMALL_RECT sr_window = {0, 0, static_cast<SHORT>(x) - 1, static_cast<SHORT>(y) - 1};
COORD extension;
CONSOLE_SCREEN_BUFFER_INFO csbi;
GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi);
extension.X = max(x, csbi.dwMaximumWindowSize.X);
extension.Y = max(y, csbi.dwMaximumWindowSize.Y);
SetConsoleScreenBufferSize(GetStdHandle(STD_OUTPUT_HANDLE), extension);
SetConsoleWindowInfo(GetStdHandle(STD_OUTPUT_HANDLE), TRUE, &sr_window);
extension.X = x;
extension.Y = y * yMulti;
SetConsoleScreenBufferSize(GetStdHandle(STD_OUTPUT_HANDLE), extension);
}
void ClearScreen(WORD attribute = 7)
{
CONSOLE_SCREEN_BUFFER_INFO csbi;
COORD target = {0, 0};
DWORD written;
GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi);
FillConsoleOutputCharacter(GetStdHandle(STD_OUTPUT_HANDLE), ' ',
csbi.dwSize.X * csbi.dwSize.Y,
target, &written);
FillConsoleOutputAttribute(GetStdHandle(STD_OUTPUT_HANDLE), attribute,
csbi.dwSize.X * csbi.dwSize.Y,
target, &written);
}
void DruckSimpleText(int x, int y, char const *text)
{
COORD target = {static_cast<SHORT>(x), static_cast<SHORT>(y)};
DWORD written;
WriteConsoleOutputCharacter(GetStdHandle(STD_OUTPUT_HANDLE), text,
strlen(text),
target, &written);
}
void DruckSimpleChar(int x, int y, char c)
{
char text[2] = {c, 0};
DruckSimpleText(x, y, text);
}
struct taste
{
taste(int c, int k) : AsciiChar(c), VirtualKey(k){};
int AsciiChar;
int VirtualKey;
};
taste getInput()
{
INPUT_RECORD ir;
DWORD dummy;
do
{
ReadConsoleInput(GetStdHandle(STD_INPUT_HANDLE), &ir, 1, &dummy);
}while(ir.EventType != KEY_EVENT || !ir.Event.KeyEvent.bKeyDown);
return taste(ir.Event.KeyEvent.uChar.AsciiChar, ir.Event.KeyEvent.wVirtualKeyCode);
}
// Funktionen zum Spiel
void BerechneNextGeneration(const spielfeldTyp &spielfeld, spielfeldTyp &next)
{
next = spielfeld;
for(int z = 0; z < zeilen; ++z)
{
for(int s = 0; s < spalten; ++s)
{
int nachbarn = 0;
for(int pz = z - 1; pz < z + 2; ++pz)
{
for(int ps = s - 1; ps < s + 2; ++ps)
{
if(pz == z && ps == s //zu prüfendes Feld ausschließen
|| pz < 0 || ps < 0 //linker oder oberer Rand
|| pz > zeilen - 1 || ps > spalten - 1 //recher oder unterer Rand
)
continue;
if(spielfeld[pz * spalten + ps] == 1)
nachbarn++;
}
}
if(spielfeld[z * spalten + s] == 0 && nachbarn >= minAnzFuerNeu)
next[z * spalten + s] = 1;
if(spielfeld[z * spalten + s] == 1 && (nachbarn < minAnzFuerErhalt || nachbarn > maxAnzFuerErhalt))
next[z * spalten + s] = 0;
}
}
}
void WarteAufTaste()
{
getInput();
}
void SpielfeldAusgeben(const spielfeldTyp &spielfeld, int xOffset = 0, int yOffset = 0)
{
for(int z = 0; z < zeilen; ++z)
{
for(int s = 0; s < spalten; ++s)
{
DruckSimpleChar(2 * s + xOffset, 2 * z + yOffset, spielfeld[spalten * z + s] + '0');
}
}
}
int main()
{
// Spielfeld initialisieren
spielfeldTyp spielfeld;
spielfeldTyp nextGeneration;
for(int i = 0; i < spalten * zeilen; ++i)
spielfeld[i] = 0;
SetWindowExt(60, 40);
//Testwerte ins Spielfeld schreiben
spielfeld[2 * spalten + 3] = 1;
spielfeld[2 * spalten + 5] = 1;
spielfeld[3 * spalten + 2] = 1;
spielfeld[4 * spalten + 3] = 1;
ClearScreen();
SetCursorVisible(false);
DruckSimpleText(spielfeldOffX, spielfeldOffY - 3, "Spielfeld");
DruckSimpleText(nextOffX, nextOffY - 3, "naechste Gen.");
BerechneNextGeneration(spielfeld, nextGeneration);
SpielfeldAusgeben(spielfeld, spielfeldOffX, spielfeldOffY);
SpielfeldAusgeben(nextGeneration, nextOffX, nextOffY);
WarteAufTaste();
for(int i = 0; i < 10; ++i)
{
spielfeld.swap(nextGeneration);
BerechneNextGeneration(spielfeld, nextGeneration);
SpielfeldAusgeben(spielfeld, spielfeldOffX, spielfeldOffY);
SpielfeldAusgeben(nextGeneration, nextOffX, nextOffY);
WarteAufTaste();
}
SetCursorVisible(true);
}
