Baier_Hendrik_AnhB.txt

/*
* alte Kodierung des Spielfelds: mittels Integer-Array
*/


class Spielfeld {

public final static int WEISSERSTEIN = 1;

public final static int SCHWARZERSTEIN = 2;

public final static int LEER = 0;

public final static boolean WEISS = true;

public final static boolean SCHWARZ = false;

protected int Brett[][];

protected int Hoehe[];

protected boolean amZug;


public Spielfeld()
{
Brett = new int[7][6];
Hoehe = new int[7];
for (int i = 0; i <= 6; i++) {
for (int j = 0; j <= 5; j++) {
Brett[i][j] = LEER;
}
Hoehe[i] = 0;
}
amZug = WEISS;
}

public Spielfeld(Spielfeld p)
{
Brett = new int[7][6];
Hoehe = new int[7];
for (int i = 0; i <= 6; i++) {
Hoehe[i] = 6;
for (int j = 5; j >= 0; j--) {
Brett[i][j] = p.Brett[i][j];
if(Brett[i][j]==p.LEER) Hoehe[i] = j;
}
}
amZug = p.amZug;
}

public Spielfeld(String dateiname) throws java.io.IOException {
Brett = new int[7][6];
Hoehe = new int[7];
File inputFile = new File(dateiname);
InputStreamReader input = new InputStreamReader(new FileInputStream(inputFile));
System.out.println("Position wird eingelesen.");
int korrektur = 0;
for(int i=1;i<=54;i++) {
if(i%9==0 || (i+1)%9==0) {
input.read();
korrektur += 1;
continue;
}
setzeFeld( ( ((i-korrektur)%7)==0 ? 6 : (((i-korrektur)%7)-1) ), (5-((i-korrektur-1)/7)), Integer.parseInt(String.valueOf((char)input.read())));
}
setzeZug((char)input.read()=='w' ? WEISS : SCHWARZ);
input.close();
for (int i = 0; i <= 6; i++) {
Hoehe[i] = 6;
for (int j = 5; j >= 0; j--) {
if(Brett[i][j]==LEER) Hoehe[i] = j;
}
}
}

public int gibFeld(int a, int b) {
if (!(a >= 0) || !(b >= 0) || !(a <= 6) || !(b <= 5))
return -1;
return Brett[a][b];
}

public void setzeFeld(int a, int b, int c) {
if (!(a >= 0) || !(b >= 0) || !(a <= 6) || !(b <= 5))
throw new IllegalArgumentException("Versuchter Zugriff auf Feld "+a+", "+b);
if (c != WEISSERSTEIN && c != SCHWARZERSTEIN && c != LEER)
throw new IllegalArgumentException("Versuch, ein Feld auf "+c+" zu setzen.");
Brett[a][b] = c;
Hoehe[a] = b+1;
}

public boolean amZug() {
return amZug;
}

public void setzeZug(boolean c) {
amZug = c;
}

public static String farbezuString(boolean color) {
return color == WEISS ? "weiss" : "schwarz";
}


public static int farbezuFigur(boolean c) {
return c == SCHWARZ ? SCHWARZERSTEIN : WEISSERSTEIN;
}


public static boolean figurzuFarbe(int piece)
{
switch (piece) {
case WEISSERSTEIN:
return WEISS;
case SCHWARZERSTEIN:
return SCHWARZ;
default:
throw new IllegalArgumentException("Versuch, die Farbe von " + piece + " zu bestimmen.");
}
}

public int farbezuAnzahl(boolean c) {
int ergebnis = 0;
if(c==SCHWARZ) {
for(int i=0;i<=6;i++) {
for(int j=0;j<=5;j++) {
if(Brett[i][j]==SCHWARZERSTEIN) {
ergebnis += 1;
}
}
}
} else {
for(int i=0;i<=6;i++) {
for(int j=0;j<=5;j++) {
if(Brett[i][j]==WEISSERSTEIN) {
ergebnis += 1;
}
}
}
}
return ergebnis;
}

public int anzahlSteine() {
int ergebnis = 0;
for(int i=0;i<7;i++) {
ergebnis += Hoehe[i];
}
return ergebnis;
}

public String toString() {
String s = new String();
for(int j=5;j>=0;j--) {
for(int i=0;i<=6;i++) {
s = s.concat(buchstabe(Brett[i][j])+" ");
}
s = s.concat("\n");
}
s = s.concat("am Zug: ");
if(amZug==WEISS)
s = s.concat("weiss\n");
else
s = s.concat("schwarz\n");
return s;
}

public String buchstabe(int x) {
String s = new String();
if(x==LEER) s = ".";
if(x==WEISSERSTEIN) s = "W";
if(x==SCHWARZERSTEIN) s = "S";
return s;
}

public boolean equals(Object o){
if (!(o instanceof Spielfeld))
return false;
Spielfeld p = (Spielfeld)o;
for (int i = 0; i <= 6; i++) {
for( int j= 0; j <= 5; j++) {
if (Brett[i][j] != p.Brett[i][j]) return false;
}
}
return (amZug == p.amZug);
}

public void ziehen(int m) {

Brett[m][Hoehe[m]] = farbezuFigur(amZug);
Hoehe[m] += 1;
amZug = !amZug;

}

public void undo(int m) {

Brett[m][Hoehe[m]-1] = LEER;
Hoehe[m] -= 1;
amZug = !amZug;

}

public boolean istlegalerZug(int m) {
return (Hoehe[m]<6) ? true : false;

}

//langsamere Version von istgewonnen(boolean s) - wegen Zugriffen ausserhalb des Brettes
/* public boolean istgewonnen(boolean s) {
int x = farbezuFigur(s);

for(int i=0;i<=6;i++) {

for(int j=0;j<6;j++) {

if(gibFeld(i,j)!=x) {
continue;
}

if(gibFeld(i,j-1)==x && gibFeld(i,j-2)==x && gibFeld(i,j-3)==x) {
return true;
}

inner: for(int k=0;k<=2;k++) {
if(k==0) {
if(gibFeld(i+1,j)==x) {
if(gibFeld(i-1,j)==x) {
if(gibFeld(i+2,j)==x) {
return true;
} else if(gibFeld(i-2,j)==x) {
return true;
} else {
continue inner;
}
} else if(gibFeld(i+2,j)==x) {
if(gibFeld(i+3,j)==x) {
return true;
} else {
continue inner;
}
} else {
continue inner;
}
} else if(gibFeld(i-1,j)==x && gibFeld(i-2,j)==x && gibFeld(i-3,j)==x) {
return true;
}
}
if(k==1) {
if(gibFeld(i+1,j+1)==x) {
if(gibFeld(i-1,j-1)==x) {
if(gibFeld(i+2,j+2)==x) {
return true;
} else if(gibFeld(i-2,j-2)==x) {
return true;
} else {
continue inner;
}
} else if(gibFeld(i+2,j+2)==x) {
if(gibFeld(i+3,j+3)==x) {
return true;
} else {
continue inner;
}
} else {
continue inner;
}
} else if(gibFeld(i-1,j-1)==x && gibFeld(i-2,j-2)==x && gibFeld(i-3,j-3)==x) {
return true;
}
}
if(k==2) {
if(gibFeld(i+1,j-1)==x) {
if(gibFeld(i-1,j+1)==x) {
if(gibFeld(i+2,j-2)==x) {
return true;
} else if(gibFeld(i-2,j+2)==x) {
return true;
} else {
continue inner;
}
} else if(gibFeld(i+2,j-2)==x) {
if(gibFeld(i+3,j-3)==x) {
return true;
} else {
continue inner;
}
} else {
continue inner;
}
} else if(gibFeld(i-1,j+1)==x && gibFeld(i-2,j+2)==x && gibFeld(i-3,j+3)==x) {
return true;
}
}
}
}
}
return false;
}
*/

public boolean istgewonnen(boolean s) {
int x = farbezuFigur(s);
for(int i=0;i<=6;i++) {
for(int j=0;j<=2;j++) {
if(gibFeld(i,j)==x && gibFeld(i,j+1)==x && gibFeld(i,j+2)==x && gibFeld(i,j+3)==x) { return true; }
}
}
for(int i=0;i<=3;i++) {
for(int j=0;j<=5;j++) {
if(gibFeld(i,j)==x && gibFeld(i+1,j)==x && gibFeld(i+2,j)==x && gibFeld(i+3,j)==x) { return true; }
}
}
for(int i=0;i<=3;i++) {
for(int j=0;j<=2;j++) {
if(gibFeld(i,j)==x && gibFeld(i+1,j+1)==x && gibFeld(i+2,j+2)==x && gibFeld(i+3,j+3)==x) { return true; }
}
}
for(int i=0;i<=3;i++) {
for(int j=3;j<=5;j++) {
if(gibFeld(i,j)==x && gibFeld(i+1,j-1)==x && gibFeld(i+2,j-2)==x && gibFeld(i+3,j-3)==x) { return true; }
}
}
return false;
}

public boolean istgewonnen(boolean s, int zug) {
int x = farbezuFigur(s);
int y = Hoehe[zug]-1;
if(gibFeld(zug-2,y+2)==x && gibFeld(zug-1,y+1)==x && gibFeld(zug+1,y-1)==x) { return true; }
if(gibFeld(zug-1,y+1)==x && gibFeld(zug+1,y-1)==x && gibFeld(zug+2,y-2)==x) { return true; }
if(gibFeld(zug+2,y+2)==x && gibFeld(zug+1,y+1)==x && gibFeld(zug-1,y-1)==x) { return true; }
if(gibFeld(zug+1,y+1)==x && gibFeld(zug-1,y-1)==x && gibFeld(zug-2,y-2)==x) { return true; }
if(gibFeld(zug-2,y)==x && gibFeld(zug-1,y)==x && gibFeld(zug+1,y)==x) { return true; }
if(gibFeld(zug+2,y)==x && gibFeld(zug+1,y)==x && gibFeld(zug-1,y)==x) { return true; }
if(gibFeld(zug,y-3)==x && gibFeld(zug,y-2)==x && gibFeld(zug,y-1)==x) { return true; }
if(gibFeld(zug+3,y-3)==x && gibFeld(zug+2,y-2)==x && gibFeld(zug+1,y-1)==x) { return true; }
if(gibFeld(zug-3,y-3)==x && gibFeld(zug-2,y-2)==x && gibFeld(zug-1,y-1)==x) { return true; }
if(gibFeld(zug-3,y)==x && gibFeld(zug-2,y)==x && gibFeld(zug-1,y)==x) { return true; }
if(gibFeld(zug+3,y)==x && gibFeld(zug+2,y)==x && gibFeld(zug+1,y)==x) { return true; }
if(gibFeld(zug-3,y+3)==x && gibFeld(zug-2,y+2)==x && gibFeld(zug-1,y+1)==x) { return true; }
if(gibFeld(zug+3,y+3)==x && gibFeld(zug+2,y+2)==x && gibFeld(zug+1,y+1)==x) { return true; }
return false;
}

public boolean istunentschieden() {
for(int i=0;i<=6;i++) {
if(Hoehe[i]!=6) return false;
}
return true;
}

}


/*
* Alpha-Beta mit Search Extensions
*/


