boards.cpp

c+++ game uploading now

/**
 @file
 The implementation of different board representations.
*/

/* It looks ugly, it is ugly. This was more or  less generated so do 
** not edit.
*/
#include <cstring>
#include "Boards.h"

using namespace Othello;

Board::Board() 
{
    InitBoard();
    InitPrecomp();
}

void Board::InitBoard()
{
    memcpy(table, sboard, sizeof(sboard));
    isblacksturn=true;
    blacks=2;
    empties=60;
}

bool Board::IsClean() const
{
    for(unsigned int i=p11; i<s89; i++)
        switch(table[i])
        {
        case black:
        case empty:
        case white:
        case sentl:
            continue;
        default:
            return false;
        }
    return true;
}


BookBoard& BookBoard::operator= (const Board& b)
{
    memset(l, 0, 4*sizeof(l[0]));
    isblacksturn=b.isblacksturn;
    
    for(unsigned i=p11; i<s89; i++)
    {
        int x= i / 10;
        int y= i % 10;
        switch(b.table[i])
        {
        case white:
            l[(x-1)/2] |= maskwhite[y-1+8*((x-1)%2)];
            break;
        case black:
            l[(x-1)/2] &= maskblack[y-1+8*((x-1)%2)];
            break;
        case empty:
            l[(x-1)/2] |= maskempty[y-1+8*((x-1)%2)];
            break;
        }
    }
    return *this;
}

int Board::Mul4(int p1, int p2, int p3, int p4)
{
    return 3*(3*(3*table[p1]+table[p2])+table[p3])+table[p4];
}

int Board::Mul5(int p1, int p2, int p3, int p4, int p5)
{
    return 3*(3*(3*(3*table[p1]+table[p2])+table[p3])+table[p4])
           +table[p5];
}

int Board::Mul6(int p1, int p2, int p3, int p4, int p5, int p6)
{
    return 3*(3*(3*(3*(3*table[p1]+table[p2])+table[p3])+table[p4])
           +table[p5])+table[p6];
}

int Board::Mul7(int p1, int p2, int p3, int p4, int p5, int p6, int p7)
{
    return 3*(3*(3*(3*(3*(3*table[p1]+table[p2])+table[p3])+table[p4])
           +table[p5])+table[p6])+table[p7];
}

int Board::Mul8(int p1, int p2, int p3, int p4, int p5, int p6, int p7, int p8)
{
    return 3*(3*(3*(3*(3*(3*(3*table[p1]+table[p2])+table[p3])+table[p4])
           +table[p5])+table[p6])+table[p7])+table[p8];
}

