Chess-Engine/evalutation.cpp at main · RedHerisson/Chess-Engine · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
#include "game.h"


float Game::eval(bool team) {

	int evalPoint = 0;
	float MaterialPoint = 0;
	int nbrPiece[2];
	nbrPiece[0] = 0;
	nbrPiece[1] = 0;
	int boardPoint[8][8] = {
		{0,0,0,0,0,0,0,0},
		{0,0,0,0,0,0,0,0},
		{0,0,1,1,1,1,0,0},
		{0,0,1,2,2,1,0,0},
		{0,0,1,2,2,1,0,0},
		{0,0,1,1,1,1,0,0},
		{0,0,0,0,0,0,0,0},
		{0,0,0,0,0,0,0,0}
	};
	for (auto piece : PieceList) {
		MaterialPoint += eval_pieceWeight(team, piece);
		//evalPoint += eval_centerPosition(team, piece, boardPoint);
		if (piece.getifAlive()) {
			if (piece.getTeam() == 0) nbrPiece[0]++;
			else nbrPiece[1]++;
		}
	}
	MaterialPoint = (150 * MaterialPoint) / (97 * ((abs(MaterialPoint) / 970) + 1));

	evalPoint += MaterialPoint;
	if (nbrPiece[team] <= 3) evalPoint -= eval_lateGameMat(!team);
	if (nbrPiece[!team] <= 3) evalPoint += eval_lateGameMat(team);
	//evalPoint += eval_kingProtection(team);
	evalPoint += eval_kingCheck(team);
	return evalPoint;
}

float Game::eval_pieceWeight(bool team, Piece piece) {
	float evalPoint = 0;
	if (piece.getifAlive()) {
		if (piece.getTeam() == team) {
			//if (piece.getType() == 2) return 400;
			return piece.getWeight();
		}
		else return ( - piece.getWeight());
	}
	return 0;
}

float Game::eval_centerPosition(bool team, Piece piece, int boardPoint[8][8]) {

	//std::cout << boardPoint[piece.getLocation().first][piece.getLocation().second] * piece.getWeight() << std::endl;
	return ((boardPoint[piece.getLocation().first][piece.getLocation().second] * piece.getWeight()*0.05)/m_nbrTour);


}
float Game::eval_kingProtection(bool team) {
	int evalPoint = 0;
	std::vector<position > kingMove;
	kingMove = checkKingMove(PieceList[kingId[team]].getLocation(), team);
	for (auto move : kingMove) {
		if (!m_board[move.first][move.second].isEmpty()) {
			if (PieceList[m_board[move.first][move.second].getPieceId()].getType() == 1) evalPoint += 1;
		}
	}

	return evalPoint *0.6* m_nbrTour * 20;
} // dep

float Game::eval_kingCheck(bool team) {

	int evalPoint = 0;

	if (m_kingInCheck[team]) {
		std::vector<position> kingMoveList = checkKingMove(PieceList[kingId[team]].getLocation(), team);
		int kingMoveNbr = kingMoveList.size(); /// nbr de cases dispo
		int tileOnCheck = 0;
		for (auto KingMove : kingMoveList) {
			if (checkCheckOnTile(KingMove, !team)) tileOnCheck++;
		}
		evalPoint -= 200 / (pow(10, -0.113636 * tileOnCheck) + 1) - 100;
		evalPoint -= 404.4 / (kingMoveNbr + 3);
	}

	if (m_kingInCheck[!team]) {

		std::vector<position> kingMoveList = checkKingMove(PieceList[kingId[!team]].getLocation(), !team);
		int kingMoveNbr = kingMoveList.size(); /// nbr de cases indispo
		int tileOnCheck = 0;
		for (auto KingMove : kingMoveList) {
			if (checkCheckOnTile(KingMove, team)) tileOnCheck++;
		}

		evalPoint += 200 / (pow(10, -0.113636 * tileOnCheck) + 1) - 100;
		evalPoint += 404.4 / (kingMoveNbr + 3);


	}

	return evalPoint;
}

float Game::eval_casltingBonus(bool team) {
	//if (m_stat.Castles == 1) return 75;
	return 0.0;
}
float Game::eval_pawnPromotionBonus(bool team) {
	return 0.0;
}

float eval_terrainOccupation(bool team) {
	return 0.0;
}

float Game::eval_lateGameMat(bool team) {
	float evalPoint = 0.0;
	int boardPoint[8][8] = {
		{5,4,3,3,3,3,4,5},
		{4,2,1,1,1,1,2,4},
		{3,1,0,0,0,0,1,3},
		{3,1,0,0,0,0,1,3},
		{3,1,0,0,0,0,1,3},
		{3,1,0,0,0,0,1,3},
		{4,2,1,1,1,1,2,4},
		{5,4,3,3,3,3,4,5}
	};
	evalPoint = 10* boardPoint[PieceList[kingId[!team]].getLocation().first][PieceList[kingId[!team]].getLocation().second];
	return evalPoint;
}