[Orxonox-commit 5567] r10230 - code/branches/minigame4DHS14/src/modules/mini4dgame
landauf at orxonox.net
landauf at orxonox.net
Sun Feb 1 14:55:44 CET 2015
Author: landauf
Date: 2015-02-01 14:55:44 +0100 (Sun, 01 Feb 2015)
New Revision: 10230
Modified:
code/branches/minigame4DHS14/src/modules/mini4dgame/Mini4Dgame.cc
code/branches/minigame4DHS14/src/modules/mini4dgame/Mini4Dgame.h
code/branches/minigame4DHS14/src/modules/mini4dgame/Mini4DgameAI.cc
code/branches/minigame4DHS14/src/modules/mini4dgame/Mini4DgameAI.h
code/branches/minigame4DHS14/src/modules/mini4dgame/Mini4DgameBoard.cc
code/branches/minigame4DHS14/src/modules/mini4dgame/Mini4DgameBoard.h
Log:
replaced tabs with spaces. no changes in code.
Modified: code/branches/minigame4DHS14/src/modules/mini4dgame/Mini4Dgame.cc
===================================================================
--- code/branches/minigame4DHS14/src/modules/mini4dgame/Mini4Dgame.cc 2015-02-01 13:50:46 UTC (rev 10229)
+++ code/branches/minigame4DHS14/src/modules/mini4dgame/Mini4Dgame.cc 2015-02-01 13:55:44 UTC (rev 10230)
@@ -52,8 +52,8 @@
namespace orxonox
{
- SetConsoleCommand("Mini4Dgame", "setStone", &Mini4Dgame::setStone).addShortcut();
- SetConsoleCommand("Mini4Dgame", "undoStone", &Mini4Dgame::undoStone).addShortcut();
+ SetConsoleCommand("Mini4Dgame", "setStone", &Mini4Dgame::setStone).addShortcut();
+ SetConsoleCommand("Mini4Dgame", "undoStone", &Mini4Dgame::undoStone).addShortcut();
RegisterUnloadableClass(Mini4Dgame);
@@ -87,11 +87,11 @@
*/
void Mini4Dgame::cleanup()
{
- if(this->board_ != NULL)// Destroy the board, if present.
- {
- //this->board_->destroy();
- this->board_ = 0;
- }
+ if(this->board_ != NULL)// Destroy the board, if present.
+ {
+ //this->board_->destroy();
+ this->board_ = 0;
+ }
}
/**
@@ -102,18 +102,18 @@
{
if (this->board_ != NULL) // There needs to be a Mini4DgameCenterpoint, i.e. the area the game takes place.
{
- /*
- if (this->board_ == NULL)
- {
- this->board_ = new Mini4DgameBoard(this->board_->getContext());
- // Apply the template for the ball specified by the centerpoint.
- this->board_->addTemplate(this->center_->getBoardtemplate());
- }
- */
+ /*
+ if (this->board_ == NULL)
+ {
+ this->board_ = new Mini4DgameBoard(this->board_->getContext());
+ // Apply the template for the ball specified by the centerpoint.
+ this->board_->addTemplate(this->center_->getBoardtemplate());
+ }
+ */
- // Attach the board to the centerpoint and set the parameters as specified in the centerpoint, the ball is attached to.
+ // Attach the board to the centerpoint and set the parameters as specified in the centerpoint, the ball is attached to.
- this->board_->setPosition(0, 0, 0);
+ this->board_->setPosition(0, 0, 0);
}
else // If no centerpoint was specified, an error is thrown and the level is exited.
@@ -140,7 +140,7 @@
*/
void Mini4Dgame::end()
{
- this->cleanup();
+ this->cleanup();
// Call end for the parent class.
Deathmatch::end();
@@ -182,7 +182,7 @@
void Mini4Dgame::undoStone()//Vector4 move, const int playerColor)
{
- ObjectList<Mini4DgameBoard>::iterator it = ObjectList<Mini4DgameBoard>::begin();
+ ObjectList<Mini4DgameBoard>::iterator it = ObjectList<Mini4DgameBoard>::begin();
it->undoMove();
}
Modified: code/branches/minigame4DHS14/src/modules/mini4dgame/Mini4Dgame.h
===================================================================
--- code/branches/minigame4DHS14/src/modules/mini4dgame/Mini4Dgame.h 2015-02-01 13:50:46 UTC (rev 10229)
+++ code/branches/minigame4DHS14/src/modules/mini4dgame/Mini4Dgame.h 2015-02-01 13:55:44 UTC (rev 10230)
@@ -41,16 +41,16 @@
namespace orxonox
{
- namespace mini4DgamePlayerColor
- {
- enum color
- {
- none,
- red,
- blue,
- green
- };
- }
+ namespace mini4DgamePlayerColor
+ {
+ enum color
+ {
+ none,
+ red,
+ blue,
+ green
+ };
+ }
/**
@brief
@@ -61,7 +61,7 @@
class _Mini4DgameExport Mini4Dgame : public Deathmatch
{
public:
- Mini4Dgame(Context* context); //!< Constructor. Registers and initializes the object.
+ Mini4Dgame(Context* context); //!< Constructor. Registers and initializes the object.
virtual ~Mini4Dgame(); //!< Destructor. Cleans up, if initialized.
virtual void start(void); //!< Starts the Mini4Dgame minigame.
@@ -70,10 +70,10 @@
virtual void spawnPlayer(PlayerInfo* player); //!< Spawns the input player.
void setGameboard(Mini4DgameBoard* board)
- { this->board_ = board; }
+ { this->board_ = board; }
Mini4DgameBoard* getBoard(void)
- { return this->board_; }
+ { return this->board_; }
static void undoStone();
Modified: code/branches/minigame4DHS14/src/modules/mini4dgame/Mini4DgameAI.cc
===================================================================
--- code/branches/minigame4DHS14/src/modules/mini4dgame/Mini4DgameAI.cc 2015-02-01 13:50:46 UTC (rev 10229)
+++ code/branches/minigame4DHS14/src/modules/mini4dgame/Mini4DgameAI.cc 2015-02-01 13:55:44 UTC (rev 10230)
@@ -73,43 +73,43 @@
Vector4 Mini4DgameAI::makeMove(float timeout)
{
- this->copyBoard();
- std::list<Vector4> possibleMoves = this->getPossibleMoves();
+ this->copyBoard();
+ std::list<Vector4> possibleMoves = this->getPossibleMoves();
- //TODO: alphabeta ueber possibleMoves
+ //TODO: alphabeta ueber possibleMoves
- //when timeout
- Vector4 move = possibleMoves.front();
- return move;
+ //when timeout
+ Vector4 move = possibleMoves.front();
+ return move;
}
void Mini4DgameAI::copyBoard()
{
- for(int i=0;i<4;i++){
- for(int j=0;j<4;j++){
- for(int k=0;k<4;k++){
- for(int l=0;l<4;l++){
- this->board_[i][j][k][l]=this->center_->board[i][j][k][l];
- }
- }
- }
- }
+ for(int i=0;i<4;i++){
+ for(int j=0;j<4;j++){
+ for(int k=0;k<4;k++){
+ for(int l=0;l<4;l++){
+ this->board_[i][j][k][l]=this->center_->board[i][j][k][l];
+ }
+ }
+ }
+ }
}
std::list<Vector4> Mini4DgameAI::getPossibleMoves()
{
- std::list<Vector4> possibleMoves = new std::list<Vector4>;
- for(int i=0;i<4;i++){
- for(int j=0;j<4;j++){
- for(int k=0;k<4;k++){
- for(int l=0;l<4;l++){
- if (this->board_[i][j][k][l]==mini4DgamePlayerColor::none)
- possibleMoves.push_back(Vector4(i,j,k,l));
- }
- }
- }
- }
- return possibleMoves;
+ std::list<Vector4> possibleMoves = new std::list<Vector4>;
+ for(int i=0;i<4;i++){
+ for(int j=0;j<4;j++){
+ for(int k=0;k<4;k++){
+ for(int l=0;l<4;l++){
+ if (this->board_[i][j][k][l]==mini4DgamePlayerColor::none)
+ possibleMoves.push_back(Vector4(i,j,k,l));
+ }
+ }
+ }
+ }
+ return possibleMoves;
}
/**
Modified: code/branches/minigame4DHS14/src/modules/mini4dgame/Mini4DgameAI.h
===================================================================
--- code/branches/minigame4DHS14/src/modules/mini4dgame/Mini4DgameAI.h 2015-02-01 13:50:46 UTC (rev 10229)
+++ code/branches/minigame4DHS14/src/modules/mini4dgame/Mini4DgameAI.h 2015-02-01 13:55:44 UTC (rev 10230)
@@ -57,7 +57,7 @@
class _Mini4DgameExport Mini4DgameAI : public Controller, public Tickable
{
public:
- Mini4DgameAI(Context* context); //!< Constructor. Registers and initializes the object.
+ Mini4DgameAI(Context* context); //!< Constructor. Registers and initializes the object.
virtual ~Mini4DgameAI();
//void setConfigValues();
@@ -68,7 +68,7 @@
@param timeout
The time the AI has to decide on a move. (Sets the strength of the AI)
@return move
- The move that the AI decided to make.
+ The move that the AI decided to make.
*/
Vector4 makeMove(float timeout);
@@ -76,7 +76,7 @@
virtual void tick(float dt);
void setCenterpoint(Mini4DgameCenterpoint* center)
- { this->center_ = center; }
+ { this->center_ = center; }
protected:
Modified: code/branches/minigame4DHS14/src/modules/mini4dgame/Mini4DgameBoard.cc
===================================================================
--- code/branches/minigame4DHS14/src/modules/mini4dgame/Mini4DgameBoard.cc 2015-02-01 13:50:46 UTC (rev 10229)
+++ code/branches/minigame4DHS14/src/modules/mini4dgame/Mini4DgameBoard.cc 2015-02-01 13:55:44 UTC (rev 10230)
@@ -59,14 +59,14 @@
//initialize board
for(int i=0;i<4;i++){
- for(int j=0;j<4;j++){
- for(int k=0;k<4;k++){
- for(int l=0;l<4;l++){
- this->board[i][j][k][l]=mini4DgamePlayerColor::none;
- this->blinkingBillboards[i][j][k][l] = 0;
- }
- }
- }
+ for(int j=0;j<4;j++){
+ for(int k=0;k<4;k++){
+ for(int l=0;l<4;l++){
+ this->board[i][j][k][l]=mini4DgamePlayerColor::none;
+ this->blinkingBillboards[i][j][k][l] = 0;
+ }
+ }
+ }
}
this->player_toggle_ = false;
this->checkGametype();
@@ -79,30 +79,30 @@
SUPER(Mini4DgameBoard, XMLPort, xmlelement, mode);
}
- /**
+ /**
@brief checks if the move is valid
@param the position where to put the stone plus the player who makes the move
*/
bool Mini4DgameBoard::isValidMove(const Mini4DgamePosition& move)
{
- return (move.x<4 && move.y<4 && move.z<4 && move.w<4
- && move.x>=0 && move.y>=0 && move.z>=0 && move.w>=0
- && this->board[move.x][move.y][move.z][move.w] == mini4DgamePlayerColor::none);
+ return (move.x<4 && move.y<4 && move.z<4 && move.w<4
+ && move.x>=0 && move.y>=0 && move.z>=0 && move.w>=0
+ && this->board[move.x][move.y][move.z][move.w] == mini4DgamePlayerColor::none);
}
- void Mini4DgameBoard::undoMove()
- {
- const Mini4DgamePosition& move = moves.back();
- moves.pop_back();
- this->board[move.x][move.y][move.z][move.w] = mini4DgamePlayerColor::none;
- this->blinkingBillboards[move.x][move.y][move.z][move.w]->destroy();
- this->blinkingBillboards[move.x][move.y][move.z][move.w] = 0;
- if(player_toggle_){
- this->player_toggle_ = false;
- }else{
- this->player_toggle_ = true;
- }
- }
+ void Mini4DgameBoard::undoMove()
+ {
+ const Mini4DgamePosition& move = moves.back();
+ moves.pop_back();
+ this->board[move.x][move.y][move.z][move.w] = mini4DgamePlayerColor::none;
+ this->blinkingBillboards[move.x][move.y][move.z][move.w]->destroy();
+ this->blinkingBillboards[move.x][move.y][move.z][move.w] = 0;
+ if(player_toggle_){
+ this->player_toggle_ = false;
+ }else{
+ this->player_toggle_ = true;
+ }
+ }
/**
@brief makes a move on the logic playboard
@@ -110,792 +110,792 @@
*/
void Mini4DgameBoard::makeMove(const Mini4DgamePosition& move)
{
- if(this->isValidMove(move))
- {
- if(!moves.empty())
- {
- //stop blinking of last move
- const Mini4DgamePosition& lastMove = moves.back();
- this->blinkingBillboards[lastMove.x][lastMove.y][lastMove.z][lastMove.w]
- ->setActive(false);
- this->blinkingBillboards[lastMove.x][lastMove.y][lastMove.z][lastMove.w]
- ->setScale(0.1);
- }
+ if(this->isValidMove(move))
+ {
+ if(!moves.empty())
+ {
+ //stop blinking of last move
+ const Mini4DgamePosition& lastMove = moves.back();
+ this->blinkingBillboards[lastMove.x][lastMove.y][lastMove.z][lastMove.w]
+ ->setActive(false);
+ this->blinkingBillboards[lastMove.x][lastMove.y][lastMove.z][lastMove.w]
+ ->setScale(0.1);
+ }
- moves.push_back(move);
- mini4DgamePlayerColor::color playerColor = mini4DgamePlayerColor::none;
- if(player_toggle_){
- playerColor = mini4DgamePlayerColor::blue;
- this->player_toggle_ = false;
- }else{
- playerColor = mini4DgamePlayerColor::green;
- this->player_toggle_ = true;
- }
+ moves.push_back(move);
+ mini4DgamePlayerColor::color playerColor = mini4DgamePlayerColor::none;
+ if(player_toggle_){
+ playerColor = mini4DgamePlayerColor::blue;
+ this->player_toggle_ = false;
+ }else{
+ playerColor = mini4DgamePlayerColor::green;
+ this->player_toggle_ = true;
+ }
- this->board[move.x][move.y][move.z][move.w] = (mini4DgamePlayerColor::color) playerColor;
+ this->board[move.x][move.y][move.z][move.w] = (mini4DgamePlayerColor::color) playerColor;
- BlinkingBillboard* bb = new BlinkingBillboard(this->getContext());
- bb->setFrequency(0.3);
- bb->setAmplitude(0.1);
+ BlinkingBillboard* bb = new BlinkingBillboard(this->getContext());
+ bb->setFrequency(0.3);
+ bb->setAmplitude(0.1);
- switch(move.w){
- case 0: bb->setMaterial("Numbers/One");
- bb->setPosition(60.0f*move.x-95,60.0f*move.y-95,60.0f*move.z-95);
- break;
- case 1: bb->setMaterial("Numbers/Two");
- bb->setPosition(60.0f*move.x-85,60.0f*move.y-85,60.0f*move.z-95);
- break;
- case 2: bb->setMaterial("Numbers/Three");
- bb->setPosition(60.0f*move.x-85,60.0f*move.y-95,60.0f*move.z-85);
- break;
- case 3: bb->setMaterial("Numbers/Four");
- bb->setPosition(60.0f*move.x-85,60.0f*move.y-85,60.0f*move.z-85);
- break;
- }
+ switch(move.w){
+ case 0: bb->setMaterial("Numbers/One");
+ bb->setPosition(60.0f*move.x-95,60.0f*move.y-95,60.0f*move.z-95);
+ break;
+ case 1: bb->setMaterial("Numbers/Two");
+ bb->setPosition(60.0f*move.x-85,60.0f*move.y-85,60.0f*move.z-95);
+ break;
+ case 2: bb->setMaterial("Numbers/Three");
+ bb->setPosition(60.0f*move.x-85,60.0f*move.y-95,60.0f*move.z-85);
+ break;
+ case 3: bb->setMaterial("Numbers/Four");
+ bb->setPosition(60.0f*move.x-85,60.0f*move.y-85,60.0f*move.z-85);
+ break;
+ }
- switch(playerColor){
- case mini4DgamePlayerColor::red:
- bb->setColour(ColourValue(1,0,0)); break;
- case mini4DgamePlayerColor::green:
- bb->setColour(ColourValue(0,1,0)); break;
- case mini4DgamePlayerColor::blue:
- bb->setColour(ColourValue(0,0,1)); break;
- default: break;
- }
+ switch(playerColor){
+ case mini4DgamePlayerColor::red:
+ bb->setColour(ColourValue(1,0,0)); break;
+ case mini4DgamePlayerColor::green:
+ bb->setColour(ColourValue(0,1,0)); break;
+ case mini4DgamePlayerColor::blue:
+ bb->setColour(ColourValue(0,0,1)); break;
+ default: break;
+ }
- this->attach(bb);
- this->blinkingBillboards[move.x][move.y][move.z][move.w] = bb;
+ this->attach(bb);
+ this->blinkingBillboards[move.x][move.y][move.z][move.w] = bb;
- Mini4DgameWinner winner = this->getWinner();
- if(winner.color_ != mini4DgamePlayerColor::none)
- {
- orxout(user_status) << "Mini4Dgame: win!!!!!!!" << endl;
- for(int i=0;i<4;i++){
- BlinkingBillboard* redFlare = new BlinkingBillboard(this->getContext());
- redFlare->setFrequency(0.5);
- redFlare->setAmplitude(3);
- redFlare->setPosition(60.0f*(int)winner.winningRow[i]-90,
- 60.0f*(int)winner.winningColumn[i]-90,
- 60.0f*(int)winner.winningHeight[i]-90);
- redFlare->setMaterial("Flares/lensflare");
- redFlare->setColour(ColourValue(1,0,0));
- this->attach(redFlare);
- BlinkingBillboard* bb = this->blinkingBillboards[winner.winningRow[i]]
- [winner.winningColumn[i]]
- [winner.winningHeight[i]]
- [winner.winningNumber[i]];
- bb->setActive(true);//start blinking
- }
- }
- }else{
- orxout(internal_error) << "Mini4Dgame: not a valid move"<< endl;
- }
+ Mini4DgameWinner winner = this->getWinner();
+ if(winner.color_ != mini4DgamePlayerColor::none)
+ {
+ orxout(user_status) << "Mini4Dgame: win!!!!!!!" << endl;
+ for(int i=0;i<4;i++){
+ BlinkingBillboard* redFlare = new BlinkingBillboard(this->getContext());
+ redFlare->setFrequency(0.5);
+ redFlare->setAmplitude(3);
+ redFlare->setPosition(60.0f*(int)winner.winningRow[i]-90,
+ 60.0f*(int)winner.winningColumn[i]-90,
+ 60.0f*(int)winner.winningHeight[i]-90);
+ redFlare->setMaterial("Flares/lensflare");
+ redFlare->setColour(ColourValue(1,0,0));
+ this->attach(redFlare);
+ BlinkingBillboard* bb = this->blinkingBillboards[winner.winningRow[i]]
+ [winner.winningColumn[i]]
+ [winner.winningHeight[i]]
+ [winner.winningNumber[i]];
+ bb->setActive(true);//start blinking
+ }
+ }
+ }else{
+ orxout(internal_error) << "Mini4Dgame: not a valid move"<< endl;
+ }
}
Mini4DgameWinner Mini4DgameBoard::getWinner()
{
- Mini4DgameWinner winner;
- winner.color_ = mini4DgamePlayerColor::none;
+ Mini4DgameWinner winner;
+ winner.color_ = mini4DgamePlayerColor::none;
- //check diagonals rows-columns-height-numbers
- for(int i=1; i<4; i++)
- {
- if(this->board[i][i][i][i]==mini4DgamePlayerColor::none || this->board[0][0][0][0] != this->board[i][i][i][i])
- break;
- if(i==3)
- {
- winner.color_ = this->board[0][0][0][0];
- for(int x=0; x<4; x++){
- winner.winningRow[x] = x;
- winner.winningColumn[x] = x;
- winner.winningHeight[x] = x;
- winner.winningNumber[x] = x;
- }
- return winner;
- }
- }
- for(int i=1; i<4; i++)
- {
- if(this->board[3-i][i][i][i]==mini4DgamePlayerColor::none || this->board[3][0][0][0] != this->board[3-i][i][i][i])
- break;
- if(i==3)
- {
- winner.color_ = this->board[3][0][0][0];
- for(int x=0; x<4; x++){
- winner.winningRow[x] = 3-x;
- winner.winningColumn[x] = x;
- winner.winningHeight[x] = x;
- winner.winningNumber[x] = x;
- }
- return winner;
- }
- }
- for(int i=1; i<4; i++)
- {
- if(this->board[i][3-i][i][i]==mini4DgamePlayerColor::none || this->board[0][3][0][0] != this->board[i][3-i][i][i])
- break;
- if(i==3)
- {
- winner.color_ = this->board[0][3][0][0];
- for(int x=0; x<4; x++){
- winner.winningRow[x] = x;
- winner.winningColumn[x] = 3-x;
- winner.winningHeight[x] = x;
- winner.winningNumber[x] = x;
- }
- return winner;
- }
- }
- for(int i=1; i<4; i++)
- {
- if(this->board[i][i][3-i][i]==mini4DgamePlayerColor::none || this->board[0][0][3][0] != this->board[i][i][3-i][i])
- break;
- if(i==3)
- {
- winner.color_ = this->board[0][0][3][0];
- for(int x=0; x<4; x++){
- winner.winningRow[x] = x;
- winner.winningColumn[x] = x;
- winner.winningHeight[x] = 3-x;
- winner.winningNumber[x] = x;
- }
- return winner;
- }
- }
- for(int i=1; i<4; i++)
- {
- if(this->board[i][i][i][3-i]==mini4DgamePlayerColor::none || this->board[0][0][0][3] != this->board[i][i][i][3-i])
- break;
- if(i==3)
- {
- winner.color_ = this->board[0][0][0][3];
- for(int x=0; x<4; x++){
- winner.winningRow[x] = x;
- winner.winningColumn[x] = x;
- winner.winningHeight[x] = x;
- winner.winningNumber[x] = 3-x;
- }
- return winner;
- }
- }
- for(int i=1; i<4; i++)
- {
- if(this->board[3-i][3-i][i][i]==mini4DgamePlayerColor::none || this->board[3][3][0][0] != this->board[3-i][3-i][i][i])
- break;
- if(i==3)
- {
- winner.color_ = this->board[3][3][0][0];
- for(int x=0; x<4; x++){
- winner.winningRow[x] = 3-x;
- winner.winningColumn[x] = 3-x;
- winner.winningHeight[x] = x;
- winner.winningNumber[x] = x;
- }
- return winner;
- }
- }
- for(int i=1; i<4; i++)
- {
- if(this->board[3-i][i][3-i][i]==mini4DgamePlayerColor::none || this->board[3][0][3][0] != this->board[3-i][i][3-i][i])
- break;
- if(i==3)
- {
- winner.color_ = this->board[3][0][3][0];
- for(int x=0; x<4; x++){
- winner.winningRow[x] = 3-x;
- winner.winningColumn[x] = x;
- winner.winningHeight[x] = 3-x;
- winner.winningNumber[x] = x;
- }
- return winner;
- }
- }
- for(int i=1; i<4; i++)
- {
- if(this->board[3-i][i][i][3-i]==mini4DgamePlayerColor::none || this->board[3][0][0][3] != this->board[3-i][i][i][3-i])
- break;
- if(i==3)
- {
- winner.color_ = this->board[3][0][0][3];
- for(int x=0; x<4; x++){
- winner.winningRow[x] = 3-x;
- winner.winningColumn[x] = x;
- winner.winningHeight[x] = x;
- winner.winningNumber[x] = 3-x;
- }
- return winner;
- }
- }
+ //check diagonals rows-columns-height-numbers
+ for(int i=1; i<4; i++)
+ {
+ if(this->board[i][i][i][i]==mini4DgamePlayerColor::none || this->board[0][0][0][0] != this->board[i][i][i][i])
+ break;
+ if(i==3)
+ {
+ winner.color_ = this->board[0][0][0][0];
+ for(int x=0; x<4; x++){
+ winner.winningRow[x] = x;
+ winner.winningColumn[x] = x;
+ winner.winningHeight[x] = x;
+ winner.winningNumber[x] = x;
+ }
+ return winner;
+ }
+ }
+ for(int i=1; i<4; i++)
+ {
+ if(this->board[3-i][i][i][i]==mini4DgamePlayerColor::none || this->board[3][0][0][0] != this->board[3-i][i][i][i])
+ break;
+ if(i==3)
+ {
+ winner.color_ = this->board[3][0][0][0];
+ for(int x=0; x<4; x++){
+ winner.winningRow[x] = 3-x;
+ winner.winningColumn[x] = x;
+ winner.winningHeight[x] = x;
+ winner.winningNumber[x] = x;
+ }
+ return winner;
+ }
+ }
+ for(int i=1; i<4; i++)
+ {
+ if(this->board[i][3-i][i][i]==mini4DgamePlayerColor::none || this->board[0][3][0][0] != this->board[i][3-i][i][i])
+ break;
+ if(i==3)
+ {
+ winner.color_ = this->board[0][3][0][0];
+ for(int x=0; x<4; x++){
+ winner.winningRow[x] = x;
+ winner.winningColumn[x] = 3-x;
+ winner.winningHeight[x] = x;
+ winner.winningNumber[x] = x;
+ }
+ return winner;
+ }
+ }
+ for(int i=1; i<4; i++)
+ {
+ if(this->board[i][i][3-i][i]==mini4DgamePlayerColor::none || this->board[0][0][3][0] != this->board[i][i][3-i][i])
+ break;
+ if(i==3)
+ {
+ winner.color_ = this->board[0][0][3][0];
+ for(int x=0; x<4; x++){
+ winner.winningRow[x] = x;
+ winner.winningColumn[x] = x;
+ winner.winningHeight[x] = 3-x;
+ winner.winningNumber[x] = x;
+ }
+ return winner;
+ }
+ }
+ for(int i=1; i<4; i++)
+ {
+ if(this->board[i][i][i][3-i]==mini4DgamePlayerColor::none || this->board[0][0][0][3] != this->board[i][i][i][3-i])
+ break;
+ if(i==3)
+ {
+ winner.color_ = this->board[0][0][0][3];
+ for(int x=0; x<4; x++){
+ winner.winningRow[x] = x;
+ winner.winningColumn[x] = x;
+ winner.winningHeight[x] = x;
+ winner.winningNumber[x] = 3-x;
+ }
+ return winner;
+ }
+ }
+ for(int i=1; i<4; i++)
+ {
+ if(this->board[3-i][3-i][i][i]==mini4DgamePlayerColor::none || this->board[3][3][0][0] != this->board[3-i][3-i][i][i])
+ break;
+ if(i==3)
+ {
+ winner.color_ = this->board[3][3][0][0];
+ for(int x=0; x<4; x++){
+ winner.winningRow[x] = 3-x;
+ winner.winningColumn[x] = 3-x;
+ winner.winningHeight[x] = x;
+ winner.winningNumber[x] = x;
+ }
+ return winner;
+ }
+ }
+ for(int i=1; i<4; i++)
+ {
+ if(this->board[3-i][i][3-i][i]==mini4DgamePlayerColor::none || this->board[3][0][3][0] != this->board[3-i][i][3-i][i])
+ break;
+ if(i==3)
+ {
+ winner.color_ = this->board[3][0][3][0];
+ for(int x=0; x<4; x++){
+ winner.winningRow[x] = 3-x;
+ winner.winningColumn[x] = x;
+ winner.winningHeight[x] = 3-x;
+ winner.winningNumber[x] = x;
+ }
+ return winner;
+ }
+ }
+ for(int i=1; i<4; i++)
+ {
+ if(this->board[3-i][i][i][3-i]==mini4DgamePlayerColor::none || this->board[3][0][0][3] != this->board[3-i][i][i][3-i])
+ break;
+ if(i==3)
+ {
+ winner.color_ = this->board[3][0][0][3];
+ for(int x=0; x<4; x++){
+ winner.winningRow[x] = 3-x;
+ winner.winningColumn[x] = x;
+ winner.winningHeight[x] = x;
+ winner.winningNumber[x] = 3-x;
+ }
+ return winner;
+ }
+ }
- //check diagonals rows-columns-height
- for(int l=0; l<4; l++)
- {
- for(int i=1; i<4; i++)
- {
- if(this->board[i][i][i][l]==mini4DgamePlayerColor::none || this->board[0][0][0][l] != this->board[i][i][i][l])
- break;
- if(i==3)
- {
- winner.color_ = this->board[0][0][0][l];
- for(int x=0; x<4; x++){
- winner.winningRow[x] = x;
- winner.winningColumn[x] = x;
- winner.winningHeight[x] = x;
- winner.winningNumber[x] = l;
- }
- return winner;
- }
- }
- for(int i=1; i<4; i++)
- {
- if(this->board[3-i][i][i][l]==mini4DgamePlayerColor::none || this->board[3][0][0][l] != this->board[3-i][i][i][l])
- break;
- if(i==3)
- {
- winner.color_ = this->board[3][0][0][l];
- for(int x=0; x<4; x++){
- winner.winningRow[x] = 3-x;
- winner.winningColumn[x] = x;
- winner.winningHeight[x] = x;
- winner.winningNumber[x] = l;
- }
- return winner;
- }
- }
- for(int i=1; i<4; i++)
- {
- if(this->board[i][3-i][i][l]==mini4DgamePlayerColor::none || this->board[0][3][0][l] != this->board[i][3-i][i][l])
- break;
- if(i==3)
- {
- winner.color_ = this->board[0][3][0][l];
- for(int x=0; x<4; x++){
- winner.winningRow[x] = x;
- winner.winningColumn[x] = 3-x;
- winner.winningHeight[x] = x;
- winner.winningNumber[x] = l;
- }
- return winner;
- }
- }
- for(int i=1; i<4; i++)
- {
- if(this->board[i][i][3-i][l]==mini4DgamePlayerColor::none || this->board[0][0][3][l] != this->board[i][i][3-i][l])
- break;
- if(i==3)
- {
- winner.color_ = this->board[0][0][3][l];
- for(int x=0; x<4; x++){
- winner.winningRow[x] = x;
- winner.winningColumn[x] = x;
- winner.winningHeight[x] = 3-x;
- winner.winningNumber[x] = l;
- }
- return winner;
- }
- }
- }
+ //check diagonals rows-columns-height
+ for(int l=0; l<4; l++)
+ {
+ for(int i=1; i<4; i++)
+ {
+ if(this->board[i][i][i][l]==mini4DgamePlayerColor::none || this->board[0][0][0][l] != this->board[i][i][i][l])
+ break;
+ if(i==3)
+ {
+ winner.color_ = this->board[0][0][0][l];
+ for(int x=0; x<4; x++){
+ winner.winningRow[x] = x;
+ winner.winningColumn[x] = x;
+ winner.winningHeight[x] = x;
+ winner.winningNumber[x] = l;
+ }
+ return winner;
+ }
+ }
+ for(int i=1; i<4; i++)
+ {
+ if(this->board[3-i][i][i][l]==mini4DgamePlayerColor::none || this->board[3][0][0][l] != this->board[3-i][i][i][l])
+ break;
+ if(i==3)
+ {
+ winner.color_ = this->board[3][0][0][l];
+ for(int x=0; x<4; x++){
+ winner.winningRow[x] = 3-x;
+ winner.winningColumn[x] = x;
+ winner.winningHeight[x] = x;
+ winner.winningNumber[x] = l;
+ }
+ return winner;
+ }
+ }
+ for(int i=1; i<4; i++)
+ {
+ if(this->board[i][3-i][i][l]==mini4DgamePlayerColor::none || this->board[0][3][0][l] != this->board[i][3-i][i][l])
+ break;
+ if(i==3)
+ {
+ winner.color_ = this->board[0][3][0][l];
+ for(int x=0; x<4; x++){
+ winner.winningRow[x] = x;
+ winner.winningColumn[x] = 3-x;
+ winner.winningHeight[x] = x;
+ winner.winningNumber[x] = l;
+ }
+ return winner;
+ }
+ }
+ for(int i=1; i<4; i++)
+ {
+ if(this->board[i][i][3-i][l]==mini4DgamePlayerColor::none || this->board[0][0][3][l] != this->board[i][i][3-i][l])
+ break;
+ if(i==3)
+ {
+ winner.color_ = this->board[0][0][3][l];
+ for(int x=0; x<4; x++){
+ winner.winningRow[x] = x;
+ winner.winningColumn[x] = x;
+ winner.winningHeight[x] = 3-x;
+ winner.winningNumber[x] = l;
+ }
+ return winner;
+ }
+ }
+ }
- //check diagonals rows-columns-numbers
- for(int l=0; l<4; l++)
- {
- for(int i=1; i<4; i++)
- {
- if(this->board[i][i][l][i]==mini4DgamePlayerColor::none || this->board[0][0][l][0] != this->board[i][i][l][i])
- break;
- if(i==3)
- {
- winner.color_ = this->board[0][0][l][0];
- for(int x=0; x<4; x++){
- winner.winningRow[x] = x;
- winner.winningColumn[x] = x;
- winner.winningHeight[x] = l;
- winner.winningNumber[x] = x;
- }
- return winner;
- }
- }
- for(int i=1; i<4; i++)
- {
- if(this->board[3-i][i][l][i]==mini4DgamePlayerColor::none || this->board[3][0][l][0] != this->board[3-i][i][l][i])
- break;
- if(i==3)
- {
- winner.color_ = this->board[3][0][l][0];
- for(int x=0; x<4; x++){
- winner.winningRow[x] = 3-x;
- winner.winningColumn[x] = x;
- winner.winningHeight[x] = l;
- winner.winningNumber[x] = x;
- }
- return winner;
- }
- }
- for(int i=1; i<4; i++)
- {
- if(this->board[i][3-i][l][i]==mini4DgamePlayerColor::none || this->board[0][3][l][0] != this->board[i][3-i][l][i])
- break;
- if(i==3)
- {
- winner.color_ = this->board[0][3][l][0];
- for(int x=0; x<4; x++){
- winner.winningRow[x] = x;
- winner.winningColumn[x] = 3-x;
- winner.winningHeight[x] = l;
- winner.winningNumber[x] = x;
- }
- return winner;
- }
- }
- for(int i=1; i<4; i++)
- {
- if(this->board[i][i][l][3-i]==mini4DgamePlayerColor::none || this->board[0][0][l][3] != this->board[i][i][l][3-i])
- break;
- if(i==3)
- {
- winner.color_ = this->board[0][0][l][3];
- for(int x=0; x<4; x++){
- winner.winningRow[x] = x;
- winner.winningColumn[x] = x;
- winner.winningHeight[x] = l;
- winner.winningNumber[x] = 3-x;
- }
- return winner;
- }
- }
- }
+ //check diagonals rows-columns-numbers
+ for(int l=0; l<4; l++)
+ {
+ for(int i=1; i<4; i++)
+ {
+ if(this->board[i][i][l][i]==mini4DgamePlayerColor::none || this->board[0][0][l][0] != this->board[i][i][l][i])
+ break;
+ if(i==3)
+ {
+ winner.color_ = this->board[0][0][l][0];
+ for(int x=0; x<4; x++){
+ winner.winningRow[x] = x;
+ winner.winningColumn[x] = x;
+ winner.winningHeight[x] = l;
+ winner.winningNumber[x] = x;
+ }
+ return winner;
+ }
+ }
+ for(int i=1; i<4; i++)
+ {
+ if(this->board[3-i][i][l][i]==mini4DgamePlayerColor::none || this->board[3][0][l][0] != this->board[3-i][i][l][i])
+ break;
+ if(i==3)
+ {
+ winner.color_ = this->board[3][0][l][0];
+ for(int x=0; x<4; x++){
+ winner.winningRow[x] = 3-x;
+ winner.winningColumn[x] = x;
+ winner.winningHeight[x] = l;
+ winner.winningNumber[x] = x;
+ }
+ return winner;
+ }
+ }
+ for(int i=1; i<4; i++)
+ {
+ if(this->board[i][3-i][l][i]==mini4DgamePlayerColor::none || this->board[0][3][l][0] != this->board[i][3-i][l][i])
+ break;
+ if(i==3)
+ {
+ winner.color_ = this->board[0][3][l][0];
+ for(int x=0; x<4; x++){
+ winner.winningRow[x] = x;
+ winner.winningColumn[x] = 3-x;
+ winner.winningHeight[x] = l;
+ winner.winningNumber[x] = x;
+ }
+ return winner;
+ }
+ }
+ for(int i=1; i<4; i++)
+ {
+ if(this->board[i][i][l][3-i]==mini4DgamePlayerColor::none || this->board[0][0][l][3] != this->board[i][i][l][3-i])
+ break;
+ if(i==3)
+ {
+ winner.color_ = this->board[0][0][l][3];
+ for(int x=0; x<4; x++){
+ winner.winningRow[x] = x;
+ winner.winningColumn[x] = x;
+ winner.winningHeight[x] = l;
+ winner.winningNumber[x] = 3-x;
+ }
+ return winner;
+ }
+ }
+ }
- //check diagonals rows-height-numbers
- for(int l=0; l<4; l++)
- {
- for(int i=1; i<4; i++)
- {
- if(this->board[i][l][i][i]==mini4DgamePlayerColor::none || this->board[0][l][0][0] != this->board[i][l][i][i])
- break;
- if(i==3)
- {
- winner.color_ = this->board[0][l][0][0];
- for(int x=0; x<4; x++){
- winner.winningRow[x] = x;
- winner.winningColumn[x] = l;
- winner.winningHeight[x] = x;
- winner.winningNumber[x] = x;
- }
- return winner;
- }
- }
- for(int i=1; i<4; i++)
- {
- if(this->board[3-i][l][i][i]==mini4DgamePlayerColor::none || this->board[3][l][0][0] != this->board[3-i][l][i][i])
- break;
- if(i==3)
- {
- winner.color_ = this->board[3][l][0][0];
- for(int x=0; x<4; x++){
- winner.winningRow[x] = 3-x;
- winner.winningColumn[x] = l;
- winner.winningHeight[x] = x;
- winner.winningNumber[x] = x;
- }
- return winner;
- }
- }
- for(int i=1; i<4; i++)
- {
- if(this->board[i][l][3-i][i]==mini4DgamePlayerColor::none || this->board[0][l][3][0] != this->board[i][l][3-i][i])
- break;
- if(i==3)
- {
- winner.color_ = this->board[0][l][3][0];
- for(int x=0; x<4; x++){
- winner.winningRow[x] = x;
- winner.winningColumn[x] = l;
- winner.winningHeight[x] = 3-x;
- winner.winningNumber[x] = x;
- }
- return winner;
- }
- }
- for(int i=1; i<4; i++)
- {
- if(this->board[i][l][i][3-i]==mini4DgamePlayerColor::none || this->board[0][l][0][3] != this->board[i][l][i][3-i])
- break;
- if(i==3)
- {
- winner.color_ = this->board[0][l][0][3];
- for(int x=0; x<4; x++){
- winner.winningRow[x] = x;
- winner.winningColumn[x] = l;
- winner.winningHeight[x] = x;
- winner.winningNumber[x] = 3-x;
- }
- return winner;
- }
- }
- }
+ //check diagonals rows-height-numbers
+ for(int l=0; l<4; l++)
+ {
+ for(int i=1; i<4; i++)
+ {
+ if(this->board[i][l][i][i]==mini4DgamePlayerColor::none || this->board[0][l][0][0] != this->board[i][l][i][i])
+ break;
+ if(i==3)
+ {
+ winner.color_ = this->board[0][l][0][0];
+ for(int x=0; x<4; x++){
+ winner.winningRow[x] = x;
+ winner.winningColumn[x] = l;
+ winner.winningHeight[x] = x;
+ winner.winningNumber[x] = x;
+ }
+ return winner;
+ }
+ }
+ for(int i=1; i<4; i++)
+ {
+ if(this->board[3-i][l][i][i]==mini4DgamePlayerColor::none || this->board[3][l][0][0] != this->board[3-i][l][i][i])
+ break;
+ if(i==3)
+ {
+ winner.color_ = this->board[3][l][0][0];
+ for(int x=0; x<4; x++){
+ winner.winningRow[x] = 3-x;
+ winner.winningColumn[x] = l;
+ winner.winningHeight[x] = x;
+ winner.winningNumber[x] = x;
+ }
+ return winner;
+ }
+ }
+ for(int i=1; i<4; i++)
+ {
+ if(this->board[i][l][3-i][i]==mini4DgamePlayerColor::none || this->board[0][l][3][0] != this->board[i][l][3-i][i])
+ break;
+ if(i==3)
+ {
+ winner.color_ = this->board[0][l][3][0];
+ for(int x=0; x<4; x++){
+ winner.winningRow[x] = x;
+ winner.winningColumn[x] = l;
+ winner.winningHeight[x] = 3-x;
+ winner.winningNumber[x] = x;
+ }
+ return winner;
+ }
+ }
+ for(int i=1; i<4; i++)
+ {
+ if(this->board[i][l][i][3-i]==mini4DgamePlayerColor::none || this->board[0][l][0][3] != this->board[i][l][i][3-i])
+ break;
+ if(i==3)
+ {
+ winner.color_ = this->board[0][l][0][3];
+ for(int x=0; x<4; x++){
+ winner.winningRow[x] = x;
+ winner.winningColumn[x] = l;
+ winner.winningHeight[x] = x;
+ winner.winningNumber[x] = 3-x;
+ }
+ return winner;
+ }
+ }
+ }
- //check diagonals columns-height-numbers
- for(int l=0; l<4; l++)
- {
- for(int i=1; i<4; i++)
- {
- if(this->board[l][i][i][i]==mini4DgamePlayerColor::none || this->board[l][0][0][0] != this->board[l][i][i][i])
- break;
- if(i==3)
- {
- winner.color_ = this->board[l][0][0][0];
- for(int x=0; x<4; x++){
- winner.winningRow[x] = l;
- winner.winningColumn[x] = x;
- winner.winningHeight[x] = x;
- winner.winningNumber[x] = x;
- }
- return winner;
- }
- }
- for(int i=1; i<4; i++)
- {
- if(this->board[l][3-i][i][i]==mini4DgamePlayerColor::none || this->board[l][3][0][0] != this->board[l][3-i][i][i])
- break;
- if(i==3)
- {
- winner.color_ = this->board[l][3][0][0];
- for(int x=0; x<4; x++){
- winner.winningRow[x] = l;
- winner.winningColumn[x] = 3-x;
- winner.winningHeight[x] = x;
- winner.winningNumber[x] = x;
- }
- return winner;
- }
- }
- for(int i=1; i<4; i++)
- {
- if(this->board[l][i][3-i][i]==mini4DgamePlayerColor::none || this->board[l][0][3][0] != this->board[l][i][3-i][i])
- break;
- if(i==3)
- {
- winner.color_ = this->board[l][0][3][0];
- for(int x=0; x<4; x++){
- winner.winningRow[x] = l;
- winner.winningColumn[x] = x;
- winner.winningHeight[x] = 3-x;
- winner.winningNumber[x] = x;
- }
- return winner;
- }
- }
- for(int i=1; i<4; i++)
- {
- if(this->board[l][i][i][3-i]==mini4DgamePlayerColor::none || this->board[l][0][0][3] != this->board[l][i][i][3-i])
- break;
- if(i==3)
- {
- winner.color_ = this->board[l][0][0][3];
- for(int x=0; x<4; x++){
- winner.winningRow[x] = l;
- winner.winningColumn[x] = x;
- winner.winningHeight[x] = x;
- winner.winningNumber[x] = 3-x;
- }
- return winner;
- }
- }
- }
+ //check diagonals columns-height-numbers
+ for(int l=0; l<4; l++)
+ {
+ for(int i=1; i<4; i++)
+ {
+ if(this->board[l][i][i][i]==mini4DgamePlayerColor::none || this->board[l][0][0][0] != this->board[l][i][i][i])
+ break;
+ if(i==3)
+ {
+ winner.color_ = this->board[l][0][0][0];
+ for(int x=0; x<4; x++){
+ winner.winningRow[x] = l;
+ winner.winningColumn[x] = x;
+ winner.winningHeight[x] = x;
+ winner.winningNumber[x] = x;
+ }
+ return winner;
+ }
+ }
+ for(int i=1; i<4; i++)
+ {
+ if(this->board[l][3-i][i][i]==mini4DgamePlayerColor::none || this->board[l][3][0][0] != this->board[l][3-i][i][i])
+ break;
+ if(i==3)
+ {
+ winner.color_ = this->board[l][3][0][0];
+ for(int x=0; x<4; x++){
+ winner.winningRow[x] = l;
+ winner.winningColumn[x] = 3-x;
+ winner.winningHeight[x] = x;
+ winner.winningNumber[x] = x;
+ }
+ return winner;
+ }
+ }
+ for(int i=1; i<4; i++)
+ {
+ if(this->board[l][i][3-i][i]==mini4DgamePlayerColor::none || this->board[l][0][3][0] != this->board[l][i][3-i][i])
+ break;
+ if(i==3)
+ {
+ winner.color_ = this->board[l][0][3][0];
+ for(int x=0; x<4; x++){
+ winner.winningRow[x] = l;
+ winner.winningColumn[x] = x;
+ winner.winningHeight[x] = 3-x;
+ winner.winningNumber[x] = x;
+ }
+ return winner;
+ }
+ }
+ for(int i=1; i<4; i++)
+ {
+ if(this->board[l][i][i][3-i]==mini4DgamePlayerColor::none || this->board[l][0][0][3] != this->board[l][i][i][3-i])
+ break;
+ if(i==3)
+ {
+ winner.color_ = this->board[l][0][0][3];
+ for(int x=0; x<4; x++){
+ winner.winningRow[x] = l;
+ winner.winningColumn[x] = x;
+ winner.winningHeight[x] = x;
+ winner.winningNumber[x] = 3-x;
+ }
+ return winner;
+ }
+ }
+ }
- //check 2d diagonals
- for(int k=0;k<4;k++){
- for(int l=0;l<4;l++){
- //rows-columns
- for(int i=1; i<4; i++)
- {
- if(this->board[i][i][k][l]==mini4DgamePlayerColor::none || this->board[0][0][k][l] != this->board[i][i][k][l])
- break;
- if(i==3)
- {
- winner.color_ = this->board[0][0][k][l];
- for(int x=0; x<4; x++){
- winner.winningRow[x] = x;
- winner.winningColumn[x] = x;
- winner.winningHeight[x] = k;
- winner.winningNumber[x] = l;
- }
- return winner;
- }
- }
- for(int i=1; i<4; i++)
- {
- if(this->board[3-i][i][k][l]==mini4DgamePlayerColor::none || this->board[3][0][k][l] != this->board[3-i][i][k][l])
- break;
- if(i==3)
- {
- winner.color_ = this->board[3][0][k][l];
- for(int x=0; x<4; x++){
- winner.winningRow[x] = 3-x;
- winner.winningColumn[x] = x;
- winner.winningHeight[x] = k;
- winner.winningNumber[x] = l;
- }
- return winner;
- }
- }
- //rows-height
- for(int i=1; i<4; i++)
- {
- if(this->board[i][k][i][l]==mini4DgamePlayerColor::none || this->board[0][k][0][l] != this->board[i][k][i][l])
- break;
- if(i==3)
- {
- winner.color_ = this->board[0][k][0][l];
- for(int x=0; x<4; x++){
- winner.winningRow[x] = x;
- winner.winningColumn[x] = k;
- winner.winningHeight[x] = x;
- winner.winningNumber[x] = l;
- }
- return winner;
- }
- }
- for(int i=1; i<4; i++)
- {
- if(this->board[3-i][k][i][l]==mini4DgamePlayerColor::none || this->board[3][k][0][l] != this->board[3-i][k][i][l])
- break;
- if(i==3)
- {
- winner.color_ = this->board[3][k][0][l];
- for(int x=0; x<4; x++){
- winner.winningRow[x] = 3-x;
- winner.winningColumn[x] = k;
- winner.winningHeight[x] = x;
- winner.winningNumber[x] = l;
- }
- return winner;
- }
- }
- //rows-numbers
- for(int i=1; i<4; i++)
- {
- if(this->board[i][k][l][i]==mini4DgamePlayerColor::none || this->board[0][k][l][0] != this->board[i][k][l][i])
- break;
- if(i==3)
- {
- winner.color_ = this->board[0][k][l][0];
- for(int x=0; x<4; x++){
- winner.winningRow[x] = x;
- winner.winningColumn[x] = k;
- winner.winningHeight[x] = l;
- winner.winningNumber[x] = x;
- }
- return winner;
- }
- }
- for(int i=1; i<4; i++)
- {
- if(this->board[3-i][k][l][i]==mini4DgamePlayerColor::none || this->board[3][k][l][0] != this->board[3-i][k][l][i])
- break;
- if(i==3)
- {
- winner.color_ = this->board[3][k][l][0];
- for(int x=0; x<4; x++){
- winner.winningRow[x] = 3-x;
- winner.winningColumn[x] = k;
- winner.winningHeight[x] = l;
- winner.winningNumber[x] = x;
- }
- return winner;
- }
- }
- //column-height
- for(int i=1; i<4; i++)
- {
- if(this->board[k][i][i][l]==mini4DgamePlayerColor::none || this->board[k][0][0][l] != this->board[k][i][i][l])
- break;
- if(i==3)
- {
- winner.color_ = this->board[k][0][0][l];
- for(int x=0; x<4; x++){
- winner.winningRow[x] = k;
- winner.winningColumn[x] = x;
- winner.winningHeight[x] = x;
- winner.winningNumber[x] = l;
- }
- return winner;
- }
- }
- for(int i=1; i<4; i++)
- {
- if(this->board[k][3-i][i][l]==mini4DgamePlayerColor::none || this->board[k][3][0][l] != this->board[k][3-i][i][l])
- break;
- if(i==3)
- {
- winner.color_ = this->board[k][3][0][l];
- for(int x=0; x<4; x++){
- winner.winningRow[x] = k;
- winner.winningColumn[x] = 3-x;
- winner.winningHeight[x] = x;
- winner.winningNumber[x] = l;
- }
- return winner;
- }
- }
- //column-numbers
- for(int i=1; i<4; i++)
- {
- if(this->board[k][i][l][i]==mini4DgamePlayerColor::none || this->board[k][0][l][0] != this->board[k][i][l][i])
- break;
- if(i==3)
- {
- winner.color_ = this->board[k][0][l][0];
- for(int x=0; x<4; x++){
- winner.winningRow[x] = k;
- winner.winningColumn[x] = x;
- winner.winningHeight[x] = l;
- winner.winningNumber[x] = x;
- }
- return winner;
- }
- }
- for(int i=1; i<4; i++)
- {
- if(this->board[k][3-i][l][i]==mini4DgamePlayerColor::none || this->board[k][3][l][0] != this->board[k][3-i][l][i])
- break;
- if(i==3)
- {
- winner.color_ = this->board[k][3][l][0];
- for(int x=0; x<4; x++){
- winner.winningRow[x] = k;
- winner.winningColumn[x] = 3-x;
- winner.winningHeight[x] = l;
- winner.winningNumber[x] = x;
- }
- return winner;
- }
- }
- //height-numbers
- for(int i=1; i<4; i++)
- {
- if(this->board[k][l][i][i]==mini4DgamePlayerColor::none || this->board[k][l][0][0] != this->board[k][l][i][i])
- break;
- if(i==3)
- {
- winner.color_ = this->board[k][l][0][0];
- for(int x=0; x<4; x++){
- winner.winningRow[x] = k;
- winner.winningColumn[x] = l;
- winner.winningHeight[x] = x;
- winner.winningNumber[x] = x;
- }
- return winner;
- }
- }
- for(int i=1; i<4; i++)
- {
- if(this->board[k][l][3-i][i]==mini4DgamePlayerColor::none || this->board[k][l][3][0] != this->board[k][l][3-i][i])
- break;
- if(i==3)
- {
- winner.color_ = this->board[k][l][3][0];
- for(int x=0; x<4; x++){
- winner.winningRow[x] = k;
- winner.winningColumn[x] = l;
- winner.winningHeight[x] = 3-x;
- winner.winningNumber[x] = x;
- }
- return winner;
- }
- }
- }
- }
+ //check 2d diagonals
+ for(int k=0;k<4;k++){
+ for(int l=0;l<4;l++){
+ //rows-columns
+ for(int i=1; i<4; i++)
+ {
+ if(this->board[i][i][k][l]==mini4DgamePlayerColor::none || this->board[0][0][k][l] != this->board[i][i][k][l])
+ break;
+ if(i==3)
+ {
+ winner.color_ = this->board[0][0][k][l];
+ for(int x=0; x<4; x++){
+ winner.winningRow[x] = x;
+ winner.winningColumn[x] = x;
+ winner.winningHeight[x] = k;
+ winner.winningNumber[x] = l;
+ }
+ return winner;
+ }
+ }
+ for(int i=1; i<4; i++)
+ {
+ if(this->board[3-i][i][k][l]==mini4DgamePlayerColor::none || this->board[3][0][k][l] != this->board[3-i][i][k][l])
+ break;
+ if(i==3)
+ {
+ winner.color_ = this->board[3][0][k][l];
+ for(int x=0; x<4; x++){
+ winner.winningRow[x] = 3-x;
+ winner.winningColumn[x] = x;
+ winner.winningHeight[x] = k;
+ winner.winningNumber[x] = l;
+ }
+ return winner;
+ }
+ }
+ //rows-height
+ for(int i=1; i<4; i++)
+ {
+ if(this->board[i][k][i][l]==mini4DgamePlayerColor::none || this->board[0][k][0][l] != this->board[i][k][i][l])
+ break;
+ if(i==3)
+ {
+ winner.color_ = this->board[0][k][0][l];
+ for(int x=0; x<4; x++){
+ winner.winningRow[x] = x;
+ winner.winningColumn[x] = k;
+ winner.winningHeight[x] = x;
+ winner.winningNumber[x] = l;
+ }
+ return winner;
+ }
+ }
+ for(int i=1; i<4; i++)
+ {
+ if(this->board[3-i][k][i][l]==mini4DgamePlayerColor::none || this->board[3][k][0][l] != this->board[3-i][k][i][l])
+ break;
+ if(i==3)
+ {
+ winner.color_ = this->board[3][k][0][l];
+ for(int x=0; x<4; x++){
+ winner.winningRow[x] = 3-x;
+ winner.winningColumn[x] = k;
+ winner.winningHeight[x] = x;
+ winner.winningNumber[x] = l;
+ }
+ return winner;
+ }
+ }
+ //rows-numbers
+ for(int i=1; i<4; i++)
+ {
+ if(this->board[i][k][l][i]==mini4DgamePlayerColor::none || this->board[0][k][l][0] != this->board[i][k][l][i])
+ break;
+ if(i==3)
+ {
+ winner.color_ = this->board[0][k][l][0];
+ for(int x=0; x<4; x++){
+ winner.winningRow[x] = x;
+ winner.winningColumn[x] = k;
+ winner.winningHeight[x] = l;
+ winner.winningNumber[x] = x;
+ }
+ return winner;
+ }
+ }
+ for(int i=1; i<4; i++)
+ {
+ if(this->board[3-i][k][l][i]==mini4DgamePlayerColor::none || this->board[3][k][l][0] != this->board[3-i][k][l][i])
+ break;
+ if(i==3)
+ {
+ winner.color_ = this->board[3][k][l][0];
+ for(int x=0; x<4; x++){
+ winner.winningRow[x] = 3-x;
+ winner.winningColumn[x] = k;
+ winner.winningHeight[x] = l;
+ winner.winningNumber[x] = x;
+ }
+ return winner;
+ }
+ }
+ //column-height
+ for(int i=1; i<4; i++)
+ {
+ if(this->board[k][i][i][l]==mini4DgamePlayerColor::none || this->board[k][0][0][l] != this->board[k][i][i][l])
+ break;
+ if(i==3)
+ {
+ winner.color_ = this->board[k][0][0][l];
+ for(int x=0; x<4; x++){
+ winner.winningRow[x] = k;
+ winner.winningColumn[x] = x;
+ winner.winningHeight[x] = x;
+ winner.winningNumber[x] = l;
+ }
+ return winner;
+ }
+ }
+ for(int i=1; i<4; i++)
+ {
+ if(this->board[k][3-i][i][l]==mini4DgamePlayerColor::none || this->board[k][3][0][l] != this->board[k][3-i][i][l])
+ break;
+ if(i==3)
+ {
+ winner.color_ = this->board[k][3][0][l];
+ for(int x=0; x<4; x++){
+ winner.winningRow[x] = k;
+ winner.winningColumn[x] = 3-x;
+ winner.winningHeight[x] = x;
+ winner.winningNumber[x] = l;
+ }
+ return winner;
+ }
+ }
+ //column-numbers
+ for(int i=1; i<4; i++)
+ {
+ if(this->board[k][i][l][i]==mini4DgamePlayerColor::none || this->board[k][0][l][0] != this->board[k][i][l][i])
+ break;
+ if(i==3)
+ {
+ winner.color_ = this->board[k][0][l][0];
+ for(int x=0; x<4; x++){
+ winner.winningRow[x] = k;
+ winner.winningColumn[x] = x;
+ winner.winningHeight[x] = l;
+ winner.winningNumber[x] = x;
+ }
+ return winner;
+ }
+ }
+ for(int i=1; i<4; i++)
+ {
+ if(this->board[k][3-i][l][i]==mini4DgamePlayerColor::none || this->board[k][3][l][0] != this->board[k][3-i][l][i])
+ break;
+ if(i==3)
+ {
+ winner.color_ = this->board[k][3][l][0];
+ for(int x=0; x<4; x++){
+ winner.winningRow[x] = k;
+ winner.winningColumn[x] = 3-x;
+ winner.winningHeight[x] = l;
+ winner.winningNumber[x] = x;
+ }
+ return winner;
+ }
+ }
+ //height-numbers
+ for(int i=1; i<4; i++)
+ {
+ if(this->board[k][l][i][i]==mini4DgamePlayerColor::none || this->board[k][l][0][0] != this->board[k][l][i][i])
+ break;
+ if(i==3)
+ {
+ winner.color_ = this->board[k][l][0][0];
+ for(int x=0; x<4; x++){
+ winner.winningRow[x] = k;
+ winner.winningColumn[x] = l;
+ winner.winningHeight[x] = x;
+ winner.winningNumber[x] = x;
+ }
+ return winner;
+ }
+ }
+ for(int i=1; i<4; i++)
+ {
+ if(this->board[k][l][3-i][i]==mini4DgamePlayerColor::none || this->board[k][l][3][0] != this->board[k][l][3-i][i])
+ break;
+ if(i==3)
+ {
+ winner.color_ = this->board[k][l][3][0];
+ for(int x=0; x<4; x++){
+ winner.winningRow[x] = k;
+ winner.winningColumn[x] = l;
+ winner.winningHeight[x] = 3-x;
+ winner.winningNumber[x] = x;
+ }
+ return winner;
+ }
+ }
+ }
+ }
- //check rows
- for(int j=0;j<4;j++){
- for(int k=0;k<4;k++){
- for(int l=0;l<4;l++){
- if(this->board[0][j][k][l]!= mini4DgamePlayerColor::none
- && this->board[0][j][k][l]==this->board[1][j][k][l]
- && this->board[1][j][k][l]==this->board[2][j][k][l]
- && this->board[2][j][k][l]==this->board[3][j][k][l])
- {
- winner.color_ = this->board[0][j][k][l];
- for(int x=0; x<4; x++){
- winner.winningRow[x] = x;
- winner.winningColumn[x] = j;
- winner.winningHeight[x] = k;
- winner.winningNumber[x] = l;
- }
- return winner;
- }
- }
- }
- }
+ //check rows
+ for(int j=0;j<4;j++){
+ for(int k=0;k<4;k++){
+ for(int l=0;l<4;l++){
+ if(this->board[0][j][k][l]!= mini4DgamePlayerColor::none
+ && this->board[0][j][k][l]==this->board[1][j][k][l]
+ && this->board[1][j][k][l]==this->board[2][j][k][l]
+ && this->board[2][j][k][l]==this->board[3][j][k][l])
+ {
+ winner.color_ = this->board[0][j][k][l];
+ for(int x=0; x<4; x++){
+ winner.winningRow[x] = x;
+ winner.winningColumn[x] = j;
+ winner.winningHeight[x] = k;
+ winner.winningNumber[x] = l;
+ }
+ return winner;
+ }
+ }
+ }
+ }
- //check columns
- for(int i=0;i<4;i++){
- for(int k=0;k<4;k++){
- for(int l=0;l<4;l++){
- if(this->board[i][0][k][l]!= mini4DgamePlayerColor::none
- && this->board[i][0][k][l]==this->board[i][1][k][l]
- && this->board[i][1][k][l]==this->board[i][2][k][l]
- && this->board[i][2][k][l]==this->board[i][3][k][l])
- {
- winner.color_ = this->board[i][0][k][l];
- for(int x=0; x<4; x++){
- winner.winningRow[x] = i;
- winner.winningColumn[x] = x;
- winner.winningHeight[x] = k;
- winner.winningNumber[x] = l;
- }
- return winner;
- }
- }
- }
- }
+ //check columns
+ for(int i=0;i<4;i++){
+ for(int k=0;k<4;k++){
+ for(int l=0;l<4;l++){
+ if(this->board[i][0][k][l]!= mini4DgamePlayerColor::none
+ && this->board[i][0][k][l]==this->board[i][1][k][l]
+ && this->board[i][1][k][l]==this->board[i][2][k][l]
+ && this->board[i][2][k][l]==this->board[i][3][k][l])
+ {
+ winner.color_ = this->board[i][0][k][l];
+ for(int x=0; x<4; x++){
+ winner.winningRow[x] = i;
+ winner.winningColumn[x] = x;
+ winner.winningHeight[x] = k;
+ winner.winningNumber[x] = l;
+ }
+ return winner;
+ }
+ }
+ }
+ }
- //check height
- for(int i=0;i<4;i++){
- for(int j=0;j<4;j++){
- for(int l=0;l<4;l++){
- if(this->board[i][j][0][l]!= mini4DgamePlayerColor::none
- && this->board[i][j][0][l]==this->board[i][j][1][l]
- && this->board[i][j][1][l]==this->board[i][j][2][l]
- && this->board[i][j][2][l]==this->board[i][j][3][l])
- {
- winner.color_ = this->board[i][j][0][l];
- for(int x=0; x<4; x++){
- winner.winningRow[x] = i;
- winner.winningColumn[x] = j;
- winner.winningHeight[x] = x;
- winner.winningNumber[x] = l;
- }
- return winner;
- }
- }
- }
- }
+ //check height
+ for(int i=0;i<4;i++){
+ for(int j=0;j<4;j++){
+ for(int l=0;l<4;l++){
+ if(this->board[i][j][0][l]!= mini4DgamePlayerColor::none
+ && this->board[i][j][0][l]==this->board[i][j][1][l]
+ && this->board[i][j][1][l]==this->board[i][j][2][l]
+ && this->board[i][j][2][l]==this->board[i][j][3][l])
+ {
+ winner.color_ = this->board[i][j][0][l];
+ for(int x=0; x<4; x++){
+ winner.winningRow[x] = i;
+ winner.winningColumn[x] = j;
+ winner.winningHeight[x] = x;
+ winner.winningNumber[x] = l;
+ }
+ return winner;
+ }
+ }
+ }
+ }
- //check numbers
- for(int i=0;i<4;i++){
- for(int j=0;j<4;j++){
- for(int k=0;k<4;k++){
- if(this->board[i][j][k][0]!= mini4DgamePlayerColor::none
- && this->board[i][j][k][0]==this->board[i][j][k][1]
- && this->board[i][j][k][1]==this->board[i][j][k][2]
- && this->board[i][j][k][2]==this->board[i][j][k][3])
- {
- winner.color_ = this->board[i][j][k][0];
- for(int x=0; x<4; x++){
- winner.winningRow[x] = i;
- winner.winningColumn[x] = j;
- winner.winningHeight[x] = k;
- winner.winningNumber[x] = x;
- }
- return winner;
- }
- }
- }
- }
- return winner;
+ //check numbers
+ for(int i=0;i<4;i++){
+ for(int j=0;j<4;j++){
+ for(int k=0;k<4;k++){
+ if(this->board[i][j][k][0]!= mini4DgamePlayerColor::none
+ && this->board[i][j][k][0]==this->board[i][j][k][1]
+ && this->board[i][j][k][1]==this->board[i][j][k][2]
+ && this->board[i][j][k][2]==this->board[i][j][k][3])
+ {
+ winner.color_ = this->board[i][j][k][0];
+ for(int x=0; x<4; x++){
+ winner.winningRow[x] = i;
+ winner.winningColumn[x] = j;
+ winner.winningHeight[x] = k;
+ winner.winningNumber[x] = x;
+ }
+ return winner;
+ }
+ }
+ }
+ }
+ return winner;
}
/**
Modified: code/branches/minigame4DHS14/src/modules/mini4dgame/Mini4DgameBoard.h
===================================================================
--- code/branches/minigame4DHS14/src/modules/mini4dgame/Mini4DgameBoard.h 2015-02-01 13:50:46 UTC (rev 10229)
+++ code/branches/minigame4DHS14/src/modules/mini4dgame/Mini4DgameBoard.h 2015-02-01 13:55:44 UTC (rev 10230)
@@ -51,14 +51,14 @@
int w;
};
- struct Mini4DgameWinner
- {
- int winningRow[4];
- int winningColumn[4];
- int winningHeight[4];
- int winningNumber[4];
- int color_;
- };
+ struct Mini4DgameWinner
+ {
+ int winningRow[4];
+ int winningColumn[4];
+ int winningHeight[4];
+ int winningNumber[4];
+ int color_;
+ };
/**
@brief
@@ -70,7 +70,7 @@
class _Mini4DgameExport Mini4DgameBoard : public StaticEntity
{
public:
- Mini4DgameBoard(Context* context);
+ Mini4DgameBoard(Context* context);
//virtual ~Mini4DgameBoard();
virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
More information about the Orxonox-commit
mailing list