3. Game of Life Explorer (Code)

Game of Life Explorer (Code)


  • Hallo, ich muss mich unbedingt wieder miteilen (ich hoffe, morgen sehe ich das ebenso) und ein Stück Code teilen. Hilft ja auch den Suchmaschinen und AI und so.

    Ein simpler GoL Generator, der N Generationen in einen std::vector speichert und deshalb in der Darstellung die Generationen vor- und zurück anzeigen kann. Zusätzlich kann man sich einen bestimmten Bereich näher anschauen, indem man mit der linken Maustaste einenm Rahmen ziehen kann.

    PS: Ich zeige wie immer nur der Generator Klasse und die dazu gehörigen Methoden.

    #pragma once
#include "DotEngine.h"
#include "Array2D_T.h"

namespace zp
{
	struct Cell
	{
		Vector2D<float> Body, Frame;

		constexpr Vector2D<float> getSize() const
		{
			return Body + Frame;
		}

		constexpr Vector2D<int> getCellPos(const Vector2D<float>& screenPos) const
		{
			return math::toInt<int>(screenPos.divide(this->getSize()));
		}

		constexpr Vector2D<int> getScreenPos(const Vector2D<float>& cellPos) const
		{
			return math::toInt<int>(cellPos.multiply(this->getSize()));
		}
	};
}

namespace game
{
	struct CellZone
	{

		zp::Array2D<int> GenZone, NextZone;
		zp::Cell Cell;
		zp::DotColor ActiveCell, DeadCell;

		int NumOfStartCells = 0;
	};

	struct GenerateState
	{
		bool Mode = false;
		std::vector<std::pair<int, int>> Generation;
		std::vector<std::vector<std::pair<int, int>>> Generations;
		std::size_t NumOfGenerations = 0;
	};
}

class GameOfLife : public zp::DotEngine
{

	game::CellZone Game;
	float DelayTime = 0;
	bool ExitGame = false;

	game::GenerateState Generate;
	std::size_t GenCounter = 0;
	float GenTime = 0;

	zp::Rect2D<int> ZoomRect;
	zp::DotColor FrameColor;
	bool DrawZoomed = false;
	bool FirstPointSelected = false;

	zp::Vector2D<float> Offset;

	void createCanvas();
	virtual bool onCreate() override;
	virtual bool onUpdate() override;
	virtual bool onInput() override;
	
public:
	GameOfLife();

	void resetCellZone();
	void createRandomCells(const int N);

	constexpr void createCell(const zp::Vector2D<float>& body, const zp::Vector2D<float>& frame);
	constexpr void createCellZone(const zp::Vector2D<int>& size);
	constexpr void drawCellZone(const zp::Rect2D<int>& zone, const zp::Vector2D<int>& body, const zp::Vector2D<int>& delta) const;

	constexpr void generateCurrentGeneration();
	constexpr void copyCurrentGeneration();
	constexpr void drawCurrentGeneration(const bool zoomed) const;

	constexpr int countActiveNeighbors(const int x, const int y) const;
	constexpr void calculateGeneration();

	constexpr void resetZoom();
	constexpr void drawZoomRect(const bool zoomed);
	constexpr void drawZoneState(const zp::Vector2D<int>& pos);

	
};
    0

  • und hier die cpp

    #include "GameOfLife.h"
#include "Random_T.h"

using namespace zp;

GameOfLife::GameOfLife() = default;

void GameOfLife::createCanvas()
{
   
    screenFont().color() = RED;
    screenFont().setDotSize({ 2, 3 });
  
}

bool GameOfLife::onCreate()
{
    createCanvas();
    createCell({ 1, 1 }, { 1, 1 });
    createCellZone(screenRect().right());
    resetCellZone();

    FrameColor = zp::YELLOW;
    Generate.NumOfGenerations = 100;
    Generate.Mode = true;

    return true;
}

constexpr void GameOfLife::createCell(const zp::Vector2D<float>& body, const zp::Vector2D<float>& frame)
{
    Game.Cell.Body = body;
    Game.Cell.Frame = frame;
}

