// --- Globale Konstanten ---
// --- Wegen dem §$&$§ IE darf ich keider nicht "const" benutzen, deswegen gibts halt "var" :/ ---

var axleveleasy = 2; var axlevelnormal = 3; var axlevelhard = 4;
var axflagblank = 0; var axflagyou = 1; var axflagcpu = 2; var axflagpillar = 3;
var axturnyou = 1; var axturncpu = 2;
var axpillarconfigurationmax = 8;
var axpieceselection = 0;
var axpieceplacement = 1;
/* var axgameboardwidth = 7; // Nur ungerade, minimal 5 bei easy, minimal 7 bei > easy und hard, maximal 9 
<-- geändert. hoffentlich treten bei mehr als 9 keine Fehler auf --- */
var axturncputimeout = 1000;
var axwinnerfoundtimeout = 300;
// --- Globale Variablen. ---
var axanimation = false;
var axgameover = false;
var axgamestarted = false;
var axcurrentlevel = axlevelnormal;
var axscoreyou = 0;
var axscorecpu = 0;
var axmaxposscore = 0;
var axturnwhos = axturnyou;
var axpillarconfiguration = 0;
var axpieceselectorplace = axpieceselection;
var axpieceselectionx = 0;
var axpieceselectiony = 0;
var axwinnerfoundmsgstate = 0;
var axyouwins = 0;
var axcpuwins = 0;
var axturncputimeoutid = 0;
var axwinnerfoundtimeoutid = 0;

// --- 2 Dimensionales Array für das Spielbrett erstellen. ---
var axcount = 0;
var axboardarray = new Array(axgameboardwidth);
for (axcount = 0; axcount < axgameboardwidth; axcount++) {
	axboardarray[axcount] = new Array(axgameboardwidth);	// 7*7 = 49 Felder = [0][0] bis [6][6].
}

// --- Alle Bilder laden, die im Dokument benutzt werden. ---
counteryou = new Image(); counteryou.src = "aximages/brainyou.gif";
counteryouno = new Image(); counteryouno.src = "aximages/brainyouno.gif";
counteryouyes = new Image(); counteryouyes.src = "aximages/brainyouyes.gif";
counteryounew = new Image(); counteryounew.src = "aximages/brainyounew.gif";
counteryoudie = new Image(); counteryoudie.src = "aximages/brainyoudie.gif";
counteryoukill = new Image(); counteryoukill.src = "aximages/brainyoukill.gif";

countercpu = new Image(); countercpu.src = "aximages/braincpu.gif";
countercpuno = new Image(); countercpuno.src = "aximages/braincpuno.gif";
countercpuno = new Image(); countercpuno.src = "aximages/braincpuno.gif";
countercpuyes = new Image(); countercpuyes.src = "aximages/braincpuyes.gif";
countercpunew = new Image(); countercpunew.src = "aximages/braincpunew.gif";
countercpudie = new Image(); countercpudie.src = "aximages/braincpudie.gif";
countercpukill = new Image(); countercpukill.src = "aximages/braincpukill.gif";

pillar = new Image(); pillar.src = "aximages/brainpillar.gif";

number0 = new Image(); number0.src = "aximages/0.gif";
number1 = new Image(); number1.src = "aximages/1.gif";
number2 = new Image(); number2.src = "aximages/2.gif";
number3 = new Image(); number3.src = "aximages/3.gif";
number4 = new Image(); number4.src = "aximages/4.gif";
number5 = new Image(); number5.src = "aximages/5.gif";
number6 = new Image(); number6.src = "aximages/6.gif";
number7 = new Image(); number7.src = "aximages/7.gif";
number8 = new Image(); number8.src = "aximages/8.gif";
number9 = new Image(); number9.src = "aximages/9.gif";

easy1sel = new Image(); easy1sel.src = "aximages/braineasysel.gif";
normal1sel = new Image(); normal1sel.src = "aximages/brainnormalsel.gif";
hard1sel = new Image(); hard1sel.src = "aximages/brainhardsel.gif";
easy1desel = new Image(); easy1desel.src = "aximages/braineasydesel.gif";
normal1desel = new Image(); normal1desel.src = "aximages/brainnormaldesel.gif";
hard1desel = new Image(); hard1desel.src = "aximages/brainharddesel.gif";

pointerleftoff = new Image(); pointerleftoff.src = "aximages/brainpointerleftoff.gif";
pointerrightoff = new Image(); pointerrightoff.src = "aximages/brainpointerrightoff.gif";
pointerlefton = new Image(); pointerlefton.src = "aximages/brainpointerlefton.gif";
pointerrighton = new Image(); pointerrighton.src = "aximages/brainpointerrighton.gif";

youwin1off = new Image(); youwin1off.src = "aximages/brainpointerleftoff.gif";
cpuwin1off = new Image(); cpuwin1off.src = "aximages/brainpointerrightoff.gif";
youwin1on = new Image(); youwin1on.src = "aximages/brainpointerlefton.gif";
cpuwin1on = new Image(); cpuwin1on.src = "aximages/brainpointerrighton.gif";

