C++ - XXO

#ifndef _DEF_ACTOR_H_
#define _DEF_ACTOR_H_
#include "gamegrid.h"


class actor{
protected:
    int enemy;
    int who(int field);
public:
    int own;
    virtual MOVE nextMOVE(const gamegrid grid, const int messagecode);
    actor(int own, int enemy);
};
#endif

#ifndef _DEF_AI8SECTIONS_H_
#define _DEF_AI8SECTIONS_H_
#include "actor.h"
#include "gamegrid.h"


class AI8section : public actor{
    typedef MOVE(AI8section::*AI8func)(const gamegrid);
    typedef int sumgrid[3][3];
    /*
     *    from wikipedia:
     *    Win: If the player has two in a row, he or she can place a third to get three in a row.
     *    Block: If the [opponent] has two in a row, the player must play the third himself or herself to block them.
     *    Fork: Creation of an opportunity where the player has two threats to win (two non-blocked lines of 2).
     *    Blocking an opponent's fork:
     *        Option 1: The player should create two in a row to force the opponent into defending, as long as it doesn't result in 
     *        them creating a fork. For example, if "X" has a corner, "O" has the center, and "X" has the opposite corner as well, 
     *        "O" must not play a corner in order to win. (Playing a corner in this scenario creates a fork for "X" to win.)
     *
     *        Option 2: If there is a configuration where the opponent can fork, the player should block that fork.
     *    Center: A player marks the center. (If it is the first move of the game, playing on a corner gives "O" more opportunities 
     *    to make a mistake and may therefore be the better choice; however, it makes no difference between perfect players.)
     *    Opposite corner: If the opponent is in the corner, the player plays the opposite corner.
     *    Empty corner: The player plays in a corner square.
     *    Empty side: The player plays in a middle square on any of the 4 sides.
     */
    public:
        AI8section(int own, int enemy);
private:
    MOVE nextMOVE(const gamegrid grid, const int messagecode);
    MOVE Win(const gamegrid grid);
    MOVE Block(const gamegrid grid);
    MOVE Fork(const gamegrid grid);
    MOVE BlockFork(const gamegrid grid);
    MOVE Center(const gamegrid grid);
    MOVE OppCo(const gamegrid grid);
    MOVE EmpCo(const gamegrid grid);
    MOVE EmpSide(const gamegrid grid);
    AI8func steps[8];
    void calcsumgrid(const gamegrid grid, sumgrid sum);
    MOVE findemptyspaceinrowforplayer(const gamegrid grid, const sumgrid sum, int player);
};
#endif

#ifndef _DEF_GAMEGRID_H_
#define _DEF_GAMEGRID_H_

enum message{MSGNEXTMOVE, MSGWON, MSGLOST, MSGINVALIDMOVE, MSGDRAW};
enum fields{DRAW=0, J1=16, J1WON=48, J2=256, J2WON=768, NONE=4096};
typedef int gamegrid[3][3];

struct MOVE {
    int x;
    int y;
    MOVE(int x = -1, int y = -1);
    bool operator==(const MOVE rhs);
};

const MOVE EMPTYMOVE;
#endif

#ifndef _DEF_GAMEMASTER_H_
#define _DEF_GAMEMASTER_H_
#include "gamegrid.h"
#include "actor.h"
#include <map>


class gamemaster{
public:
    gamemaster(actor* actorJ1, actor* actorJ2);
    bool play();
private:
    int currentplayer;
    int message;
    gamegrid grid;
    std::map<int, actor* > players;
    void emptygrid(gamegrid grid);
    bool validMOVE(MOVE move);
    int evaluategrid();
    int enemy(int player);
};
#endif

#ifndef _DEF_PLAYER_HUMAN_H_
#define _DEF_PLAYER_HUMAN_H_
#include "actor.h"
#include "gamegrid.h"
#include<string>
#include<sstream>
#include<set>