public int AlphaBeta(Position p, int depth, int alpha, int beta, double extension, MoveList pv, long Zkey, int move) throws IOException, TooManyNodesException {

if(nodecount[1]+nodecount[0]>NODELIMIT) {
throw new TooManyNodesException();
}

if(depth < maxDepth) {
maxDepth = depth;
}

if(debug) {
out.println();
out.println("Aufruf in Tiefe "+depth+", Extension "+extension+", alpha "+alpha+", beta "+beta+", move "+move);
out.println(p);
}

p.makeMove(move);
nodecount[0] += 1;
int hashflag = HASHALPHA;

//letzte Bits des Keys in Index umwandeln
int index = (int)Zkey&(HASHSIZE-1);
if(debug) {
out.println("Index "+index);
}

//Hash Tables
hvalue = -1;
bestMove = -1;
newbeta = beta;
newalpha = alpha;
if(HashTable2[index].key == Zkey) {
if(debug) out.println("in 2 gefunden.");
if(HashTable2[index].depth >= (depth+extension)) {
if(debug) out.println("Ausreichend in 2: Benoetigte Tiefe "+(depth+extension)+", vorgefundene depth "+HashTable2[index].depth);
if(HashTable2[index].flag==HASHEXACT) {
if(debug) out.println("Exakter Wert in 1: "+HashTable2[index].value);
hvalue = HashTable2[index].value;
}
if(HashTable2[index].flag==HASHALPHA && HashTable2[index].value <= alpha) {
if(debug) out.println("Alphawert in 1: "+alpha);
hvalue = alpha;
}
if(HashTable2[index].flag==HASHALPHA && HashTable2[index].value < beta) {
newbeta = HashTable2[index].value;
if(debug) out.println("Beta-Update in 1: "+newbeta);
}
if(HashTable2[index].flag==HASHBETA && HashTable2[index].value >= beta) {
if(debug) out.println("Betawert in 1: "+beta);
hvalue = beta;
}
if(HashTable2[index].flag==HASHBETA && HashTable2[index].value > alpha) {
newalpha = HashTable2[index].value;
if(debug) out.println("Alpha-Update in 1: "+newalpha);
}
}
if(debug) out.println("Bester Zug in 2: "+HashTable2[index].move);
bestMove = HashTable2[index].move;
}
if(HashTable1[index].key == Zkey) {
if(debug) out.println("in 1 gefunden.");
if(HashTable1[index].depth >= (depth+extension)) {
if(debug) out.println("Ausreichend in 1: Benoetigte Tiefe "+(depth+extension)+", vorgefundene depth "+HashTable1[index].depth);
if(HashTable1[index].flag==HASHEXACT) {
if(debug) out.println("Exakter Wert in 1: "+HashTable1[index].value);
hvalue = HashTable1[index].value;
}
if(HashTable1[index].flag==HASHALPHA && HashTable1[index].value <= alpha) {
if(debug) out.println("Alphawert in 1: "+alpha);
hvalue = alpha;
}
if(HashTable1[index].flag==HASHALPHA && HashTable1[index].value < beta) {
newbeta = HashTable1[index].value;
if(debug) out.println("Beta-Update in 1: "+newbeta);
}
if(HashTable1[index].flag==HASHBETA && HashTable1[index].value >= beta) {
if(debug) out.println("Betawert in 1: "+beta);
hvalue = beta;
}
if(HashTable1[index].flag==HASHBETA && HashTable1[index].value > alpha) {
newalpha = HashTable1[index].value;
if(debug) out.println("Alpha-Update in 1: "+newalpha);
}
}
if(debug) out.println("Bester Zug in 1: "+HashTable1[index].move);
bestMove = HashTable1[index].move;
}
if(HashTable3[index].key == Zkey) {
if(debug) out.println("in 3 gefunden.");
if(debug) out.println("Exakter Wert in 3: "+HashTable3[index].value);
hvalue = HashTable3[index].value;
}
beta = newbeta;
alpha = newalpha;
if(hvalue != -1) {
if(debug) {
out.println("Wert "+hvalue+" wird zurueckgegeben.");
out.println();
}
counterhorizon += 1;
counterhashaccess += 1;
evalDepthSum += depth;
pv.length = 0;
return hvalue;
}
if(debug) {
out.println("Suche wird fortgesetzt.");
out.println("Bester Zug "+bestMove);
}

if(bestMove!=-1) {
counterhashmove += 1;
} else {
counterhashfailure += 1;
}

MoveList mypv = new MoveList();

//entschiedene Positionen
if(p.isWon(!p.toMove,move)) {
if(debug) out.println("Ist verloren, "+(-1000+p.numberOfDiscs())+" zurück und gespeichert in "+index+" in Tiefe "+(depth+extension));
counterhorizon += 1;
counterwon += 1;
evalDepthSum += depth;
pv.length = 0;
addHashEntries(Zkey, index, depth+extension, -1000+p.numberOfDiscs(), HASHEXACT, -1);
return -1000+p.numberOfDiscs();
}

if(p.isDraw()) {
if(debug) out.println("Ist unentschieden, 0 zurück und gespeichert in "+index+" in Tiefe "+(depth+extension));
counterhorizon += 1;
counterdraw += 1;
evalDepthSum += depth;
pv.length = 0;
addHashEntries(Zkey, index, depth+extension, 0, HASHEXACT, -1);
return 0;
}

//Eröffnungsbuchzugriff
if(opening) {
if(p.numberOfDiscs()==8) {
value = searchBook(p);
if(value != -1) {
if(debug) out.println("Ist in DB, "+value+" zurück und gespeichert in "+index+" in Tiefe "+(depth+extension));
counterbookaccess += 1;
counterhorizon += 1;
evalDepthSum += depth;
pv.length = 0;
addHashEntries(Zkey, index, depth+extension, value, HASHEXACT, -1);
return value;
}
counterbookfailure += 1;
}
}

//Interior Node Recognition
firstFreeColumn = -1;
secondFreeColumn = -1;
freeColumns = 0;
for(int i=0;i<7;i++) {
if(p.height[i]!=6) {
freeColumns += 1;
if(freeColumns==3)
break;
if(freeColumns==1)
firstFreeColumn = i;
if(freeColumns==2)
secondFreeColumn = i;
}
}

if(freeColumns==1 || (freeColumns==2 && (secondFreeColumn-firstFreeColumn>=4))) {
if(acuteThreat(p,p.toMove)==-1 && acuteThreat(p,!p.toMove)==-1) {
value = evaluate(p, true);
counterhorizon += 1;
evalDepthSum += depth;
pv.length = 0;
if(debug) out.println("Ist recognized, "+value+" zurück und gespeichert in "+index+" in Tiefe "+(depth+extension));
addHashEntries(Zkey, index, depth+extension, value, HASHEXACT, -1);
return value;
}
}


if(depth <= (0-extension)) {
int akut2 = acuteThreat(p, p.toMove);
if(akut2!=-1) {
if(debug) out.println("Horizont erreicht. Ist gewonnen im nächsten Zug, 1000 zurück und gespeichert in "+index+" in Tiefe "+(depth+extension));
evalDepthSum += depth;
counterhorizon += 1;
pv.length = 0;
addHashEntries(Zkey, index, depth+extension, 1000-p.numberOfDiscs()-1, HASHEXACT, -1);
return 1000-p.numberOfDiscs()-1;
}
int akut = acuteThreat(p, !p.toMove);
if(akut==-1) {
evalDepthSum += depth;
counterhorizon += 1;
pv.length = 0;
int val = evaluate(p, false);
addHashEntries(Zkey, index, depth+extension, val, HASHEXACT, -1);
if(debug) out.println("Horizont erreicht. Evaluiert, "+val+" zurück und gespeichert in "+index+" in Tiefe "+(depth+extension));
return val;
}
extension += 2;
Zkey = Zkey^(p.toMove ? zobristKeys[akut][0] : zobristKeys[akut][1]);
if(debug) out.println("Horizont erreicht. Suche wird vertieft");
int value = -AlphaBeta(p, depth-1, -beta, -alpha, extension, mypv, Zkey, akut);
p.undoMove(akut);
Zkey = Zkey^(p.toMove ? zobristKeys[akut][0] : zobristKeys[akut][1]);
if(value>=beta) {
addHashEntries(Zkey, index, depth+extension-2, beta, HASHBETA, -1);
if(debug) out.println("Beta-Cutoff. "+beta+" als Betavalue gespeichert in "+index+" in Tiefe "+(depth+extension-2));
return beta;
}
if(value>alpha) {
hashflag = HASHEXACT;
alpha = value;
pv.setFirst(new MoveListElement(akut));
if(mypv.length!=0) {
pv.setRest(mypv);
}
pv.length = mypv.length + 1;
}
addHashEntries(Zkey, index, depth+extension-2, alpha, hashflag, -1);
if(debug) out.println("Alpha-Update. "+alpha+" als "+(hashflag==HASHEXACT?"exakter Wert ":"Alphavalue ")+"gespeichert in "+index+" in Tiefe "+(depth+extension-2));
return alpha;
}

int[] moves = generateMoves(p, searchDepth-depth);
sort(moves, p);

if(moves[7]==1) {
extension += 0.5;
if(debug) out.println("Nur ein Zug möglich. Extension wird erhöht");
}

//Suchvertiefung
for(int i=0;i<moves[7];i++) {
Zkey = Zkey^(p.toMove ? zobristKeys[moves[i]][0] : zobristKeys[moves[i]][1]);
value = -AlphaBeta(p, depth-1, -beta, -alpha, extension, mypv, Zkey, moves[i]);
p.undoMove(moves[i]);
Zkey = Zkey^(p.toMove ? zobristKeys[moves[i]][0] : zobristKeys[moves[i]][1]);
if(value>=beta) {
if(moves[7]==1) {
addHashEntries(Zkey, index, depth+extension-0.5, value, HASHBETA, moves[i]);
}
else {
addHashEntries(Zkey, index, depth+extension, value, HASHBETA, moves[i]);
}
if(debug) out.println("Beta-Cutoff. "+beta+" als Betawert gespeichert in "+index+" mit Zug "+moves[i]+" in Tiefe "+(moves[7]==1 ? (depth+extension-1) : (depth+extension)));
return beta;
}
if(value>alpha) {
hashflag = HASHEXACT;
alpha = value;
pv.setFirst(new MoveListElement(moves[i]));
if(mypv.length!=0) {
pv.setRest(mypv);
}
pv.length = mypv.length + 1;
}
}
if(moves[7]==1) {
addHashEntries(Zkey, index, depth+extension-0.5, alpha, hashflag, (hashflag == HASHEXACT ? pv.pop() : -1));
}
else {
addHashEntries(Zkey, index, depth+extension, alpha, hashflag, (hashflag == HASHEXACT ? pv.pop() : -1));
}
if(debug) out.println("Alpha-Update. "+alpha+" als "+(hashflag==HASHEXACT?"exakter Wert ":"Alphawert ")+"gespeichert in "+index+" mit Zug "+(hashflag == HASHEXACT ? pv.pop() : -1)+" in Tiefe "+(moves[7]==1 ? (depth+extension-1) : (depth+extension)));
return alpha;

}


/*
* Alpha-Beta mit variablen Feldgewichten (Rohfassung)
*/


public int bestimmeZug(Spielfeldeff p) throws IOException {

out.println(p);
out.println();

//startwerte für iterative deepening
nodecount[0] = 0;
nodecount[1] = 1;
nodecount[2] = 0;
nodecount[4] = 0;
nodecount[5] = zwischensumme;
boolean korrektur = false;

letzterundezug = -1;
letzterundewert = -1000;
bestmove = -1;

//initialisierung der felder
wfeld = new int[][] {{3, 4, 5, 5, 4, 3},{4, 6, 8, 8, 6, 4},{5, 8, 11, 11, 8, 5},{7, 10, 13, 13, 10, 7},{5, 8, 11, 11, 8, 5},{4, 6, 8, 8, 6, 4},{3, 4, 5, 5, 4, 3}};
sfeld = new int[][] {{3, 4, 5, 5, 4, 3},{4, 6, 8, 8, 6, 4},{5, 8, 11, 11, 8, 5},{7, 10, 13, 13, 10, 7},{5, 8, 11, 11, 8, 5},{4, 6, 8, 8, 6, 4},{3, 4, 5, 5, 4, 3}};
for(int i=0;i<69;i++) {
wuvierer[i] = false;
suvierer[i] = false;
}

//Zobrist-Key bauen und Possibilities testen
long Zkey = 0;
for(int i=0;i<42;i++) {
if((p.weissesteine & (0x0000000000400000L<<i))==(0x0000000000400000L<<i)) {
Zkey = Zkey^ZKEYS[i][0];
feldupdate(p, p.SCHWARZ, i%7, i/7, true);
} else if((p.schwarzesteine & (0x0000000000400000L<<i))==(0x0000000000400000L<<i)) {
Zkey = Zkey^ZKEYS[i][1];
feldupdate(p, p.WEISS, i%7, i/7, true);
}
}

for(int j=5;j>=0;j--) {
for(int i=0;i<7;i++) {
System.out.print(wfeld[i][j]+" ");
}
System.out.println();
}

System.out.println();

for(int j=5;j>=0;j--) {
for(int i=0;i<7;i++) {
System.out.print(sfeld[i][j]+" ");
}
System.out.println();
}

System.out.println();

int bisherbesterwert = 0;
suchtiefe = 1;
int alpha = -10000;
int beta = 10000;
ZugListe pv = new ZugListe();

for(int i=0;i<HASHSIZE;i++) {
HashTable1[i].clear();
HashTable2[i].clear();
}

if(p.anzahlSteine()<=3) {
for(int i=0;i<HASHSIZE;i++) {
HashTable3[i].clear();
}
}

if(buchaktiv && p.anzahlSteine()<8) { eroeffnung = true; } else { eroeffnung = false; }


while(!(suchtiefe>(42-p.anzahlSteine()))) {


korrektur = false;
nodecount[2] = nodecount[1];
nodecount[1] = nodecount[0];
nodecount[0] = 0;
nodecount[4] = 0;
gesamtevaluierungstiefe = 0;
maxtiefe = 100;
zahl = zahl2 = zahl3 = zahl4 = zahl5 = zahl7 = zahl8 = zahl9 = zahl10 = zahl11 = 0;

pv = new ZugListe();
long starttime = 0;
long duration = 0;

try {
while(true) {
System.out.println("Suchfenster: "+alpha+" bis "+beta);

starttime = System.currentTimeMillis();

bisherbesterwert = StartAlphaBeta(p,suchtiefe,alpha,beta,0,pv,Zkey);

duration = korrektur? duration + System.currentTimeMillis() - starttime : System.currentTimeMillis() - starttime;

if(bisherbesterwert<=alpha && !korrektur) {
korrektur = true;
alpha = -10000;
beta = bisherbesterwert + 2;
continue;
}
if(bisherbesterwert>=beta && !korrektur) {
korrektur = true;
beta = 10000;
alpha = bisherbesterwert - 2;
continue;
}
if(korrektur && (bisherbesterwert<=alpha || bisherbesterwert>=beta)) {
alpha = -10000;
beta = 10000;
continue;
}
if(bisherbesterwert==0) {
alpha = bisherbesterwert - 2;
beta = bisherbesterwert + 2;
}
if(bisherbesterwert>0 && bisherbesterwert<600) {
alpha = bisherbesterwert;
beta = bisherbesterwert + 2;
}
if(bisherbesterwert<0 && bisherbesterwert>-600) {
alpha = bisherbesterwert - 2;
beta = bisherbesterwert;
}
if(bisherbesterwert>600) {
alpha = bisherbesterwert-1;
beta = bisherbesterwert+1;
}
if(bisherbesterwert<-600) {
alpha = bisherbesterwert-1;
beta = bisherbesterwert+1;
}
break;
}
}
catch (TooManyNodesException t) {
duration = korrektur? duration + System.currentTimeMillis() - starttime : System.currentTimeMillis() - starttime;
gesamtdauer = gesamtdauer + duration;
nodecount[3] = nodecount[3] + nodecount[0];
nodecount[5] = nodecount[5] + nodecount[0];
System.out.println("Dauer: "+duration);
System.out.println("Gesamtdauer: "+gesamtdauer);
// out.println(zahl7);
// out.println("Dauer: "+duration);
// out.println("Gesamtdauer: "+gesamtdauer);
out.println();
out.println(letzterundezug);
out.println();
return letzterundezug;
}
letzterundezug = pv.pop();
letzterundewert = bisherbesterwert;

gesamtdauer = gesamtdauer + duration;
nodecount[3] = nodecount[3] + nodecount[0];
nodecount[5] = nodecount[5] + nodecount[0];

System.out.println("Bewertung in Tiefe "+suchtiefe+": "+bisherbesterwert);
System.out.println("Knoten: " + nodecount[3] + "; diese Runde " + nodecount[0] + "; diesen Zug "+ nodecount[5]);
out.println("Bewertung in Tiefe "+suchtiefe+": "+bisherbesterwert);
out.println("Knoten: " + nodecount[3] + "; diese Runde " + nodecount[0] + "; diesen Zug "+ nodecount[5]);
out.println("Gezaehlte Positionen: "+gezaehltepos+", durchschnittlich "+((double)gesamtzuganzahl)/gezaehltepos + " Zuege.");
int sum;
for(int i=0;i<7;i++) {
sum = 0;
for(int j=0;j<7;j++) {
sum += GEILO[i][j];
}
for(int j=0;j<7;j++) {
out.print(((double)GEILO[i][j]/sum)*100+" ");
}
out.println();
}
out.println();
/* System.out.println("Evaluierungstiefe: " + (suchtiefe-(gesamtevaluierungstiefe/nodecount[4])));
System.out.println("Maximale Tiefe: " + (suchtiefe-(maxtiefe)));
System.out.println("PV: "+pv);
System.out.println("erfolgreiche Eroeffnungsbuchzugriffe: "+zahl);
System.out.println("erfolglose Eroeffnungsbuchzugriffe: "+zahl2);
System.out.println("erfolgreiche Hashzugriffe: "+zahl3);
System.out.println("erfolglose Hashzugriffe: "+zahl4);
System.out.println("dabei wenigstens besten Zug gefunden: "+zahl5);
System.out.println("Recognized: "+zahl7);
System.out.println("Normal evaluiert: "+zahl8);*/
int ueberschrieben1 = 0;
int ueberschrieben2 = 0;
int ueberschrieben3 = 0;
for(int i=0;i<HASHSIZE;i++) {
if(HashTable1[i].depth != -1) { zahl9 += 1; ueberschrieben1 += HashTable1[i].ueberschrieben; }
if(HashTable2[i].depth != -1) { zahl10 += 1; ueberschrieben2 += HashTable2[i].ueberschrieben; }
if(HashTable3[i].depth != -1) { zahl11 += 1; ueberschrieben3 += HashTable3[i].ueberschrieben; }
}
/* System.out.println("HashTable1: "+zahl9+" Eintraege.");
System.out.println("HashTable2: "+zahl10+" Eintraege.");
System.out.println("HashTable3: "+zahl11+" Eintraege.");
System.out.println("HashTable1: durchschnittlich "+((double)ueberschrieben1/zahl9)+"mal beschrieben.");
System.out.println("HashTable2: durchschnittlich "+((double)ueberschrieben2/zahl10)+"mal beschrieben.");
System.out.println("HashTable3: durchschnittlich "+((double)ueberschrieben3/zahl11)+"mal beschrieben.");
System.out.println("Am Horizont angekommen: "+zahl12+" Mal.");
System.out.println("Dort gewonnen: "+zahl15+" Mal.");
System.out.println("Dort evaluiert: "+zahl13+" Mal.");
System.out.println("Dort weitergesucht: "+zahl14+" Mal.");
System.out.println("alleZuege: Vierer wird geschlossen - "+zahl16+" Mal.");
System.out.println("alleZuege: Vierer wird verhindert - "+zahl17+" Mal.");
System.out.println("alleZuege: mehrere Zuege werden erzeugt - "+zahl18+" Mal.");*/
System.out.println("Dauer: "+duration);
System.out.println("Gesamtdauer: "+gesamtdauer);
/* out.println("HashTable1: "+zahl9+" Einträge.");
out.println("HashTable2: "+zahl10+" Einträge.");
out.println("HashTable3: "+zahl11+" Einträge.");
out.println("HashTable1: durchschnittlich "+((double)ueberschrieben1/zahl9)+"mal beschrieben.");
out.println("HashTable2: durchschnittlich "+((double)ueberschrieben2/zahl10)+"mal beschrieben.");
out.println("HashTable3: durchschnittlich "+((double)ueberschrieben3/zahl11)+"mal beschrieben.");
out.println("Am Horizont angekommen: "+zahl12+" Mal.");
out.println("Dort gewonnen: "+zahl15+" Mal.");
out.println("Dort evaluiert: "+zahl13+" Mal.");
out.println("Dort weitergesucht: "+zahl14+" Mal.");
out.println("alleZuege: Vierer wird geschlossen - "+zahl16+" Mal.");
out.println("alleZuege: Vierer wird verhindert - "+zahl17+" Mal.");
out.println("alleZuege: mehrere Zuege werden erzeugt - "+zahl18+" Mal.");
out.println("Dauer: "+duration);
out.println("Gesamtdauer: "+gesamtdauer); */
out.println();
// System.out.println("Gezaehlte Positionen: "+gezaehltepos+", durchschnittlich "+((double)gesamtzuganzahl)/gezaehltepos + " Zuege.");
System.out.println();

if(bisherbesterwert>900 || bisherbesterwert<-900) {
break;
}

suchtiefe += 1;

}

if(bisherbesterwert<-900) {
if(!eroeffnung) {
out.println(letzterundezug);
out.println();
out.println();
return letzterundezug;
} else {
buchaktiv = false;
zwischensumme = nodecount[5];
for(int i=0;i<HASHSIZE;i++) {
HashTable3[i].clear();
}
int ergebnis = bestimmeZug(p);
for(int i=0;i<HASHSIZE;i++) {
HashTable3[i].clear();
}
zwischensumme = 0;
buchaktiv = true;
out.println(ergebnis);
out.println();
out.println();
return ergebnis;
}
} else {
out.println(letzterundezug);
out.println();
out.println();
return letzterundezug;
}

}

