private static List <Board> allaDragFörPjäs(Board originalBoard, string färg, int x, int y)
{
List <Board> allaBoards = new List <Board>();
Pjäs pjäs = originalBoard.Pjäser[y, x];
//Om rutan innehåller en pjäs och pjäsens färg stämmer överens med rundans spelare
if (pjäs != null && pjäs.färg == färg)
{
//lägger till alla möjliga board från pjäsen till totala listan
allaBoards.AddRange(pjäs.allaMoves(originalBoard, x, y));
}
return(allaBoards);
}
private static List <Board> allaDrag(Board originalBoard, string färg)
{
List <Board> allaBoards = new List <Board>();
//Kollar alla möjliga board states utifrån varje pjäs
for (int x = 0; x < 8; x++)
{
for (int y = 0; y < 8; y++)
{
Pjäs pjäs = originalBoard.Pjäser[y, x];
//Om rutan innehåller en pjäs och pjäsens färg stämmer överens med rundans spelare
if (pjäs != null && pjäs.färg == färg)
{
//lägger till alla möjliga board från pjäsen till totala listan
allaBoards.AddRange(pjäs.allaMoves(originalBoard, x, y));
}
}
}
return(allaBoards);
}
private void selectPjäs(int x, int y)
{
if (flyttaPjäs)
{
return;
}
if (currentBoard.Pjäser[y, x] == null || currentBoard.Pjäser[y, x].färg == "Svart") //ska flytta egen pjäs
{
if (markeradPjäs != null)
{
Board testBoard = new Board();
testBoard.copyBoard(currentBoard);
testBoard.Pjäser[y, x] = testBoard.Pjäser[markeradIndexY, markeradIndexX];
testBoard.Pjäser[markeradIndexY, markeradIndexX] = null;
markeradPjäs = null;
markeradIndexY = 0;
markeradIndexX = 0;
selectRam.transform.position = new Vector3(20, 20);
if (Rekursiv.godkäntDrag(currentBoard, testBoard, 2, 0))
{
ändraBoard(currentBoard, testBoard);
}
}
}
else //markerar egen pjäs
{
if (markeradPjäs == currentBoard.Pjäser[y, x]) //klickar på markerad pjäs
{
markeradPjäs = null;
markeradIndexY = 0;
markeradIndexX = 0;
selectRam.transform.position = new Vector3(20, 20);
return;
}
markeradPjäs = currentBoard.Pjäser[y, x];
markeradIndexY = y;
markeradIndexX = x;
selectRam.transform.position = currentBoard.Pjäser[y, x].objekt.transform.position - new Vector3(0.5f, 0);
}
}
public void ändraBoard(Board originalBoard, Board slutBoard)
{
int xStart = 0;
int yStart = 0;
int xSlut = 0;
int ySlut = 0;
for (int y = 0; y < 8; y++)
{
for (int x = 0; x < 8; x++)
{
if (originalBoard.Pjäser[y, x] != null && slutBoard.Pjäser[y, x] == null) //om pjäs finns på original men inte på s**t
{
xStart = x;
yStart = y;
}
else if (slutBoard.Pjäser[y, x] != null && originalBoard.Pjäser[y, x] == null) //om pjäs finns på s**t men inte på original
{
xSlut = x;
ySlut = y;
}
else if (slutBoard.Pjäser[y, x] != null && originalBoard.Pjäser[y, x] != null)
{
if (!slutBoard.Pjäser[y, x].färg.Equals(originalBoard.Pjäser[y, x].färg)) //om pjäs har en färg på original och anna färg på s**t
{
xSlut = x;
ySlut = y;
tagenPjäs = originalBoard.Pjäser[ySlut, xSlut];
}
}
}
}
flyttObjekt = originalBoard.Pjäser[yStart, xStart];
flyttObjekt.objekt.GetComponent <SpriteRenderer>().sortingOrder = 3;
originalBoard.Pjäser[ySlut, xSlut] = originalBoard.Pjäser[yStart, xStart];
flyttPosition = new Vector2(xSlut - 4, 3 - ySlut);
startPosition = flyttObjekt.objekt.transform.position;
flyttaPjäs = true;
originalBoard.Pjäser[yStart, xStart] = null;
}
public void copyBoard(Board originalBoard)
{
for (int y = 0; y < 8; y++)
{
for (int x = 0; x < 8; x++)
{
Pjäs pjäs = originalBoard.Pjäser[y, x];
if (pjäs == null)
{
continue;
}
else if (pjäs is Bonde)
{
Pjäser[y, x] = new Bonde(pjäs.färg);
}
else if (pjäs is Torn)
{
Pjäser[y, x] = new Torn(pjäs.färg);
}
else if (pjäs is Häst)
{
Pjäser[y, x] = new Häst(pjäs.färg);
}
else if (pjäs is Löpare)
{
Pjäser[y, x] = new Löpare(pjäs.färg);
}
else if (pjäs is Kung)
{
Pjäser[y, x] = new Kung(pjäs.färg);
}
else if (pjäs is Dam)
{
Pjäser[y, x] = new Dam(pjäs.färg);
}
}
}
}
void Update()
{
botDragCount++;
if (botDragCount == 5)
{
botDrag();
}
if (flyttaPjäs)
{
GameObject.Find("chessIndicator").transform.position = new Vector2(25f, 25f);
flyttObjekt.objekt.transform.position += ((Vector3)(flyttPosition - startPosition)).normalized / 25;
if ((flyttPosition - (Vector2)flyttObjekt.objekt.transform.position).magnitude < 0.05f)
{
flyttObjekt.objekt.transform.position = flyttPosition;
if (tagenPjäs != null)
{
tagenPjäs.objekt.transform.position = new Vector2(20, 20);
if (tagenPjäs.färg == "Vit")
{
tagenPjäs.objekt.transform.position = new Vector2((antalTagnaVita % 3) - 7.1f, 3 - antalTagnaVita / 3);
antalTagnaVita++;
}
else
{
tagenPjäs.objekt.transform.position = new Vector2((antalTagnaSvarta % 3) - 7.1f, antalTagnaSvarta / 3 - 4);
antalTagnaSvarta++;
}
tagenPjäs = null;
}
flyttObjekt.objekt.GetComponent <SpriteRenderer>().sortingOrder = 0;
if (flyttObjekt.färg == "Vit")
{
botDragCount = 0;
}
if (Rekursiv.checkSchackmatt(currentBoard, 1, 0) || Rekursiv.checkSchackmatt(currentBoard, 1, 1))
{
botDragCount = 10;
GameObject.Find("Schackmatt").transform.position = new Vector2(5.6f, 0);
GameObject.Find("Playagain").transform.position = new Vector2(5.6f, -2.05f);
Destroy(turnIndicator);
Destroy(GameObject.Find("Bakknapp"));
Destroy(GameObject.Find("Reverseknapp"));
Destroy(GameObject.Find("ValdBit"));
Destroy(GameObject.Find("chessIndicator"));
if (flyttObjekt.färg != "Vit")
{
GetComponent <AudioSource>().Play();
}
}
//if (flyttObjekt.färg == "Vit")
//{
// botDragCount = 0;
// if (Rekursiv.checkSchackmatt(currentBoard, 1, 0))
// {
// Debug.Log("Schackmatt");
// botDragCount = 10;
// }
//}
//else
//{
// if (Rekursiv.checkSchackmatt(currentBoard, 1, 1))
// Debug.Log("Schackmatt");
//}
turnFärg++;
turnIndicator.GetComponent <SpriteRenderer>().color = new Color(turnFärg % 2, (turnFärg + 1) % 2, 0);
flyttaPjäs = false;
GameObject.Find("Scoreboard").GetComponentInChildren <TextMesh>().text = "Score: " + -currentBoard.boardVärde(true) / 100;
if (Rekursiv.checkSchackmatt(currentBoard, 2, 0) || Rekursiv.checkSchackmatt(currentBoard, 2, 1))
{
GameObject.Find("chessIndicator").transform.position = new Vector2(5.63f, -3.47f);
}
}
}
if (Input.GetButton("Fire1"))
{
klick = true;
}
else if (klick)
{
klick = false;
Vector2 musPosition = Camera.main.ScreenToWorldPoint(Input.mousePosition);
if (musPosition.x > -4.5f && musPosition.x < 3.5f && musPosition.y > -4.5f && musPosition.y < 3.5f)
{
selectPjäs((int)(musPosition.x + 4.5), (int)(3.5f - musPosition.y));
}
}
}
public static Board BästaDrag(Board originalBoard, int rekNivå, int svårhetsgrad, int alphaBetaVärde)
{
List <Board> allaBoard = new List <Board>();
int multiplier = ((rekNivå % 2) * 2) - 1; // om rekNivå är jämnt (player1:s runda) antar multiplier -1
int bästaVärde = -15000 * multiplier; //antar negativt värde om rekNivå är ojämt och positivt och rekNivå är jämnt
int allaBoardTotalCount = 0;
Board bästaBoard = new Board();
//om rekNivå är jämnt (player1:s runda)
//om fler boards ska framskaffas
for (int x = 0; x < 8; x++)
{
for (int y = 0; y < 8; y++)
{
Pjäs pjäs = originalBoard.Pjäser[y, x];
if (pjäs != null)
{
allaBoard = allaDragFörPjäs(originalBoard, färg[rekNivå % 2], x, y);
allaBoardTotalCount += allaBoard.Count;
if (rekNivå < svårhetsgrad)
{
foreach (Board board in allaBoard)
{
Board nyBoard = BästaDrag(board, rekNivå + 1, svårhetsgrad, bästaVärde);
int nyVärde = nyBoard.boardVärde(false);
if (nyVärde * multiplier > bästaVärde * multiplier) //letar största värde, för player1 är negativt bättre värde
{
bästaVärde = nyVärde;
bästaBoard = nyBoard;
if (rekNivå == 1) //vid första nivån skickar tillbaka det boardet som gav upphov till bästa boardet
{
bästaBoard = board;
}
}
if (bästaVärde * multiplier > alphaBetaVärde * multiplier)
{
goto skip;
}
}
}
//sista nivån, inte rekursiva fler boards
else
{
if (svårhetsgrad == 1)
{
foreach (Board board in allaBoard)
{
if (godkäntDrag(originalBoard, board, 2, 1))
{
int nyVärde = board.boardVärde(false);
if (nyVärde > bästaVärde) //letar största värde, för boten är negativt bättre värde
{
bästaBoard = board;
bästaVärde = nyVärde;
}
}
}
}
else
{
foreach (Board board in allaBoard)
{
int nyVärde = board.boardVärde(false);
if (nyVärde * multiplier > bästaVärde * multiplier) //letar största värde, för boten är negativt bättre värde
{
bästaBoard = board;
bästaVärde = nyVärde;
}
if (bästaVärde * multiplier > alphaBetaVärde * multiplier)
{
goto skip;
}
}
}
}
}
}
}
skip:
if (rekNivå == 3)
{
bästaBoard.rörelsehetsVärde = allaBoardTotalCount;
bästaBoard.connectionVärde = originalBoard.beräknaConnectionVärde();
}
return(bästaBoard);
}