class human : public actor{
public:
    human(int own, int enemy, std::string ownsymbol, std::string enemysymbol);
    MOVE nextMOVE(const gamegrid grid, const int messagecode);
private:
    std::string ownsymbol;
    std::string enemysymbol;
    MOVE askhuman(const gamegrid grid);
    std::string display(const gamegrid grid);
};
#endif

#include "gamegrid.h"
#include "actor.h"


MOVE actor::nextMOVE(const gamegrid grid, const int messagecode){
    return EMPTYMOVE;
}

actor::actor(int own, int enemy){
    actor::own = own;
    actor::enemy = enemy;
}

int actor::who(const int field){
    if(field == actor::own){
        return J1;
    } else if (field == actor::enemy){
        return J2;
    } else {
        return field;
    }
}

#include "AI8sections.h"
#include <iostream>


AI8section::AI8section(int own, int enemy):actor(own, enemy){
    this->steps[0] = &AI8section::Win;
    this->steps[1] = &AI8section::Block;
    this->steps[2] = &AI8section::Fork;
    this->steps[3] = &AI8section::BlockFork;
    this->steps[4] = &AI8section::Center;
    this->steps[5] = &AI8section::OppCo;
    this->steps[6] = &AI8section::EmpCo;
    this->steps[7] = &AI8section::EmpSide;
}

void AI8section::calcsumgrid(const gamegrid grid, sumgrid sum){
    for(int i = 0; i < 3; i++){
        for(int j = 0; j < 3; j++){
            sum[0][i] += grid[i][j];
            sum[1][i] += grid[j][i];
        }
        sum[2][0] += grid[2 - i][i];
        sum[2][1] += grid[i][2 - i];
    }
}

MOVE AI8section::findemptyspaceinrowforplayer(const gamegrid grid, const sumgrid sum, int player){
    for(int i = 0; i < 3; i++){
        for(int j = 0; j < 3; j++){
            if(sum[i][j] == player * 2 + NONE){
                switch(i){
                    case 0:
                        for(int k = 0; k < 3; k++){
                            if(grid[j][k] == NONE){
                                return MOVE(j, k);
                            }
                        }
                    case 1:
                        for(int k = 0; k < 3; k++){
                            if(grid[k][j] == NONE){
                                return MOVE(k, j);
                            }
                        }
                    case 2:
                        for(int k = 0; k < 3; k++){
                            if(grid[2 - k][k] == NONE){
                                return MOVE(2 - k, k);
                            }
                            if(grid[k][2 - k] == NONE){
                                return MOVE(k, 2 - k);
                            }
                        }
                }
            }
        }
    }
    return EMPTYMOVE;
}

MOVE AI8section::nextMOVE(const gamegrid grid, const int messagecode){
    std::cout << "nextMOVE AI init" << std::endl;
    switch(messagecode){
        case MSGINVALIDMOVE:
            std::cout << "AI produced a invalid move" << std::endl;
        case MSGNEXTMOVE:{
            //this is still in for debugging
            std::cout << "nextMOVE" << std::endl;
            MOVE tmp = EMPTYMOVE;
            int i = 0;
            std::cout << "Int i: " << i << std::endl;
            AI8func function;
            while(tmp == EMPTYMOVE){
                tmp = (this->*(AI8section::steps[i++]))(grid);
                std::cout << i << std::endl;
            }
            std::cout << "nextMOVE exited" << std::endl;
            return tmp;}
        default:
            return EMPTYMOVE;
    }
}

MOVE AI8section::Win(const gamegrid grid){
    sumgrid sum = {0};
    this->calcsumgrid(grid, sum);
    return this->findemptyspaceinrowforplayer(grid, sum, this->own);
}
MOVE AI8section::Block(const gamegrid grid){
    sumgrid sum = {0};
    this->calcsumgrid(grid, sum);
    return this->findemptyspaceinrowforplayer(grid, sum, this->enemy);
}

MOVE AI8section::Fork(const gamegrid grid){return EMPTYMOVE;}
MOVE AI8section::BlockFork(const gamegrid grid){return EMPTYMOVE;}

