void PlayerSetupDialog::playerSelected(const QModelIndex & idx)
{
if(!m_playerList)
return;
if(idx.isValid())
setCurrentPlayer(m_playerList->at(idx.row()));
}
void MainWindow::resetGame()
{
history.clear();
delete gbw->gameBoard();
GameBoard* gb = nullptr;
if(startBoard.getRunSize() == boardSize) {
gb = new GameBoard(startBoard);
}
else {
gb = new GameBoard(boardSize);
}
gbw->setGameBoard(gb);
if(whitePlayerAgent) {
delete whitePlayerAgent;
}
if(redPlayerAgent) {
delete redPlayerAgent;
}
int thinksize = 0;
if(boardSize <= 3) thinksize = 5;
if(boardSize >= 4) thinksize = 4;
whitePlayerAgent = new MinMaxAgent(T_WHITE, thinksize);
if(redai) {
redPlayerAgent = new MinMaxAgent(T_RED, thinksize);
queueAIMove(redPlayerAgent, T_RED);
}
setCurrentPlayer(T_RED);
}
void Game::recieveMove() {
GAMESTATE res_flag;
//sleep(1);
MOVE mv = current->getMove();
delete thread;
// check move
if (!board.move(mv)) {
// wrong move - request move again
//qDebug() << "(!) wrong move: " << mv.from.x+1 << "," << mv.from.y+1 << " >> " << mv.to.x+1 << "," << mv.to.y+1;
move();
return;
}
emit updateBoard();
// check finish
if (res_flag = board.isWin()) {
finish(res_flag);
return;
}
// continue game
if (!board.canMove()) {
// change current player
setCurrentPlayer(current->getColor() == WHITE ? BLACK : WHITE);
}
// next move, please!
move();
}
void MainWindow::queueAIMove(MinMaxAgent *agent, TokenColour tc)
{
setCurrentPlayer(tc);
// Do a little heuristic.
int minSearch = 4;
int deepenDelay = 2;
if(boardSize <= 4) {
minSearch = 5;
deepenDelay = 1;
}
int runs = gbw->gameBoard()->getRunSize();
int positions = ((runs + 1) * (gbw->gameBoard()->getRunSize()-1))
+ (runs * gbw->gameBoard()->getRunSize());
int available = gbw->gameBoard()->availableMoves(tc).size();
agent->setMaxDepth(std::max(minSearch, -deepenDelay + (positions - available)/2));
statusBar()->showMessage(QString("Thinking… (depth: %1)")
.arg(agent->maxDepth()), 5000);
// AIPlayerWorker thread should clean itself up.
currentWorker = new AIPlayerWorker(agent);
connect(currentWorker, SIGNAL(moveDecided(BoardIndex,BoardIndex,TokenColour)), this, SLOT(makeMove(BoardIndex,BoardIndex,TokenColour)));
currentWorker->startMove( gbw->gameBoard() );
}
void MainWindow::onResetBoard()
{
#ifdef DEBUG_VIEW
print("Resetting game board.");
#endif
setCurrentPlayer(Elements::PLAYER_1);
emit tellResetBoard();
}
void Game::start() {
//qDebug() << "Game::start()";
setCurrentPlayer(WHITE);
// first move
move();
}
Player* PlayerManager::createPlayer(const QString& nickname)
{
Player* player = new Player("", nickname);
player->autogenerateId();
setCurrentPlayer(player);
loadPlayers();
return player;
}
Player* PlayerManager::setCurrentPlayer(const QByteArray& playerId)
{
Q_ASSERT(playerId.isEmpty() == false);
Player* player = new Player(playerId);
Q_ASSERT(player);
player->load();
return setCurrentPlayer(player);
}
void PlayerSetupDialog::removePlayer()
{
if(!m_con)
return;
if(!m_playerList)
return;
/// TODO confirm deletion
m_playerList->removePlayer(m_con);
m_con->deleteLater();
m_con = 0;
if(m_playerList->size() > 0)
setCurrentPlayer(m_playerList->at(0));
else
setCurrentPlayer(0);
}
/**
* Setzt den aktuellen Spieler anhand des Spieler-Indexes.
*
* @param playerIndex Spieler-Index.
*/
void setCurrentPlayer(int playerIndex) {
LOGD("Game.setCurrentPlayer");
// Spieler-Index merken
currentPlayerIndex = playerIndex;
// Spieler merken
currentPlayer = &players[playerIndex];
// erforderliche Aktionen auf der Java-Ebene anstoßen
setCurrentPlayer(currentPlayer);
}
void PlayerSetupDialog::newPlayer()
{
if(!m_playerList)
return;
PlayerConnection *con = new PlayerConnection();
m_playerList->addPlayer(con);
setCurrentPlayer(con);
ui->playerListview->setCurrentIndex(m_playerList->index(m_playerList->size()-1,0));
}
void PlayerSetupDialog::setPlayerList(PlayerConnectionList *list)
{
m_playerList = list;
ui->playerListview->setModel(list);
if(list->size() > 0)
{
ui->playerListview->setCurrentIndex(list->index(0,0));
setCurrentPlayer(list->at(0));
}
else
newPlayer();
}
void MainWindow::forfeitMove()
{
if(currentTurn == T_RED) {
// ask AI player to do something.
queueAIMove(whitePlayerAgent, T_WHITE);
}
else if(currentTurn == T_WHITE) {
if(redai) {
queueAIMove(redPlayerAgent, T_RED);
} else {
setCurrentPlayer(T_RED);
}
}
}
MainWindow::MainWindow(QWidget* parent, Qt::WindowFlags flags)
: QMainWindow(parent, flags), gbw(nullptr), boardSize(5), redai(false),
redPlayerAgent(nullptr), whitePlayerAgent(nullptr), startBoard(5),
currentWorker(nullptr)
{
setMinimumSize(400, 400);
QMenuBar *mb = menuBar();
QMenu* game = mb->addMenu("&Game");
QMenu* size = game->addMenu("&New");
connect(size, SIGNAL(triggered(QAction*)), this, SLOT(resetGame()));
size->addAction("&Tiny", this, SLOT(tinyGame()));
size->addAction("&Small", this, SLOT(smallGame()));
size->addAction("&Medium", this, SLOT(mediumGame()));
size->addAction("&Normal", this, SLOT(normalGame()));
size->addAction("&Large", this, SLOT(largeGame()));
game->addAction("&AI Versus", this, SLOT(AIGame()));
game->addSeparator();
game->addAction("&Quit", QApplication::instance(), SLOT(quit()), QKeySequence::Quit);
QMenu* state = mb->addMenu("&State");
state->addAction("&Forfeit move", this, SLOT(forfeitMove()));
state->addSeparator();
state->addAction("&Print History", this, SLOT(printGameHistory()));
state->addAction("Write &Graph", this, SLOT(writeGraphviz()));
state->addAction("Write &Image", this, SLOT(writeStateImage()));
QMenu* help = mb->addMenu("&Help");
help->addAction("&About Qt", QGuiApplication::instance(), SLOT(aboutQt()));
statusLabel = new QLabel();
statusBar()->addWidget(statusLabel);
gbw = new GameBoardWidget(this);
setCentralWidget(gbw);
normalGame();
setCurrentPlayer(T_RED);
connect(gbw, SIGNAL(boardClicked(BoardIndex,BoardIndex)), this, SLOT(playerClick(BoardIndex,BoardIndex)));
}
void GameProfile::loadProfile()
{
loadXml();
// if no profile found, create default player
if (m_players.count() == 0)
setCurrentPlayer(tr("Player"));
if (m_current >= 0 && m_current < m_players.count()) {
sndEngine->setChannelVolume(currentPlayer()->soundVolume);
sndEngine->setMusicVolume(currentPlayer()->musicVolume);
sndEngine->enableMusic(currentPlayer()->musicEnabled);
}
// loadTopTen();
}
bool PlayerManager::removePlayer(const QByteArray& playerId)
{
if ( currentPlayer && currentPlayer->getId() == playerId )
{
currentPlayer->remove();
setCurrentPlayer(nullptr);
}
else
{
Player* player = findPlayerById(playerId);
if ( player )
player->remove();
}
loadPlayers();
return true;
}
void MainWindow::makeMove(BoardIndex row, BoardIndex column)
{
gbw->gameBoard()->putToken(row, column, currentTurn);
history.push_back(*gbw->gameBoard());
gbw->update();
if(gbw->gameBoard()->isEndGame()) {
auto winner = gbw->gameBoard()->getWinner();
QMessageBox mbx;
if(winner == T_RED) {
mbx.setText("Red Player Wins!");
} else if (winner == T_WHITE) {
mbx.setText("White Player Wins!");
}
else {
mbx.setText("Nobody Wins!");
}
mbx.exec();
redai = false;
resetGame();
}
else {
if(currentTurn == T_RED) {
// ask AI player to do something.
queueAIMove(whitePlayerAgent, T_WHITE);
}
else if(currentTurn == T_WHITE) {
if(redai) {
queueAIMove(redPlayerAgent, T_RED);
} else {
setCurrentPlayer(T_RED);
}
}
}
}
int main(int argc, char *argv[])
{
char **playersNameList;
int totalPlayersNumber;
int turn, i;
char buffer[BUFF_SIZE];
FILE *configFile;
/* legge gli argomenti */
char **name1, **name2;
if (argc < 4) {
fprintf(stderr,
"ERROR: Wrong number of arguments. \n USAGE: %s\n",
USAGE);
exit(EXIT_FAILURE);
}
playersNameList = argv + 3;
totalPlayersNumber = argc - 3;
/* controlla se ci sono due giocatori con lo stesso nome */
for (name1 = playersNameList; *name1; name1++)
for (name2 = name1 + 1; *name2; name2++)
if (strcmp(*name1, *name2) == 0) {
fprintf(stderr, "ERROR: found two player with the"
"same name \"%s\"\n", *name1);
exit(EXIT_FAILURE);
}
initIoInterface(argv[2]);
/* crea e inizializza le strutture dati per i giocatori */
initPlayersManager(totalPlayersNumber);
for (; *playersNameList; playersNameList++)
addPlayer(*playersNameList);
initBoard();
/*
* legge il file di configurazione secondo il formato:
* numero_casella:descrizione della prova\n
* e aggiunge le descrizioni al tabellone
*/
if ((configFile = fopen(argv[1], "r")) == NULL) {
printErr("ERROR: error while opening configuration file\n");
exit(EXIT_FAILURE);
}
while (fgets(buffer, BUFF_SIZE, configFile)) {
char *description;
int boxNumber;
/* legge il numero di casella */
if ((boxNumber = atoi(buffer)) <= 0) {
printErr("ERROR:invalid box num(\"%s\") in"
" configuration file\n", buffer);
exit(EXIT_FAILURE);
}
/* aggiunge una nuova casella con la relativa descrizione */
if ((description = strchr(buffer, ':')) == NULL) {
printErr("ERROR: missing ':' in configuration file\n");
exit(EXIT_FAILURE);
}
addBox(boxNumber, description + 1);
}
if (getTotalBoxesNumber() == 0) {
printErr("ERROR: invalid configuration file\n");
exit(EXIT_FAILURE);
}
fclose(configFile);
printBoard();
showGame();
/* avvia la simulazione del gioco */
srand(time(NULL));
for (turn = 0; !allPlayersDone(); turn++) {
if (!nextStep())
return EXIT_SUCCESS;
printMessage("\n**************************************\n");
printMessage("turno %d", turn + 1);
printMessage("\n**************************************\n");
showGame();
/*
* per ogni giocatore G che non ha terminato il gioco:
* 1. se G e' fermo per un turno cambia il suo stato in
* modo che al turno successivo venga rimesso in gioco
* 2. altrimenti viene lanciato il dado, mosso il giocatore
* e visualizzata la sua prova
*/
while (nextPlayer()) {
int state = getPlayerState();
if (state == ACTIVE || state == TEST_PASSED
|| state == TO_BE_ACTIVATED) {
if (state != ACTIVE)
setPlayerState(ACTIVE, 0);
movePlayer((rand() % 6) + 1);
if (getPlayerBox() > getTotalBoxesNumber())
setPlayerState(DONE, turn);
else
printMessage("player %s: \"%s\"\n",
getPlayerName(),
getDescription(getPlayerBox()));
} else if (state == OUT_OF_TURN)
setPlayerState(TO_BE_ACTIVATED, 0);
}
showGame();
/*
* Legge e registra l'esito di tutte le prove sostenute nel
* turno corrente dai giocatori
*/
for (i = getActivePlayersNumber(); i > 0; i--) {
int playerNumber;
bool result;
do {
result = askPlayerResult(&playerNumber);
if (playerNumber > totalPlayersNumber)
printErr("WARNING: player number %d out of "
"bounds [1; %d]\n", playerNumber,
totalPlayersNumber);
else {
setCurrentPlayer(playerNumber);
if (getPlayerState() != ACTIVE)
printErr("WARNING: player number %d not "
"valid because player:"
"\n\t-won"
"\n\t-is out of turn"
"\n\t-already passed the test\n",
playerNumber);
}
}
while (playerNumber > totalPlayersNumber
|| getPlayerState() != ACTIVE);
if (result)
setPlayerState(TEST_PASSED, 0);
else
setPlayerState(OUT_OF_TURN, 0);
}
}
printScore();
closeIoInterface();
return EXIT_SUCCESS;
}
/**
* Aktualisiert den aktuellen Spiel-Zustand.
*
* @param newGameState Neuer Spielzustand.
*/
void updateGameState(int newGameState) {
LOGD("updateGameState");
// nichts tun, wenn sich der Zustand nicht verändert hat
if (newGameState == gameState) {
return;
}
// Spielzustand speichern
gameState = newGameState;
// Buffer für Toast-Inhalte
char text[256];
// Spiel-Zustand auswerten und die entsprechenden Aktionen ausführen
switch (gameState) {
case GAME_STATE_SHOW_HINT_MARKER_NEEDED:
// um spielen zu können, muss die Kamera auf den Marker gerichtet sein
sprintf(text, "Halte die Kamera auf den Marker.");
showToast(text, TOAST_DURATION_LONG);
gameState = GAME_STATE_WAITING_FOR_MARKER;
break;
case GAME_STATE_WAITING_FOR_MARKER:
// warten, bis die Handy-Kamera auf das Bild gerichtet ist
break;
case GAME_STATE_SHOW_HINT_CREATE_SPACES:
// Hinweise anzeigen, wie das Spielfeld erzeugt werden kann
sprintf(text, "Halte die Kamera weiterhin auf den Marker.");
showToast(text, TOAST_DURATION_LONG);
sprintf(text, "Erzeuge nun ein Spielfeld, indem du auf den Bildschirm tippst oder ...");
showToast(text, TOAST_DURATION_LONG);
sprintf(text, "... mit einem Finger langsam ueber den Bildschirm ziehst.");
showToast(text, TOAST_DURATION_LONG);
sprintf(text,
"Einzelne Felder koennen durch Antippen in Sonderfelder umgewandelt werden.");
showToast(text, TOAST_DURATION_LONG);
sprintf(text, "Bleibt ein Spieler auf einem Sonderfeld stehen, ...");
showToast(text, TOAST_DURATION_LONG);
sprintf(text,
"... darf er um ein paar Felder vorruecken oder muss ein paar Felder zurueck.");
showToast(text, TOAST_DURATION_LONG);
gameState = GAME_STATE_CREATING_FIELD;
break;
case GAME_STATE_CREATING_FIELD:
// Spielfeld kann erzeugt werden
break;
case GAME_STATE_DRAWING_BEGINNING_PLAYER:
// ersten Spieler durch Würfeln bestimmen
LOGI("Drawing beginning player");
// Die Felder auf denen die Spielfiguren stehen, können erst jetzt initialisiert werden,
// weil die Positionen der Felder erst jetzt bekannt sind.
for (int i = 0; i < PLAYER_COUNT; ++i) {
initPawnSpaces(&players[i].pawn);
}
// currentPlayerTextView anzeigen
showView("currentPlayerTextView");
// aktuellen Spieler auswürfeln und setzen
setCurrentPlayer(rand() % PLAYER_COUNT);
// "Würfeln"-Buuton anzeigen, damit der menschliche Spieler würfeln kann
if (currentPlayer->type == PLAYER_TYPE_HUMAN) {
showView("diceButton");
}
updateGameState(GAME_STATE_RUNNING);
break;
case GAME_STATE_RUNNING:
// Spiel läuft
break;
default:
LOGE("Unknown game state: %d", gameState);
break;
}
}
/**
* Verarbeitet den Zug.
*
* @param timeIntervalSinceLastFrame Zeit in ms, die seit der Berechnung des letzten Bildes
* vergangen ist (nötig für die Animation der Spielfiguren).
*/
void processMove(float timeIntervalSinceLastFrame) {
// aktuellen Spiel-Zustand auswerten und die entsprechenden Aktionen ausführen
switch (gameState) {
case GAME_STATE_RUNNING: {
// Spiel läuft
// Prüfung, ob der aktuelle Spieler senen Zug beeendet hat
if (currentPlayer->state == PLAYER_STATE_POST_MOVING) {
// Prüfung, ob der Spieler auf einem Sonderfeld gelandet ist
if (field.spaces[currentPlayer->targetSpaceIndex].type == SPECIAL_SPACE) {
// Spieler ist auf einem Sonderfeld gelandet. Es wird per Zufall bestimmt, ob er
// vor oder zurück darf und wie weit.
// Vorzeichen bestimmen, 0: Spieler darf vor, 1: Spieler muss zurück
int sign = rand() % 2;
// Betrag bestimmen
int value = rand() % MAX_DIE_PIP_COUNT + 1;
// Betrag evtl. negieren
value *= sign == 0 ? +1 : -1;
// neues Ziel setzen
setPlayerTargetSpace(currentPlayer, currentPlayer->targetSpaceIndex + value);
// Hinweis anzeigen
char text[256];
sprintf(text, "%s ist auf einem Sonderfeld gelandet und %s %d %s %s",
currentPlayer->name, value >= 0 ? "darf um" : "muss", abs(value),
abs(value) == 1 ? "Feld" : "Felder",
value >= 0 ? "vorruecken" : "zurueck");
showToast(text, TOAST_DURATION_LONG);
// Zug vorbereiten
prepareMove(currentPlayer);
} else if (currentPlayer->targetSpaceIndex < field.length - 1) {
// Aktueller Spieler hat das Zielfeld noch nicht erreicht. Es wird der nächste
// Spieler bestimmt und die dafür nötigen Aktionen ausgeführt.
// aktuellen Spieler schon mal für seinen nächsten Zug vorbereiten
if (currentPlayer->type == PLAYER_TYPE_HUMAN) {
// menschlicher Spieler muss warten, bis der "Würfeln"-Button gedrückt wird
currentPlayer->state = PLAYER_STATE_WAITING;
} else {
// Computer-Spieler kann gleich würfeln und ziehen
currentPlayer->state = PLAYER_STATE_PRE_MOVING;
}
// aktuellen Spieler aktualisieren
setCurrentPlayer((currentPlayerIndex + 1) % PLAYER_COUNT);
// evtl. den "Würfeln"-Button anzeigen
if (currentPlayer->type == PLAYER_TYPE_HUMAN) {
showView("diceButton");
}
} else {
// Der aktuelle Spieler hat das Ziel erreicht und gewinnt.
// Hinweis anzeigen
char text[256];
sprintf(text, "%s erreicht als erster das Ziel und gewinnt",
currentPlayer->name);
showToast(text, TOAST_DURATION_LONG);
// Spiel-Zustand aktualisieren
gameState = GAME_STATE_GAME_OVER;
}
}
// den Zug vom aktuellen Spieler weiterverarbeiten lassen
processPlayerMove(currentPlayer, timeIntervalSinceLastFrame);
break;
}
case GAME_STATE_GAME_OVER: {
// Spiel ist zu Ende
LOGD("Game state is GAME_STATE_GAME_OVER");
break;
}
default:
break;
}
}
void GameProfile::setPlayerNames(const QStringList &sl)
{
m_players.clear();
for (int i = 0; i < sl.count(); i++)
setCurrentPlayer(sl.at(i));
}