public int StartAlphaBeta(Spielfeldeff p, int tiefe, int alpha, int beta, double extension, ZugListe pv, long Zkey) throws IOException, TooManyNodesException {
if(debug) {
out.println("Startaufruf in Tiefe "+tiefe+", Extension "+extension +", alpha "+alpha+", beta "+beta);
out.println(p);
}

nodecount[0] += 1;
int hashflag = HASHALPHA;

//letzte Bits des Keys in Index umwandeln
int index = (int)Zkey&(HASHSIZE-1);
if(debug) {
out.println("Index "+index);
}

bestmove = -1;
if(HashTable1[index].key == Zkey) {
bestmove = HashTable1[index].move;
}
if(HashTable2[index].key == Zkey) {
bestmove = HashTable2[index].move;
}

if(debug) {
out.println("nicht gesucht und nicht gefunden.");
out.println("Bestmove "+bestmove);
}

if(bestmove!=-1) {
zahl5 += 1;
}

ZugListe mypv = new ZugListe();

int[] Zuege = alleZuege(p, suchtiefe-tiefe);
sortiere(Zuege, p);

gezaehltepos += 1;
gesamtzuganzahl += Zuege[7];

for(int i=0;i<Zuege[7];i++) {
System.out.print(Zuege[i]+" ");
}
System.out.println();

for(int i=0;i<Zuege.length;i++) {
out.print((Zuege[i])+" ");
}
out.println();

if(Zuege[7]==1) {
extension += 0.5;
if(debug) out.println("Nur ein Zug möglich. Extension wird erhöht");
}

int geilozug = -1;
int j = 0;

for(int i=0;i<Zuege[7];i++) {
Zkey = Zkey^(p.amZug == p.WEISS ? ZKEYS[Zuege[i]][0] : ZKEYS[Zuege[i]][1]);
feldupdate(p,!p.amZug,Zuege[i]%7,Zuege[i]/7,true);
int wert = -AlphaBeta(p, tiefe-1, -beta, -alpha, extension, mypv, Zkey, Zuege[i]);
p.undo(Zuege[i]);
feldupdate(p,!p.amZug,Zuege[i]%7,Zuege[i]/7,false);
Zkey = Zkey^(p.amZug == p.WEISS ? ZKEYS[Zuege[i]][0] : ZKEYS[Zuege[i]][1]);
if(wert>=beta) {
if(Zuege[7]==1) {
HashEintrag(Zkey, index, tiefe+extension-1, wert, HASHBETA, Zuege[i]);
}
else {
HashEintrag(Zkey, index, tiefe+extension, wert, HASHBETA, Zuege[i]);
}
if(debug) { out.println("Beta-Cutoff. "+beta+" als Betawert gespeichert in "+index+" mit Zug "+(Zuege[i])+" in Tiefe "+(Zuege[7]==1 ? (tiefe+extension-1):(tiefe+extension))); }
GEILO[Zuege[7]-1][i] += 1;
return beta;
}
if(wert>alpha) {
hashflag = HASHEXACT;
alpha = wert;
geilozug = i;
pv.setfirst(new ZugListenElement(Zuege[i]));
if(mypv.length!=0) {
pv.setrest(mypv);
}
pv.length = mypv.length + 1;
}
}
if(Zuege[7]==1) {
HashEintrag(Zkey, index, tiefe+extension-1, alpha, hashflag, (hashflag == HASHEXACT ? pv.pop() : -1));
}
else {
HashEintrag(Zkey, index, tiefe+extension, alpha, hashflag, (hashflag == HASHEXACT ? pv.pop() : -1));
}
if(hashflag==HASHEXACT) {
GEILO[Zuege[7]-1][geilozug] += 1;
}
if(debug) {
out.println("Alpha-Update. "+alpha+" als "+(hashflag==HASHEXACT?"exakter Wert ":"Alphawert ")+"gespeichert in "+index+" mit Zug "+(hashflag == HASHEXACT ? pv.pop() : -1)+" in Tiefe "+(Zuege[7]==1 ? (tiefe+extension-1):(tiefe+extension)));

out.println();
out.println("---");
out.println();
}
return alpha == -10000 ? -1000 : alpha;
}


//normal
public int AlphaBeta(Spielfeldeff p, int tiefe, int alpha, int beta, double extension, ZugListe pv, long Zkey, int Zug) throws IOException, TooManyNodesException {

if(nodecount[5]+nodecount[0]>613590) {
throw new TooManyNodesException();
}

p.ziehen(Zug);
if(debug) {
out.println();
out.println("Aufruf in Tiefe "+tiefe+", Extension "+extension+", alpha "+alpha+", beta "+beta+", Zug "+Zug);
out.println(p);
}

nodecount[0] += 1;

int hashflag = HASHALPHA;

//letzte Bits des Keys in Index umwandeln
int index = (int)Zkey&(HASHSIZE-1);
if(debug) {
out.println("Index "+index);
}

int value = -1;
bestmove = -1;
int newbeta = beta;
int newalpha = alpha;
if(HashTable2[index].key == Zkey) {
if(debug) out.println("in 2 gefunden.");
if(HashTable2[index].depth >= (tiefe+extension)) {
if(debug) out.println("Ausreichend in 2: Benoetigte Tiefe "+(tiefe+extension)+", vorgefundene Tiefe "+HashTable2[index].depth);
if(HashTable2[index].flag==HASHEXACT) {
if(debug) out.println("Exakter Wert in 1: "+HashTable2[index].value);
value = HashTable2[index].value;
}
if(HashTable2[index].flag==HASHALPHA && HashTable2[index].value <= alpha) {
if(debug) out.println("Alphawert in 1: "+alpha);
value = alpha;
}
if(HashTable2[index].flag==HASHALPHA && HashTable2[index].value < beta) {
newbeta = HashTable2[index].value;
if(debug) out.println("Beta-Update in 1: "+newbeta);
}
if(HashTable2[index].flag==HASHBETA && HashTable2[index].value >= beta) {
if(debug) out.println("Betawert in 1: "+beta);
value = beta;
}
if(HashTable2[index].flag==HASHBETA && HashTable2[index].value > alpha) {
newalpha = HashTable2[index].value;
if(debug) out.println("Alpha-Update in 1: "+newalpha);
}
}
if(debug) out.println("Bestmove in 2: "+HashTable2[index].move);
bestmove = HashTable2[index].move;
}
if(HashTable1[index].key == Zkey) {
if(debug) out.println("in 1 gefunden.");
if(HashTable1[index].depth >= (tiefe+extension)) {
if(debug) out.println("Ausreichend in 1: Benoetigte Tiefe "+(tiefe+extension)+", vorgefundene Tiefe "+HashTable1[index].depth);
if(HashTable1[index].flag==HASHEXACT) {
if(debug) out.println("Exakter Wert in 1: "+HashTable1[index].value);
value = HashTable1[index].value;
}
if(HashTable1[index].flag==HASHALPHA && HashTable1[index].value <= alpha) {
if(debug) out.println("Alphawert in 1: "+alpha);
value = alpha;
}
if(HashTable1[index].flag==HASHALPHA && HashTable1[index].value < beta) {
newbeta = HashTable1[index].value;
if(debug) out.println("Beta-Update in 1: "+newbeta);
}
if(HashTable1[index].flag==HASHBETA && HashTable1[index].value >= beta) {
if(debug) out.println("Betawert in 1: "+beta);
value = beta;
}
if(HashTable1[index].flag==HASHBETA && HashTable1[index].value > alpha) {
newalpha = HashTable1[index].value;
if(debug) out.println("Alpha-Update in 1: "+newalpha);
}
}
if(debug) out.println("Bestmove in 1: "+HashTable1[index].move);
bestmove = HashTable1[index].move;
}
if(HashTable3[index].key == Zkey) {
if(debug) out.println("in 3 gefunden.");
if(debug) out.println("Exakter Wert in 3: "+HashTable3[index].value);
value = HashTable3[index].value;
}
beta = newbeta;
alpha = newalpha;

if(value != -1) {
if(debug) {
out.println("Wert "+value+" wird zurueckgegeben.");
out.println();
}
zahl3 += 1;
nodecount[4] += 1;
gesamtevaluierungstiefe += tiefe;
pv.length = 0;
return value;
}
if(debug) {
out.println("Suche wird fortgesetzt.");
out.println("Bestmove "+bestmove);
}

zahl4 += 1;

if(bestmove!=-1) {
zahl5 += 1;
}

ZugListe mypv = new ZugListe();

if(tiefe < maxtiefe) {
maxtiefe = tiefe;
}

if(p.istgewonnen(!p.amZug,Zug)) {
if(debug) out.println("Ist verloren, "+(-1000+p.anzahlSteine())+" zurück und gespeichert in "+index+" in Tiefe "+(tiefe+extension));
nodecount[4] += 1;
gesamtevaluierungstiefe += tiefe;
pv.length = 0;
HashEintrag(Zkey, index, tiefe+extension, -1000+p.anzahlSteine(), HASHEXACT, -1);
return -1000+p.anzahlSteine();
}

if(p.istunentschieden()) {
if(debug) out.println("Ist unentschieden, 0 zurück und gespeichert in "+index+" in Tiefe "+(tiefe+extension));
nodecount[4] += 1;
gesamtevaluierungstiefe += tiefe;
pv.length = 0;
HashEintrag(Zkey, index, tiefe+extension, 0, HASHEXACT, -1);
return 0;
}

if(eroeffnung) {
if(p.anzahlSteine()==8) {
int datenbankwert = buchsuche(p);
if(datenbankwert != -1) {
if(debug) out.println("Ist in DB, "+datenbankwert+" zurück und gespeichert in "+index+" in Tiefe "+(tiefe+extension));
zahl += 1;
nodecount[4] += 1;
gesamtevaluierungstiefe += tiefe;
pv.length = 0;
HashEintrag(Zkey, index, tiefe+extension, datenbankwert, HASHEXACT, -1);
return datenbankwert;
}
zahl2 += 1;
}
}

int a = -1;
int b = -1;
int anzahlfreiespalten = 0;
for(int i=0;i<7;i++) {
if(p.Hoehe[i]!=6) {
anzahlfreiespalten += 1;
if(anzahlfreiespalten==3)
break;
if(anzahlfreiespalten==1)
a = i;
if(anzahlfreiespalten==2)
b = i;
}
}

//interior node recognition
if(anzahlfreiespalten==1 || (anzahlfreiespalten==2 && (b-a>=4))) {
if(akuterdreier(p,p.amZug)==-1 && akuterdreier(p,!p.amZug)==-1) {
int val = evaluate(p, true);
pv.length = 0;
if(debug) out.println("Ist recognized, "+val+" zurück und gespeichert in "+index+" in Tiefe "+(tiefe+extension));
HashEintrag(Zkey, index, tiefe+extension, val, HASHEXACT, -1);
return val;
}
}

//HIER:WAS PASSIERT, WENN KEINE VIERER MEHR MOEGLICH SIND

if(tiefe <= (0-extension)) {
nodecount[4] += 1;
gesamtevaluierungstiefe += tiefe;
pv.length = 0;
int val = evaluate(p, false);
HashEintrag(Zkey, index, tiefe+extension, val, HASHEXACT, -1);
if(debug) out.println("Horizont erreicht. Evaluiert, "+val+" zurück und gespeichert in "+index+" int Tiefe "+(tiefe+extension));
return val;
}

int[] Zuege = alleZuege(p, suchtiefe-tiefe);
sortiere(Zuege, p);

gezaehltepos += 1;
gesamtzuganzahl += Zuege[7];

if(Zuege[7]==1) {
extension += 0.5;
if(debug) out.println("Nur ein Zug möglich. Extension wird erhöht");
}

int geilozug = -1;

for(int i=0;i<Zuege[7];i++) {
Zkey = Zkey^(p.amZug ? ZKEYS[Zuege[i]][0] : ZKEYS[Zuege[i]][1]);
feldupdate(p,!p.amZug,Zuege[i]%7,Zuege[i]/7,true);
int wert = -AlphaBeta(p, tiefe-1, -beta, -alpha, extension, mypv, Zkey, Zuege[i]);
p.undo(Zuege[i]);
feldupdate(p,!p.amZug,Zuege[i]%7,Zuege[i]/7,false);
Zkey = Zkey^(p.amZug ? ZKEYS[Zuege[i]][0] : ZKEYS[Zuege[i]][1]);
if(wert>=beta) {
if(Zuege[7]==1) {
HashEintrag(Zkey, index, tiefe+extension-1, wert, HASHBETA, Zuege[i]);
}
else {
HashEintrag(Zkey, index, tiefe+extension, wert, HASHBETA, Zuege[i]);
}
if(debug) out.println("Beta-Cutoff. "+beta+" als Betawert gespeichert in "+index+" mit Zug "+Zuege[i]+" in Tiefe "+(Zuege[7]==1 ? (tiefe+extension-1) : (tiefe+extension)));
GEILO[Zuege[7]-1][i] += 1;
return beta;
}
if(wert>alpha) {
hashflag = HASHEXACT;
alpha = wert;
geilozug = i;
pv.setfirst(new ZugListenElement(Zuege[i]));
if(mypv.length!=0) {
pv.setrest(mypv);
}
pv.length = mypv.length + 1;
}
}
if(Zuege[7]==1) {
HashEintrag(Zkey, index, tiefe+extension-1, alpha, hashflag, (hashflag == HASHEXACT ? pv.pop() : -1));
}
else {
HashEintrag(Zkey, index, tiefe+extension, alpha, hashflag, (hashflag == HASHEXACT ? pv.pop() : -1));
}
if(debug) out.println("Alpha-Update. "+alpha+" als "+(hashflag==HASHEXACT?"exakter Wert ":"Alphawert ")+"gespeichert in "+index+" mit Zug "+(hashflag == HASHEXACT ? pv.pop() : -1)+" in Tiefe "+(Zuege[7]==1 ? (tiefe+extension-1) : (tiefe+extension)));
if(hashflag==HASHEXACT) {
GEILO[Zuege[7]-1][geilozug] += 1;
}
return alpha;

}