MOVE AI8section::Center(const gamegrid grid){
    if(grid[1][1] == NONE){
        return MOVE(1, 1);
    }
    else{
        return EMPTYMOVE;
    }
}

MOVE AI8section::OppCo(const gamegrid grid){
    if(grid[0][0] + grid[2][2] == this->enemy + NONE){
        if(grid[0][0] == NONE){
            return MOVE(0, 0);
        }else{
            return MOVE(2, 2);
        }
    }else if(grid[2][0] + grid[0][2] == this->enemy + NONE){
        if(grid[2][0] == NONE){
            return MOVE(2, 0);
        }else{
            return MOVE(0, 2);
        }
    }else{
        return EMPTYMOVE;
    }
}

MOVE AI8section::EmpCo(const gamegrid grid){
    if(grid[0][0] == NONE){
        return MOVE(0,0);
    }else if (grid[0][2] == NONE){
        return MOVE(0,2);
    }else if (grid[2][0] == NONE){
        return MOVE(2,0);
    }else if (grid[2][2] == NONE){
        return MOVE(2,2);
    }else{
        return EMPTYMOVE;
    }
}
MOVE AI8section::EmpSide(const gamegrid grid){
    if(grid[0][1] == NONE){
        return MOVE(0,1);
    }else if (grid[1][0] == NONE){
        return MOVE(1,0);
    }else if (grid[1][2] == NONE){
        return MOVE(1,2);
    }else if (grid[2][1] == NONE){
        return MOVE(2,1);
    }else{
        return EMPTYMOVE;
    }
}

#include "gamegrid.h"

MOVE::MOVE(int x, int y){
    MOVE::x = x;
    MOVE::y = y;
}

bool MOVE::operator==(const MOVE rhs){
    if(MOVE::x == rhs.x && MOVE::y == rhs.y){
        return true;
    }else{
        return false;
    }
}

#include "gamemaster.h"

int gamemaster::enemy(int player){
    switch(player){
        case J1: return J2;
        case J2: return J1;
        default: return NONE;
    }
}

gamemaster::gamemaster(actor* actorJ1, actor* actorJ2){
    gamemaster::players[J1] = actorJ1;
    gamemaster::players[J2] = actorJ2;
    gamemaster::emptygrid(gamemaster::grid);
    gamemaster::currentplayer = J1;
    gamemaster::message = MSGNEXTMOVE;
}

void gamemaster::emptygrid(gamegrid grid){
    for(int i=0; i < 3; i++){
        for(int j = 0; j < 3; j++){
            grid[i][j] = NONE;
        }
    }
}

bool gamemaster::validMOVE(MOVE move){
    if (gamemaster::grid[move.x][move.y] == NONE){
        return true;
    }
    else{
        return false;
    }
}

int gamemaster::evaluategrid(){
    int summs[9] = {0};
    //summs[0]-summs[5] -> vertical and horizontal
    //summs[6] and summs[7] -> diagonal
    //summs[8] summ over all fields
    for(int i=0; i < 3; i++){
        for(int j = 0; j < 3; j++){
            summs[i*2] += gamemaster::grid[i][j];
            summs[i*2 + 1] += gamemaster::grid[j][i];
        }
        summs[6] += gamemaster::grid[i][i];
        summs[7] += gamemaster::grid[i][2-i];
        summs[8] += summs[i*2];
    }
    int returnvalue = DRAW;
    for(int i = 0; i<9; i++){
        switch(summs[i]){
            case J1WON: return J1WON;
            case J2WON: return J2WON;
        }
        if(NONE <= summs[i]){
            returnvalue = NONE;
        }
    }
    return returnvalue;
}

