int getPermutations(Board *startBoard, int *pieces, Turn *possibleTurns) {
int turnNumber = 0;
Board board;
Board nextBoard;
for (int a = 0; a <=2; a++) {
for (int b = 0; b <= 2; b++) {
if (a == b) continue;
for (int c = 0; c <= 2; c++) {
if (c == b || c == a) continue;
// initialise board back to start state
copyBoard(startBoard, &board);
// execute moves, recording moves to the turn
getPiecePlacement(&board, pieces[a], &(possibleTurns[turnNumber].moves[0]));
executeMove(&board, &nextBoard, &(possibleTurns[turnNumber].moves[0]));
getPiecePlacement(&nextBoard, pieces[b], &(possibleTurns[turnNumber].moves[1]));
executeMove(&nextBoard, &board, &(possibleTurns[turnNumber].moves[1]));
getPiecePlacement(&board, pieces[c], &(possibleTurns[turnNumber].moves[2]));
executeMove(&board, &nextBoard, &(possibleTurns[turnNumber].moves[2]));
turnNumber++;
}
}
}
return turnNumber;
}
void Tank::handleOrders(float delta)
{
while (!_orders.empty()) {
Order order = _orders.front();
ExecResult result = ExecResult::Done;
switch (order.type) {
case OrderType::Move: result = executeMove(order.p); break;
case OrderType::Aim: result = executeAim(order.p); break;
default: break;
}
if (result == ExecResult::Done) {
_orderDelayElapsed = 0;
_orders.pop_front();
continue; // Handle next order
} else if (result == ExecResult::InProgress) {
_orderDelayElapsed = 0;
break; // Stop handling
} else if (result == ExecResult::Delayed) {
_orderDelayElapsed += delta;
if (_orderDelayElapsed > gOrderDelayTimeout) {
_orderDelayElapsed = 0;
// Fail order by timeout (see below)
} else {
break; // Continue trying
}
}
// Failed order -- stop all orders in list
_orders.clear();
}
}
int main(int argc, char **argv) {
char *buffer;
size_t bufsize = 32;
size_t characters;
buffer = (char *)malloc(bufsize * sizeof(char));
printf("To get started, whos score do you want to beat?\n");
getline(&buffer, &bufsize, stdin);
removeNewLine(buffer, bufsize);
printf("Ok! Time to beat %s!\n", buffer);
/////////////////////////////////////
Board board = {0};
Board nextBoard = {0};
while (true) {
printBoard(&board);
prettyPrintPieces(PIECES);
printf("Enter 3 piece numbers:\n");
int pieces[3];
scanf("%d %d %d", &pieces[0], &pieces[1], &pieces[2]);
Turn turns[20];
int nTurns = getPermutations(&board, pieces, turns);
int t = getMaxTurnIndex(turns, nTurns);
printf(">>>>>>>\n");
printTurn(&turns[t]);
executeMove(&board, &nextBoard, &(turns[t].moves[0]));
executeMove(&nextBoard, &board, &(turns[t].moves[1]));
executeMove(&board, &nextBoard, &(turns[t].moves[2]));
cleanRows(&nextBoard, &board);
}
}
void Game::moveDirection(std::string direct){
int legt = this->length;
//Horizontal +1 ==left, -1 ==right, 0== doesn't move
for(int i = 0; i < legt; i++){
for (int j = 0; j < legt; j++){
for (int k = j+1; k < legt; k++){
bool contin =false;
if(direct=="left"){
contin = executeMove(i,j,i,k);
}else if(direct=="right"){
contin = executeMove(i,legt-1-j,i,legt-1-k);
}else if(direct=="up"){
contin = executeMove(j,i,k,i);
}else if(direct=="down"){
contin = executeMove(legt-1-j, i, legt-1-k, i);
}
if(contin==false)
break;
}
}
}
}
int main(int argc, const char * argv[])
{
int origIndex, destIndex, origX, origY, destX, destY;
bool legalMove = false;
short unsigned int victory = VC_NO_VICTORY;
initialize();
printBoard();
while(!victory){
while (!legalMove){
origIndex = readIndex(ORIGINE);
destIndex = readIndex(DESTINATION);
transf_index2rel(origIndex, &origX, &origY);
transf_index2rel(destIndex, &destX, &destY);
if (isMoveLegal (origX, origY, destX, destY)){
executeMove(origX, origY, destX, destY);
printBoard();
victory = checkForVictory();
victoryMessage(victory);
setColor();
}
else printf("Illegal move, let's try again!\n");
}
}
printf("END\n");
return 0;
}
