крестики-нолики, морской бой, карты...

#ifndef The_Game_XO_h__
#define The_Game_XO_h__
 
 
#include <iostream>
#include <algorithm>
#include <vector>
#include <map>
#include <stack>
#include <numeric>
 
const int       InitWeight      = 100;  // начальный вес.
const int       PrecCoeff       = 50;   // точность генератора случайных чисел.
const double    StepCoeff       = 0.65; // коэффициент обучения.
const int       LearningStep    = 20;   // шаг обучения.
 
char GameField[9];                      // Игровое поле.
 
enum OUTCOME { Xs, Os, DRAW, UNFINISHED };
 
struct TField
{
    char Field[9];
 
    TField(){ std::copy( GameField, GameField + 9, Field ); }
 
    bool operator < ( const TField &rhs ) const
    {
        return std::lexicographical_compare( Field, Field + 9, rhs.Field, rhs.Field + 9 );
    }
};
 
struct TWeight
{
    int Weight[9];
 
    TWeight() { std::fill( Weight, Weight + 9, InitWeight ); }
};
 
class Player
{
public:
    Player( char _symbol ) : Symbol( _symbol ) {}
    
    virtual void MakeMove() = 0;
    virtual void Learn( int ) {}
protected:
    char Symbol;
};
 
class HumanPlayer: public Player
{
public:
    HumanPlayer( char _symbol ) : Player( _symbol ) {}
 
    virtual void MakeMove()
    {
        int Cell;
        std::cout << "Input Position: ";
        std::cin >> Cell;
        GameField[Cell] = Symbol;
    }
};
 
class RandomPlayer: public Player
{
public:
    RandomPlayer( char _symbol ): Player( _symbol ) {}
    
    virtual void MakeMove()
    {
        std::vector<int> v;
 
        for(int i = 0; i < 9; ++i)
        {
            if( GameField[i] == ' ')
                v.push_back(i);
        }
 
        GameField[ v[rand()%v.size()] ] = Symbol;
    }
};
 
class SmartPlayer: public Player
{
public:
    SmartPlayer( char _sumbol ): Player( _sumbol ) {}
 
    virtual void MakeMove();
    void Learn( int );
private:
    struct HistoryElement
    {
        std::map<TField, TWeight>::iterator Situation;
        int Move;
        HistoryElement( std::map<TField, TWeight>::iterator s, int m)
            : Situation(s), Move(m) {}
    };
 
    std::stack<HistoryElement> History;
    std::map<TField, TWeight> Database;
 
    std::map<TField, TWeight>::iterator GetSituation();
    int GetRandom(std::map<TField, TWeight>::iterator s);
};
 
std::map<TField, TWeight>::iterator SmartPlayer::GetSituation()
{
    std::map<TField, TWeight>::iterator p = Database.find(TField());
 
    if(p == Database.end())
    {
        TWeight w;
 
        for(int i = 0; i < 9; ++i)
        {
            if( GameField[i] != ' ')
                w.Weight[i] = 0;
        }
 
        Database[TField()] = w;
        return Database.find(TField());
    }
 
    return p;
}
 
int SmartPlayer::GetRandom(std::map<TField, TWeight>::iterator s)
{
    int sum = std::accumulate( s->second.Weight, s->second.Weight + 9, 0 );
 
    if( !sum )
        return std::find( GameField, GameField + 9, ' ') - GameField;
 
    std::vector<int> coords;
 
    for(int i = 0; i < 9; ++i)
        std::fill_n( std::back_inserter(coords), PrecCoeff * s->second.Weight[i] / sum, i);
 
    return coords[ rand()%coords.size() ];
 
}
 
void SmartPlayer::Learn( int Step )
{
    if( History.empty() )
        return;
 
    HistoryElement h = History.top();
    History.pop();
 
    TWeight &w = h.Situation->second;
 
    w.Weight[h.Move] += Step;
    if(w.Weight[h.Move] < 0)
        w.Weight[h.Move] = 0;
 
    Learn(Step * StepCoeff);
}
 
void SmartPlayer::MakeMove()
{
    std::map<TField, TWeight>::iterator s = GetSituation();
 
    int move = GetRandom(s);
    GameField[move] = Symbol;
    History.push(HistoryElement(s,move));
}
OUTCOME GetOutCome()
{
    int v[8][3] = { {0,1,2}, {3,4,5}, {6,7,8}, {0,3,6},
                    {1,4,7}, {2,5,8}, {0,4,8}, {2,4,6} };
 
    for(int i = 0; i < 8; ++i)
    {
        if( GameField[ v[i][0] ] == GameField[ v[i][1] ] &&
            GameField[ v[i][0] ] == GameField[ v[i][2] ] &&
            GameField[ v[i][0] ] != ' ' )
            return GameField[ v[i][0] ] == 'x' ? Xs : Os;
    }
 
    return ( std::find(GameField, GameField + 9, ' ') == GameField + 9 )
                                                    ? DRAW : UNFINISHED;
}
 
void PrintField()
{
    system("cls");
    std::cout << GameField[0] << '|' << GameField[1] << '|' << GameField[2] << std::endl;
    std::cout << GameField[3] << '|' << GameField[4] << '|' << GameField[5] << std::endl;
    std::cout << GameField[6] << '|' << GameField[7] << '|' << GameField[8] << std::endl;
    std::cout << std::endl;
}
 
 
 
void PlayGame(Player *Xp, Player *Op, bool Verbose)
{
    Player *Cp[] = { Xp, Op };
    int move = 0;
    std::fill( GameField, GameField + 9, ' ');
 
    while( GetOutCome() == UNFINISHED )
    {
        Cp[move++ % 2]->MakeMove();
        if(Verbose)
            PrintField();
    }
 
    if( GetOutCome() == Xs )
    {
        Xp->Learn(LearningStep);
        Op->Learn(-LearningStep);
    }else if( GetOutCome() == Os )
    {
        Xp->Learn(-LearningStep);
        Op->Learn(LearningStep);
    }
}
 
#endif // The_Game_XO_h__