blank = new Image(); blank.src = "aximages/blankx1y1.gif"; // temporär deaktiviert
// blank = new Image(); blank.src = "aximages/blankx2y2.gif"; // temporär aktiviert
pillarsel = new Image(); pillarsel.src = "aximages/pillarsel.gif";

animonsel = new Image(); animonsel.src = "aximages/brainanimonsel.gif";
animoffsel = new Image(); animoffsel.src = "aximages/brainanimoffsel.gif";
animondesel = new Image(); animondesel.src = "aximages/brainanimondesel.gif";
animoffdesel = new Image(); animoffdesel.src = "aximages/brainanimoffdesel.gif";

braineasy = new Image(); braineasy.src = "aximages/brain-scan-easy.jpg";
brainnormal = new Image(); brainnormal.src = "aximages/brain-scan-normal.jpg";
brainhard = new Image(); brainhard.src = "aximages/brain-scan-hard.jpg";

// ------------------------------------------------------------------
// Brett malen
// ------------------------------------------------------------------

// --- Das DIV kann entfallen, wenn man es selbst im HTML Code einträgt.
/* var myDIV = document.createElement("div");
var Ausgabebereich = document.body;
Ausgabebereich.appendChild(myDIV);
myDIV.setAttribute("id","Inhalt"); */
axdrawtable();

function axdrawtable(){
table = "";
tableWidth = 0;

for(var i=0;i<axgameboardwidth;i++)
{
	table += "<tr>\n";
	for(var j=0;j<axgameboardwidth;j++)
	{
		a = (i*100)+j;
		table += "<td width=\"50px\" height=\"50px\"><a href=\"javascript:axProcessBoardClick('" + a +"');\">"
		table += "<img src=\"aximages/" + blank + "\" id=\"board" + a +"\" alt=\"\" border=\"0\"></a></td>\n";
	}
	table += "</tr>\n";	
	tableWidth += 50;
}

table = "<table border=\"0\" width=\""+tableWidth+"px\" cellspacing=\"0\" cellpadding=\"0\">\n"+table+"</table>";
document.getElementById("Inhalt").innerHTML = table;
}


// ------------------------------------------------------------------
// Funktionen.
// ------------------------------------------------------------------

// ------------------------------------------------------------------
// Berechnungen nach Klick auf Stein.
// ------------------------------------------------------------------

// hierhin werden die Koordinaten in der Form xy übergeben. ---
function axProcessBoardClick(boardxy) {
	var colloop = 0; var rowloop = 0;
	var topx = 0; var topy = 0;
	var botx = 0; var boty = 0;
	var arrayindexx = 0; var arrayindexy = 0;
	var moveablepiece = false;
	
	// --- Spiel gestartet? ---
	if (!axgameover) {
		// --- Alle Klicks ausfiltern, so lange die CPU rechnet. ---
		if (axturnwhos == axturnyou) {
			// --- Die übergebenem Variablen in x,y trennen. ---
			arrayindexx = (boardxy - (boardxy % 100)) / 100;
			arrayindexy = boardxy % 100;
			// --- Hat der Spieler auf einen seiner Steine geklickt? ---
			if (axboardarray[arrayindexx][arrayindexy] == axflagyou) {
				// --- Kann der ausgewählte Stein bewegt werden? ---
				// --- Bewegungsrechteck Eckpunkte für den ausgewählten Stein erstellen. ---
				topx = arrayindexx - 2; if (topx < 0) topx = 0;
				topy = arrayindexy - 2; if (topy < 0) topy = 0;
				botx = arrayindexx + 2; if (botx > axgameboardwidth - 1) botx = axgameboardwidth - 1;
				boty = arrayindexy + 2; if (boty > axgameboardwidth - 1) boty = axgameboardwidth - 1;
				// --- Nach jedem möglichen Zug suchen. ---
				moveablepiece = false;
				for (rowloop = topy; rowloop <= boty; rowloop++) {
					for (colloop = topx; colloop <= botx; colloop++) {
						if (axboardarray[colloop][rowloop] == axflagblank) moveablepiece = true;
					}
				}
				// --- Anzeigen, dass der Stein bewegt werden darf. ---
				if (moveablepiece) {
					document.images["board" + boardxy].src = counteryouyes.src;
				} else {
					document.images["board" + boardxy].src = counteryouno.src;
				}
				// --- War der Stein schon ausgewält? ---
				if (axpieceselectorplace == axpieceplacement) {
					if (!(axpieceselectionx == arrayindexx && axpieceselectiony == arrayindexy)) {
						// --- Wiederherstellen des normalen, nicht ausgewählten Zustands. ---
						a=(axpieceselectionx*100) + axpieceselectiony;
						document.images["board" + a].src = counteryou.src;
					}
				}
				// --- Abspeichern der Steinposition und die Auswahl als komplett vermerken. ---
				axpieceselectionx = arrayindexx;
				axpieceselectiony = arrayindexy;
				axpieceselectorplace = axpieceplacement;
			} else {
				// --- Noch Auswahl des zu ziehenden Steins, oder schon Plazierung? ---
				if (axpieceselectorplace == axpieceplacement) {
					// --- Hat der Spieler auf ein leeres Feld geklickt? ---
					if (axboardarray[arrayindexx][arrayindexy] == axflagblank) {
						// --- Ist das leere Feld nicht weiter als 2 Felder entfernt? ---
						if (Math.abs(axpieceselectionx - arrayindexx) <= 2 && Math.abs(axpieceselectiony - arrayindexy) <= 2) {
							// --- Zug machen. ---
							axmakeamove(axpieceselectionx, axpieceselectiony, arrayindexx, arrayindexy, "you");
							// --- Ist das Board voll oder hat ein Spieler keine Steine mehr? ---
							axdisplayscores();	
							if (axfindawinner()) return;	// Ausstieg hier als Game over "Du". ---
							// --- Überprüfen, ob die CPU nicht in der Lage ist, einen Zug zu machen, bevor die Kontrolle zurück gegeben wird. ---
							if (axcheckplayercanmove("cpu")) {
								// --- Kontrolle an die CPU zurück geben. ---
								axturnwhos = axturncpu;
								axdisplaywhosturn("cpu");
								// --- Zugeständnis an die Langsamkeit der Spieler - man soll auch etwas erkennen können ;) ---
								axturncputimeoutid = setTimeout("axprocesscomputersturn()", axturncputimeout);
							} else {
								// --- "Du" kann noch einen Zug machen, da die CPU derzeit keinen machen kann. ---
								axpieceselectorplace = axpieceselection;
							}
						}
					}
				}
			}
		}
	}
}