private void sortiere(int[] z, Spielfeldeff p) {

/* out.println(p);
for(int i=0;i<69;i++) {
if(wuvierer[i]) out.println("w "+(i+1));
if(suvierer[i]) out.println("s "+(i+1));
}*/

for(int i=0;i<z[7];i++) {
feldwerte[i] = wfeld[z[i]%7][p.Hoehe[z[i]%7]] + sfeld[z[i]%7][p.Hoehe[z[i]%7]];
}

int swap;
for(int i=z[7]-2;i>=0;i--) {
for(int j=0;j<=i;j++) {
if(feldwerte[j+1]>feldwerte[j]) {
swap = z[j+1];
z[j+1] = z[j];
z[j] = swap;
swap = feldwerte[j+1];
feldwerte[j+1] = feldwerte[j];
feldwerte[j] = swap;
}
}
}

if(bestmove!=-1) {
for(int i=0;i<z[7];i++) {
if(z[i]==bestmove) {
if(i<1) { break; }
for(int j=i;i>0;i--) {
z[i] = z[i-1];
}
z[0] = bestmove;
break;
}
}
}

}


private void feldupdate(Spielfeldeff p, boolean fuerwen, int i, int j, boolean setzen) {
boolean[] vierer = (fuerwen==p.WEISS ? wuvierer : suvierer);
int[][] feld = (fuerwen==p.WEISS ? wfeld : sfeld);
switch(i) {
case 0:
switch(j) {
case 0:
viererupdate(p,vierer,feld,0,setzen);
viererupdate(p,vierer,feld,21,setzen);
viererupdate(p,vierer,feld,45,setzen);
break;
case 1:
viererupdate(p,vierer,feld,0,setzen);
viererupdate(p,vierer,feld,7,setzen);
viererupdate(p,vierer,feld,25,setzen);
viererupdate(p,vierer,feld,49,setzen);
break;
case 2:
viererupdate(p,vierer,feld,0,setzen);
viererupdate(p,vierer,feld,7,setzen);
viererupdate(p,vierer,feld,14,setzen);
viererupdate(p,vierer,feld,29,setzen);
viererupdate(p,vierer,feld,53,setzen);
break;
case 3:
viererupdate(p,vierer,feld,0,setzen);
viererupdate(p,vierer,feld,7,setzen);
viererupdate(p,vierer,feld,14,setzen);
viererupdate(p,vierer,feld,33,setzen);
viererupdate(p,vierer,feld,57,setzen);
break;
case 4:
viererupdate(p,vierer,feld,7,setzen);
viererupdate(p,vierer,feld,14,setzen);
viererupdate(p,vierer,feld,37,setzen);
viererupdate(p,vierer,feld,61,setzen);
break;
case 5:
viererupdate(p,vierer,feld,14,setzen);
viererupdate(p,vierer,feld,41,setzen);
viererupdate(p,vierer,feld,65,setzen);
break;
default: System.out.println("MISTj"); break;
}
break;
case 1:
switch(j) {
case 0:
viererupdate(p,vierer,feld,1,setzen);
viererupdate(p,vierer,feld,21,setzen);
viererupdate(p,vierer,feld,22,setzen);
viererupdate(p,vierer,feld,46,setzen);
break;
case 1:
viererupdate(p,vierer,feld,1,setzen);
viererupdate(p,vierer,feld,8,setzen);
viererupdate(p,vierer,feld,25,setzen);
viererupdate(p,vierer,feld,26,setzen);
viererupdate(p,vierer,feld,45,setzen);
viererupdate(p,vierer,feld,50,setzen);
break;
case 2:
viererupdate(p,vierer,feld,1,setzen);
viererupdate(p,vierer,feld,8,setzen);
viererupdate(p,vierer,feld,15,setzen);
viererupdate(p,vierer,feld,29,setzen);
viererupdate(p,vierer,feld,30,setzen);
viererupdate(p,vierer,feld,49,setzen);
viererupdate(p,vierer,feld,54,setzen);
viererupdate(p,vierer,feld,57,setzen);
break;
case 3:
viererupdate(p,vierer,feld,1,setzen);
viererupdate(p,vierer,feld,8,setzen);
viererupdate(p,vierer,feld,15,setzen);
viererupdate(p,vierer,feld,33,setzen);
viererupdate(p,vierer,feld,34,setzen);
viererupdate(p,vierer,feld,53,setzen);
viererupdate(p,vierer,feld,58,setzen);
viererupdate(p,vierer,feld,61,setzen);
break;
case 4:
viererupdate(p,vierer,feld,8,setzen);
viererupdate(p,vierer,feld,15,setzen);
viererupdate(p,vierer,feld,37,setzen);
viererupdate(p,vierer,feld,38,setzen);
viererupdate(p,vierer,feld,62,setzen);
viererupdate(p,vierer,feld,65,setzen);
break;
case 5:
viererupdate(p,vierer,feld,15,setzen);
viererupdate(p,vierer,feld,41,setzen);
viererupdate(p,vierer,feld,42,setzen);
viererupdate(p,vierer,feld,66,setzen);
break;
default: System.out.println("MISTj"); break;
}
break;
case 2:
switch(j) {
case 0:
viererupdate(p,vierer,feld,2,setzen);
viererupdate(p,vierer,feld,21,setzen);
viererupdate(p,vierer,feld,22,setzen);
viererupdate(p,vierer,feld,23,setzen);
viererupdate(p,vierer,feld,47,setzen);
break;
case 1:
viererupdate(p,vierer,feld,2,setzen);
viererupdate(p,vierer,feld,9,setzen);
viererupdate(p,vierer,feld,25,setzen);
viererupdate(p,vierer,feld,26,setzen);
viererupdate(p,vierer,feld,27,setzen);
viererupdate(p,vierer,feld,46,setzen);
viererupdate(p,vierer,feld,51,setzen);
viererupdate(p,vierer,feld,57,setzen);
break;
case 2:
viererupdate(p,vierer,feld,2,setzen);
viererupdate(p,vierer,feld,9,setzen);
viererupdate(p,vierer,feld,16,setzen);
viererupdate(p,vierer,feld,29,setzen);
viererupdate(p,vierer,feld,30,setzen);
viererupdate(p,vierer,feld,31,setzen);
viererupdate(p,vierer,feld,45,setzen);
viererupdate(p,vierer,feld,50,setzen);
viererupdate(p,vierer,feld,55,setzen);
viererupdate(p,vierer,feld,58,setzen);
viererupdate(p,vierer,feld,61,setzen);
break;
case 3:
viererupdate(p,vierer,feld,2,setzen);
viererupdate(p,vierer,feld,9,setzen);
viererupdate(p,vierer,feld,16,setzen);
viererupdate(p,vierer,feld,33,setzen);
viererupdate(p,vierer,feld,34,setzen);
viererupdate(p,vierer,feld,35,setzen);
viererupdate(p,vierer,feld,49,setzen);
viererupdate(p,vierer,feld,54,setzen);
viererupdate(p,vierer,feld,59,setzen);
viererupdate(p,vierer,feld,62,setzen);
viererupdate(p,vierer,feld,65,setzen);
break;
case 4:
viererupdate(p,vierer,feld,9,setzen);
viererupdate(p,vierer,feld,16,setzen);
viererupdate(p,vierer,feld,37,setzen);
viererupdate(p,vierer,feld,38,setzen);
viererupdate(p,vierer,feld,39,setzen);
viererupdate(p,vierer,feld,53,setzen);
viererupdate(p,vierer,feld,63,setzen);
viererupdate(p,vierer,feld,66,setzen);
break;
case 5:
viererupdate(p,vierer,feld,16,setzen);
viererupdate(p,vierer,feld,41,setzen);
viererupdate(p,vierer,feld,42,setzen);
viererupdate(p,vierer,feld,43,setzen);
viererupdate(p,vierer,feld,67,setzen);
break;
default: System.out.println("MISTj"); break;
}
break;
case 3:
switch(j) {
case 0:
viererupdate(p,vierer,feld,3,setzen);
viererupdate(p,vierer,feld,21,setzen);
viererupdate(p,vierer,feld,22,setzen);
viererupdate(p,vierer,feld,23,setzen);
viererupdate(p,vierer,feld,24,setzen);
viererupdate(p,vierer,feld,48,setzen);
viererupdate(p,vierer,feld,57,setzen);
break;
case 1:
viererupdate(p,vierer,feld,3,setzen);
viererupdate(p,vierer,feld,10,setzen);
viererupdate(p,vierer,feld,25,setzen);
viererupdate(p,vierer,feld,26,setzen);
viererupdate(p,vierer,feld,27,setzen);
viererupdate(p,vierer,feld,28,setzen);
viererupdate(p,vierer,feld,47,setzen);
viererupdate(p,vierer,feld,52,setzen);
viererupdate(p,vierer,feld,58,setzen);
viererupdate(p,vierer,feld,61,setzen);
break;
case 2:
viererupdate(p,vierer,feld,3,setzen);
viererupdate(p,vierer,feld,10,setzen);
viererupdate(p,vierer,feld,17,setzen);
viererupdate(p,vierer,feld,29,setzen);
viererupdate(p,vierer,feld,30,setzen);
viererupdate(p,vierer,feld,31,setzen);
viererupdate(p,vierer,feld,32,setzen);
viererupdate(p,vierer,feld,46,setzen);
viererupdate(p,vierer,feld,51,setzen);
viererupdate(p,vierer,feld,56,setzen);
viererupdate(p,vierer,feld,59,setzen);
viererupdate(p,vierer,feld,62,setzen);
viererupdate(p,vierer,feld,65,setzen);
break;
case 3:
viererupdate(p,vierer,feld,3,setzen);
viererupdate(p,vierer,feld,10,setzen);
viererupdate(p,vierer,feld,17,setzen);
viererupdate(p,vierer,feld,33,setzen);
viererupdate(p,vierer,feld,34,setzen);
viererupdate(p,vierer,feld,35,setzen);
viererupdate(p,vierer,feld,36,setzen);
viererupdate(p,vierer,feld,45,setzen);
viererupdate(p,vierer,feld,50,setzen);
viererupdate(p,vierer,feld,55,setzen);
viererupdate(p,vierer,feld,60,setzen);
viererupdate(p,vierer,feld,63,setzen);
viererupdate(p,vierer,feld,66,setzen);
break;
case 4:
viererupdate(p,vierer,feld,10,setzen);
viererupdate(p,vierer,feld,17,setzen);
viererupdate(p,vierer,feld,37,setzen);
viererupdate(p,vierer,feld,38,setzen);
viererupdate(p,vierer,feld,39,setzen);
viererupdate(p,vierer,feld,40,setzen);
viererupdate(p,vierer,feld,49,setzen);
viererupdate(p,vierer,feld,54,setzen);
viererupdate(p,vierer,feld,64,setzen);
viererupdate(p,vierer,feld,67,setzen);
break;
case 5:
viererupdate(p,vierer,feld,17,setzen);
viererupdate(p,vierer,feld,41,setzen);
viererupdate(p,vierer,feld,42,setzen);
viererupdate(p,vierer,feld,43,setzen);
viererupdate(p,vierer,feld,44,setzen);
viererupdate(p,vierer,feld,53,setzen);
viererupdate(p,vierer,feld,68,setzen);
break;
default: System.out.println("MISTj"); break;
}
break;
case 4:
switch(j) {
case 0:
viererupdate(p,vierer,feld,4,setzen);
viererupdate(p,vierer,feld,22,setzen);
viererupdate(p,vierer,feld,23,setzen);
viererupdate(p,vierer,feld,24,setzen);
viererupdate(p,vierer,feld,58,setzen);
break;
case 1:
viererupdate(p,vierer,feld,4,setzen);
viererupdate(p,vierer,feld,11,setzen);
viererupdate(p,vierer,feld,26,setzen);
viererupdate(p,vierer,feld,27,setzen);
viererupdate(p,vierer,feld,28,setzen);
viererupdate(p,vierer,feld,48,setzen);
viererupdate(p,vierer,feld,59,setzen);
viererupdate(p,vierer,feld,62,setzen);
break;
case 2:
viererupdate(p,vierer,feld,4,setzen);
viererupdate(p,vierer,feld,11,setzen);
viererupdate(p,vierer,feld,18,setzen);
viererupdate(p,vierer,feld,30,setzen);
viererupdate(p,vierer,feld,31,setzen);
viererupdate(p,vierer,feld,32,setzen);
viererupdate(p,vierer,feld,47,setzen);
viererupdate(p,vierer,feld,52,setzen);
viererupdate(p,vierer,feld,60,setzen);
viererupdate(p,vierer,feld,63,setzen);
viererupdate(p,vierer,feld,66,setzen);
break;
case 3:
viererupdate(p,vierer,feld,4,setzen);
viererupdate(p,vierer,feld,11,setzen);
viererupdate(p,vierer,feld,18,setzen);
viererupdate(p,vierer,feld,34,setzen);
viererupdate(p,vierer,feld,35,setzen);
viererupdate(p,vierer,feld,36,setzen);
viererupdate(p,vierer,feld,46,setzen);
viererupdate(p,vierer,feld,51,setzen);
viererupdate(p,vierer,feld,56,setzen);
viererupdate(p,vierer,feld,64,setzen);
viererupdate(p,vierer,feld,67,setzen);
break;
case 4:
viererupdate(p,vierer,feld,11,setzen);
viererupdate(p,vierer,feld,18,setzen);
viererupdate(p,vierer,feld,38,setzen);
viererupdate(p,vierer,feld,39,setzen);
viererupdate(p,vierer,feld,40,setzen);
viererupdate(p,vierer,feld,50,setzen);
viererupdate(p,vierer,feld,55,setzen);
viererupdate(p,vierer,feld,68,setzen);
break;
case 5:
viererupdate(p,vierer,feld,18,setzen);
viererupdate(p,vierer,feld,42,setzen);
viererupdate(p,vierer,feld,43,setzen);
viererupdate(p,vierer,feld,44,setzen);
viererupdate(p,vierer,feld,54,setzen);
break;
default: System.out.println("MISTj"); break;
}
break;
case 5:
switch(j) {
case 0:
viererupdate(p,vierer,feld,5,setzen);
viererupdate(p,vierer,feld,23,setzen);
viererupdate(p,vierer,feld,24,setzen);
viererupdate(p,vierer,feld,59,setzen);
break;
case 1:
viererupdate(p,vierer,feld,5,setzen);
viererupdate(p,vierer,feld,12,setzen);
viererupdate(p,vierer,feld,27,setzen);
viererupdate(p,vierer,feld,28,setzen);
viererupdate(p,vierer,feld,60,setzen);
viererupdate(p,vierer,feld,63,setzen);
break;
case 2:
viererupdate(p,vierer,feld,5,setzen);
viererupdate(p,vierer,feld,12,setzen);
viererupdate(p,vierer,feld,19,setzen);
viererupdate(p,vierer,feld,31,setzen);
viererupdate(p,vierer,feld,32,setzen);
viererupdate(p,vierer,feld,48,setzen);
viererupdate(p,vierer,feld,64,setzen);
viererupdate(p,vierer,feld,67,setzen);
break;
case 3:
viererupdate(p,vierer,feld,5,setzen);
viererupdate(p,vierer,feld,12,setzen);
viererupdate(p,vierer,feld,19,setzen);
viererupdate(p,vierer,feld,35,setzen);
viererupdate(p,vierer,feld,36,setzen);
viererupdate(p,vierer,feld,47,setzen);
viererupdate(p,vierer,feld,52,setzen);
viererupdate(p,vierer,feld,68,setzen);
break;
case 4:
viererupdate(p,vierer,feld,12,setzen);
viererupdate(p,vierer,feld,19,setzen);
viererupdate(p,vierer,feld,39,setzen);
viererupdate(p,vierer,feld,40,setzen);
viererupdate(p,vierer,feld,51,setzen);
viererupdate(p,vierer,feld,56,setzen);
break;
case 5:
viererupdate(p,vierer,feld,19,setzen);
viererupdate(p,vierer,feld,43,setzen);
viererupdate(p,vierer,feld,44,setzen);
viererupdate(p,vierer,feld,55,setzen);
break;
default: System.out.println("MISTj"); break;
}
break;
case 6:
switch(j) {
case 0:
viererupdate(p,vierer,feld,6,setzen);
viererupdate(p,vierer,feld,24,setzen);
viererupdate(p,vierer,feld,60,setzen);
break;
case 1:
viererupdate(p,vierer,feld,6,setzen);
viererupdate(p,vierer,feld,13,setzen);
viererupdate(p,vierer,feld,28,setzen);
viererupdate(p,vierer,feld,64,setzen);
break;
case 2:
viererupdate(p,vierer,feld,6,setzen);
viererupdate(p,vierer,feld,13,setzen);
viererupdate(p,vierer,feld,20,setzen);
viererupdate(p,vierer,feld,32,setzen);
viererupdate(p,vierer,feld,68,setzen);
break;
case 3:
viererupdate(p,vierer,feld,6,setzen);
viererupdate(p,vierer,feld,13,setzen);
viererupdate(p,vierer,feld,20,setzen);
viererupdate(p,vierer,feld,36,setzen);
viererupdate(p,vierer,feld,48,setzen);
break;
case 4:
viererupdate(p,vierer,feld,13,setzen);
viererupdate(p,vierer,feld,20,setzen);
viererupdate(p,vierer,feld,40,setzen);
viererupdate(p,vierer,feld,52,setzen);
break;
case 5:
viererupdate(p,vierer,feld,20,setzen);
viererupdate(p,vierer,feld,44,setzen);
viererupdate(p,vierer,feld,56,setzen);
break;
default: System.out.println("MISTj"); break;
}
break;
default: System.out.println("MISTi");break;
}
}