void Board::Syncronize()
{
    //pattern 4
    diag4A1D= Mul4(p41, p32, p23, p14);
    diag5A8D= Mul4(p51, p62, p73, p84);
    diag4H1E= Mul4(p48, p37, p26, p15);
    diag5H8E= Mul4(p58, p67, p76, p85);

    //pattern 5
    diag5A1E= Mul5(p51, p42, p33, p24, p15);
    diag4A8E= Mul5(p41, p52, p63, p74, p85);
    diag5H1D= Mul5(p58, p47, p36, p25, p14);
    diag4H8D= Mul5(p48, p57, p66, p75, p84);
    
    //pattern 6
    diag6A1F= Mul6(p61, p52, p43, p34, p25, p16);
    diag3A8F= Mul6(p31, p42, p53, p64, p75, p86);
    diag3H8C= Mul6(p38, p47, p56, p65, p74, p83);
    diag6H1C= Mul6(p68, p57, p46, p35, p24, p13);

    //pattern 7
    diag7A1G= Mul7(p71, p62, p53, p44, p35, p26, p17);
    diag2A8G= Mul7(p21, p32, p43, p54, p65, p76, p87);
    diag2H8B= Mul7(p28, p37, p46, p55, p64, p73, p82);
    diag7H1B= Mul7(p78, p67, p56, p45, p34, p23, p12);

    //pattern 8
    diag1A8H= Mul8(p11, p22, p33, p44, p55, p66, p77, p88);
    diag8A1H= Mul8(p81, p72, p63, p54, p45, p36, p27, p18);
    
    line1= Mul8(p11, p12, p13, p14, p15, p16, p17, p18);
    line2= Mul8(p21, p22, p23, p24, p25, p26, p27, p28);
    line3= Mul8(p31, p32, p33, p34, p35, p36, p37, p38);
    line4= Mul8(p41, p42, p43, p44, p45, p46, p47, p48);
    line5= Mul8(p51, p52, p53, p54, p55, p56, p57, p58);
    line6= Mul8(p61, p62, p63, p64, p65, p66, p67, p68);
    line7= Mul8(p71, p72, p73, p74, p75, p76, p77, p78);
    line8= Mul8(p81, p82, p83, p84, p85, p86, p87, p88);

    colA= Mul8(p11, p21, p31, p41, p51, p61, p71, p81);
    colB= Mul8(p12, p22, p32, p42, p52, p62, p72, p82);
    colC= Mul8(p13, p23, p33, p43, p53, p63, p73, p83);
    colD= Mul8(p14, p24, p34, p44, p54, p64, p74, p84);
    colE= Mul8(p15, p25, p35, p45, p55, p65, p75, p85);
    colF= Mul8(p16, p26, p36, p46, p56, p66, p76, p86);
    colG= Mul8(p17, p27, p37, p47, p57, p67, p77, p87);
    colH= Mul8(p18, p28, p38, p48, p58, p68, p78, p88);

    //2x4 corners
    cornA1D2= Mul8(p11, p12, p13, p14, p21, p22, p23, p24);
    cornA1B4= Mul8(p11, p21, p31, p41, p12, p22, p32, p42);
    cornA8B5= Mul8(p81, p71, p61, p51, p82, p72, p62, p52);
    cornA8D7= Mul8(p81, p82, p83, p84, p71, p72, p73, p74);
    cornH8E7= Mul8(p88, p87, p86, p85, p78, p77, p76, p75);
    cornH8G5= Mul8(p88, p78, p68, p58, p87, p77, p67, p57);
    cornH1G4= Mul8(p18, p28, p38, p48, p17, p27, p37, p47);
    cornH1E2= Mul8(p18, p17, p16, p15, p28, p27, p26, p25);
    
    empties=0;
    blacks=0;
    for(unsigned int i=p11; i<s89; i++)
    {
        switch(table[i])
        {
        case empty:
            empties++;
            break;
        case black:
            blacks++;
            break;
        }
    }
}