function axprocesscomputersturn() {
	var colloop = 0; var rowloop = 0;
	var colloop2 = 0; var rowloop2 = 0;
	var colloop3 = 0; var rowloop3 = 0;
	var topx = 0; var topy = 0;
	var botx = 0; var boty = 0;
	var topx2 = 0; var topy2 = 0;
	var botx2 = 0; var boty2 = 0;

	// --- Ein Array (Eher eine Liste) erstellen, um alle möglichen CPU Züge zu speichern. ---
	var movearray = new Array(axgameboardwidth * axgameboardwidth * 24);	// Unmöglich zu erweitern ;) ---
	for (colloop = 0; colloop < axgameboardwidth * axgameboardwidth * 24; colloop++) {
		movearray[colloop] = new Array(3);
		movearray[colloop][0] = null;	// [x][0] = Zugwert (value). ---
		movearray[colloop][1] = 0;		// [x][1] = sourcexy  Start des Zuges. ---
		movearray[colloop][2] = 0;		// [x][2] = destxy  Ziel des Zuges. ---
	}
	var posmovecount = 0;	// Index zum Zugarray (movearray). ---
	var movevalue = 0;		// Wert, der zu diesem speziellen Zug gehört. ---
	var sourcex = 0; var sourcey = 0;
	var destx = 0; var desty = 0;
	var count = 0;
	var swaparray = new Array(3);
	var swapindex = 0;
		
	// --- Alla möglichen Züge ermitteln. ---
	for (rowloop = 0; rowloop < axgameboardwidth; rowloop++) {
		for (colloop = 0; colloop < axgameboardwidth; colloop++) {
			if (axboardarray[colloop][rowloop] == axflagcpu) {
				// --- Bewegungsrechteck um das ausgewählte Stück definieren. ---
				topx = colloop - 2; if (topx < 0) topx = 0;
				topy = rowloop - 2; if (topy < 0) topy = 0;
				botx = colloop + 2; if (botx > axgameboardwidth - 1) botx = axgameboardwidth - 1;
				boty = rowloop + 2; if (boty > axgameboardwidth - 1) boty = axgameboardwidth - 1;
				// --- Nach jedem möglichen Zug suchen (Freies Feld). ---
				for (rowloop2 = topy; rowloop2 <= boty; rowloop2++) {
					for (colloop2 = topx; colloop2 <= botx; colloop2++) {
						if (axboardarray[colloop2][rowloop2] == axflagblank) {
							// --- Zug speichern (Start und Ziel). ---
							a=b="";
							if (rowloop<10) a= "0";
							if (rowloop2<10) b= "0";
							movearray[posmovecount][1] = String(colloop)+ a + String(rowloop);		// Start des Zuges (sourceXY). ---
							movearray[posmovecount][2] = String(colloop2) + b + String(rowloop2);	// Ziel des Zuges (destXY). ---
							// --- Den Wert des Zuges bestimmen (oder initialisieren). ---
							if (Math.abs(colloop - colloop2) == 2 || Math.abs(rowloop - rowloop2) == 2) {
								movevalue = 0;	// Wenn der Zug über 2 Felder geht, ist er 0. ---
							} else {
								movevalue = 1;	// Wenn der Zug über 1 Feld geht, ist er 1. ---
							}
							// --- Hier werden ein paar Kleinigkeiten für die SCHWERe Stufe berechnet. ---
							if (Math.abs(colloop - colloop2) == 2 || Math.abs(rowloop - rowloop2) == 2) {
								if (axcurrentlevel == axlevelhard) {
									// --- Alle CPU Steine um den Startpunkt erkennen. ---
									topx2 = colloop - 1; if (topx2 < 0) topx2 = 0;
									topy2 = rowloop - 1; if (topy2 < 0) topy2 = 0;
									botx2 = colloop + 1; if (botx2 > axgameboardwidth - 1) botx2 = axgameboardwidth - 1;
									boty2 = rowloop + 1; if (boty2 > axgameboardwidth - 1) boty2 = axgameboardwidth - 1;
									// --- -1 für jeden angrenzenden CPU Stein. ---
									for (rowloop3 = topy2; rowloop3 <= boty2; rowloop3++) {
										for (colloop3 = topx2; colloop3 <= botx2; colloop3++) {
											if (axboardarray[colloop3][rowloop3] == axflagcpu) {
												// --- Den ziehenden Stein nicht mitzählen. ---
												if (!(colloop == colloop3 && rowloop == rowloop3)) movevalue--;
											}
										}
									}
								}
							}
							// --- Alle gegnerischen Steine um den Zielpunkt bestimmen. ---
							topx2 = colloop2 - 1; if (topx2 < 0) topx2 = 0;
							topy2 = rowloop2 - 1; if (topy2 < 0) topy2 = 0;
							botx2 = colloop2 + 1; if (botx2 > axgameboardwidth - 1) botx2 = axgameboardwidth - 1;
							boty2 = rowloop2 + 1; if (boty2 > axgameboardwidth - 1) boty2 = axgameboardwidth - 1;
							// --- +1 für jeden angrenzenden gegnerischen Stein. ---
							for (rowloop3 = topy2; rowloop3 <= boty2; rowloop3++) {
								for (colloop3 = topx2; colloop3 <= botx2; colloop3++) {
									if (axboardarray[colloop3][rowloop3] == axflagyou) movevalue++;
								}
							}
							movearray[posmovecount][0] = movevalue;
							posmovecount++;	// Und ab zum nächsten verfügbaren Array Elment. ---
						}
					}
				}
			}
		}
	}
	// --- Liste verwürfeln, damit der Rechnerzug nicht vorhersagbar wird. ---
	for (count = 0; count < posmovecount; count++) {
		swapindex = Math.round(Math.random() * (posmovecount - 1));
		swaparray[0] = movearray[count][0];
		swaparray[1] = movearray[count][1];
		swaparray[2] = movearray[count][2];
		movearray[count][0] = movearray[swapindex][0];
		movearray[count][1] = movearray[swapindex][1];
		movearray[count][2] = movearray[swapindex][2];
		movearray[swapindex][0] = swaparray[0];
		movearray[swapindex][1] = swaparray[1];
		movearray[swapindex][2] = swaparray[2];
	}	
	// --- Hier startet die "Künstliche Intelligenz" :) ---
	// --- Finde den besten Zug und nimm ihn. ---
	movevalue = -255;
	for (count = 0; count < posmovecount; count++) {
		if (axcurrentlevel != axleveleasy) {
			if (movearray[count][0] > movevalue) {
				movevalue = movearray[count][0];
				sourcex = (movearray[count][1] - (movearray[count][1] % 100)) / 100;
				sourcey = movearray[count][1] % 100;
				destx = (movearray[count][2] - (movearray[count][2] % 100)) / 100;
				desty = movearray[count][2] % 100;
			}
		}
		// --- Hier sind die LEICHTen Sachen zu finden. ---
		if (axcurrentlevel == axleveleasy) {
			// --- LEICHT ist eigentlich wie NORMAL, bloß dass er in ca der Hälfte aller Fälle den besten Zug verpasst. ---
			if (movearray[count][0] > movevalue) {
				if ((count == 0) || (Math.round(Math.random()) == 1 )) {
					movevalue = movearray[count][0];
					sourcex = (movearray[count][1] - (movearray[count][1] % 100)) / 100;
					sourcey = movearray[count][1] % 100;
					destx = (movearray[count][2] - (movearray[count][2] % 100)) / 100;
					desty = movearray[count][2] % 100;
				}
			}
		}
	}
	// --- Den Zug machen. ---
	axmakeamove(sourcex, sourcey, destx, desty, "cpu");
	// --- Ist das Board voll oder hat ein Spieler keine Steine mehr? ---
	axdisplayscores();	
	if (axfindawinner()) return;	// Hier der Ausstieg als Spiel beendet. ---
	// --- Überprüfen, ob der Spieler nicht ziehen kann, bevor die Kontrolle an die CPU übergeben wird. ---
	if (axcheckplayercanmove("you")) {
		// --- Kontrolle an den Spieler übergeben. ---
		axturnwhos = axturnyou;
		axdisplaywhosturn("you");
		axpieceselectorplace = axpieceselection;
	} else {
		// --- Die CPU kann einen weiteren Zug machen, da der Spieler nicht  ziehen kannn. ---
		// --- Und wieder der Timeout, da es sonst zu schnell zum beobachten ist. ---
		axturncputimeoutid = setTimeout("axprocesscomputersturn()", axturncputimeout);
	}
}