private final void viererupdate(Spielfeldeff p, boolean[] vierer, int[][] feld, int i, boolean setzen) {
if(setzen && !vierer[i]) {
// out.println((vierer==wuvierer ? "w " : "s ")+(i+1)+" unmoeglich!");
vierer[i] = true;
for(int x=0;x<7;x=x+2) {
feld[VIERERFELD[i][x]][VIERERFELD[i][x+1]] -= 1;
}
}
if(!setzen && vierer[i]) {
long x = (vierer == wuvierer ? p.schwarzesteine : p.weissesteine);
if((x & (0x0000000000400000L<<(VIERERFELD[i][1]*7+VIERERFELD[i][0])))!=(0x0000000000400000L<<(VIERERFELD[i][1]*7+VIERERFELD[i][0]))
&& (x & (0x0000000000400000L<<(VIERERFELD[i][3]*7+VIERERFELD[i][2])))!=(0x0000000000400000L<<(VIERERFELD[i][3]*7+VIERERFELD[i][2]))
&& (x & (0x0000000000400000L<<(VIERERFELD[i][5]*7+VIERERFELD[i][4])))!=(0x0000000000400000L<<(VIERERFELD[i][5]*7+VIERERFELD[i][4]))
&& (x & (0x0000000000400000L<<(VIERERFELD[i][7]*7+VIERERFELD[i][6])))!=(0x0000000000400000L<<(VIERERFELD[i][7]*7+VIERERFELD[i][6]))) {
vierer[i] = false;
// out.println((vierer==wuvierer ? "w " : "s ")+(i+1)+" moeglich!");
for(int y=0;y<7;y=y+2) {
feld[VIERERFELD[i][y]][VIERERFELD[i][y+1]] += 1;
}
}
}
}


//nur in situationen anwendbar, in denen niemand gewonnen hat, und kein unentschieden vorliegt
private int evaluate(Spielfeldeff p, boolean recognized) {


//drohungen ermitteln (mehr effizienz möglich!!!)
getthreats(p, p.WEISS);
getthreats(p, p.SCHWARZ);

//array initialisieren
int[] hoehe = new int[7];
int gesamthoehe = 0;
outer: for(int i=0;i<7;i++) {
hoehe[i] = 6;
for(int j=0;j<6;j++) {
if(blackthreats[i][j] || whitethreats[i][j]) {
hoehe[i] = p.Hoehe[i];
gesamthoehe += hoehe[i];
continue outer;
}
}
gesamthoehe += 6;
}

if(gesamthoehe==42) {
return 0;
}

//gewinner feststellen, falls auf restlichem brett nichts passiert
boolean amZug = (gesamthoehe%2 == 0) ? p.WEISS : p.SCHWARZ;
int winner = p.LEER;

boolean gefunden = true;
outer: while(gefunden) {
gefunden = false;

//eigenen threat besetzen
for(int i=0;i<7;i++) {
if(hoehe[i]<6 && (amZug == p.WEISS ? whitethreats[i][hoehe[i]] : blackthreats[i][hoehe[i]])) {
winner = (amZug == p.WEISS ? p.WEISSERSTEIN : p.SCHWARZERSTEIN);
if(recognized) {
zahl7 += 1;
int res = (p.farbezuFigur(p.amZug())==winner) ? (699-gesamthoehe) : (-699+gesamthoehe);
return res;
} else {
zahl8 += 1;
int res = (p.farbezuFigur(p.amZug())==winner) ? (458+p.anzahlSteine()) : (-458-p.anzahlSteine());
return res;
}
}
}

//gegnerischen threat besetzen
for(int i=0;i<7;i++) {
if(hoehe[i]<6 && (amZug == p.WEISS ? blackthreats[i][hoehe[i]] : whitethreats[i][hoehe[i]])) {
hoehe[i] += 1;
amZug = !amZug;
gefunden = true;
continue outer;
}
}

//unkritisches feld besetzen
for(int i=0;i<7;i++) {
if((hoehe[i] == 5) || (hoehe[i]<5 && !blackthreats[i][hoehe[i]+1] && !whitethreats[i][hoehe[i]+1])) {
hoehe[i] += 1;
amZug = !amZug;
gefunden = true;
continue outer;
}
}

//unter eigene drohung ziehen, ungerade anzahl freier felder
for(int i=0;i<7;i++) {
if(hoehe[i]<5 && (amZug == p.WEISS ? !blackthreats[i][hoehe[i]+1] : !whitethreats[i][hoehe[i]+1]) && ((6-hoehe[i])%2==1)) {
hoehe[i] += 1;
amZug = !amZug;
gefunden = true;
continue outer;
}
}

//unter eigene drohung ziehen, gerade anzahl freier felder
for(int i=0;i<7;i++) {
if(hoehe[i]<5 && (amZug == p.WEISS ? !blackthreats[i][hoehe[i]+1] : !whitethreats[i][hoehe[i]+1])) {
hoehe[i] += 1;
amZug = !amZug;
gefunden = true;
continue outer;
}
}

//unter gegnerische drohung ziehen
for(int i=0;i<7;i++) {
if(hoehe[i]<5) {
hoehe[i] += 1;
amZug = !amZug;
gefunden = true;
continue outer;
}
}

break outer;

}

return 0;

}

