You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
tdegames/kenolaba/Move.cpp

262 lines
4.7 KiB

/* Classes Move, MoveList
* - represents a move in the game of Abalone
*
* Josef Weidendorfer, 28.8.97
*/
#include <assert.h>
#include <stdio.h>
#include <tqstring.h>
#include <klocale.h>
#include "Move.h"
#include "Board.h"
const TQString nameOfDir(int dir)
{
dir = dir % 6;
return
(dir == 1) ? i18n("Right") :
(dir == 2) ? i18n("RightDown") :
(dir == 3) ? i18n("LeftDown") :
(dir == 4) ? i18n("Left") :
(dir == 5) ? i18n("LeftUp") :
(dir == 0) ? i18n("RightUp") : TQString("??");
}
TQString nameOfPos(int p)
{
static char tmp[3];
tmp[0] = 'A' + (p-12)/11;
tmp[1] = '1' + (p-12)%11;
tmp[2] = 0;
return TQString( tmp );
}
TQString Move::name() const
{
TQString s,tmp;
/* sideway moves... */
if (type == left3 || type == right3) {
int f1, f2, df;
f1 = f2 = field;
df = 2* Board::fieldDiffOfDir(direction);
if (df > 0)
f2 += df;
else
f1 += df;
s = nameOfPos( f1 );
s += '-';
s += nameOfPos( f2 );
s+= '/';
s+= (type == left3) ? nameOfDir(direction-1): nameOfDir(direction+1);
}
else if ( type == left2 || type == right2) {
int f1, f2, df;
f1 = f2 = field;
df = Board::fieldDiffOfDir(direction);
if (df > 0)
f2 += df;
else
f1 += df;
s = nameOfPos( f1 );
s += '-';
s += nameOfPos( f2 );
s+= '/';
s+= (type == left2) ? nameOfDir(direction-1): nameOfDir(direction+1);
}
else if (type == none) {
s = TQString("??");
}
else {
s = nameOfPos( field );
s += '/';
s += nameOfDir(direction);
tmp = (type <3 ) ? i18n("Out") :
(type <6 ) ? i18n("Push") : TQString("");
if (!tmp.isEmpty()) {
s += '/';
s += tmp;
}
}
return s;
}
void Move::print() const
{
printf("%s", name().ascii() );
}
MoveTypeCounter::MoveTypeCounter()
{
init();
}
void MoveTypeCounter::init()
{
for(int i=0;i < Move::typeCount;i++)
count[i] = 0;
}
int MoveTypeCounter::sum()
{
int sum = count[0];
for(int i=1;i < Move::typeCount;i++)
sum += count[i];
return sum;
}
InARowCounter::InARowCounter()
{
init();
}
void InARowCounter::init()
{
for(int i=0;i < inARowCount;i++)
count[i] = 0;
}
MoveList::MoveList()
{
clear();
}
void MoveList::clear()
{
int i;
for(i=0;i<Move::typeCount;i++)
first[i] = actual[i] = -1;
nextUnused = 0;
actualType = -1;
}
void MoveList::insert(Move m)
{
int t = m.type;
/* valid and possible ? */
if (t <0 || t >= Move::typeCount) return;
if (nextUnused == MaxMoves) return;
assert( nextUnused < MaxMoves );
/* adjust queue */
if (first[t] == -1) {
first[t] = last[t] = nextUnused;
}
else {
assert( last[t] < nextUnused );
next[last[t]] = nextUnused;
last[t] = nextUnused;
}
next[nextUnused] = -1;
move[nextUnused] = m;
nextUnused++;
}
bool MoveList::isElement(int f)
{
int i;
for(i=0; i<nextUnused; i++)
if (move[i].field == f)
return true;
return false;
}
bool MoveList::isElement(Move &m, int startType,bool del)
{
int i;
for(i=0; i<nextUnused; i++) {
Move& mm = move[i];
if (mm.field != m.field)
continue;
/* if direction is supplied it has to match */
if ((m.direction > 0) && (mm.direction != m.direction))
continue;
/* if type is supplied it has to match */
if ((m.type != Move::none) && (m.type != mm.type))
continue;
if (m.type == mm.type) {
/* exact match; eventually supply direction */
m.direction = mm.direction;
if (del) mm.type = Move::none;
return true;
}
switch(mm.type) {
case Move::left3:
case Move::right3:
if (startType == start3 || startType == all) {
m.type = mm.type;
m.direction = mm.direction;
if (del) mm.type = Move::none;
return true;
}
break;
case Move::left2:
case Move::right2:
if (startType == start2 || startType == all) {
m.type = mm.type;
m.direction = mm.direction;
if (del) mm.type = Move::none;
return true;
}
break;
default:
if (startType == start1 || startType == all) {
/* unexact match: supply type */
m.type = mm.type;
m.direction = mm.direction;
if (del) mm.type = Move::none;
return true;
}
}
}
return false;
}
bool MoveList::getNext(Move& m, int maxType)
{
if (actualType == Move::typeCount) return false;
while(1) {
while(actualType < 0 || actual[actualType] == -1) {
actualType++;
if (actualType == Move::typeCount) return false;
actual[actualType] = first[actualType];
if (actualType > maxType) return false;
}
m = move[actual[actualType]];
actual[actualType] = next[actual[actualType]];
if (m.type != Move::none) break;
}
return true;
}