function axmakeamove(sourcex, sourcey, destx, desty, who) {
	if (destx<100)a = (destx*100)+desty;
	if (sourcex<100) b = (sourcex*100)+sourcey; 
	var colloop = 0; var rowloop = 0;
	var topx = 0; var topy = 0;
	var botx = 0; var boty = 0;
	var opponent = "you";
	
	if (who == "you") opponent = "cpu";	// Umkehren, wenn nötig. ---
	axboardarray[destx][desty] = eval("axflag" + who);
	axgamestarted = true;	// Globale Variable. Das Spiel wurde durch den ersten Zug wirklich gestartet. ---
	if (axanimation) {
		document.images["board" + a].src = eval("counter" + who + "new.src");
	} else {
		document.images["board" + a].src = eval("counter" + who + ".src");
	}
	// --- Ist es ein 2 Felder Zug? Wenn ja, wird der Startpunkt (source) aus dem Zähler entfernt. ---
	if (Math.abs(sourcex - destx) == 2 || Math.abs(sourcey - desty) == 2) {
		axboardarray[sourcex][sourcey] = axflagblank;
		if (axanimation) {
			document.images["board" + b].src = eval("counter" + who + "die.src");
		} else {
			document.images["board" + b].src = blank.src;
		}
	} else {
		// --- Jeden vorher ausgewählten Stein wieder herstellen. ---
		document.images["board" + b].src = eval("counter" + who + ".src");
	}
	// --- Alle Randsteine identifizieren. ---
	topx = destx - 1; if (topx < 0) topx = 0;
	topy = desty - 1; if (topy < 0) topy = 0;
	botx = destx + 1; if (botx > axgameboardwidth - 1) botx = axgameboardwidth - 1;
	boty = desty + 1; if (boty > axgameboardwidth - 1) boty = axgameboardwidth - 1;
	// --- Alle angrenzenden gegnerischen Steine identifizieren. ---
	for (rowloop = topy; rowloop <= boty; rowloop++) {
		for (colloop = topx; colloop <= botx; colloop++) {
			if (axboardarray[colloop][rowloop] == eval("axflag" + opponent)) {
				axboardarray[colloop][rowloop] = eval("axflag" + who);
				a=(colloop*100)+rowloop;
				if (axanimation) {
					document.images["board" + a].src = eval("counter" + who + "kill.src");
				} else {
					document.images["board" + a].src = eval("counter" + who + ".src");
				}
			}
		}
	}
}