//gibt selbst -1 zurück, falls s keinen akuten dreier in p hat, ansonsten den ersten gefundenen
private int akuterdreier(Spielfeldeff p, boolean s) {
long x = (s==p.WEISS ? p.weissesteine : p.schwarzesteine);
switch(p.Hoehe[0]) {
case 0: if((x & 0x0000000003800000L)==0x0000000003800000L) return 0;
if((x & 0x0000404040000000L)==0x0000404040000000L) return 0;
break;
case 1: if((x & 0x00000001C0000000L)==0x00000001C0000000L) return 7;
if((x & 0x0020202000000000L)==0x0020202000000000L) return 7;
break;
case 2: if((x & 0x000000E000000000L)==0x000000E000000000L) return 14;
if((x & 0x1010100000000000L)==0x1010100000000000L) return 14;
break;
case 3: if((x & 0x0000700000000000L)==0x0000700000000000L) return 21;
if((x & 0x0000002082000000L)==0x0000002082000000L) return 21;
if((x & 0x0000001020400000L)==0x0000001020400000L) return 21;
break;
case 4: if((x & 0x0038000000000000L)==0x0038000000000000L) return 28;
if((x & 0x0000104100000000L)==0x0000104100000000L) return 28;
if((x & 0x0000081020000000L)==0x0000081020000000L) return 28;
break;
case 5: if((x & 0x1C00000000000000L)==0x1C00000000000000L) return 35;
if((x & 0x0008208000000000L)==0x0008208000000000L) return 35;
if((x & 0x0004081000000000L)==0x0004081000000000L) return 35;
break;
default: break;
}
switch(p.Hoehe[1]) {
case 0: if((x & 0x0000000003400000L)==0x0000000003400000L) return 1;
if((x & 0x0000000007000000L)==0x0000000007000000L) return 1;
if((x & 0x0000808080000000L)==0x0000808080000000L) return 1;
break;
case 1: if((x & 0x00000001A0000000L)==0x00000001A0000000L) return 8;
if((x & 0x0000000380000000L)==0x0000000380000000L) return 8;
if((x & 0x0000404000400000L)==0x0000404000400000L) return 8;
if((x & 0x0040404000000000L)==0x0040404000000000L) return 8;
break;
case 2: if((x & 0x000000D000000000L)==0x000000D000000000L) return 15;
if((x & 0x000001C000000000L)==0x000001C000000000L) return 15;
if((x & 0x0020200020000000L)==0x0020200020000000L) return 15;
if((x & 0x2020200000000000L)==0x2020200000000000L) return 15;
if((x & 0x0000080082000000L)==0x0000080082000000L) return 15;
break;
case 3: if((x & 0x0000680000000000L)==0x0000680000000000L) return 22;
if((x & 0x0000E00000000000L)==0x0000E00000000000L) return 22;
if((x & 0x0000004104000000L)==0x0000004104000000L) return 22;
if((x & 0x0004004100000000L)==0x0004004100000000L) return 22;
if((x & 0x1010001000000000L)==0x1010001000000000L) return 22;
if((x & 0x0000002040800000L)==0x0000002040800000L) return 22;
break;
case 4: if((x & 0x0034000000000000L)==0x0034000000000000L) return 29;
if((x & 0x0070000000000000L)==0x0070000000000000L) return 29;
if((x & 0x0000208200000000L)==0x0000208200000000L) return 29;
if((x & 0x0200208000000000L)==0x0200208000000000L) return 29;
if((x & 0x0000102040000000L)==0x0000102040000000L) return 29;
break;
case 5: if((x & 0x1A00000000000000L)==0x1A00000000000000L) return 36;
if((x & 0x3800000000000000L)==0x3800000000000000L) return 36;
if((x & 0x0010410000000000L)==0x0010410000000000L) return 36;
if((x & 0x0008102000000000L)==0x0008102000000000L) return 36;
break;
default: break;
}
switch(p.Hoehe[2]) {
case 0: if((x & 0x0000000002C00000L)==0x0000000002C00000L) return 2;
if((x & 0x0000000006800000L)==0x0000000006800000L) return 2;
if((x & 0x000000000E000000L)==0x000000000E000000L) return 2;
if((x & 0x0001010100000000L)==0x0001010100000000L) return 2;
break;
case 1: if((x & 0x0000000160000000L)==0x0000000160000000L) return 9;
if((x & 0x0000000340000000L)==0x0000000340000000L) return 9;
if((x & 0x0000000700000000L)==0x0000000700000000L) return 9;
if((x & 0x0000082002000000L)==0x0000082002000000L) return 9;
if((x & 0x0000808000800000L)==0x0000808000800000L) return 9;
if((x & 0x0080808000000000L)==0x0080808000000000L) return 9;
break;
case 2: if((x & 0x000000B000000000L)==0x000000B000000000L) return 16;
if((x & 0x000001A000000000L)==0x000001A000000000L) return 16;
if((x & 0x0000038000000000L)==0x0000038000000000L) return 16;
if((x & 0x0000400040400000L)==0x0000400040400000L) return 16;
if((x & 0x0040400040000000L)==0x0040400040000000L) return 16;
if((x & 0x4040400000000000L)==0x4040400000000000L) return 16;
if((x & 0x0000100104000000L)==0x0000100104000000L) return 16;
if((x & 0x0004100100000000L)==0x0004100100000000L) return 16;
break;
case 3: if((x & 0x0000580000000000L)==0x0000580000000000L) return 23;
if((x & 0x0000D00000000000L)==0x0000D00000000000L) return 23;
if((x & 0x0001C00000000000L)==0x0001C00000000000L) return 23;
if((x & 0x0020002020000000L)==0x0020002020000000L) return 23;
if((x & 0x2020002000000000L)==0x2020002000000000L) return 23;
if((x & 0x0000008208000000L)==0x0000008208000000L) return 23;
if((x & 0x0008008200000000L)==0x0008008200000000L) return 23;
if((x & 0x0208008000000000L)==0x0208008000000000L) return 23;
if((x & 0x0000004081000000L)==0x0000004081000000L) return 23;
break;
case 4: if((x & 0x002C000000000000L)==0x002C000000000000L) return 30;
if((x & 0x0068000000000000L)==0x0068000000000000L) return 30;
if((x & 0x00E0000000000000L)==0x00E0000000000000L) return 30;
if((x & 0x0000410400000000L)==0x0000410400000000L) return 30;
if((x & 0x0400410000000000L)==0x0400410000000000L) return 30;
if((x & 0x1000101000000000L)==0x1000101000000000L) return 30;
if((x & 0x0000204080000000L)==0x0000204080000000L) return 30;
break;
case 5: if((x & 0x1600000000000000L)==0x1600000000000000L) return 37;
if((x & 0x3400000000000000L)==0x3400000000000000L) return 37;
if((x & 0x7000000000000000L)==0x7000000000000000L) return 37;
if((x & 0x0020820000000000L)==0x0020820000000000L) return 37;
if((x & 0x0010204000000000L)==0x0010204000000000L) return 37;
break;
default: break;
}
switch(p.Hoehe[3]) {
case 0: if((x & 0x0000000001C00000L)==0x0000000001C00000L) return 3;
if((x & 0x0000000005800000L)==0x0000000005800000L) return 3;
if((x & 0x000000000D000000L)==0x000000000D000000L) return 3;
if((x & 0x000000001C000000L)==0x000000001C000000L) return 3;
if((x & 0x0000082080000000L)==0x0000082080000000L) return 3;
if((x & 0x0002020200000000L)==0x0002020200000000L) return 3;
break;
case 1: if((x & 0x00000000E0000000L)==0x00000000E0000000L) return 10;
if((x & 0x00000002C0000000L)==0x00000002C0000000L) return 10;
if((x & 0x0000000680000000L)==0x0000000680000000L) return 10;
if((x & 0x0000000E00000000L)==0x0000000E00000000L) return 10;
if((x & 0x0000104004000000L)==0x0000104004000000L) return 10;
if((x & 0x0004104000000000L)==0x0004104000000000L) return 10;
if((x & 0x0001010001000000L)==0x0001010001000000L) return 10;
if((x & 0x0101010000000000L)==0x0101010000000000L) return 10;
break;
case 2: if((x & 0x0000007000000000L)==0x0000007000000000L) return 17;
if((x & 0x0000016000000000L)==0x0000016000000000L) return 17;
if((x & 0x0000034000000000L)==0x0000034000000000L) return 17;
if((x & 0x0000070000000000L)==0x0000070000000000L) return 17;
if((x & 0x0000800080800000L)==0x0000800080800000L) return 17;
if((x & 0x0080800080000000L)==0x0080800080000000L) return 17;
if((x & 0x8080800000000000L)==0x8080800000000000L) return 17;
if((x & 0x0000200208000000L)==0x0000200208000000L) return 17;
if((x & 0x0008200200000000L)==0x0008200200000000L) return 17;
if((x & 0x0208200000000000L)==0x0208200000000000L) return 17;
break;
case 3: if((x & 0x0000380000000000L)==0x0000380000000000L) return 24;
if((x & 0x0000B00000000000L)==0x0000B00000000000L) return 24;
if((x & 0x0001A00000000000L)==0x0001A00000000000L) return 24;
if((x & 0x0003800000000000L)==0x0003800000000000L) return 24;
if((x & 0x0000004040400000L)==0x0000004040400000L) return 24;
if((x & 0x0040004040000000L)==0x0040004040000000L) return 24;
if((x & 0x4040004000000000L)==0x4040004000000000L) return 24;
if((x & 0x0000010410000000L)==0x0000010410000000L) return 24;
if((x & 0x0010010400000000L)==0x0010010400000000L) return 24;
if((x & 0x0410010000000000L)==0x0410010000000000L) return 24;
if((x & 0x0000008102000000L)==0x0000008102000000L) return 24;
break;
case 4: if((x & 0x001C000000000000L)==0x001C000000000000L) return 31;
if((x & 0x0058000000000000L)==0x0058000000000000L) return 31;
if((x & 0x00D0000000000000L)==0x00D0000000000000L) return 31;
if((x & 0x01C0000000000000L)==0x01C0000000000000L) return 31;
if((x & 0x0000202020000000L)==0x0000202020000000L) return 31;
if((x & 0x2000202000000000L)==0x2000202000000000L) return 31;
if((x & 0x0000820800000000L)==0x0000820800000000L) return 31;
if((x & 0x0800820000000000L)==0x0800820000000000L) return 31;
if((x & 0x0000408100000000L)==0x0000408100000000L) return 31;
break;
case 5: if((x & 0x0E00000000000000L)==0x0E00000000000000L) return 38;
if((x & 0x2C00000000000000L)==0x2C00000000000000L) return 38;
if((x & 0x6800000000000000L)==0x6800000000000000L) return 38;
if((x & 0xE000000000000000L)==0xE000000000000000L) return 38;
if((x & 0x0010101000000000L)==0x0010101000000000L) return 38;
if((x & 0x0041040000000000L)==0x0041040000000000L) return 38;
if((x & 0x0020408000000000L)==0x0020408000000000L) return 38;
break;
default: break;
}
switch(p.Hoehe[4]) {
case 0: if((x & 0x0000000003800000L)==0x0000000003800000L) return 4;
if((x & 0x000000000B000000L)==0x000000000B000000L) return 4;
if((x & 0x000000001A000000L)==0x000000001A000000L) return 4;
if((x & 0x0000104100000000L)==0x0000104100000000L) return 4;
break;
case 1: if((x & 0x00000001C0000000L)==0x00000001C0000000L) return 11;
if((x & 0x0000000580000000L)==0x0000000580000000L) return 11;
if((x & 0x0000000D00000000L)==0x0000000D00000000L) return 11;
if((x & 0x0002020002000000L)==0x0002020002000000L) return 11;
if((x & 0x0000208008000000L)==0x0000208008000000L) return 11;
if((x & 0x0008208000000000L)==0x0008208000000000L) return 11;
break;
case 2: if((x & 0x000000E000000000L)==0x000000E000000000L) return 18;
if((x & 0x000002C000000000L)==0x000002C000000000L) return 18;
if((x & 0x0000068000000000L)==0x0000068000000000L) return 18;
if((x & 0x0001000101000000L)==0x0001000101000000L) return 18;
if((x & 0x0101000100000000L)==0x0101000100000000L) return 18;
if((x & 0x0000400410000000L)==0x0000400410000000L) return 18;
if((x & 0x0010400400000000L)==0x0010400400000000L) return 18;
if((x & 0x0410400000000000L)==0x0410400000000000L) return 18;
break;
case 3: if((x & 0x0000700000000000L)==0x0000700000000000L) return 25;
if((x & 0x0001600000000000L)==0x0001600000000000L) return 25;
if((x & 0x0003400000000000L)==0x0003400000000000L) return 25;
if((x & 0x0000008080800000L)==0x0000008080800000L) return 25;
if((x & 0x0080008080000000L)==0x0080008080000000L) return 25;
if((x & 0x8080008000000000L)==0x8080008000000000L) return 25;
if((x & 0x0020020800000000L)==0x0020020800000000L) return 25;
if((x & 0x0820020000000000L)==0x0820020000000000L) return 25;
if((x & 0x0000010204000000L)==0x0000010204000000L) return 25;
break;
case 4: if((x & 0x0038000000000000L)==0x0038000000000000L) return 32;
if((x & 0x00B0000000000000L)==0x00B0000000000000L) return 32;
if((x & 0x01A0000000000000L)==0x01A0000000000000L) return 32;
if((x & 0x0000404040000000L)==0x0000404040000000L) return 32;
if((x & 0x4000404000000000L)==0x4000404000000000L) return 32;
if((x & 0x1001040000000000L)==0x1001040000000000L) return 32;
if((x & 0x0000810200000000L)==0x0000810200000000L) return 32;
break;
case 5: if((x & 0x1C00000000000000L)==0x1C00000000000000L) return 39;
if((x & 0x5800000000000000L)==0x5800000000000000L) return 39;
if((x & 0xD000000000000000L)==0xD000000000000000L) return 39;
if((x & 0x0020202000000000L)==0x0020202000000000L) return 39;
if((x & 0x0040810000000000L)==0x0040810000000000L) return 39;
break;
default: break;
}
switch(p.Hoehe[5]) {
case 0: if((x & 0x0000000007000000L)==0x0000000007000000L) return 5;
if((x & 0x0000000016000000L)==0x0000000016000000L) return 5;
if((x & 0x0000208200000000L)==0x0000208200000000L) return 5;
break;
case 1: if((x & 0x0000000380000000L)==0x0000000380000000L) return 12;
if((x & 0x0000000B00000000L)==0x0000000B00000000L) return 12;
if((x & 0x0000410010000000L)==0x0000410010000000L) return 12;
if((x & 0x0010410000000000L)==0x0010410000000000L) return 12;
break;
case 2: if((x & 0x000001C000000000L)==0x000001C000000000L) return 19;
if((x & 0x0000058000000000L)==0x0000058000000000L) return 19;
if((x & 0x0002000202000000L)==0x0002000202000000L) return 19;
if((x & 0x0020800800000000L)==0x0020800800000000L) return 19;
if((x & 0x0820800000000000L)==0x0820800000000000L) return 19;
break;
case 3: if((x & 0x0000E00000000000L)==0x0000E00000000000L) return 26;
if((x & 0x0002C00000000000L)==0x0002C00000000000L) return 26;
if((x & 0x0000010101000000L)==0x0000010101000000L) return 26;
if((x & 0x0100010100000000L)==0x0100010100000000L) return 26;
if((x & 0x1040040000000000L)==0x1040040000000000L) return 26;
if((x & 0x0000020408000000L)==0x0000020408000000L) return 26;
break;
case 4: if((x & 0x0070000000000000L)==0x0070000000000000L) return 33;
if((x & 0x0160000000000000L)==0x0160000000000000L) return 33;
if((x & 0x0000808080000000L)==0x0000808080000000L) return 33;
if((x & 0x8000808000000000L)==0x8000808000000000L) return 33;
if((x & 0x0001020400000000L)==0x0001020400000000L) return 33;
break;
case 5: if((x & 0x3800000000000000L)==0x3800000000000000L) return 40;
if((x & 0xB000000000000000L)==0xB000000000000000L) return 40;
if((x & 0x0040404000000000L)==0x0040404000000000L) return 40;
if((x & 0x0081020000000000L)==0x0081020000000000L) return 40;
break;
default: break;
}
switch(p.Hoehe[6]) {
case 0: if((x & 0x000000000E000000L)==0x000000000E000000L) return 6;
if((x & 0x0000410400000000L)==0x0000410400000000L) return 6;
break;
case 1: if((x & 0x0000000700000000L)==0x0000000700000000L) return 13;
if((x & 0x0020820000000000L)==0x0020820000000000L) return 13;
break;
case 2: if((x & 0x0000038000000000L)==0x0000038000000000L) return 20;
if((x & 0x1041000000000000L)==0x1041000000000000L) return 20;
break;
case 3: if((x & 0x0001C00000000000L)==0x0001C00000000000L) return 27;
if((x & 0x0000020202000000L)==0x0000020202000000L) return 27;
if((x & 0x0000040810000000L)==0x0000040810000000L) return 27;
break;
case 4: if((x & 0x00E0000000000000L)==0x00E0000000000000L) return 34;
if((x & 0x0001010100000000L)==0x0001010100000000L) return 34;
if((x & 0x0002040800000000L)==0x0002040800000000L) return 34;
break;
case 5: if((x & 0x7000000000000000L)==0x7000000000000000L) return 41;
if((x & 0x0080808000000000L)==0x0080808000000000L) return 41;
if((x & 0x0102040000000000L)==0x0102040000000000L) return 41;
break;
default: break;
}
return -1;
}