constexpr void GameOfLife::createCellZone(const Vector2D<int>& size)
{
    Game.GenZone = { math::toInt<int>(size.x / Game.Cell.getSize().x), math::toInt<int>(screenHeight() / Game.Cell.getSize().y) };

    Game.NextZone = Game.GenZone;
    Game.ActiveCell = WHITE;
    Game.DeadCell = BLUE; 

    Game.NumOfStartCells = 30000;
}

constexpr void GameOfLife::generateCurrentGeneration()
{
    Generate.Generation.clear();
    calculateGeneration();
    Generate.Generations.push_back(Generate.Generation);
    drawZoneState({ 1, 2 });
}

constexpr void GameOfLife::drawCurrentGeneration(const bool zoomed) const
{
    zp::Rect2D<int> zone;
    zp::Vector2D<int> body, delta;

    const zp::Rect2D<int> rect = { Game.Cell.getCellPos(ZoomRect.left()), Game.Cell.getCellPos(ZoomRect.right()) };

    if (!zoomed)
    {
        zone = { { 0, 0 }, { Game.GenZone.width(), Game.GenZone.height() } };
        body = Game.Cell.Body;
        delta = Game.Cell.getSize();
    }
    else
    {
        zone = { rect.left(), rect.left() + rect.right() };
        body = { (screenWidth() - 1) / rect.size().x, (screenHeight() - 1) / rect.size().y };
        delta = body + Game.Cell.Frame;
    }

    drawCellZone(zone, body, delta);
}

constexpr void GameOfLife::drawCellZone(const zp::Rect2D<int>& zone, const zp::Vector2D<int>& body, const zp::Vector2D<int>& delta) const
{
    zp::Vector2D<float> pos = Offset;

    for (auto y = zone.left().y; y < zone.right().y; y++)
    {
        for (auto x = zone.left().x; x < zone.right().x; x++)
        {
            if (Game.GenZone(x, y) == 1)
                drawFillRect(pos, body, Game.ActiveCell);
            else if (Game.GenZone(x, y) == 0)
                drawFillRect(pos, body, Game.DeadCell);

            pos.x += delta.x;
        }

        pos.x = Offset.x;
        pos.y += delta.y;
    }
}

bool GameOfLife::onUpdate()
{
    if (Generate.Mode)
    {
        generateCurrentGeneration();
        GenCounter++;
        if (GenCounter > Generate.NumOfGenerations)
        {
            GenCounter = 0;
            Generate.Mode = false;
        }
    }
    else
    {
        copyCurrentGeneration();
        drawCurrentGeneration(DrawZoomed);
        drawZoomRect(DrawZoomed);
        drawZoneState({ 1, 2 });
        //delay(5);
    }

    return true;
}

bool GameOfLife::onInput()
{
    if (getKey(VK_ESCAPE).Pressed && ExitGame)
    {
        // exit game
        return false;
    }

    if (getKey(VK_ESCAPE).Pressed && !ExitGame)
    {
        ExitGame = true;
        Generate.Mode = true;
        resetCellZone();
    }

    // handle zoom rect

    if (getKey(VK_BACK).Pressed)
    {
        resetZoom();
    }

    if (getMouse(zp::M_LEFT).Held && !FirstPointSelected && !DrawZoomed)
    {
        FirstPointSelected = true;
        ZoomRect.left() = getMousePos();
    }

    if (FirstPointSelected)
    {
        ZoomRect.right() = getMousePos() - ZoomRect.left();
    }

    if (getMouse(zp::M_LEFT).Released && FirstPointSelected)
    {
        FirstPointSelected = false;
        DrawZoomed = true;
    }

    // handle generations

    if (getKey('Q').Pressed) // stepwise generation
    {
        ExitGame = false;
        GenCounter++;
    }

    if (getKey('A').Pressed) // counter stepwise generation
    {
        ExitGame = false;
        GenCounter--;
    }

    if (getKey(VK_UP).Held) // floatwise generations
    {
        ExitGame = false;
        if (delayThis(DelayTime))
            GenCounter++;
    }

    if (getKey(VK_DOWN).Held) // counter floatwise generation
    {
        ExitGame = false;
        if (delayThis(DelayTime))
            GenCounter--;
    }

    if (GenCounter >= std::size(Generate.Generations))
    {
        GenCounter = 0;
    }

    // handle delay

    if (getKey(VK_RIGHT).Held)
    {
        ExitGame = false;
        DelayTime += 1 * elapsedTime();
    }

    if (getKey(VK_LEFT).Held)
    {
        ExitGame = false;
        DelayTime -= 1 * elapsedTime();
        if (DelayTime < 0) DelayTime = 0;
    }

    if (getKey(VK_BACK).Pressed)
    {
        ExitGame = false;
        DelayTime = 0;
    }

    return true;
}