function axcheckplayercanmove(who) {
	var colloop = 0; var rowloop = 0;
	var colloop2 = 0; var rowloop2 = 0;
	var topx = 0; var topy = 0;
	var botx = 0; var boty = 0;
	var moveablepiece = false;

	for (rowloop = 0; rowloop < axgameboardwidth; rowloop++) {
		for (colloop = 0; colloop < axgameboardwidth; colloop++) {
			if (axboardarray[colloop][rowloop] == eval("axflag" + who)) {
				// --- Bewegungsrechteck um die ausgewählten Steine erstellen. ---
				topx = colloop - 2; if (topx < 0) topx = 0;
				topy = rowloop - 2; if (topy < 0) topy = 0;
				botx = colloop + 2; if (botx > axgameboardwidth - 1) botx = axgameboardwidth - 1;
				boty = rowloop + 2; if (boty > axgameboardwidth - 1) boty = axgameboardwidth - 1;
				// --- Nach möglichem erlaubten Zug suchen. ---
				for (rowloop2 = topy; rowloop2 <= boty; rowloop2++) {
					for (colloop2 = topx; colloop2 <= botx; colloop2++) {
						if (axboardarray[colloop2][rowloop2] == axflagblank) moveablepiece = true;
					}
				}
			}
		}
	}
	return moveablepiece;
}

function axfindawinner() {
	if ((axscoreyou + axscorecpu == axmaxposscore) || (axscoreyou == 0 || axscorecpu == 0)) {
		axgameover = true;	// Globale Variable. ---
		// --- Unentschieden sind nicht möglich, da es immer eine ungerade Anzahl von Feldern ist. ---
		if (axscoreyou > axscorecpu) {
			axyouwins++;
			axdisplaywins();
			axwinnerfound("you");
		} else {
			axcpuwins++;
			axdisplaywins();
			axwinnerfound("cpu");
		}
		// Statistiken im Cookie speichern.	---
		cookiemanager("write", "axyouwins", axyouwins, 366);
		cookiemanager("write", "axcpuwins", axcpuwins, 366);
		return true;
	} else {
		return false;
	}
}

function axwinnerfound(who) {
	if (axgameover) {
		if (axwinnerfoundmsgstate == 0) {
			axwinnerfoundmsgstate = 1;
		//	document.images[who + "win1"].src = blank.src;
			document.images[who + "win1"].src = eval(who + "win1off.src");
		} else {
			axwinnerfoundmsgstate = 0;
		//	document.images[who + "win1"].src = eval(who + "win1off.src");
			document.images[who + "win1"].src = eval(who + "win1on.src");
		}
		// --- "Sieger" beim Spieler oder der CPU. ---
		axwinnerfoundtimeoutid = setTimeout("axwinnerfound('" + who + "')", axwinnerfoundtimeout);
	}
}