private void getthreats(Spielfeldeff p, boolean s) {
long x = (s==p.WEISS ? p.weissesteine : p.schwarzesteine);
boolean[][] drohungen = (s==p.WEISS ? whitethreats : blackthreats);

switch(p.Hoehe[0]) {
case 0: if((x & 0x0000000003800000L)==0x0000000003800000L) drohungen[0][0]=true;
else if((x & 0x0000404040000000L)==0x0000404040000000L) drohungen[0][0]=true;
else drohungen[0][0] = false;

case 1: if((x & 0x00000001C0000000L)==0x00000001C0000000L) drohungen[0][1]=true;
else if((x & 0x0020202000000000L)==0x0020202000000000L) drohungen[0][1]=true;
else drohungen[0][1] = false;

case 2: if((x & 0x000000E000000000L)==0x000000E000000000L) drohungen[0][2]=true;
else if((x & 0x1010100000000000L)==0x1010100000000000L) drohungen[0][2]=true;
else drohungen[0][2] = false;

case 3: if((x & 0x0000700000000000L)==0x0000700000000000L) drohungen[0][3]=true;
else if((x & 0x0000002082000000L)==0x0000002082000000L) drohungen[0][3]=true;
else if((x & 0x0000001020400000L)==0x0000001020400000L) drohungen[0][3]=true;
else drohungen[0][3] = false;

case 4: if((x & 0x0038000000000000L)==0x0038000000000000L) drohungen[0][4]=true;
else if((x & 0x0000104100000000L)==0x0000104100000000L) drohungen[0][4]=true;
else if((x & 0x0000081020000000L)==0x0000081020000000L) drohungen[0][4]=true;
else drohungen[0][4] = false;

case 5: if((x & 0x1C00000000000000L)==0x1C00000000000000L) drohungen[0][5]=true;
else if((x & 0x0008208000000000L)==0x0008208000000000L) drohungen[0][5]=true;
else if((x & 0x0004081000000000L)==0x0004081000000000L) drohungen[0][5]=true;
else drohungen[0][5] = false;

default: break;
}
switch(p.Hoehe[1]) {
case 0: if((x & 0x0000000003400000L)==0x0000000003400000L) drohungen[1][0]=true;
else if((x & 0x0000000007000000L)==0x0000000007000000L) drohungen[1][0]=true;
else if((x & 0x0000808080000000L)==0x0000808080000000L) drohungen[1][0]=true;
else drohungen[1][0] = false;

case 1: if((x & 0x00000001A0000000L)==0x00000001A0000000L) drohungen[1][1]=true;
else if((x & 0x0000000380000000L)==0x0000000380000000L) drohungen[1][1]=true;
else if((x & 0x0000404000400000L)==0x0000404000400000L) drohungen[1][1]=true;
else if((x & 0x0040404000000000L)==0x0040404000000000L) drohungen[1][1]=true;
else drohungen[1][1] = false;

case 2: if((x & 0x000000D000000000L)==0x000000D000000000L) drohungen[1][2]=true;
else if((x & 0x000001C000000000L)==0x000001C000000000L) drohungen[1][2]=true;
else if((x & 0x0020200020000000L)==0x0020200020000000L) drohungen[1][2]=true;
else if((x & 0x2020200000000000L)==0x2020200000000000L) drohungen[1][2]=true;
else if((x & 0x0000080082000000L)==0x0000080082000000L) drohungen[1][2]=true;
else drohungen[1][2] = false;

case 3: if((x & 0x0000680000000000L)==0x0000680000000000L) drohungen[1][3]=true;
else if((x & 0x0000E00000000000L)==0x0000E00000000000L) drohungen[1][3]=true;
else if((x & 0x0000004104000000L)==0x0000004104000000L) drohungen[1][3]=true;
else if((x & 0x0004004100000000L)==0x0004004100000000L) drohungen[1][3]=true;
else if((x & 0x1010001000000000L)==0x1010001000000000L) drohungen[1][3]=true;
else if((x & 0x0000002040800000L)==0x0000002040800000L) drohungen[1][3]=true;
else drohungen[1][3] = false;

case 4: if((x & 0x0034000000000000L)==0x0034000000000000L) drohungen[1][4]=true;
else if((x & 0x0070000000000000L)==0x0070000000000000L) drohungen[1][4]=true;
else if((x & 0x0000208200000000L)==0x0000208200000000L) drohungen[1][4]=true;
else if((x & 0x0200208000000000L)==0x0200208000000000L) drohungen[1][4]=true;
else if((x & 0x0000102040000000L)==0x0000102040000000L) drohungen[1][4]=true;
else drohungen[1][4] = false;

case 5: if((x & 0x1A00000000000000L)==0x1A00000000000000L) drohungen[1][5]=true;
else if((x & 0x3800000000000000L)==0x3800000000000000L) drohungen[1][5]=true;
else if((x & 0x0010410000000000L)==0x0010410000000000L) drohungen[1][5]=true;
else if((x & 0x0008102000000000L)==0x0008102000000000L) drohungen[1][5]=true;
else drohungen[1][5] = false;

default: break;
}
switch(p.Hoehe[2]) {
case 0: if((x & 0x0000000002C00000L)==0x0000000002C00000L) drohungen[2][0]=true;
else if((x & 0x0000000006800000L)==0x0000000006800000L) drohungen[2][0]=true;
else if((x & 0x000000000E000000L)==0x000000000E000000L) drohungen[2][0]=true;
else if((x & 0x0001010100000000L)==0x0001010100000000L) drohungen[2][0]=true;
else drohungen[2][0] = false;

case 1: if((x & 0x0000000160000000L)==0x0000000160000000L) drohungen[2][1]=true;
else if((x & 0x0000000340000000L)==0x0000000340000000L) drohungen[2][1]=true;
else if((x & 0x0000000700000000L)==0x0000000700000000L) drohungen[2][1]=true;
else if((x & 0x0000082002000000L)==0x0000082002000000L) drohungen[2][1]=true;
else if((x & 0x0000808000800000L)==0x0000808000800000L) drohungen[2][1]=true;
else if((x & 0x0080808000000000L)==0x0080808000000000L) drohungen[2][1]=true;
else drohungen[2][1] = false;

case 2: if((x & 0x000000B000000000L)==0x000000B000000000L) drohungen[2][2]=true;
else if((x & 0x000001A000000000L)==0x000001A000000000L) drohungen[2][2]=true;
else if((x & 0x0000038000000000L)==0x0000038000000000L) drohungen[2][2]=true;
else if((x & 0x0000400040400000L)==0x0000400040400000L) drohungen[2][2]=true;
else if((x & 0x0040400040000000L)==0x0040400040000000L) drohungen[2][2]=true;
else if((x & 0x4040400000000000L)==0x4040400000000000L) drohungen[2][2]=true;
else if((x & 0x0000100104000000L)==0x0000100104000000L) drohungen[2][2]=true;
else if((x & 0x0004100100000000L)==0x0004100100000000L) drohungen[2][2]=true;
else drohungen[2][2] = false;

case 3: if((x & 0x0000580000000000L)==0x0000580000000000L) drohungen[2][3]=true;
else if((x & 0x0000D00000000000L)==0x0000D00000000000L) drohungen[2][3]=true;
else if((x & 0x0001C00000000000L)==0x0001C00000000000L) drohungen[2][3]=true;
else if((x & 0x0020002020000000L)==0x0020002020000000L) drohungen[2][3]=true;
else if((x & 0x2020002000000000L)==0x2020002000000000L) drohungen[2][3]=true;
else if((x & 0x0000008208000000L)==0x0000008208000000L) drohungen[2][3]=true;
else if((x & 0x0008008200000000L)==0x0008008200000000L) drohungen[2][3]=true;
else if((x & 0x0208008000000000L)==0x0208008000000000L) drohungen[2][3]=true;
else if((x & 0x0000004081000000L)==0x0000004081000000L) drohungen[2][3]=true;
else drohungen[2][3] = false;

case 4: if((x & 0x002C000000000000L)==0x002C000000000000L) drohungen[2][4]=true;
else if((x & 0x0068000000000000L)==0x0068000000000000L) drohungen[2][4]=true;
else if((x & 0x00E0000000000000L)==0x00E0000000000000L) drohungen[2][4]=true;
else if((x & 0x0000410400000000L)==0x0000410400000000L) drohungen[2][4]=true;
else if((x & 0x0400410000000000L)==0x0400410000000000L) drohungen[2][4]=true;
else if((x & 0x1000101000000000L)==0x1000101000000000L) drohungen[2][4]=true;
else if((x & 0x0000204080000000L)==0x0000204080000000L) drohungen[2][4]=true;
else drohungen[2][4] = false;

case 5: if((x & 0x1600000000000000L)==0x1600000000000000L) drohungen[2][5]=true;
else if((x & 0x3400000000000000L)==0x3400000000000000L) drohungen[2][5]=true;
else if((x & 0x7000000000000000L)==0x7000000000000000L) drohungen[2][5]=true;
else if((x & 0x0020820000000000L)==0x0020820000000000L) drohungen[2][5]=true;
else if((x & 0x0010204000000000L)==0x0010204000000000L) drohungen[2][5]=true;
else drohungen[2][5] = false;

default: break;
}
switch(p.Hoehe[3]) {
case 0: if((x & 0x0000000001C00000L)==0x0000000001C00000L) drohungen[3][0]=true;
else if((x & 0x0000000005800000L)==0x0000000005800000L) drohungen[3][0]=true;
else if((x & 0x000000000D000000L)==0x000000000D000000L) drohungen[3][0]=true;
else if((x & 0x000000001C000000L)==0x000000001C000000L) drohungen[3][0]=true;
else if((x & 0x0000082080000000L)==0x0000082080000000L) drohungen[3][0]=true;
else if((x & 0x0002020200000000L)==0x0002020200000000L) drohungen[3][0]=true;
else drohungen[3][0] = false;

case 1: if((x & 0x00000000E0000000L)==0x00000000E0000000L) drohungen[3][1]=true;
else if((x & 0x00000002C0000000L)==0x00000002C0000000L) drohungen[3][1]=true;
else if((x & 0x0000000680000000L)==0x0000000680000000L) drohungen[3][1]=true;
else if((x & 0x0000000E00000000L)==0x0000000E00000000L) drohungen[3][1]=true;
else if((x & 0x0000104004000000L)==0x0000104004000000L) drohungen[3][1]=true;
else if((x & 0x0004104000000000L)==0x0004104000000000L) drohungen[3][1]=true;
else if((x & 0x0001010001000000L)==0x0001010001000000L) drohungen[3][1]=true;
else if((x & 0x0101010000000000L)==0x0101010000000000L) drohungen[3][1]=true;
else drohungen[3][1] = false;

case 2: if((x & 0x0000007000000000L)==0x0000007000000000L) drohungen[3][2]=true;
else if((x & 0x0000016000000000L)==0x0000016000000000L) drohungen[3][2]=true;
else if((x & 0x0000034000000000L)==0x0000034000000000L) drohungen[3][2]=true;
else if((x & 0x0000070000000000L)==0x0000070000000000L) drohungen[3][2]=true;
else if((x & 0x0000800080800000L)==0x0000800080800000L) drohungen[3][2]=true;
else if((x & 0x0080800080000000L)==0x0080800080000000L) drohungen[3][2]=true;
else if((x & 0x8080800000000000L)==0x8080800000000000L) drohungen[3][2]=true;
else if((x & 0x0000200208000000L)==0x0000200208000000L) drohungen[3][2]=true;
else if((x & 0x0008200200000000L)==0x0008200200000000L) drohungen[3][2]=true;
else if((x & 0x0208200000000000L)==0x0208200000000000L) drohungen[3][2]=true;
else drohungen[3][2] = false;

case 3: if((x & 0x0000380000000000L)==0x0000380000000000L) drohungen[3][3]=true;
else if((x & 0x0000B00000000000L)==0x0000B00000000000L) drohungen[3][3]=true;
else if((x & 0x0001A00000000000L)==0x0001A00000000000L) drohungen[3][3]=true;
else if((x & 0x0003800000000000L)==0x0003800000000000L) drohungen[3][3]=true;
else if((x & 0x0000004040400000L)==0x0000004040400000L) drohungen[3][3]=true;
else if((x & 0x0040004040000000L)==0x0040004040000000L) drohungen[3][3]=true;
else if((x & 0x4040004000000000L)==0x4040004000000000L) drohungen[3][3]=true;
else if((x & 0x0000010410000000L)==0x0000010410000000L) drohungen[3][3]=true;
else if((x & 0x0010010400000000L)==0x0010010400000000L) drohungen[3][3]=true;
else if((x & 0x0410010000000000L)==0x0410010000000000L) drohungen[3][3]=true;
else if((x & 0x0000008102000000L)==0x0000008102000000L) drohungen[3][3]=true;
else drohungen[3][3] = false;

case 4: if((x & 0x001C000000000000L)==0x001C000000000000L) drohungen[3][4]=true;
else if((x & 0x0058000000000000L)==0x0058000000000000L) drohungen[3][4]=true;
else if((x & 0x00D0000000000000L)==0x00D0000000000000L) drohungen[3][4]=true;
else if((x & 0x01C0000000000000L)==0x01C0000000000000L) drohungen[3][4]=true;
else if((x & 0x0000202020000000L)==0x0000202020000000L) drohungen[3][4]=true;
else if((x & 0x2000202000000000L)==0x2000202000000000L) drohungen[3][4]=true;
else if((x & 0x0000820800000000L)==0x0000820800000000L) drohungen[3][4]=true;
else if((x & 0x0800820000000000L)==0x0800820000000000L) drohungen[3][4]=true;
else if((x & 0x0000408100000000L)==0x0000408100000000L) drohungen[3][4]=true;
else drohungen[3][4] = false;

case 5: if((x & 0x0E00000000000000L)==0x0E00000000000000L) drohungen[3][5]=true;
else if((x & 0x2C00000000000000L)==0x2C00000000000000L) drohungen[3][5]=true;
else if((x & 0x6800000000000000L)==0x6800000000000000L) drohungen[3][5]=true;
else if((x & 0xE000000000000000L)==0xE000000000000000L) drohungen[3][5]=true;
else if((x & 0x0010101000000000L)==0x0010101000000000L) drohungen[3][5]=true;
else if((x & 0x0041040000000000L)==0x0041040000000000L) drohungen[3][5]=true;
else if((x & 0x0020408000000000L)==0x0020408000000000L) drohungen[3][5]=true;
else drohungen[3][5] = false;

default: break;
}
switch(p.Hoehe[4]) {
case 0: if((x & 0x0000000003800000L)==0x0000000003800000L) drohungen[4][0]=true;
else if((x & 0x000000000B000000L)==0x000000000B000000L) drohungen[4][0]=true;
else if((x & 0x000000001A000000L)==0x000000001A000000L) drohungen[4][0]=true;
else if((x & 0x0000104100000000L)==0x0000104100000000L) drohungen[4][0]=true;
else drohungen[4][0] = false;

case 1: if((x & 0x00000001C0000000L)==0x00000001C0000000L) drohungen[4][1]=true;
else if((x & 0x0000000580000000L)==0x0000000580000000L) drohungen[4][1]=true;
else if((x & 0x0000000D00000000L)==0x0000000D00000000L) drohungen[4][1]=true;
else if((x & 0x0002020002000000L)==0x0002020002000000L) drohungen[4][1]=true;
else if((x & 0x0000208008000000L)==0x0000208008000000L) drohungen[4][1]=true;
else if((x & 0x0008208000000000L)==0x0008208000000000L) drohungen[4][1]=true;
else drohungen[4][1] = false;

case 2: if((x & 0x000000E000000000L)==0x000000E000000000L) drohungen[4][2]=true;
else if((x & 0x000002C000000000L)==0x000002C000000000L) drohungen[4][2]=true;
else if((x & 0x0000068000000000L)==0x0000068000000000L) drohungen[4][2]=true;
else if((x & 0x0001000101000000L)==0x0001000101000000L) drohungen[4][2]=true;
else if((x & 0x0101000100000000L)==0x0101000100000000L) drohungen[4][2]=true;
else if((x & 0x0000400410000000L)==0x0000400410000000L) drohungen[4][2]=true;
else if((x & 0x0010400400000000L)==0x0010400400000000L) drohungen[4][2]=true;
else if((x & 0x0410400000000000L)==0x0410400000000000L) drohungen[4][2]=true;
else drohungen[4][2] = false;

case 3: if((x & 0x0000700000000000L)==0x0000700000000000L) drohungen[4][3]=true;
else if((x & 0x0001600000000000L)==0x0001600000000000L) drohungen[4][3]=true;
else if((x & 0x0003400000000000L)==0x0003400000000000L) drohungen[4][3]=true;
else if((x & 0x0000008080800000L)==0x0000008080800000L) drohungen[4][3]=true;
else if((x & 0x0080008080000000L)==0x0080008080000000L) drohungen[4][3]=true;
else if((x & 0x8080008000000000L)==0x8080008000000000L) drohungen[4][3]=true;
else if((x & 0x0020020800000000L)==0x0020020800000000L) drohungen[4][3]=true;
else if((x & 0x0820020000000000L)==0x0820020000000000L) drohungen[4][3]=true;
else if((x & 0x0000010204000000L)==0x0000010204000000L) drohungen[4][3]=true;
else drohungen[4][3] = false;

case 4: if((x & 0x0038000000000000L)==0x0038000000000000L) drohungen[4][4]=true;
else if((x & 0x00B0000000000000L)==0x00B0000000000000L) drohungen[4][4]=true;
else if((x & 0x01A0000000000000L)==0x01A0000000000000L) drohungen[4][4]=true;
else if((x & 0x0000404040000000L)==0x0000404040000000L) drohungen[4][4]=true;
else if((x & 0x4000404000000000L)==0x4000404000000000L) drohungen[4][4]=true;
else if((x & 0x1001040000000000L)==0x1001040000000000L) drohungen[4][4]=true;
else if((x & 0x0000810200000000L)==0x0000810200000000L) drohungen[4][4]=true;
else drohungen[4][4] = false;

case 5: if((x & 0x1C00000000000000L)==0x1C00000000000000L) drohungen[4][5]=true;
else if((x & 0x5800000000000000L)==0x5800000000000000L) drohungen[4][5]=true;
else if((x & 0xD000000000000000L)==0xD000000000000000L) drohungen[4][5]=true;
else if((x & 0x0020202000000000L)==0x0020202000000000L) drohungen[4][5]=true;
else if((x & 0x0040810000000000L)==0x0040810000000000L) drohungen[4][5]=true;
else drohungen[4][5] = false;

default: break;
}
switch(p.Hoehe[5]) {
case 0: if((x & 0x0000000007000000L)==0x0000000007000000L) drohungen[5][0]=true;
else if((x & 0x0000000016000000L)==0x0000000016000000L) drohungen[5][0]=true;
else if((x & 0x0000208200000000L)==0x0000208200000000L) drohungen[5][0]=true;
else drohungen[5][0] = false;

case 1: if((x & 0x0000000380000000L)==0x0000000380000000L) drohungen[5][1]=true;
else if((x & 0x0000000B00000000L)==0x0000000B00000000L) drohungen[5][1]=true;
else if((x & 0x0000410010000000L)==0x0000410010000000L) drohungen[5][1]=true;
else if((x & 0x0010410000000000L)==0x0010410000000000L) drohungen[5][1]=true;
else drohungen[5][1] = false;

case 2: if((x & 0x000001C000000000L)==0x000001C000000000L) drohungen[5][2]=true;
else if((x & 0x0000058000000000L)==0x0000058000000000L) drohungen[5][2]=true;
else if((x & 0x0002000202000000L)==0x0002000202000000L) drohungen[5][2]=true;
else if((x & 0x0020800800000000L)==0x0020800800000000L) drohungen[5][2]=true;
else if((x & 0x0820800000000000L)==0x0820800000000000L) drohungen[5][2]=true;
else drohungen[5][2] = false;

case 3: if((x & 0x0000E00000000000L)==0x0000E00000000000L) drohungen[5][3]=true;
else if((x & 0x0002C00000000000L)==0x0002C00000000000L) drohungen[5][3]=true;
else if((x & 0x0000010101000000L)==0x0000010101000000L) drohungen[5][3]=true;
else if((x & 0x0100010100000000L)==0x0100010100000000L) drohungen[5][3]=true;
else if((x & 0x1040040000000000L)==0x1040040000000000L) drohungen[5][3]=true;
else if((x & 0x0000020408000000L)==0x0000020408000000L) drohungen[5][3]=true;
else drohungen[5][3] = false;

case 4: if((x & 0x0070000000000000L)==0x0070000000000000L) drohungen[5][4]=true;
else if((x & 0x0160000000000000L)==0x0160000000000000L) drohungen[5][4]=true;
else if((x & 0x0000808080000000L)==0x0000808080000000L) drohungen[5][4]=true;
else if((x & 0x8000808000000000L)==0x8000808000000000L) drohungen[5][4]=true;
else if((x & 0x0001020400000000L)==0x0001020400000000L) drohungen[5][4]=true;
else drohungen[5][4] = false;

case 5: if((x & 0x3800000000000000L)==0x3800000000000000L) drohungen[5][5]=true;
else if((x & 0xB000000000000000L)==0xB000000000000000L) drohungen[5][5]=true;
else if((x & 0x0040404000000000L)==0x0040404000000000L) drohungen[5][5]=true;
else if((x & 0x0081020000000000L)==0x0081020000000000L) drohungen[5][5]=true;
else drohungen[5][5] = false;

default: break;
}
switch(p.Hoehe[6]) {
case 0: if((x & 0x000000000E000000L)==0x000000000E000000L) drohungen[6][0]=true;
else if((x & 0x0000410400000000L)==0x0000410400000000L) drohungen[6][0]=true;
else drohungen[6][0] = false;

case 1: if((x & 0x0000000700000000L)==0x0000000700000000L) drohungen[6][1]=true;
else if((x & 0x0020820000000000L)==0x0020820000000000L) drohungen[6][1]=true;
else drohungen[6][1] = false;

case 2: if((x & 0x0000038000000000L)==0x0000038000000000L) drohungen[6][2]=true;
else if((x & 0x1041000000000000L)==0x1041000000000000L) drohungen[6][2]=true;
else drohungen[6][2] = false;

case 3: if((x & 0x0001C00000000000L)==0x0001C00000000000L) drohungen[6][3]=true;
else if((x & 0x0000020202000000L)==0x0000020202000000L) drohungen[6][3]=true;
else if((x & 0x0000040810000000L)==0x0000040810000000L) drohungen[6][3]=true;
else drohungen[6][3] = false;

case 4: if((x & 0x00E0000000000000L)==0x00E0000000000000L) drohungen[6][4]=true;
else if((x & 0x0001010100000000L)==0x0001010100000000L) drohungen[6][4]=true;
else if((x & 0x0002040800000000L)==0x0002040800000000L) drohungen[6][4]=true;
else drohungen[6][4] = false;

case 5: if((x & 0x7000000000000000L)==0x7000000000000000L) drohungen[6][5]=true;
else if((x & 0x0080808000000000L)==0x0080808000000000L) drohungen[6][5]=true;
else if((x & 0x0102040000000000L)==0x0102040000000000L) drohungen[6][5]=true;
else drohungen[6][5] = false;

default: break;
}
for(int i=0;i<=6;i++) {
for(int j=0;j<p.Hoehe[i];j++) {
drohungen[i][j] = false;
}
}
}


