Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
Nov 19, 2014, 4:08:42 PM (11 years ago)
Author:
richtero
Message:

new structure: Board in separate class

File:
1 edited

Legend:

Unmodified
Added
Removed
  • code/branches/minigame4DHS14/src/modules/mini4Dgame/Mini4DgameCenterpoint.cc

    r10121 r10131  
    3737#include "core/XMLPort.h"
    3838
     39#include "../orxonox/graphics/BlinkingBillboard.h"
     40
    3941#include "Mini4Dgame.h"
    4042
    4143namespace orxonox
    4244{
     45
    4346    RegisterClass(Mini4DgameCenterpoint);
    44 
    4547    /**
    4648    @brief
     
    5456        this->height_ = 200;
    5557        this->length_ = 200;
    56 
    57         for(int i=0;i<4;i++){
    58                 for(int j=0;j<4;j++){
    59                         for(int k=0;k<4;k++){
    60                                 for(int l=0;l<4;l++){
    61                                         this->board[i][j][k][l]=mini4DgamePlayerColor::none;
    62                                 }
    63                         }
    64                 }
    65         }
    6658
    6759        this->checkGametype();
     
    7769
    7870        XMLPortParam(Mini4DgameCenterpoint, "dimension", setFieldDimension, getFieldDimension, xmlelement, mode);
     71        XMLPortParam(Mini4DgameCenterpoint, "boardtemplate", setBoardtemplate, getBoardtemplate, xmlelement, mode);
    7972    }
    8073
     
    10396        }
    10497    }
    105 
    106     /**
    107         @brief checks if the move is valid
    108         @param the position where to put the stone plus the player who makes the move
    109     */
    110     bool Mini4DgameCenterpoint::isValidMove(const Vector4 move)
    111     {
    112         return (this->board[(int)move.x][(int)move.y][(int)move.z][(int)move.w] == mini4DgamePlayerColor::none);
    113     }
    114 
    115     /**
    116     @brief makes a move on the logic playboard
    117     @param the position where to put the stone plus the player who makes the move
    118     */
    119     void Mini4DgameCenterpoint::makeMove(const Vector4 move, const mini4DgamePlayerColor::color playerColor)
    120     {
    121         if(this->isValidMove(move))
    122         {
    123                 this->board[(int)move.x][(int)move.y][(int)move.z][(int)move.w] = playerColor;
    124                 Mini4DgameWinner winner = this->getWinner();
    125                 if(winner.color_ != mini4DgamePlayerColor::none)
    126                 {
    127                         Mini4Dgame->win(winner);
    128                 }
    129         }
    130     }
    131 
    132     Mini4DgameWinner Mini4DgameCenterpoint::getWinner()
    133     {
    134         Mini4DgameWinner winner;
    135                 winner.color_ = mini4DgamePlayerColor::none;
    136 
    137         //check diagonals rows-columns-height-numbers
    138                 for(int i=1; i<4; i++)
    139                 {
    140                         if(this->board[i][i][i][i]==mini4DgamePlayerColor::none || this->board[0][0][0][0] != this->board[i][i][i][i])
    141                                 break;
    142                         if(i==3)
    143                         {
    144                                 winner.color_ = this->board[0][0][0][0];
    145                                 for(int x=0; x<4; x++){
    146                                         winner.winningRow[x] = x;
    147                                         winner.winningColumn[x] = x;
    148                                         winner.winningHeight[x] = x;
    149                                         winner.winningNumber[x] = x;
    150                                 }
    151                                 return winner;
    152                         }
    153                 }
    154                 for(int i=1; i<4; i++)
    155                 {
    156                         if(this->board[3-i][i][i][i]==mini4DgamePlayerColor::none || this->board[3][0][0][0] != this->board[3-i][i][i][i])
    157                                 break;
    158                         if(i==3)
    159                         {
    160                                 winner.color_ = this->board[3][0][0][0];
    161                                 for(int x=0; x<4; x++){
    162                                         winner.winningRow[x] = 3-x;
    163                                         winner.winningColumn[x] = x;
    164                                         winner.winningHeight[x] = x;
    165                                         winner.winningNumber[x] = x;
    166                                 }
    167                                 return winner;
    168                         }
    169                 }
    170                 for(int i=1; i<4; i++)
    171                 {
    172                         if(this->board[i][3-i][i][i]==mini4DgamePlayerColor::none || this->board[0][3][0][0] != this->board[i][3-i][i][i])
    173                                 break;
    174                         if(i==3)
    175                         {
    176                                 winner.color_ = this->board[0][3][0][0];
    177                                 for(int x=0; x<4; x++){
    178                                         winner.winningRow[x] = x;
    179                                         winner.winningColumn[x] = 3-x;
    180                                         winner.winningHeight[x] = x;
    181                                         winner.winningNumber[x] = x;
    182                                 }
    183                                 return winner;
    184                         }
    185                 }
    186                 for(int i=1; i<4; i++)
    187                 {
    188                         if(this->board[i][i][3-i][i]==mini4DgamePlayerColor::none || this->board[0][0][3][0] != this->board[i][i][3-i][i])
    189                                 break;
    190                         if(i==3)
    191                         {
    192                                 winner.color_ = this->board[0][0][3][0];
    193                                 for(int x=0; x<4; x++){
    194                                         winner.winningRow[x] = x;
    195                                         winner.winningColumn[x] = x;
    196                                         winner.winningHeight[x] = 3-x;
    197                                         winner.winningNumber[x] = x;
    198                                 }
    199                                 return winner;
    200                         }
    201                 }
    202                 for(int i=1; i<4; i++)
    203                 {
    204                         if(this->board[i][i][i][3-i]==mini4DgamePlayerColor::none || this->board[0][0][0][3] != this->board[i][i][i][3-i])
    205                                 break;
    206                         if(i==3)
    207                         {
    208                                 winner.color_ = this->board[0][0][0][3];
    209                                 for(int x=0; x<4; x++){
    210                                         winner.winningRow[x] = x;
    211                                         winner.winningColumn[x] = x;
    212                                         winner.winningHeight[x] = x;
    213                                         winner.winningNumber[x] = 3-x;
    214                                 }
    215                                 return winner;
    216                         }
    217                 }
    218                 for(int i=1; i<4; i++)
    219                 {
    220                         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])
    221                                 break;
    222                         if(i==3)
    223                         {
    224                                 winner.color_ = this->board[3][3][0][0];
    225                                 for(int x=0; x<4; x++){
    226                                         winner.winningRow[x] = 3-x;
    227                                         winner.winningColumn[x] = 3-x;
    228                                         winner.winningHeight[x] = x;
    229                                         winner.winningNumber[x] = x;
    230                                 }
    231                                 return winner;
    232                         }
    233                 }
    234                 for(int i=1; i<4; i++)
    235                 {
    236                         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])
    237                                 break;
    238                         if(i==3)
    239                         {
    240                                 winner.color_ = this->board[3][0][3][0];
    241                                 for(int x=0; x<4; x++){
    242                                         winner.winningRow[x] = 3-x;
    243                                         winner.winningColumn[x] = x;
    244                                         winner.winningHeight[x] = 3-x;
    245                                         winner.winningNumber[x] = x;
    246                                 }
    247                                 return winner;
    248                         }
    249                 }
    250                 for(int i=1; i<4; i++)
    251                 {
    252                         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])
    253                                 break;
    254                         if(i==3)
    255                         {
    256                                 winner.color_ = this->board[3][0][0][3];
    257                                 for(int x=0; x<4; x++){
    258                                         winner.winningRow[x] = 3-x;
    259                                         winner.winningColumn[x] = x;
    260                                         winner.winningHeight[x] = x;
    261                                         winner.winningNumber[x] = 3-x;
    262                                 }
    263                                 return winner;
    264                         }
    265                 }
    266 
    267                 //check diagonals rows-columns-height
    268                 for(int l=0; l<4; l++)
    269                 {
    270                         for(int i=1; i<4; i++)
    271                         {
    272                                 if(this->board[i][i][i][l]==mini4DgamePlayerColor::none || this->board[0][0][0][l] != this->board[i][i][i][l])
    273                                         break;
    274                                 if(i==3)
    275                                 {
    276                                         winner.color_ = this->board[0][0][0][l];
    277                                         for(int x=0; x<4; x++){
    278                                                 winner.winningRow[x] = x;
    279                                                 winner.winningColumn[x] = x;
    280                                                 winner.winningHeight[x] = x;
    281                                                 winner.winningNumber[x] = l;
    282                                         }
    283                                         return winner;
    284                                 }
    285                         }
    286                         for(int i=1; i<4; i++)
    287                         {
    288                                 if(this->board[3-i][i][i][l]==mini4DgamePlayerColor::none || this->board[3][0][0][l] != this->board[3-i][i][i][l])
    289                                         break;
    290                                 if(i==3)
    291                                 {
    292                                         winner.color_ = this->board[3][0][0][l];
    293                                         for(int x=0; x<4; x++){
    294                                                 winner.winningRow[x] = 3-x;
    295                                                 winner.winningColumn[x] = x;
    296                                                 winner.winningHeight[x] = x;
    297                                                 winner.winningNumber[x] = l;
    298                                         }
    299                                         return winner;
    300                                 }
    301                         }
    302                         for(int i=1; i<4; i++)
    303                         {
    304                                 if(this->board[i][3-i][i][l]==mini4DgamePlayerColor::none || this->board[0][3][0][l] != this->board[i][3-i][i][l])
    305                                         break;
    306                                 if(i==3)
    307                                 {
    308                                         winner.color_ = this->board[0][3][0][l];
    309                                         for(int x=0; x<4; x++){
    310                                                 winner.winningRow[x] = x;
    311                                                 winner.winningColumn[x] = 3-x;
    312                                                 winner.winningHeight[x] = x;
    313                                                 winner.winningNumber[x] = l;
    314                                         }
    315                                         return winner;
    316                                 }
    317                         }
    318                         for(int i=1; i<4; i++)
    319                         {
    320                                 if(this->board[i][i][3-i][l]==mini4DgamePlayerColor::none || this->board[0][0][3][l] != this->board[i][i][3-i][l])
    321                                         break;
    322                                 if(i==3)
    323                                 {
    324                                         winner.color_ = this->board[0][0][3][l];
    325                                         for(int x=0; x<4; x++){
    326                                                 winner.winningRow[x] = x;
    327                                                 winner.winningColumn[x] = x;
    328                                                 winner.winningHeight[x] = 3-x;
    329                                                 winner.winningNumber[x] = l;
    330                                         }
    331                                         return winner;
    332                                 }
    333                         }
    334                 }
    335 
    336                 //check diagonals rows-columns-numbers
    337                 for(int l=0; l<4; l++)
    338                 {
    339                         for(int i=1; i<4; i++)
    340                         {
    341                                 if(this->board[i][i][l][i]==mini4DgamePlayerColor::none || this->board[0][0][l][0] != this->board[i][i][l][i])
    342                                         break;
    343                                 if(i==3)
    344                                 {
    345                                         winner.color_ = this->board[0][0][l][0];
    346                                         for(int x=0; x<4; x++){
    347                                                 winner.winningRow[x] = x;
    348                                                 winner.winningColumn[x] = x;
    349                                                 winner.winningHeight[x] = l;
    350                                                 winner.winningNumber[x] = x;
    351                                         }
    352                                         return winner;
    353                                 }
    354                         }
    355                         for(int i=1; i<4; i++)
    356                         {
    357                                 if(this->board[3-i][i][l][i]==mini4DgamePlayerColor::none || this->board[3][0][l][0] != this->board[3-i][i][l][i])
    358                                         break;
    359                                 if(i==3)
    360                                 {
    361                                         winner.color_ = this->board[3][0][l][0];
    362                                         for(int x=0; x<4; x++){
    363                                                 winner.winningRow[x] = 3-x;
    364                                                 winner.winningColumn[x] = x;
    365                                                 winner.winningHeight[x] = l;
    366                                                 winner.winningNumber[x] = x;
    367                                         }
    368                                         return winner;
    369                                 }
    370                         }
    371                         for(int i=1; i<4; i++)
    372                         {
    373                                 if(this->board[i][3-i][l][i]==mini4DgamePlayerColor::none || this->board[0][3][l][0] != this->board[i][3-i][l][i])
    374                                         break;
    375                                 if(i==3)
    376                                 {
    377                                         winner.color_ = this->board[0][3][l][0];
    378                                         for(int x=0; x<4; x++){
    379                                                 winner.winningRow[x] = x;
    380                                                 winner.winningColumn[x] = 3-x;
    381                                                 winner.winningHeight[x] = l;
    382                                                 winner.winningNumber[x] = x;
    383                                         }
    384                                         return winner;
    385                                 }
    386                         }
    387                         for(int i=1; i<4; i++)
    388                         {
    389                                 if(this->board[i][i][l][3-i]==mini4DgamePlayerColor::none || this->board[0][0][l][3] != this->board[i][i][l][3-i])
    390                                         break;
    391                                 if(i==3)
    392                                 {
    393                                         winner.color_ = this->board[0][0][l][3];
    394                                         for(int x=0; x<4; x++){
    395                                                 winner.winningRow[x] = x;
    396                                                 winner.winningColumn[x] = x;
    397                                                 winner.winningHeight[x] = l;
    398                                                 winner.winningNumber[x] = 3-x;
    399                                         }
    400                                         return winner;
    401                                 }
    402                         }
    403                 }
    404 
    405                 //check diagonals rows-height-numbers
    406                 for(int l=0; l<4; l++)
    407                 {
    408                         for(int i=1; i<4; i++)
    409                         {
    410                                 if(this->board[i][l][i][i]==mini4DgamePlayerColor::none || this->board[0][l][0][0] != this->board[i][l][i][i])
    411                                         break;
    412                                 if(i==3)
    413                                 {
    414                                         winner.color_ = this->board[0][l][0][0];
    415                                         for(int x=0; x<4; x++){
    416                                                 winner.winningRow[x] = x;
    417                                                 winner.winningColumn[x] = l;
    418                                                 winner.winningHeight[x] = x;
    419                                                 winner.winningNumber[x] = x;
    420                                         }
    421                                         return winner;
    422                                 }
    423                         }
    424                         for(int i=1; i<4; i++)
    425                         {
    426                                 if(this->board[3-i][l][i][i]==mini4DgamePlayerColor::none || this->board[3][l][0][0] != this->board[3-i][l][i][i])
    427                                         break;
    428                                 if(i==3)
    429                                 {
    430                                         winner.color_ = this->board[3][l][0][0];
    431                                         for(int x=0; x<4; x++){
    432                                                 winner.winningRow[x] = 3-x;
    433                                                 winner.winningColumn[x] = l;
    434                                                 winner.winningHeight[x] = x;
    435                                                 winner.winningNumber[x] = x;
    436                                         }
    437                                         return winner;
    438                                 }
    439                         }
    440                         for(int i=1; i<4; i++)
    441                         {
    442                                 if(this->board[i][l][3-i][i]==mini4DgamePlayerColor::none || this->board[0][l][3][0] != this->board[i][l][3-i][i])
    443                                         break;
    444                                 if(i==3)
    445                                 {
    446                                         winner.color_ = this->board[0][l][3][0];
    447                                         for(int x=0; x<4; x++){
    448                                                 winner.winningRow[x] = x;
    449                                                 winner.winningColumn[x] = l;
    450                                                 winner.winningHeight[x] = 3-x;
    451                                                 winner.winningNumber[x] = x;
    452                                         }
    453                                         return winner;
    454                                 }
    455                         }
    456                         for(int i=1; i<4; i++)
    457                         {
    458                                 if(this->board[i][l][i][3-i]==mini4DgamePlayerColor::none || this->board[0][l][0][3] != this->board[i][l][i][3-i])
    459                                         break;
    460                                 if(i==3)
    461                                 {
    462                                         winner.color_ = this->board[0][l][0][3];
    463                                         for(int x=0; x<4; x++){
    464                                                 winner.winningRow[x] = x;
    465                                                 winner.winningColumn[x] = l;
    466                                                 winner.winningHeight[x] = x;
    467                                                 winner.winningNumber[x] = 3-x;
    468                                         }
    469                                         return winner;
    470                                 }
    471                         }
    472                 }
    473 
    474                 //check diagonals columns-height-numbers
    475                 for(int l=0; l<4; l++)
    476                 {
    477                         for(int i=1; i<4; i++)
    478                         {
    479                                 if(this->board[l][i][i][i]==mini4DgamePlayerColor::none || this->board[l][0][0][0] != this->board[l][i][i][i])
    480                                         break;
    481                                 if(i==3)
    482                                 {
    483                                         winner.color_ = this->board[l][0][0][0];
    484                                         for(int x=0; x<4; x++){
    485                                                 winner.winningRow[x] = l;
    486                                                 winner.winningColumn[x] = x;
    487                                                 winner.winningHeight[x] = x;
    488                                                 winner.winningNumber[x] = x;
    489                                         }
    490                                         return winner;
    491                                 }
    492                         }
    493                         for(int i=1; i<4; i++)
    494                         {
    495                                 if(this->board[l][3-i][i][i]==mini4DgamePlayerColor::none || this->board[l][3][0][0] != this->board[l][3-i][i][i])
    496                                         break;
    497                                 if(i==3)
    498                                 {
    499                                         winner.color_ = this->board[l][3][0][0];
    500                                         for(int x=0; x<4; x++){
    501                                                 winner.winningRow[x] = l;
    502                                                 winner.winningColumn[x] = 3-x;
    503                                                 winner.winningHeight[x] = x;
    504                                                 winner.winningNumber[x] = x;
    505                                         }
    506                                         return winner;
    507                                 }
    508                         }
    509                         for(int i=1; i<4; i++)
    510                         {
    511                                 if(this->board[l][i][3-i][i]==mini4DgamePlayerColor::none || this->board[l][0][3][0] != this->board[l][i][3-i][i])
    512                                         break;
    513                                 if(i==3)
    514                                 {
    515                                         winner.color_ = this->board[l][0][3][0];
    516                                         for(int x=0; x<4; x++){
    517                                                 winner.winningRow[x] = l;
    518                                                 winner.winningColumn[x] = x;
    519                                                 winner.winningHeight[x] = 3-x;
    520                                                 winner.winningNumber[x] = x;
    521                                         }
    522                                         return winner;
    523                                 }
    524                         }
    525                         for(int i=1; i<4; i++)
    526                         {
    527                                 if(this->board[l][i][i][3-i]==mini4DgamePlayerColor::none || this->board[l][0][0][3] != this->board[l][i][i][3-i])
    528                                         break;
    529                                 if(i==3)
    530                                 {
    531                                         winner.color_ = this->board[l][0][0][3];
    532                                         for(int x=0; x<4; x++){
    533                                                 winner.winningRow[x] = l;
    534                                                 winner.winningColumn[x] = x;
    535                                                 winner.winningHeight[x] = x;
    536                                                 winner.winningNumber[x] = 3-x;
    537                                         }
    538                                         return winner;
    539                                 }
    540                         }
    541                 }
    542 
    543                 //check 2d diagonals
    544                 for(int k=0;k<4;k++){
    545                 for(int l=0;l<4;l++){
    546                         //rows-columns
    547                         for(int i=1; i<4; i++)
    548                                 {
    549                                         if(this->board[i][i][k][l]==mini4DgamePlayerColor::none || this->board[0][0][k][l] != this->board[i][i][k][l])
    550                                                 break;
    551                                         if(i==3)
    552                                         {
    553                                                 winner.color_ = this->board[0][0][k][l];
    554                                                 for(int x=0; x<4; x++){
    555                                                         winner.winningRow[x] = x;
    556                                                         winner.winningColumn[x] = x;
    557                                                         winner.winningHeight[x] = k;
    558                                                         winner.winningNumber[x] = l;
    559                                                 }
    560                                                 return winner;
    561                                         }
    562                                 }
    563                                 for(int i=1; i<4; i++)
    564                                 {
    565                                         if(this->board[3-i][i][k][l]==mini4DgamePlayerColor::none || this->board[3][0][k][l] != this->board[3-i][i][k][l])
    566                                                 break;
    567                                         if(i==3)
    568                                         {
    569                                                 winner.color_ = this->board[3][0][k][l];
    570                                                 for(int x=0; x<4; x++){
    571                                                         winner.winningRow[x] = 3-x;
    572                                                         winner.winningColumn[x] = x;
    573                                                         winner.winningHeight[x] = k;
    574                                                         winner.winningNumber[x] = l;
    575                                                 }
    576                                                 return winner;
    577                                         }
    578                                 }
    579                                 //rows-height
    580                         for(int i=1; i<4; i++)
    581                         {
    582                                 if(this->board[i][k][i][l]==mini4DgamePlayerColor::none || this->board[0][k][0][l] != this->board[i][k][i][l])
    583                                         break;
    584                                 if(i==3)
    585                                 {
    586                                                 winner.color_ = this->board[0][k][0][l];
    587                                                 for(int x=0; x<4; x++){
    588                                                         winner.winningRow[x] = x;
    589                                                         winner.winningColumn[x] = k;
    590                                                         winner.winningHeight[x] = x;
    591                                                         winner.winningNumber[x] = l;
    592                                                 }
    593                                                 return winner;
    594                                         }
    595                                 }
    596                                 for(int i=1; i<4; i++)
    597                         {
    598                                 if(this->board[3-i][k][i][l]==mini4DgamePlayerColor::none || this->board[3][k][0][l] != this->board[3-i][k][i][l])
    599                                         break;
    600                                 if(i==3)
    601                                 {
    602                                                 winner.color_ = this->board[3][k][0][l];
    603                                                 for(int x=0; x<4; x++){
    604                                                         winner.winningRow[x] = 3-x;
    605                                                         winner.winningColumn[x] = k;
    606                                                         winner.winningHeight[x] = x;
    607                                                         winner.winningNumber[x] = l;
    608                                                 }
    609                                                 return winner;
    610                                         }
    611                                 }
    612                                 //rows-numbers
    613                                 for(int i=1; i<4; i++)
    614                         {
    615                                 if(this->board[i][k][l][i]==mini4DgamePlayerColor::none || this->board[0][k][l][0] != this->board[i][k][l][i])
    616                                         break;
    617                                 if(i==3)
    618                                 {
    619                                                 winner.color_ = this->board[0][k][l][0];
    620                                                 for(int x=0; x<4; x++){
    621                                                         winner.winningRow[x] = x;
    622                                                         winner.winningColumn[x] = k;
    623                                                         winner.winningHeight[x] = l;
    624                                                         winner.winningNumber[x] = x;
    625                                                 }
    626                                                 return winner;
    627                                         }
    628                                 }
    629                                 for(int i=1; i<4; i++)
    630                         {
    631                                 if(this->board[3-i][k][l][i]==mini4DgamePlayerColor::none || this->board[3][k][l][0] != this->board[3-i][k][l][i])
    632                                         break;
    633                                 if(i==3)
    634                                 {
    635                                                 winner.color_ = this->board[3][k][l][0];
    636                                                 for(int x=0; x<4; x++){
    637                                                         winner.winningRow[x] = 3-x;
    638                                                         winner.winningColumn[x] = k;
    639                                                         winner.winningHeight[x] = l;
    640                                                         winner.winningNumber[x] = x;
    641                                                 }
    642                                                 return winner;
    643                                         }
    644                                 }
    645                                 //column-height
    646                                 for(int i=1; i<4; i++)
    647                         {
    648                                 if(this->board[k][i][i][l]==mini4DgamePlayerColor::none || this->board[k][0][0][l] != this->board[k][i][i][l])
    649                                         break;
    650                                 if(i==3)
    651                                 {
    652                                                 winner.color_ = this->board[k][0][0][l];
    653                                                 for(int x=0; x<4; x++){
    654                                                         winner.winningRow[x] = k;
    655                                                         winner.winningColumn[x] = x;
    656                                                         winner.winningHeight[x] = x;
    657                                                         winner.winningNumber[x] = l;
    658                                                 }
    659                                                 return winner;
    660                                         }
    661                                 }
    662                                 for(int i=1; i<4; i++)
    663                         {
    664                                 if(this->board[k][3-i][i][l]==mini4DgamePlayerColor::none || this->board[k][3][0][l] != this->board[k][3-i][i][l])
    665                                         break;
    666                                 if(i==3)
    667                                 {
    668                                                 winner.color_ = this->board[k][3][0][l];
    669                                                 for(int x=0; x<4; x++){
    670                                                         winner.winningRow[x] = k;
    671                                                         winner.winningColumn[x] = 3-x;
    672                                                         winner.winningHeight[x] = x;
    673                                                         winner.winningNumber[x] = l;
    674                                                 }
    675                                                 return winner;
    676                                         }
    677                                 }
    678                                 //column-numbers
    679                                 for(int i=1; i<4; i++)
    680                         {
    681                                 if(this->board[k][i][l][i]==mini4DgamePlayerColor::none || this->board[k][0][l][0] != this->board[k][i][l][i])
    682                                         break;
    683                                 if(i==3)
    684                                 {
    685                                                 winner.color_ = this->board[k][0][l][0];
    686                                                 for(int x=0; x<4; x++){
    687                                                         winner.winningRow[x] = k;
    688                                                         winner.winningColumn[x] = x;
    689                                                         winner.winningHeight[x] = l;
    690                                                         winner.winningNumber[x] = x;
    691                                                 }
    692                                                 return winner;
    693                                         }
    694                                 }
    695                                 for(int i=1; i<4; i++)
    696                         {
    697                                 if(this->board[k][3-i][l][i]==mini4DgamePlayerColor::none || this->board[k][3][l][0] != this->board[k][3-i][l][i])
    698                                         break;
    699                                 if(i==3)
    700                                 {
    701                                                 winner.color_ = this->board[k][3][l][0];
    702                                                 for(int x=0; x<4; x++){
    703                                                         winner.winningRow[x] = k;
    704                                                         winner.winningColumn[x] = 3-x;
    705                                                         winner.winningHeight[x] = l;
    706                                                         winner.winningNumber[x] = x;
    707                                                 }
    708                                                 return winner;
    709                                         }
    710                                 }
    711                                 //height-numbers
    712                                 for(int i=1; i<4; i++)
    713                         {
    714                                 if(this->board[k][l][i][i]==mini4DgamePlayerColor::none || this->board[k][l][0][0] != this->board[k][l][i][i])
    715                                         break;
    716                                 if(i==3)
    717                                 {
    718                                                 winner.color_ = this->board[k][l][0][0];
    719                                                 for(int x=0; x<4; x++){
    720                                                         winner.winningRow[x] = k;
    721                                                         winner.winningColumn[x] = l;
    722                                                         winner.winningHeight[x] = x;
    723                                                         winner.winningNumber[x] = x;
    724                                                 }
    725                                                 return winner;
    726                                         }
    727                                 }
    728                                 for(int i=1; i<4; i++)
    729                         {
    730                                 if(this->board[k][l][3-i][i]==mini4DgamePlayerColor::none || this->board[k][l][3][0] != this->board[k][l][3-i][i])
    731                                         break;
    732                                 if(i==3)
    733                                 {
    734                                                 winner.color_ = this->board[k][l][3][0];
    735                                                 for(int x=0; x<4; x++){
    736                                                         winner.winningRow[x] = k;
    737                                                         winner.winningColumn[x] = l;
    738                                                         winner.winningHeight[x] = 3-x;
    739                                                         winner.winningNumber[x] = x;
    740                                                 }
    741                                                 return winner;
    742                                         }
    743                                 }
    744                 }
    745         }
    746 
    747         //check rows
    748         for(int j=0;j<4;j++){
    749                 for(int k=0;k<4;k++){
    750                         for(int l=0;l<4;l++){
    751                                 if(this->board[0][j][k][l]!= mini4DgamePlayerColor::none
    752                                    && this->board[0][j][k][l]==this->board[1][j][k][l]
    753                                    && this->board[1][j][k][l]==this->board[2][j][k][l]
    754                                    && this->board[2][j][k][l]==this->board[3][j][k][l])
    755                                 {
    756                                         winner.color_ = this->board[0][j][k][l];
    757                                                 for(int x=0; x<4; x++){
    758                                                         winner.winningRow[x] = x;
    759                                                         winner.winningColumn[x] = j;
    760                                                         winner.winningHeight[x] = k;
    761                                                         winner.winningNumber[x] = l;
    762                                                 }
    763                                                 return winner;
    764                                 }
    765                         }
    766                 }
    767         }
    768 
    769         //check columns
    770         for(int i=0;i<4;i++){
    771                 for(int k=0;k<4;k++){
    772                         for(int l=0;l<4;l++){
    773                                 if(this->board[i][0][k][l]!= mini4DgamePlayerColor::none
    774                                            && this->board[i][0][k][l]==this->board[i][1][k][l]
    775                                            && this->board[i][1][k][l]==this->board[i][2][k][l]
    776                                            && this->board[i][2][k][l]==this->board[i][3][k][l])
    777                                 {
    778                                 winner.color_ = this->board[i][0][k][l];
    779                                                 for(int x=0; x<4; x++){
    780                                                         winner.winningRow[x] = i;
    781                                                         winner.winningColumn[x] = x;
    782                                                         winner.winningHeight[x] = k;
    783                                                         winner.winningNumber[x] = l;
    784                                                 }
    785                                                 return winner;
    786                                 }
    787                         }
    788                 }
    789         }
    790 
    791         //check height
    792         for(int i=0;i<4;i++){
    793                 for(int j=0;j<4;j++){
    794                         for(int l=0;l<4;l++){
    795                                 if(this->board[i][j][0][l]!= mini4DgamePlayerColor::none
    796                                                    && this->board[i][j][0][l]==this->board[i][j][1][l]
    797                                                    && this->board[i][j][1][l]==this->board[i][j][2][l]
    798                                                    && this->board[i][j][2][l]==this->board[i][j][3][l])
    799                                 {
    800                                         winner.color_ = this->board[i][j][0][l];
    801                                                 for(int x=0; x<4; x++){
    802                                                         winner.winningRow[x] = i;
    803                                                         winner.winningColumn[x] = j;
    804                                                         winner.winningHeight[x] = x;
    805                                                         winner.winningNumber[x] = l;
    806                                                 }
    807                                                 return winner;
    808                                 }
    809                         }
    810                 }
    811         }
    812 
    813         //check numbers
    814         for(int i=0;i<4;i++){
    815                 for(int j=0;j<4;j++){
    816                         for(int k=0;k<4;k++){
    817                                 if(this->board[i][j][k][0]!= mini4DgamePlayerColor::none
    818                                                    && this->board[i][j][k][0]==this->board[i][j][k][1]
    819                                                    && this->board[i][j][k][1]==this->board[i][j][k][2]
    820                                                    && this->board[i][j][k][2]==this->board[i][j][k][3])
    821                                 {
    822                                         winner.color_ = this->board[i][j][k][0];
    823                                                 for(int x=0; x<4; x++){
    824                                                         winner.winningRow[x] = i;
    825                                                         winner.winningColumn[x] = j;
    826                                                         winner.winningHeight[x] = k;
    827                                                         winner.winningNumber[x] = x;
    828                                                 }
    829                                                 return winner;
    830                                 }
    831                         }
    832                 }
    833         }
    834         return winner;
    835     }
    83698}
Note: See TracChangeset for help on using the changeset viewer.