// ------------------------------------------------------------------
// Initialisierung start

function axreset() {
	var colloop = 0;
	var rowloop = 0;
	
	switch (axcurrentlevel) {
		case 2: 
			document.body.style.backgroundImage="url('aximages/brain-scan-easy-ataxx.jpg')";
			break;
		case 3: 
			document.body.style.backgroundImage="url('aximages/brain-scan-normal-ataxx.jpg')";
			break;
		case 4: 
			document.body.style.backgroundImage="url('aximages/brain-scan-hard-ataxx.jpg')";
			break;
		default:
			break;
	}
	

	// --- Getimte Operationen bereinigen, ansonsten können unerwartete Sachen passieren. ---
	clearTimeout(axturncputimeoutid);
	clearTimeout(axwinnerfoundtimeout);
	// --- Ein paart Default Werte setzen. ---
	axgameover = false;
	axgamestarted = false;
	axturnwhos = axturnyou;
	axpieceselectorplace = axpieceselection;
	axwinnerfoundmsgstate = 0;
	// --- Das Spielfeld initialisieren. ---
	for (rowloop = 0; rowloop < axgameboardwidth; rowloop++) {
		for (colloop = 0; colloop < axgameboardwidth; colloop++) {
			axboardarray[colloop][rowloop] = axflagblank;
		}
	}
	// --- Steine Defaults setzen. ---
	axboardarray[0][0] = axflagyou;
	axboardarray[axgameboardwidth - 1][axgameboardwidth - 1] = axflagyou;
	axboardarray[0][axgameboardwidth - 1] = axflagcpu;
	axboardarray[axgameboardwidth - 1][0] = axflagcpu;
	// --- Hindernisse setzen. ---
	if (axgameboardwidth < 7){axpillarconfiguration = axpillarconfigurationmax;}
	var a = 0;
	if ((axgameboardwidth - 7) > 0) {a = (axgameboardwidth -7) / 2;}
		switch (axpillarconfiguration) {
			
			case 0 :
				axboardarray[2+a][2+a] = axflagpillar;
				axboardarray[4+a][2+a] = axflagpillar;
				axboardarray[2+a][4+a] = axflagpillar;
				axboardarray[4+a][4+a] = axflagpillar;
				break;	
			case 1 :
				axboardarray[1+a][1+a] = axflagpillar;
				axboardarray[5+a][1+a] = axflagpillar;
				axboardarray[2+a][2+a] = axflagpillar;
				axboardarray[4+a][2+a] = axflagpillar;
				axboardarray[2+a][4+a] = axflagpillar;
				axboardarray[4+a][4+a] = axflagpillar;
				axboardarray[1+a][5+a] = axflagpillar;
				axboardarray[5+a][5+a] = axflagpillar;
				break;	
			case 2 :
				axboardarray[3+a][2+a] = axflagpillar;
				axboardarray[2+a][3+a] = axflagpillar;
				axboardarray[4+a][3+a] = axflagpillar;
				axboardarray[3+a][4+a] = axflagpillar;
				break;	
			case 3 :
				axboardarray[3+a][1+a] = axflagpillar;
				axboardarray[3+a][2+a] = axflagpillar;
				axboardarray[1+a][3+a] = axflagpillar;
				axboardarray[2+a][3+a] = axflagpillar;
				axboardarray[4+a][3+a] = axflagpillar;
				axboardarray[5+a][3+a] = axflagpillar;
				axboardarray[3+a][4+a] = axflagpillar;
				axboardarray[3+a][5+a] = axflagpillar;
				break;	
			case 4 :
				axboardarray[3+a][0+a] = axflagpillar;
				axboardarray[0+a][3+a] = axflagpillar;
				axboardarray[6+a][3+a] = axflagpillar;
				axboardarray[3+a][6+a] = axflagpillar;
				break;	
			case 5 :
				axboardarray[3+a][0+a] = axflagpillar;
				axboardarray[3+a][1+a] = axflagpillar;
				axboardarray[3+a][2+a] = axflagpillar;
				axboardarray[0+a][3+a] = axflagpillar;
				axboardarray[1+a][3+a] = axflagpillar;
				axboardarray[2+a][3+a] = axflagpillar;
				axboardarray[4+a][3+a] = axflagpillar;
				axboardarray[5+a][3+a] = axflagpillar;
				axboardarray[6+a][3+a] = axflagpillar;
				axboardarray[3+a][4+a] = axflagpillar;
				axboardarray[3+a][5+a] = axflagpillar;
				axboardarray[3+a][6+a] = axflagpillar;
				break;	
			case 6 :
				axboardarray[2+a][1+a] = axflagpillar;
				axboardarray[4+a][1+a] = axflagpillar;
				axboardarray[1+a][2+a] = axflagpillar;
				axboardarray[5+a][2+a] = axflagpillar;
				axboardarray[1+a][4+a] = axflagpillar;
				axboardarray[5+a][4+a] = axflagpillar;
				axboardarray[2+a][5+a] = axflagpillar;
				axboardarray[4+a][5+a] = axflagpillar;
				break;
			case 7 :
				axboardarray[2+a][0+a] = axflagpillar;
				axboardarray[4+a][0+a] = axflagpillar;
				axboardarray[0+a][2+a] = axflagpillar;
				axboardarray[6+a][2+a] = axflagpillar;
				axboardarray[0+a][4+a] = axflagpillar;
				axboardarray[6+a][4+a] = axflagpillar;
				axboardarray[2+a][6+a] = axflagpillar;
				axboardarray[4+a][6+a] = axflagpillar;
				break;
			default :
				break;
		}
	
	// --- Spielstand, Buttons usw. setzen. ---
	axdisplaygameboard();
	axdisplayscores();	
	axdisplaywins();
	axsetupdifficultybuttons();
	axdisplaywhosturn("you");
	axsetanimation();

	// --- Anzeige Hindernisauswahl zurücksetzen. ---
	for (colloop = 0; colloop <= axpillarconfigurationmax; colloop++) {
		document.images["pillar" + colloop].src = blank.src;
	}
	document.images["pillar" + axpillarconfiguration].src = pillarsel.src;
	// --- Sieger Anzeige zurücksetzen. ---
	// document.images["youwin1"].src = youwin1off.src;
	// document.images["cpuwin1"].src = cpuwin1off.src;
	document.images["youwin1"].src = youwin1off.src;
	document.images["cpuwin1"].src = cpuwin1off.src;
}
// Initialisierung end
// ------------------------------------------------------------------