private int[] alleZuege(Spielfeldeff p, int tiefe) {
int b = akuterdreier(p, p.amZug);
if(b!=-1) {
zahl16 += 1;
Zuege[tiefe][7] = 1;
Zuege[tiefe][0] = b;
return Zuege[tiefe];
}
int a = akuterdreier(p, !p.amZug);
if(a!=-1) {
zahl17 += 1;
Zuege[tiefe][7] = 1;
Zuege[tiefe][0] = a;
return Zuege[tiefe];
}
zahl18 += 1;
int groesse = 0;
if(p.Hoehe[0]<6) {
Zuege[tiefe][groesse]=p.Hoehe[0]*7+0;
groesse += 1;
}
if(p.Hoehe[1]<6) {
Zuege[tiefe][groesse]=p.Hoehe[1]*7+1;
groesse += 1;
}
if(p.Hoehe[2]<6) {
Zuege[tiefe][groesse]=p.Hoehe[2]*7+2;
groesse += 1;
}
if(p.Hoehe[3]<6) {
Zuege[tiefe][groesse]=p.Hoehe[3]*7+3;
groesse += 1;
}
if(p.Hoehe[4]<6) {
Zuege[tiefe][groesse]=p.Hoehe[4]*7+4;
groesse += 1;
}
if(p.Hoehe[5]<6) {
Zuege[tiefe][groesse]=p.Hoehe[5]*7+5;
groesse += 1;
}
if(p.Hoehe[6]<6) {
Zuege[tiefe][groesse]=p.Hoehe[6]*7+6;
groesse += 1;
}
Zuege[tiefe][7] = groesse;
return Zuege[tiefe];
}

}

A A A | Drucken | Impressum | Sitemap | Suche | Mobile Version
zum Seitenanfangzum Seitenanfang