#if !defined NDEBUG
//debug
bool Board::AssertIsInSync()
{
    //pattern 4
    assert(diag4A1D== Mul4(p41, p32, p23, p14));
    assert(diag5A8D== Mul4(p51, p62, p73, p84));
    assert(diag4H1E== Mul4(p48, p37, p26, p15));
    assert(diag5H8E== Mul4(p58, p67, p76, p85));

    //pattern 5
    assert(diag5A1E== Mul5(p51, p42, p33, p24, p15));
    assert(diag4A8E== Mul5(p41, p52, p63, p74, p85));
    assert(diag5H1D== Mul5(p58, p47, p36, p25, p14));
    assert(diag4H8D== Mul5(p48, p57, p66, p75, p84));
    
    //pattern 6
    assert(diag6A1F== Mul6(p61, p52, p43, p34, p25, p16));
    assert(diag3A8F== Mul6(p31, p42, p53, p64, p75, p86));
    assert(diag3H8C== Mul6(p38, p47, p56, p65, p74, p83));
    assert(diag6H1C== Mul6(p68, p57, p46, p35, p24, p13));

    //pattern 7
    assert(diag7A1G== Mul7(p71, p62, p53, p44, p35, p26, p17));
    assert(diag2A8G== Mul7(p21, p32, p43, p54, p65, p76, p87));
    assert(diag2H8B== Mul7(p28, p37, p46, p55, p64, p73, p82));
    assert(diag7H1B== Mul7(p78, p67, p56, p45, p34, p23, p12));

    //pattern 8
    assert(diag1A8H== Mul8(p11, p22, p33, p44, p55, p66, p77, p88));
    assert(diag8A1H== Mul8(p81, p72, p63, p54, p45, p36, p27, p18));
    
    assert(line1== Mul8(p11, p12, p13, p14, p15, p16, p17, p18));
    assert(line2== Mul8(p21, p22, p23, p24, p25, p26, p27, p28));
    assert(line3== Mul8(p31, p32, p33, p34, p35, p36, p37, p38));
    assert(line4== Mul8(p41, p42, p43, p44, p45, p46, p47, p48));
    assert(line5== Mul8(p51, p52, p53, p54, p55, p56, p57, p58));
    assert(line6== Mul8(p61, p62, p63, p64, p65, p66, p67, p68));
    assert(line7== Mul8(p71, p72, p73, p74, p75, p76, p77, p78));
    assert(line8== Mul8(p81, p82, p83, p84, p85, p86, p87, p88));

    assert(colA== Mul8(p11, p21, p31, p41, p51, p61, p71, p81));
    assert(colB== Mul8(p12, p22, p32, p42, p52, p62, p72, p82));
    assert(colC== Mul8(p13, p23, p33, p43, p53, p63, p73, p83));
    assert(colD== Mul8(p14, p24, p34, p44, p54, p64, p74, p84));
    assert(colE== Mul8(p15, p25, p35, p45, p55, p65, p75, p85));
    assert(colF== Mul8(p16, p26, p36, p46, p56, p66, p76, p86));
    assert(colG== Mul8(p17, p27, p37, p47, p57, p67, p77, p87));
    assert(colH== Mul8(p18, p28, p38, p48, p58, p68, p78, p88));

    assert(cornA1D2==Mul8(p11, p12, p13, p14, p21, p22, p23, p24));
    assert(cornA1B4==Mul8(p11, p21, p31, p41, p12, p22, p32, p42));
    assert(cornA8B5==Mul8(p81, p71, p61, p51, p82, p72, p62, p52));
    assert(cornA8D7==Mul8(p81, p82, p83, p84, p71, p72, p73, p74));
    assert(cornH8E7==Mul8(p88, p87, p86, p85, p78, p77, p76, p75));
    assert(cornH8G5==Mul8(p88, p78, p68, p58, p87, p77, p67, p57));
    assert(cornH1G4==Mul8(p18, p28, p38, p48, p17, p27, p37, p47));
    assert(cornH1E2==Mul8(p18, p17, p16, p15, p28, p27, p26, p25));

    unsigned int empties_=0;
    unsigned int blacks_=0;
    for(unsigned int i=p11; i<s89; i++)
    {
        switch(table[i])
        {
        case empty:
            empties_++;
            break;
        case black:
            blacks_++;
            break;
        }
    }
    assert(empties==empties_);
    assert(blacks==blacks_);

    return true;
}

#include <windows.h>
void Board::DebugPrintBoard(int x)
{
    ::OutputDebugString(isblacksturn?"Black's move\n":"White's move\n");
    for(int i=p11; i<s89; i++)
    {
        switch(table[i])
        {
        case black:
            if(x==i)
                ::OutputDebugString("B");
            else
                ::OutputDebugString("b");
            break;
        case white:
            if(x==i)
                ::OutputDebugString("W");
            else
                ::OutputDebugString("w");
            break;
        case empty:
            if(x==i)
                ::OutputDebugString("*");
            else
                ::OutputDebugString(".");
            break;
        }
        if(i%10==0)
            ::OutputDebugString("\n");
    }
    ::OutputDebugString("\n\n");
}

#endif //NDEBUG

signed char TTBoard::Persil[10*10]=
{
    -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
    -1, 0, 1, 2, 3, 4, 5, 6, 7,-1,
    -1, 8, 9,10,11,12,13,14,15,-1,
    -1,16,17,18,19,20,21,22,23,-1,
    -1,24,25,26,27,28,29,30,31,-1,
    -1,32,33,34,35,36,37,38,39,-1,
    -1,40,41,42,43,44,45,46,47,-1,
    -1,48,49,50,51,52,53,54,55,-1,
    -1,56,57,58,59,60,61,62,63,-1,