// ------------------------------------------------------------------
// Anzeige start

function axdisplaygameboard() {
	var colloop = 0;
	var rowloop = 0;

	// --- Spielfeld auf den Bildschirm ausgeben. ---
	for (rowloop = 0; rowloop < axgameboardwidth; rowloop++) {
		for (colloop = 0; colloop < axgameboardwidth; colloop++) {
			a = (rowloop*100)+colloop;
			switch (axboardarray[colloop][rowloop]) {
				case axflagblank :
					document.images["board" + a].src = blank.src;
					break;			
				case axflagyou :
					if (axanimation) {
						document.images["board" + a].src = counteryounew.src;
					} else {
						document.images["board" + a].src = counteryou.src;
					}
					break;			
				case axflagcpu :
					if (axanimation) {
						document.images["board" + a].src = countercpunew.src;
					} else {
						document.images["board" + a].src = countercpu.src;
					}
					break;			
				case axflagpillar :
					document.images["board" + a].src = pillar.src;
					break;			
			}
		}
	}
}

function axdisplaywhosturn(who) {
	if (who == "you") {
		document.images["turnyou"].src = pointerlefton.src;
		document.images["turncpu"].src = pointerrightoff.src;
	} else {
		document.images["turnyou"].src = pointerleftoff.src;
		document.images["turncpu"].src = pointerrighton.src;
	}
}

function axdisplayscores() {
	var colloop = 0;
	var rowloop = 0;
	var numberindex = 0;

	// --- Die (globalen) Spielstände berechnen und speichern. ---
	axscoreyou = 0;	// Globale Variable. ---
	axscorecpu = 0;	// Globale Variable. ---
	axmaxposscore = 0;	// Globale Variable. ---
	for (rowloop = 0; rowloop < axgameboardwidth; rowloop++) {
		for (colloop = 0; colloop < axgameboardwidth; colloop++) {
			if (axboardarray[colloop][rowloop] != axflagpillar) axmaxposscore++;
			if (axboardarray[colloop][rowloop] == axflagyou) axscoreyou++;
			if (axboardarray[colloop][rowloop] == axflagcpu) axscorecpu++;
		}
	}
	// ERRORFIX falls die Brettgröße > 31*31 Felder gewählt wird ;) ---
	if ((axscoreyou < 999)&&(axscorecpu < 999)) {
	// --- Spielstände anzeigen. ---
	numberindex = (axscoreyou - (axscoreyou % 100)) / 100; // Hunderterstellen. ---
	document.images["scoreyou1"].src = eval("number" + numberindex + ".src");
	numberindex = ((axscoreyou % 100) - (axscoreyou % 10)) / 10; // Zehnerstellen. ---
	document.images["scoreyou2"].src = eval("number" + numberindex + ".src");
	numberindex = axscoreyou % 10; // Einerstellen. ---
	document.images["scoreyou3"].src = eval("number" + numberindex + ".src");

	numberindex = (axscorecpu - (axscorecpu % 100)) / 100; // Hunderterstellen. ---
	document.images["scorecpu1"].src = eval("number" + numberindex + ".src");
	numberindex = ((axscorecpu % 100) - (axscorecpu % 10)) / 10; // Zehnerstellen. ---
	document.images["scorecpu2"].src = eval("number" + numberindex + ".src");
	numberindex = axscorecpu % 10; // Einerstellen. ---
	document.images["scorecpu3"].src = eval("number" + numberindex + ".src");
	}
}

