Board* MinimaxDecision(Board* board, int turn, clock_t st){
BoardQueue *q;
q = board->successor(turn);
cout << endl;
Board* tmpboard = NULL;
int tmpvalue = -99999;
int min;
while(!q->isEmpty()){
Board* b = q->dequeue();
min = MinValue(b, changeTurn(turn),st);
if(min > tmpvalue){
tmpvalue = min;
if(tmpboard != NULL){
Board* tmmp = tmpboard;
tmpboard = b;
delete tmmp;
}else{
tmpboard = b;
}
}else{
delete b;/////// Burayı control et hacıııı
}
}
tmpboard->resetLevel();
cout << "Min : " << tmpvalue << endl;
return tmpboard;
}
void Game::tryMovement(int vaoId, int caseX, int caseY)
{
Player ¤t = (turn == 1)?player1:player2;
Player &opponent = (turn == 1)?player2:player1;
Piece *current_piece = current.getPieceByVao(vaoId);
if (current_piece != nullptr)
{
std::cout << "--> Player " << turn << " selected vao" << vaoId << "(" << current_piece->getPosition()[0] << ";" << current_piece->getPosition()[1] << ") and clicked on cell (" << caseX << "," << caseY << ")" << std::endl;
if (current_piece->canMoveTo(caseX, caseY))
{
std::vector<int> tempPos = current_piece->getPosition();
current_piece->moveTo(caseX,caseY);
opponent.computeAvailableMovements(opponent.getPieces(),current.getPieces());
if (check(current, opponent, current.getKing()->getPosition()).size() == 0){
current_piece->moveTo(tempPos);
ejectPiece(caseX, caseY);
board.movePieceTo(current_piece->getVaoID(), caseX, caseY);
changeTurn();
}else{
std::cout << "\tMouvement non valide, votre roi est en échec !\n";
current_piece->moveTo(tempPos);
opponent.computeAvailableMovements(opponent.getPieces(),current.getPieces());
}
}
else{
std::cout << "\tMouvement non valide\n"; }
}
else
std::cout << "--> Player " << turn << " selected vao" << vaoId << " and clicked on cell (" << caseX << "," << caseY << ") VAO NULLPOINTER" << std::endl;
}
void GameMainWindow::newGame()
{
gameController = new GameController();
startDialog = new StartDialog(this);
this->setupConnections();
if(startDialog->exec() == QDialog::Accepted)
{
gameBoard = new GameBoard(this);
connect(gameController, SIGNAL(triggerPlanetLocate(Planet*, int, int)), gameBoard, SLOT(onAddPlanet(Planet*, int, int)));
connect(gameBoard, SIGNAL(changeTurn()), gameController, SLOT(onChangeTurn()));
connect(gameController, SIGNAL(displayControl(QString)), gameBoard, SLOT(onDisplayControl(QString)));
connect(gameController, SIGNAL(displayInfo(QString)), gameBoard, SLOT(onDisplayInfo(QString)));
connect(gameController, SIGNAL(displayShipNumber()), gameBoard, SLOT(onDisplayShipNumber()));
connect(gameBoard, SIGNAL(setFleetShipNumber(int)), gameController, SLOT(onSetFleetShipNumber(int)));
gameController->onStartGame();
fleetAction->setEnabled(true);
this->setCentralWidget(gameBoard);
}
else
{
delete gameController;
}
}
/*
Reset the board and display.
*/
void ViewBoard::reset()
{
m_negamax ->reset();
m_cubeWid ->reset();
changeTurn();
}
/*
Computer turn to move
Connected from TTT3DNegamax.
This function will only be called if the game is active and computer is enabled.
*/
void ViewBoard::computerMove(int move)
{
if (!m_computerEnabled)
return;
// translating 1D location in the array to 3D location for the Cube to display.
int x, y, z, temp, current;
z = move%3;
temp = move/3;
y = temp%3;
x = temp/3;
// set the location.
m_cubeWid ->setAxis(x, y, z);
current = m_negamax->currentPlayer();
// mark the cube.
m_cubeWid ->markCube((Cube::PlayerCube)(current ^= 0x3));
if(m_negamax ->checkVictory())
return;
m_cubeWid ->grabKeyboard();
changeTurn();
current ^= 0x3;
setCursor(QCursor(Qt::ArrowCursor));
/*
Find out who is the next one to go.
Mainly concern if the next player is a computer,
if not, this function will return and await the next human player to click.
When computer is in the process of moving, all keyboard inputs are blocked.
*/
if (current == 1)
{
if (m_player1 == Computer)
{
m_cubeWid ->releaseKeyboard();
setCursor(QCursor(Qt::BusyCursor));
m_negamax ->computerMove(1);
}
}
else if (current == 2)
{
if (m_player2 == Computer)
{
m_cubeWid ->releaseKeyboard();
setCursor(QCursor(Qt::BusyCursor));
m_negamax ->computerMove(2);
}
}
}
int MinValue(Board* state, int turn, clock_t st){
int beta = 99999;
if(CutOffTest(state, st)){
return state->getValue();
}
BoardQueue *q;
q = state->successor(turn);
// cout << endl;
while(!q->isEmpty()){
Board* s = q->dequeue();
beta = Min(beta, MaxValue(s,changeTurn(turn), st));
delete s;
}
delete q;
return beta;
}
/*
Human player has selected a move.
Find out which square is activated; translate the location in grid
to 1D array of the game board (stored in TTT3DNegamax).
*/
void ViewBoard::humanMove(int move)
{ // move comes from Cube.
int current;
bool good;
current = m_negamax->currentPlayer();
// not blank, return
good = m_cubeWid->markCube((Cube::PlayerCube)(current));
if (!good)
return;
// make the move in TTT3DNegamax (marking the board array).
m_negamax ->makeMove(move, current);
if (m_negamax ->checkVictory())
return;
changeTurn();
current ^= 0x3;
/*
Find out who is the next one to go.
Mainly concern if the next player is a computer,
if not, this function will return and await the next human player to click.
When computer is in the process of moving, all keyboard inputs are blocked.
*/
if (current == 1)
{
if (m_player1 == Computer)
{
m_cubeWid ->releaseKeyboard();
setCursor(QCursor(Qt::BusyCursor));
m_negamax ->computerMove(1);
}
}
else if (current == 2)
{
if (m_player2 == Computer)
{
m_cubeWid ->releaseKeyboard();
setCursor(QCursor(Qt::BusyCursor));
m_negamax ->computerMove(2);
}
}
}
void check(int pick,int initime)
{
int time = initime - clock();
if(count==pick)
{
if(time<WAIT_TIME)
{
winTimes++;
changeTurn();
}
else
{
Loser();
}
}
else
{
Loser();
}
}
void Application::update(){
static float lastTime = SDL_GetTicks() / 1000.0f;
//static float windDelay = WIND_DELAY;
float timeSinceLastTime = (SDL_GetTicks() / 1000.0f) - lastTime;
lastTime = SDL_GetTicks() / 1000.0f;
if(toChangeTurn){
changeTurn();
}
joinServerOrHostServer();
if(isBotGame){
createBot();
}
if(!isBotGame){
createSecondPlayer();
}
handleReceivedData();
Object::updateAll(timeSinceLastTime);
}
int Game::update()
{
//This is probably graphical stuff and thus commented out
//int currTime = (int)clock.getElapsedTime().asSeconds() + timeOffset;
// Update clockstring
//This is probably graphical stuff and thus commented out
//clockText.setString(std::to_string(currTime / 60) + ":" + std::to_string(currTime % 60));
// Make sure that no moves is asked after checkmate or stalemate
// Start new thread and calculate time elapsed for algorithm
//clock.restart();
std::pair<int, int> aimove = getAiMove();
movePiece(aimove);
//std::cout << "AI(lvl:" << playerOnTurn->getLevel() << ") calculated next turn in " << std::endl;
return changeTurn();
}
void GameBoard::onTurnButton()
{
emit changeTurn();
}
int bestMJalt(PGAME orgGame, PGAME game, int d, int f, int returnScore){
int i;
int bestIndex = 0;
int bestIndexScore = 0;
for(i = 0; i < game->mjCount && d > 0; i++){
GAME newGame;
memcpy(&newGame, game, sizeof(GAME));
if (newGame.canJ) {
makeJump(i, &newGame);
}else{
makeMove(i, &newGame);
}
changeTurn(&newGame);
cleanUp(&newGame);
findJumpersForGame(&newGame);
if (!newGame.canJ) {
findMoversForGame(&newGame);
}
int tempScore;
if(f > 0 && d > 0){
tempScore = bestMJalt(orgGame, &newGame, d-1, f, 1);
}
if(tempScore > bestIndexScore){
bestIndexScore = tempScore;
bestIndex = i;
}else{
if(tempScore == bestIndexScore && returnScore == 0){
if(rand()%2 == 0){
bestIndexScore = tempScore;
bestIndex = i;
}
}
}
}
if(game->turn != orgGame->turn)
bestIndexScore = -bestIndexScore;
if(returnScore)
return bestIndexScore;
return bestIndex;
}
int bestMJ(PGAME orgGame, PGAME game, int d, int f){
int i;
int bestIndex = 0;
int bestIndexScore = 0;
for(i = 0; i < game->mjCount && d > 0; i++){
GAME newGame;
memcpy(&newGame, game, sizeof(GAME));
if (newGame.canJ) {
makeJump(i, &newGame);
}else{
makeMove(i, &newGame);
}
changeTurn(&newGame);
cleanUp(&newGame);
findJumpersForGame(&newGame);
if (!newGame.canJ) {
findMoversForGame(&newGame);
}
int tempScore = scoreGames(orgGame, &newGame);
if(tempScore > bestIndexScore){
bestIndexScore = tempScore;
bestIndex = i;
f++;
}else{
if(tempScore == bestIndexScore){
if(rand()%2 == 0){
bestIndexScore = tempScore;
bestIndex = i;
}
f++;
}else{
f--;
}
}
if(f > 0 && d > 0){
bestMJ(orgGame, &newGame, d-1, f);
}
}
return bestIndex;
}
void PlayingState::changeTurn() {
changeTurn((turnTeam == Team::BLUE) ? Team::RED : Team::BLUE);
}
void PlayingState::update(const float dt) {
sf::Vector2i mousePos = sf::Mouse::getPosition(game->window);
game->updateCursorHelper(task == Task::PlacementTransition, mousePos);
std::list<Animation*>::iterator i = animations.begin();
while(i != animations.end()) {
if((*i)->update(dt) == false) {
i = animations.erase(i);
} else {
++i;
}
}
playButton->contains(mousePos);
for(Player* player : players) {
if(player->contains(mousePos)) {
if(!player->getSelectable()) {
game->updateCursorHelper(true, mousePos);
}
}
}
for(FieldCard* card : fieldCards) {
card->contains(sf::Mouse::getPosition(game->window));
}
for(ActionCard* card : currentCards) {
card->contains(sf::Mouse::getPosition(game->window));
}
if(task == Task::PlacementTransition) {
needleRotation += needleVel * dt;
if(needleRotation > 360) needleRotation -= 360;
rouletteNeedle.setRotation(needleRotation);
if(needleVel > 0) {
needleVel -= 1000.0f * dt;
} else {
needleVel = 0;
Team selectedTeam = (needleRotation >= 180.0f) ? Team::BLUE : Team::RED;
animations.push_back(new PosAnimation(*playButton,
playButton->getPosition() + sf::Vector2f(600.0f, 0.0f),
2.0f, Easing::INOUT));
animations.push_back(new PosAnimation(roulette,
roulette.getPosition() + sf::Vector2f(600.0f, 0.0f),
2.2f, Easing::INOUT));
animations.push_back(new PosAnimation(rouletteNeedle,
rouletteNeedle.getPosition() + sf::Vector2f(600.0f, 0.0f),
2.2f, Easing::INOUT));
for(Player* player : players) {
if(player->gameCoords == sf::Vector2i(2, 1) && selectedTeam == player->team) {
moveBallToPlayer(player);
task = Task::ActionSelection;
changeTurn(selectedTeam);
updateTextScore();
drawableEntities.push_back(&textAP);
return;
}
}
}
}
updatePlayerHalo();
}
//função irá atualizar a situação atual do tabuleiro e suas condições
FEN* updateFEN (FEN* fen, OBJETO *** const table, PLAY * play)
{
changeTurn (fen);
// ************************************************* atualizar a configuração do tabuleiro no fen
char *update = (char*)malloc(sizeof(char));
*update = '\0';
int i, j;
int spaces;
int size;
for(i = 0; i < TABLE_ROWS; i++)
{
spaces = 0;
for(j = 0; j < TABLE_COLS; j++)
{
//contagem de espaços vazios
if(table[i][j] == NULL)
spaces ++;
//acréscimo de espaços e de peças na notação
else
{
size = strlen(update);
//se houve espaços entre peças na horizontal acrescental o salto na notação
if(spaces)
{
update = (char*)realloc(update, sizeof(char)*(++size + 1));
update[size - 1] = '0' + size;
}
//acréscimo das peças na notação
update = (char*)realloc(update, sizeof(char)*(++size + 1));
update[size - 1] = getType(table[i][j]);
}
}
if(spaces)
{
size = strlen(update);
update = (char*)realloc(update, sizeof(char)*(++size + 1));
update[size - 1] = '0' + size;
}
//adicionar uma barra para cada linha do tabuleiro
size = strlen(update);
update = (char*)realloc(update, sizeof(char)*(++size + 1));
update[size - 1] = '/';
}
//eliminar a ultima '/' da string
size = strlen(update);
update = (char*)realloc(update, sizeof(char)*(--size + 1));
update[size] = '\0';
int turn = (fen->turn == 'w') ? 1: 0;
// ********************************* verificar condições de roque futuro
char *newRock = (char*)malloc(sizeof(char));
strcpy(newRock, "");
int adj = 7;
//analisar a jogada anterior
turn = !turn;
strcpy(fen->rock, "-");
if(getType(table[adj * turn][4]) == 'k' - (32 * turn))
{
int rockSize = strlen(fen->rock);
int newSize = 0;
char *paux = fen->rock;
int i;
for(i = 0; i < rockSize; i++)
{
if(paux[i] == 'q' - !turn * 32)
{
newSize = strlen(newRock);
newRock = (char*)realloc(newRock, sizeof(char)*(++newSize + 1));
newRock[newSize - 1] = 'q' - !turn * 32;
}
//verificar se a torre para lado da rainha não foi movida
else if(paux[i] == 'q' - turn * 32 && getType(table[adj * turn][0]) == 'q' - turn * 32)
{
newSize = strlen(newRock);
newRock = (char*)realloc(newRock, sizeof(char)*(++newSize + 1));
newRock[newSize - 1] = 'q' - turn * 32;
}
else if(paux[i] == 'k' - !turn * 32)
{
newSize = strlen(newRock);
newRock = (char*)realloc(newRock, sizeof(char)*(++newSize + 1));
newRock[newSize - 1] = 'k' - !turn * 32;
}
//verificar se a torre para o lado do rei não foi movida
else if(paux[i] == 'k' - turn * 32 && getType(table[adj * turn][0]) == 'k' - turn * 32)
{
newSize = strlen(newRock);
newRock = (char*)realloc(newRock, sizeof(char)*(++newSize + 1));
newRock[newSize - 1] = 'k' - turn * 32;
}
}//for
if(newSize)
strcpy(fen->rock, newRock); //->rock contem por padrão "", a ser modificada pelo switch
}
// ********************************* verificar descartar formação de en passant anterior e verificar a atual
strcpy(fen->pass, "-");
for(i = 0; i < TABLE_COLS; i++)
{
//se o turno é do White então os peões estão na linha 5 da matriz, senão, na linha 2 da matriz.
if(table[adj * turn + 2 - 4*turn][i] == play->obj && getType(play->obj) == 'p' - turn * 32)
{
//função update será chamada antes de atualizar a coordenada da struct da peça
int diff = abs(play->fromRow - getObjectRow(play->obj));
//se houve salto de 2 casas do peão
if(diff == 2)
{
char newPass[3];
newPass[0] = 'a' + i;
newPass[1] = '1' + 7*!turn - 1 + 2*turn;
newPass[2] = '/';
strcpy(fen->pass, newPass);
}
break;
}
}
// ********************************** verificar o acréscimo do meio turno
//se movimento foi feito de peão ou foi feito uma captura
if(getType(play->obj) == 'p' - turn * 32 || fen->fullTurn == getObjectTurn (play->obj))
fen->halfTurn ++;
// ********************************** verificar o acréscimo do turno completo
//se a jogada foi feita pela lado Preto
if(turn)
fen->fullTurn++;
//voltar para o turno atual
turn = !turn;
//guardar a nova notação do estado atual do tabuleiro
strcpy(fen->pieces, update);
return fen;
}