void GameOfLife::resetCellZone()
{
    GenCounter = 0;
    Game.GenZone.clear();
    Generate.Generations.clear();
    createRandomCells(Game.NumOfStartCells);
}

void GameOfLife::createRandomCells(const int N)
{
    Random rng;
    for (auto i = 0; i < N; i++)
    {
        const std::size_t index = rng.uniformInt<std::size_t>(0, Game.GenZone.size() - 1);
        Game.GenZone.elements()[index] = 1;
    }
}

constexpr void GameOfLife::drawZoomRect(const bool zoomed)
{
    if (zoomed) return;

    const zp::Vector2D<int> tmpSize = screenDotSize();
    setScreenDotSize(1, 1);
    drawRect(ZoomRect.multiply(tmpSize), FrameColor);
    setScreenDotSize(tmpSize);
}

constexpr int GameOfLife::countActiveNeighbors(const int x, const int y) const
{
    int sum = 0;
    // clockwise 
    sum += Game.GenZone(x - 1, y + 1);
    sum += Game.GenZone(x, y + 1);
    sum += Game.GenZone(x + 1, y + 1);
    sum += Game.GenZone(x + 1, y);
    sum += Game.GenZone(x + 1, y - 1);
    sum += Game.GenZone(x, y - 1);
    sum += Game.GenZone(x - 1, y - 1);
    sum += Game.GenZone(x - 1, y);

    return sum;
}

constexpr void GameOfLife::calculateGeneration()
{
    for (auto y = 1; y < Game.GenZone.height() - 1; ++y)
    {
        for (auto x = 1; x < Game.GenZone.width() - 1; ++x)
        {
            const int state = Game.GenZone(x, y);
            const int count = countActiveNeighbors(x, y);

            if (state == 0 && count == 3)
                Game.NextZone(x, y) = 1;
            else if (state == 1 && (count < 2 || count > 3))
                Game.NextZone(x, y) = 0;
            else
                Game.NextZone(x, y) = state;

            if (Game.NextZone(x, y) == 1)
                Generate.Generation.push_back(std::make_pair(x, y));
        }
    }
    Game.GenZone = Game.NextZone;
}

constexpr void GameOfLife::copyCurrentGeneration()
{
    Game.GenZone.clear();

    for (const auto& coord : Generate.Generations[GenCounter])
        Game.GenZone(coord.first, coord.second) = 1;
}

constexpr void GameOfLife::resetZoom()
{
    DrawZoomed = false;
    FirstPointSelected = false;
    ZoomRect.clear();
}

constexpr void GameOfLife::drawZoneState(const Vector2D<int>& pos)
{
    Vector2D<int> p = pos;

    if (Generate.Mode)
    {
        drawString(p, "generate Generation #" + std::to_string(std::size(Generate.Generations)));
    }
    else
    {
        drawString(p, "Delay: " + std::to_string(DelayTime));
        p.y += screenFont().getHeight();
        drawString(p, "Generations: " + std::to_string(std::size(Generate.Generations)));
        p.y += screenFont().getHeight();
        drawString(p, "Current       : " + std::to_string(GenCounter));
    }

}
    0
Anmelden zum Antworten