function axdisplaywins() {
	var numberindex = 0;
	// ERRORFIX falls jemand doch mehr als 999 Spiele gewinnt oder verliert ... ;) ---
	if ((axyouwins < 999) && (axcpuwins < 999)) {
	// Anzahl der Siege anzeigen (nur bei aktivierten Cookies) ---
	numberindex = (axyouwins - (axyouwins % 100)) / 100; // Hunderterstellen. ---
	document.images["winsyou1"].src = eval("number" + numberindex + ".src");
	numberindex = ((axyouwins % 100) - (axyouwins % 10)) / 10; // Zehnerstellen. ---
	document.images["winsyou2"].src = eval("number" + numberindex + ".src");
	numberindex = axyouwins % 10; // Einerstellen. ---
	document.images["winsyou3"].src = eval("number" + numberindex + ".src");

	numberindex = (axcpuwins - (axcpuwins % 100)) / 100; // Hunderterstellen. ---
	document.images["winscpu1"].src = eval("number" + numberindex + ".src");
	numberindex = ((axcpuwins % 100) - (axcpuwins % 10)) / 10; // Zehnerstellen. ---
	document.images["winscpu2"].src = eval("number" + numberindex + ".src");
	numberindex = axcpuwins % 10; // Einerstellen. ---
	document.images["winscpu3"].src = eval("number" + numberindex + ".src");
	}
}

function axsetupdifficultybuttons() {
	switch (axcurrentlevel) {
		case axleveleasy :
			document.images["easy1"].src = easy1sel.src;
			document.images["normal1"].src = normal1desel.src;
			document.images["hard1"].src = hard1desel.src;
			break;
		case axlevelnormal :
			document.images["easy1"].src = easy1desel.src;
			document.images["normal1"].src = normal1sel.src;
			document.images["hard1"].src = hard1desel.src;
			break;
		case axlevelhard :
			document.images["easy1"].src = easy1desel.src;
			document.images["normal1"].src = normal1desel.src;
			document.images["hard1"].src = hard1sel.src;
			break;
	}	
}

function axincpillarconfiguration(level) {
	if (axcurrentlevel == level) {
		axpillarconfiguration++;
		if (axpillarconfiguration > axpillarconfigurationmax) {
			axpillarconfiguration = 0
		}
	}
}

function axsetanimation() {
	if (axanimation) {
		document.images["animon"].src = animonsel.src;
		document.images["animoff"].src = animoffdesel.src;
	} else {
		document.images["animon"].src = animondesel.src;
		document.images["animoff"].src = animoffsel.src;
	}
}
// Anzeige end
// ------------------------------------------------------------------

function axresizeboard(){
	axboardarray = new Array(axgameboardwidth);
	for (axcount = 0; axcount < axgameboardwidth; axcount++) { 
		axboardarray[axcount] = new Array(axgameboardwidth);
	};
	for (rowloop = 0; rowloop < axgameboardwidth; rowloop++) {
		for (colloop = 0; colloop < axgameboardwidth; colloop++) {
			axboardarray[colloop][rowloop] = axflagblank;
		}
	}
	axdrawtable();
	axreset();
}

// ------------------------------------------------------------------
// Cookies.

function axresetcookie() {
	if (confirm("Bist Du sicher, dass Du das Cookie zurücksetzen willst?")) {
		cookiemanager('write', 'axyouwins', 0, 0);
		cookiemanager('write', 'axcpuwins', 0, 0);
	}
}

// ------------------------------------------------------------------
// Cookiemanager.
// ------------------------------------------------------------------
// Beim Einstieg:
//	action = "write" oder "read".
//	name = cookie name.
//	value = cookie value.
//	days = Verfallzeit in days.
// Beim Ausstieg:
//	Der Cookiemanager gibt den Wert "" beim lesen zurück, wenn kein Cookie da ist.
//	ANMERKUNG: Wenn man eine Nummer lesen will, ruft man sie so auf: -
//		mynum = Number(cookiemanager("read", bla, bla, bla))

function cookiemanager(action, name, value, days) {
	var cookiestring = document.cookie;
	var cookie = cookiestring.split(';');
	var cookiesize = cookie.length;
	var cookieloop = 0;
	var cookienamesvaluesarray = "";
	var cookievalue = "";
	var expires = new Date();
	var expirydays = expires.getTime() + (days * 24 * 60 * 60 * 1000);
	expires.setTime(expirydays);
	
	if (action == 'write') {
		document.cookie = name + "=" + value + "; expires=" + expires.toGMTString();
	} else {
		if (action == 'read') {
			for (cookieloop = 0; cookieloop < cookiesize; cookieloop++) {
				cookienamesvaluesarray = cookie[cookieloop].split("=");
				cookievalue = cookienamesvaluesarray[0];
				if (cookievalue.substr(0,1) == " ") cookievalue = cookievalue.substr(1);
				if (cookievalue == name) return cookienamesvaluesarray[1];
			}
			return "";
		}	
	}
}