bool gamemaster::play(){
    MOVE playermove = gamemaster::players[gamemaster::currentplayer]->nextMOVE(gamemaster::grid, gamemaster::message);
    if(gamemaster::validMOVE(playermove)){
        gamemaster::grid[playermove.x][playermove.y] = gamemaster::currentplayer;
    }else{
        gamemaster::message = MSGINVALIDMOVE;
        return true;
    }
    switch(gamemaster::evaluategrid()){
        case DRAW:
            gamemaster::players[J1]->nextMOVE(gamemaster::grid, MSGDRAW);
            gamemaster::players[J2]->nextMOVE(gamemaster::grid, MSGDRAW);
            return false;
        case J1WON:
            gamemaster::players[J1]->nextMOVE(gamemaster::grid, MSGWON);
            gamemaster::players[J2]->nextMOVE(gamemaster::grid, MSGLOST);
            return false;
        case J2WON:
            gamemaster::players[J1]->nextMOVE(gamemaster::grid, MSGLOST);
            gamemaster::players[J2]->nextMOVE(gamemaster::grid, MSGWON);
            return false;
        case NONE:
            gamemaster::currentplayer = gamemaster::enemy(gamemaster::currentplayer);
            gamemaster::message = MSGNEXTMOVE;
            return true;
        default:
            return false;
    }
}

#include "human.h"
#include<iostream>


human::human(int own, int enemy, std::string ownsymbol, std::string enemysymbol):actor(own, enemy){
    human::ownsymbol = ownsymbol;
    human::enemysymbol = enemysymbol;
}

MOVE human::nextMOVE(const gamegrid grid, const int messagecode){
    std::cout << "Player: " << human::ownsymbol << std::endl;
    switch(messagecode){
        case MSGNEXTMOVE:
            return human::askhuman(grid);
        case MSGWON:
            std::cout << "You won!" << std::endl;
            human::display(grid);
            return EMPTYMOVE;
        case MSGLOST:
            std::cout << "You lost!" << std::endl;
            human::display(grid);
            return EMPTYMOVE;
        case MSGINVALIDMOVE:
            std::cout << "You inserted a invalid move!" << std::endl;
            return human::askhuman(grid);
        case MSGDRAW: std::cout << "You entered a draw!" << std::endl;
            human::display(grid);
            return EMPTYMOVE;
        default:
            std::cout << "Unknown error happened" << std::endl;
            return human::askhuman(grid);
    }
}

std::string human::display(const gamegrid grid){
    for(int i = 0; i < 3; i++){
        for(int j = 0; j < 3; j++){
            std::cout << "|";
            if(grid[i][j] == human::own){
                std::cout << human::ownsymbol;
            }
            else if(grid[i][j] == human::enemy){
                std::cout << human::enemysymbol;
            }
            else{
                std::cout << i * 3 + j + 1;
            }
            std::cout << "|";
        }
        std::cout << std::endl;
    }
    std::string userinput;
    std::getline(std::cin,userinput);
    return userinput;
}

MOVE human::askhuman(const gamegrid grid){
    std::set<int> possiblemoves;
    for(int i = 0; i < 3; i++){
        for(int j = 0; j < 3; j++){
            if(grid[i][j] == NONE){
                possiblemoves.insert(i * 3 + j);
            }
        }
    }
    std::string userinput = human::display(grid);
    int movenumber;
    std::stringstream(userinput) >> movenumber;
    movenumber--;
    if (possiblemoves.find(movenumber) == possiblemoves.end()){
        return human::nextMOVE(grid, MSGINVALIDMOVE);
    }
    else{
        int x,y;
        x = movenumber / 3;
        y = movenumber % 3;
        MOVE tmp(x, y);
        return tmp;
    }
}

#include "actor.h"
#include "gamegrid.h"
#include "human.h"
#include "AI8sections.h"
#include "gamemaster.h"

using namespace std;

int main(void){
    human humanJ1(J1, J2, "o", "x");
    AI8section AI8sectionJ2(J2, J1);
    actor* playerJ1 = &humanJ1;
    actor* playerJ2 = &AI8sectionJ2;
    gamemaster game(playerJ1, playerJ2);
    while (game.play());
    return 0;
}