void ChessPlusPlusState::onLButtonReleased(int x, int y)
{
if(!board.valid(p)) return;
if(selected == board.end())
{
selected = find(p); //doesn't matter if board.end(), selected won't change then
if(selected != board.end() && (*selected)->suit != *turn)
{
selected = board.end(); //can't select enemy pieces
}
}
else
{
if(find(p) == board.end() || (*find(p))->suit != (*selected)->suit)[&]
{
{
auto it = std::find_if(board.pieceCapturings().begin(),
board.pieceCapturings().end(),
[&](board::Board::Movements_t::value_type const &m)
{
return m.first == selected && m.second == p;
});
if(it != board.pieceCapturings().end())
{
for(auto jt = board.pieceCapturables().begin(); jt != board.pieceCapturables().end(); ++jt)
{
if(jt->second == p)
{
if(board.capture(selected, it, jt))
{
nextTurn();
return;
}
}
}
}
}
{
auto it = std::find_if(board.pieceTrajectories().begin(),
board.pieceTrajectories().end(),
[&](board::Board::Movements_t::value_type const &m)
{
return m.first == selected && m.second == p;
});
if(it != board.pieceTrajectories().end())
{
if(board.move(selected, it))
{
nextTurn();
}
}
}
}();
selected = board.end(); //deselect
}
}
void GroupGame::groupGuessed(int right, int total)
{
nextTurn(m_WPM * right * 10 * ((total==right)?2:1));
if (right == total)
m_WPM++;
else
m_WPM--;
m_morse->createTones(m_WPM);
}
int main()
{
int field[3][3]= {0},crossFlag=0;
drawField(field);
while (endGame(field)==0)
{
nextTurn(field, crossFlag);
++crossFlag;
}
return 0;
}
void GraphicsScene::nextTurn() {
if (_scene->getGameStatus() < 2){
_scene->nextTurn();
if (_type == MachineVsHuman || _type == HumanVsMachine){
if (_scene->getGameStatus() == _computerType){
QPoint p = _computerMind->suggest();
cerr << "computerMind of type : " << _computerType << " suggest: " << p.x() << ", " << p.y() << endl;
if (p.x() >= 0 && p.y() >= 0){
moveOnPosition(p);
}else{
// skip turn:
nextTurn();
}
}
}else if (_type == MachineVsMachine){
if (_scene->getGameStatus() == _computerType){
QPoint p = _computerMind->suggest();
cerr << "suggest: " << p.x() << ", " << p.y() << endl;
if (p.x() >= 0 && p.y() >= 0){
moveOnPosition(p);
}else{
// skip turn:
nextTurn();
}
}else{
QPoint p = _computerMind2->suggest();
cerr << "suggest: " << p.x() << ", " << p.y() << endl;
if (p.x() >= 0 && p.y() >= 0){
moveOnPosition(p);
}else{
// skip turn:
nextTurn();
}
}
}
}
}
void Grid::Shoot(std::vector<int> &_ints)
{
///std::cout << "cards size = " << rCards.size() << std::endl;
///std::cout << _ints[0] << _ints[1] << _ints[2] << std::endl;
for ( int i = 0; i < _ints.size(); i++ )
{
//alldecks[ stack.whosTurn ].push_back( gp.cube[ _ints[ i ] ] );
alldecks[ stack.whosTurn ].push_back( cubeUnedited[ _ints[ i ] ] );
}
dwriter.write( alldecks[ stack.whosTurn ], ppl.vTexts[ stack.whosTurn ].getString() );
for (int i = 0; i < 3; i++)
{
if (gp.current + 3 > cube.size())
{
std::cout << "WARNINGWARNING NO MORE CARDS" << std::endl;
break;
txtEnd.setString( "Draft has ended. No more cards to fill..." );
End = 1;
}
std::swap(gp.cube[ _ints[ i ] ], gp.cube[ gp.current ] );
std::swap( cubeUnedited[ _ints[ i ] ], cubeUnedited[ gp.current ] );
gp.current++;
}
shootclock.restart();
nextTurn();
checknumber += 3;
if ( checknumber >= 45 * ppl.vTexts.size() )
End = 1;
std::cout << "End = " << End << std::endl;
}
void Server_Game::removePlayer(Server_Player *player)
{
room->getServer()->removePersistentPlayer(QString::fromStdString(player->getUserInfo()->name()), room->getId(), gameId, player->getPlayerId());
players.remove(player->getPlayerId());
GameEventStorage ges;
removeArrowsRelatedToPlayer(ges, player);
unattachCards(ges, player);
ges.enqueueGameEvent(Event_Leave(), player->getPlayerId());
ges.sendToGame(this);
bool playerActive = activePlayer == player->getPlayerId();
bool playerHost = hostId == player->getPlayerId();
bool spectator = player->getSpectator();
player->prepareDestroy();
if (!getPlayerCount()) {
gameClosed = true;
deleteLater();
return;
} else if (!spectator) {
if (playerHost) {
int newHostId = -1;
QMapIterator<int, Server_Player *> playerIterator(players);
while (playerIterator.hasNext()) {
Server_Player *p = playerIterator.next().value();
if (!p->getSpectator()) {
newHostId = p->getPlayerId();
break;
}
}
if (newHostId != -1) {
hostId = newHostId;
sendGameEventContainer(prepareGameEvent(Event_GameHostChanged(), hostId));
}
}
stopGameIfFinished();
if (gameStarted && playerActive)
nextTurn();
}
ServerInfo_Game gameInfo;
gameInfo.set_room_id(room->getId());
gameInfo.set_game_id(gameId);
gameInfo.set_player_count(getPlayerCount());
gameInfo.set_spectators_count(getSpectatorCount());
emit gameInfoChanged(gameInfo);
}
int main(void)
{
//init random
srand((unsigned int)time(NULL));
player *pc = init();
int gcount = 0;
while (gcount < TURN) {
int ret = nextTurn(pc, &gcount);
if (ret) {
printf("You made the day! score is: %d\n", gcount);
break;
}
}
endGame(pc);
return 0;
}
/**
* @brief Provedeni tahu umelou inteligenci.
* @note Vyzaduje nastaveni obtiznosti umele inteligence (TAI AIType).
*/
void Game::execTurnAI(){
TAI AI = getAIType(); /**< Typ vyhodnocovaci logiky */
gameLogic.cleanBoard(board); // Vycisteni desky
switch (AI) {
case AI_EASY: ai2NextState(board, playerColor); break; // Generovani tahu pomoci alpa-beta
case AI_DIFFICULT: ai1NextState(board, playerColor); break; // Generovani tahu pomoci SIMPLE algoritmu
default: throw std::invalid_argument("Nezname nastaveni umele inteligence");
}
gameLogic.init(0, 0, playerColor == BLACK ? WHITE : BLACK ); // Nastaveni prohledavani pro dalshio hrace
if(gameLogic.canTurn(board)) // Muze protivnik tahnout kamene?
nextTurn();
gameLogic.init(0, 0, playerColor); // Nastaveni prohledavani pro dalshio hrace
if(!onTurnAI())
gameLogic.markBoard(board);
gameLogic.countScore(board, blackScore, whiteScore); // Prepocita skore
history.storeState(board, playerColor, blackScore, whiteScore); // Ulozeni stavu po tahu a hrace, ktery bude tahnout
}
void MainScreen::nextTurn()
{
RiskMap* map = this->driver->getRiskMap();
auto iterator = map->getPlayers().find(this->driver->getCurrentPlayerName());
auto end = map->getPlayers().end();
std::advance(iterator, 1);
if (iterator == end) {
iterator = map->getPlayers().begin();
}
if((*iterator).second.isAlive()){
this->driver->setCurrentPlayerName((*iterator).first);
this->driver->setCurrentMode(REINFORCEMENT);
}else{
driver->setCurrentPlayerName((*iterator).first);
nextTurn();
}
}
void makeMove(gametable* game, int ch)
{
char* c = game->array;
int move, i = 1;
char moved = '0';
move = (ch)-1;
if (move >= 0 && move < game->width)
{
c += move*sizeof(char);
while (*c == '0' && i < game->height)
{
i++;
c += (game->width)*sizeof(char);
if (*c != '0' && i > 1)
{
c -= game->width;
*c = game->turn;
moved = '1';
break;
} else if (*c != '0' && i == 1)
{
//printw("Invalid move.");
break;
}
if (i == game->height)
{
*c = game->turn;
moved = '1';
break;
}
}
if (moved == '1')
{
nextTurn(game);
//drawTable(game);
// %)
game->moves++;
}
}
}
void battleLocalWindow::fire(){
int xFire = ui->FireRowText->text().toInt();
int yFire = ui->FireColText->text().toInt();
QString playerNum;
if(ui->FireRowText->text() == ""){
QMessageBox::information(this, tr("Bad Coordinates"),tr("No X coordinate entered. Please enter valid coordinate"));
return;
}
else if(ui->FireColText->text() == ""){
QMessageBox::information(this, tr("Bad Coordinates"), tr("No Y coordinate entered. Please enter valid coordinate"));
return;
}
else if(!goodCoordinate(xFire, yFire)){
QMessageBox::information(this, tr("Bad Coordinates"), tr("Bad coordinates entered. Please enter valid coordinates"));
return;
}
if(CurrentPlayer==1){
EnemyBoard = Player2Board;
playerNum = "1";
}
else{
EnemyBoard = Player1Board;
playerNum = "2";
}
Location firePos(xFire,yFire);
if(EnemyBoard->getSpotValue(firePos) >2){
QMessageBox::information(this, tr("Status: ERROR"), tr("Attempt to fire on repeat coordinates."));
return;
}
else if(EnemyBoard->recieveShot(firePos))
QMessageBox::information(this, tr("Status: HIT"), tr("HIT!"));
else
QMessageBox::information(this, tr("Status: MISS"), tr("MISS!"));
if(!checkGame()){
QMessageBox::information(this, tr("GAME OVER"), "Game over. Player " % playerNum %"Wins");
this->close();
}
nextTurn();
}
/**
* @brief Pokusi se provest tah ze souradnic X a Y zadanych clovekem
* @param X Uzivatelem zadana souradnice X (radek)
* @param Y Uzivatelem zadana souradnice Y (sloupec)
* @return True Uspesne | False neuspesne polozeni kamene/u
*/
bool Game::execTurnHuman(int X, int Y){
try{
gameLogic.init(X,Y, playerColor); // Inicializace herni logiky pro tah
gameLogic.checkPos(board); // Kontrola jestli je policko vubec dostupne
gameLogic.cleanBoard(board); // Vycisteni od predchozich znacek
gameLogic.nextState(board); // Vygeneruje dalsi tah
}
catch(...){
return false;
}
gameLogic.init(0, 0, playerColor == BLACK ? WHITE : BLACK); // Nastaveni prohledavani pro dalshio hrace
if(gameLogic.canTurn(board)) // Muze protivnik tahnout kamene?
nextTurn();
gameLogic.init(0, 0, playerColor); // Nastaveni prohledavani pro dalshio hrace
if(!onTurnAI())
gameLogic.markBoard(board); // Jeslize je na tahu clovek tak se oznaci mozne dalsi tahy
gameLogic.countScore(board, blackScore, whiteScore); // Prepocita skore
history.storeState(board, playerColor, blackScore, whiteScore); // Ulozeni stavu po tahu a hrace, ktery bude tahnout
return true;
}
void GraphicsScene::moveOnPosition(QPoint p)
{
int playerType = _scene->getGameStatus(); // red or blue
if (_gameRules->addFigure(playerType, p)){
_dialogMenu->setNumberOfRedFigures(_figures->getNumberOfRedFigures());
_dialogMenu->setNumberOfBlueFigures(_figures->getNumberOfBlueFigures());
cerr << "total number of figures: "<< _figures->getTotalNumberOfFigures() << endl;
if (!_gameRules->gameIsFinished(/*(_scene->getGameStatus()+1)%2)*/)){
nextTurn();
}else{
_scene->setGameStatus(2);
_scene->setWinner(_figures->getWinner());
}
}// endif if (_gameRules->addFigure(playerType, gridPos))
}
void GraphicsScene::resetGame()
{
_scene->setGameStatus(0);
_gameRules->reset();
// start computerMind:
if (_type==MachineVsHuman || _type==MachineVsMachine){
QPoint p = _computerMind->suggest();
cerr << "suggest: " << p.x() << ", " << p.y() << endl;
if (p.x() >= 0 && p.y() >= 0){
moveOnPosition(p);
}else{
// skip turn:
nextTurn();
}
}
}
void battleLocalWindow::createRandomBoard(){
Board* boardIn;
if(CurrentPlayer == 1){
boardIn = Player1Board;
ui->PlayerGoing->setText("Player 2's Turn");
}
else if(CurrentPlayer==2){
ui->PlayerGoing->setText("Player 1's Turn");
boardIn = Player2Board;
ui->RandomButton->setEnabled(FALSE);
ui->CustomButton->setEnabled(FALSE);
ui->FireButton->setEnabled(TRUE);
}
else{//Made boards already
return; //Should not make it here
}
Location PT_spot(1,rand()%10);
Location DES_spot(3,rand()%10);
Location SUB_spot(5,rand()%10);
Location BAT_spot(7,rand()%10);
Location CAR_spot(9,rand()%10);
int PT_direc(rand()%4 + 1);
int DES_direc(rand()%4 + 1);
int SUB_direc(rand()%4 + 1);
int BAT_direc(rand()%4 + 1);
int CAR_direc(rand()%4 + 1);
//do boundary checking
//Place Patrol Boat
Ship Minow( PT_BOAT );
while(!boardIn->placeShip(Minow, PT_spot, PT_direc)){
PT_spot.setColumn(rand()%10);
PT_spot.setRow(rand()%10);
PT_direc = rand()%4 + 1; // 1-5
}
cout<<"Patrol(2) "<<PT_spot.getRow()<<","<<PT_spot.getColumn() << " " <<PT_direc<<endl;
//Place Destroyer
Ship Farragut(DESTROYER);
while(!boardIn->placeShip(Farragut, DES_spot, DES_direc)){
DES_spot.setColumn(rand()%10);
DES_spot.setRow(rand()%10);
DES_direc = rand()%4 + 1; // 1-5
}
cout<<"Destroyer(3) "<<DES_spot.getRow()<<","<<DES_spot.getColumn()<< " " <<DES_direc<<endl;
//Place Submarine
Ship Virginia(SUBMARINE);
while(!boardIn->placeShip(Virginia, SUB_spot, SUB_direc)){
SUB_spot.setColumn(rand()%10);
SUB_spot.setRow(rand()%10);
SUB_direc = rand()%4 + 1; // 1-5
}
cout<<"Submarine(3) "<<SUB_spot.getRow()<<","<<SUB_spot.getColumn()<< " " <<SUB_direc<<endl;
//Place Battleship
Ship Iowa(BATTLESHIP);
while(!boardIn->placeShip(Iowa, BAT_spot, BAT_direc)){
BAT_spot.setColumn(rand()%10);
BAT_spot.setRow(rand()%10);
BAT_direc = rand()%4 + 1; // 1-5
}
cout<<"BattleShip(4) "<<BAT_spot.getRow()<<","<<BAT_spot.getColumn()<< " " <<BAT_direc<<endl;
//Place Carrier
Ship Enterprise( CARRIER );
while(!boardIn->placeShip(Enterprise, CAR_spot, CAR_direc)){
CAR_spot.setColumn(rand()%10);
CAR_spot.setRow(rand()%10);
CAR_direc = rand()%4 + 1; // 1-5
}
cout<<"Carrier(5) "<<CAR_spot.getRow()<<","<<CAR_spot.getColumn()<< " " <<CAR_direc<<endl;
if(CurrentPlayer==2)
nextTurn();
else
CurrentPlayer++;
}
void GameEngine::gameProcessing()
{
switch (currentGameState)
{
case GS_INIT:
{
//create GameState window
gameState = new GameState();
gameState->setActive("NextTurnBtn", false);
gameState->setActive("ExchangeBtn", false);
//init bank
createCardBank();
//players
createPlayers();
//init map
creatMap();
throwDices();
currentGameState = GS_SELECT_PLAYER_ORDER;
break;
}
case GS_SELECT_PLAYER_ORDER:
{
createPlayersQueue();
gameState->setCurrentPlayer(*currentPlayer);
currentChipType = VILLAGE;
currentGameState = GS_PUT_FIRST_CHIP;
break;
}
case GS_PUT_FIRST_CHIP:
{
highlightAllowedVertexes();
if (chipPut)
{
currentPlayer->putChip(*chipForPut, true);
chipPut = false;
isCalcAllowedPuts = true;
currentChipType = ROAD;
currentGameState = GS_PUT_FIRST_ROAD;
}
break;
}
case GS_PUT_FIRST_ROAD:
{
highlightAllowedVertexes();
if (chipPut)
{
currentPlayer->putChip(*chipForPut, true);
chipPut = false;
isCalcAllowedPuts = true;
currentChipType = VILLAGE;
++firstTurnsCounter;
if (firstTurnsCounter < players.size())
{
currentGameState = GS_PUT_FIRST_CHIP;
nextTurn();
}
else
{
currentGameState = GS_PUT_SECOND_CHIP;
}
}
}
case GS_PUT_SECOND_CHIP:
{
highlightAllowedVertexes();
if (chipPut)
{
currentPlayer->putChip(*chipForPut, true);
currentPlayer->getLastChip()->getRecourcesFromHexagons();
chipPut = false;
isCalcAllowedPuts = true;
currentChipType = ROAD;
currentGameState = GS_PUT_SECOND_ROAD;
}
break;
}
case GS_PUT_SECOND_ROAD:
{
highlightAllowedVertexes();
if (chipPut)
{
currentPlayer->putChip(*chipForPut, true);
chipPut = false;
isCalcAllowedPuts = true;
currentChipType = VILLAGE;
++firstTurnsCounter;
if (firstTurnsCounter < players.size()*2)
{
currentGameState = GS_PUT_SECOND_CHIP;
nextTurn();
}
else
currentGameState = GS_THROW_DICES;
}
break;
}
case GS_THROW_DICES:
{
throwDices();
for (int i = 0; i < MAX_HEXAGON_COUNT; ++i)
{
if (hexagons[i].getDice() == dices.dice())
{
int resToDist = hexagons[i].getResourcesCountToDistribute();
if (canGetFromBank((eCardType) hexagons[i].getType(), resToDist))
{
hexagons[i].distributeResources();
}
}
}
gameState->setCurrentPlayer(*currentPlayer);
currentGameState = GS_PLAYER_TURN;
break;
}
case GS_PLAYER_TURN:
{
gameState->setActive("NextTurnBtn", true);
gameState->setActive("ExchangeBtn", true);
highlightAllowedVertexes();
if (chipPut)
{
currentPlayer->putChip(*chipForPut);
chipPut = false;
allowedPuts.clear();
gameState->setCurrentPlayer(*currentPlayer);
}
break;
}
case GS_TURN_END:
{
isCalcAllowedPuts = true;
currentGameState = GS_THROW_DICES;
nextTurn();
break;
}
case GS_END:
{
break;
}
case GS_ERROR:
{
break;
}
}
}
void Server_Game::doStartGameIfReady()
{
Server_DatabaseInterface *databaseInterface = room->getServer()->getDatabaseInterface();
QMutexLocker locker(&gameMutex);
if (getPlayerCount() < maxPlayers)
return;
QMapIterator<int, Server_Player *> playerIterator(players);
while (playerIterator.hasNext()) {
Server_Player *p = playerIterator.next().value();
if (!p->getReadyStart() && !p->getSpectator())
return;
}
playerIterator.toFront();
while (playerIterator.hasNext()) {
Server_Player *p = playerIterator.next().value();
if (!p->getSpectator())
p->setupZones();
}
gameStarted = true;
playerIterator.toFront();
while (playerIterator.hasNext()) {
Server_Player *player = playerIterator.next().value();
player->setConceded(false);
player->setReadyStart(false);
}
if (firstGameStarted) {
currentReplay->set_duration_seconds(secondsElapsed - startTimeOfThisGame);
replayList.append(currentReplay);
currentReplay = new GameReplay;
currentReplay->set_replay_id(databaseInterface->getNextReplayId());
ServerInfo_Game *gameInfo = currentReplay->mutable_game_info();
getInfo(*gameInfo);
gameInfo->set_started(false);
Event_GameStateChanged omniscientEvent;
createGameStateChangedEvent(&omniscientEvent, 0, true, true);
GameEventContainer *replayCont = prepareGameEvent(omniscientEvent, -1);
replayCont->set_seconds_elapsed(0);
replayCont->clear_game_id();
currentReplay->add_event_list()->CopyFrom(*replayCont);
delete replayCont;
startTimeOfThisGame = secondsElapsed;
} else
firstGameStarted = true;
sendGameStateToPlayers();
activePlayer = -1;
nextTurn();
locker.unlock();
ServerInfo_Game gameInfo;
gameInfo.set_room_id(room->getId());
gameInfo.set_game_id(gameId);
gameInfo.set_started(true);
emit gameInfoChanged(gameInfo);
}
GraphicsScene::GraphicsScene(GameType type, QSize fieldSize, QRect sceneSize):
_type(type), QGraphicsScene(sceneSize)
{
int fszX =fieldSize.width();
int fszY =fieldSize.height();
cerr << "GraphicsScene : scene size : " << this->width() << ", " << this->height() << endl;
int fct = max(fszX, fszY);
int sz = min(width()/(fct+3), height()/(fct+3));
_scene = new Scene(QSize(width(), height()), QPoint(sz*1.5,sz*1.5), sz, fszX, fszY);
_figures = new PlayersFigures(_scene);
_gameRules = new GameRules(fszX, fszY, _figures);
_timer = new QTimer(this);
connect(_timer,SIGNAL(timeout()), this ,SLOT(update()));
// set "Skip turn" button:
_skipTurnButton = new QPushButton(tr("Skip turn"));
_skipTurnButton->resize(80,40);
connect(_skipTurnButton, SIGNAL(clicked()), SLOT(nextTurn()));
_skipTurnButton->move(width() - 100, height() - 50);
_skipTurnButton->setWindowOpacity(0.8);
// set "Menu" button
_menuOpenButton = new QPushButton(tr("Menu"));
_menuOpenButton->resize(80,40);
connect(_menuOpenButton, SIGNAL(clicked()), SLOT(openMenu()));
_menuOpenButton->move((0.1)*sz, sz/3);
_menuOpenButton->setWindowOpacity(0.8);
// set "Menu" :
_dialogMenu = new DialogMenu();
connect(_dialogMenu, SIGNAL(sendCloseMenu()), SLOT(closeMenu()));
connect(_dialogMenu, SIGNAL(sendUndoLastMove()), SLOT(undoLastMove()));
connect(_dialogMenu, SIGNAL(sendResetGame()), SLOT(resetGame()));
connect(this, SIGNAL(sendAddToRedFigures(int)), _dialogMenu, SLOT(addToRedFigures(int)));
connect(this, SIGNAL(sendAddToBlueFigures(int)), _dialogMenu, SLOT(addToBlueFigures(int)));
_dialogMenu->move(_menuOpenButton->pos());
_dialogMenu->setWindowOpacity(0.85);
_dialogMenu->hide();
QWidget * _dialogMenuWidget = dynamic_cast<QWidget *>(_dialogMenu);
// add all widgets in GraphicsScene as
QWidget *widgets[] = { _skipTurnButton, _menuOpenButton, _dialogMenuWidget };
for (uint i = 0; i < sizeof(widgets) / sizeof(*widgets); ++i) {
QGraphicsProxyWidget *proxy = new QGraphicsProxyWidget(0);
proxy->setWidget(widgets[i]);
addItem(proxy);
}
// setup ComputerPlayer:
if (_type==HumanVsMachine){
_computerType = 1;
_computerMind = new ComputerPlayer(_gameRules, _computerType);
}else if (_type==MachineVsHuman){
_computerType = 0;
_computerMind = new ComputerPlayer(_gameRules, _computerType);
}else if (_type == MachineVsMachine){
_computerMind = new ComputerPlayer(_gameRules, 0);
_computerMind2 = new ComputerPlayer(_gameRules, 1);
}
// initialize():
_scene->initialize();
_gameRules->displayGrid();
_timer->start(100);
// start computerMind:
if (_type==MachineVsHuman || _type==MachineVsMachine){
QPoint p = _computerMind->suggest();
cerr << "suggest: " << p.x() << ", " << p.y() << endl;
if (p.x() >= 0 && p.y() >= 0){
moveOnPosition(p);
}else{
// skip turn:
nextTurn();
}
}
}
int main(int argc, char * argv) {
if (argc > 1) {
printf("\n\tTicTacToe by scruff3y, 2016.\n\n");
printf("How to play:\n");
printf("The rules are the same as regular tic-tac-toe, fill a row, column or diagonal\n");
printf("with your tile, and you win!\n\n");
printf("To make a move, enter the row and column number of the tile you'd like to play on.\n\n");
printf("If you really want to get a party going, try playing on a size 10 board\n");
printf("with 10 players!\n\n");
printf("Or, for the masochists, play a game against the computer. Hint: you will lose.\n");
printf("(This is only availiable on a board size of 2 or 3\n");
exit(0);
}
// This is just used to clear stdin between inputs.
int c;
// Welcome.
printf("\n\tWelcome to TicTacToe!\n\n");
printf("What size game would you like to play?: ");
scanf("%i", &NUMBER_OF_GAME_SQUARES);
while ((NUMBER_OF_GAME_SQUARES < 2) || (NUMBER_OF_GAME_SQUARES > 10)) {
while ((c = getc(stdin)) != '\n');
printf("Sorry, the game size must be between 2 and 10 squares.\n");
printf("Please enter another value: ");
scanf("%i", &NUMBER_OF_GAME_SQUARES);
}
while ((c = getc(stdin)) != '\n');
// Init game board.
GameBoard game = {0};
char numberOfPlayers = 0;
printf("How many players?: ");
scanf("%i", &numberOfPlayers);
while ((numberOfPlayers < 2) || (numberOfPlayers > 26)) {
while ((c = getc(stdin)) != '\n');
printf("Please specify a number between 2 and 26: ");
scanf("%i", &numberOfPlayers);
}
// init playerlist.
PlayerList playerList = InitPlayerList(numberOfPlayers);
if ((numberOfPlayers == 2) && (NUMBER_OF_GAME_SQUARES <= 3)) {
while ((c = getc(stdin)) != '\n');
printf("Human or computer opponent (Y/N)?: ");
char input;
scanf("%c", &input);
while ((input != 'Y') && (input != 'N') && (input != 'y') && (input != 'n')) {
while ((c = getc(stdin)) != '\n');
printf("Please try again: ");
scanf("%c", &input);
}
if ((input == 'Y') || (input == 'y')) playerList.players[0].human = FALSE;
}
/*
Main game loop:
1. Check if game is over.
2. If it isn't, do the next turn (data on whos turn it is stored in PlayerList)
3. Otherwise, exit.
*/
while (TRUE) {
printBoard(game);
int gamestate = IsWon(game);
if (gamestate != TRUE) {
gameEnd(gamestate);
exit(0);
}
else {
nextTurn(&game, &playerList);
}
}
return 0;
}
