Life001.cpp

Go to the documentation of this file.

#include "macros.h" // needs to be declared as first entry in .cpp or .h file!
#include <string>
#include <iostream>
using namespace std;
#include "AbstractExercise.h"
#include <ctime>
#include <cstdlib>
#include "Life001.h"
// ...

namespace {
    const int SIZE_X = 30;
    const int SIZE_Y = 20;
    const char ALIVE = '*';
    const char DEAD  = ' ';
    typedef char lifeMatrix_t[SIZE_X][SIZE_Y];
}

class ModN {
public:

    ModN(int mod, int value = 0) : fMod(mod), fValue(value), fCompleted(false) {}

    inline ModN& operator++() {
        fValue = (fValue + 1) % fMod;
        fCompleted = (fValue == 0);
        return *this;
        string s;
    }

    inline ModN& operator--() {
        fValue = (fValue + fMod - 1) % fMod;
        fCompleted = (fValue == fMod - 1);
        return *this;
    }

    inline bool operator==(const ModN& operand) const { return (fMod == operand.fMod) && (fValue == operand.fValue); }

    inline operator int() const { return fValue; }

    inline bool completed() { return fCompleted; }
private:
    int fMod;
    int fValue;
    bool fCompleted;
};

class LifeMatrix {
public:
    inline void display() const {
        for(int i = 0; i<SIZE_Y; i++) {
            cout << "|";
            for(int j = 0; j<SIZE_X; j++){
                cout << fMatrix[j][i];
            }
            cout << "|";
            cout << endl;
        }   
        cout << endl;
    }

    inline int countNeighbours (const ModN& x, const ModN& y) const {
        int neighbours = 0;

        ModN mX = x;
        --mX;
        for(int i = 0; i<3; i++){ // can't use mX as counter because of mod n !
            ModN mY = y;
            --mY;
            for(int j = 0; j<3; j++){
                neighbours += !((mX == x)&&(mY == y)) && isAlive(mX, mY) ? 1 : 0;
                ++mY;
            }
            ++mX;
        }
        return neighbours;
    }

    inline void fill(){
        for(int i = 0; i<SIZE_X; i++){
            for(int j = 0; j<SIZE_Y; j++){
                fMatrix[i][j] = fillGlider(i, j);
            }
        }   
    }

    inline void kill(const ModN& i, const ModN& j){
        fMatrix[i][j] = DEAD;
    }

    inline void enliven(const ModN& x, const ModN& y){
        fMatrix[x][y] = ALIVE;
    }

    inline bool isAlive(const ModN& x, const ModN& y) const {
        return fMatrix[x][y] == ALIVE;
    }

    static inline void initRand() {
        long sek;
        time(&sek);
        srand((unsigned)sek);
    }

private:

    inline char fillRand(int x, int y) {
        return rand()%2 ? ALIVE : DEAD;
    }

    inline char fillSquare58(int x, int y){
        return (x>5)&&(x<8)&&(y>5)&&(y<8) ? ALIVE : DEAD;
    }

    inline char fillLine(int x, int y){
        return (x==8 || x== 12)&&(y>5)&&(y<9)  ? ALIVE : DEAD;
    }

    inline char fillGlider(int x, int y){
        return 
            (x==0 && y== 0)
            ||(x==0 && y== 1)
            ||(x==0 && y== 2)
            ||(x==1 && y== 0)
            ||(x==2 && y== 1)
            ? ALIVE : DEAD;
    }

    lifeMatrix_t fMatrix;
};

Life001::Life001() : fNow(new LifeMatrix()), fFuture(new LifeMatrix()) {}

void Life001::run(){
    LifeMatrix::initRand();
    fill();
    while(true){
        display();
        calculate();
        wait();
    }
}

Life001::~Life001(){
    delete fNow;
    delete fFuture;
}

inline void Life001::fill(){
    fNow->fill();
}

inline void Life001::display(){
    cls();
    fNow->display();
}

inline void Life001::calculate(){
    for(ModN i(SIZE_X, 0); !i.completed(); ++i){
        for(ModN j(SIZE_Y, 0); !j.completed(); ++j){
            int n = fNow->countNeighbours(i, j);
            if((n < 2)||(n > 3)){
                fFuture->kill(i, j);
            } else if ((n == 2) && (fNow->isAlive(i, j))) {
                fFuture->enliven(i, j);
            } else if (n == 3){
                fFuture->enliven(i, j);
            } else {
                fFuture->kill(i, j);
            }
        }
    }
    swap();
}

inline void Life001::swap(){
    LifeMatrix* tmp = fNow;
    fNow = fFuture;
    fFuture = tmp;
}

void Life001::wait() {
    for(long i= 0;i<19999999L;i++){}
}

void Life001::cls(){
    system("cls");
}

---