Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
Nov 12, 2014, 4:07:10 PM (10 years ago)
Author:
richtero
Message:

finished getWinner function which checks if somebody has won and started on the AI.

Location:
code/branches/minigame4DHS14/src/modules/mini4Dgame
Files:
2 added
5 edited

Legend:

Unmodified
Added
Removed
  • code/branches/minigame4DHS14/src/modules/mini4Dgame/CMakeLists.txt

    r10101 r10121  
    11SET_SOURCE_FILES(Mini4Dgame_SRC_FILES
    22  Mini4Dgame.cc
     3  Mini4DgameAI.cc
    34  Mini4DgameCenterpoint.cc
    45)
  • code/branches/minigame4DHS14/src/modules/mini4Dgame/Mini4Dgame.cc

    r10101 r10121  
    170170
    171171
    172     /**
    173     @brief
    174         Get the player.
    175     @return
    176         Returns a pointer to the player. If there is no player, NULL is returned.
    177     */
    178     //TODO: colors
    179     PlayerInfo* Mini4Dgame::getPlayer(int color) const
    180     {
    181         return players[color].info_;
    182         //for(int i=0;i<NUMBEROFPLAYERS;i++)
    183                 //if(color == this->mini4DgamePlayers[i].color)
    184                         //return this->mini4DgamePlayers[i].info;
    185     }
    186 
    187172}
  • code/branches/minigame4DHS14/src/modules/mini4Dgame/Mini4Dgame.h

    r10115 r10121  
    5757        };
    5858
    59 
     59        struct Mini4DgameWinner
     60        {
     61                int winningRow[4];
     62                int winningColumn[4];
     63                int winningHeight[4];
     64                int winningNumber[4];
     65                mini4DgamePlayerColor::color color_;
     66        };
    6067    /**
    6168    @brief
     
    7885                { this->center_ = center; }
    7986
    80 //TODO: enum colors
    81             PlayerInfo* getPlayer(int color) const; //!< Get the player with the specified color.
    82 
    83 
    84             //bool isValidMove(Vector4* move, const Mini4DgameBoard* board);//!< Checks if the move is valid
     87            void win(Mini4DgameWinner winner);
    8588
    8689        protected:
     
    9194            void cleanup(void); //!< Cleans up the Gametype by destroying the ball and the bats.
    9295
    93           Mini4DgamePlayer players[2];
     96            Mini4DgamePlayer players[2];
    9497
    9598            WeakPtr<Mini4DgameCenterpoint> center_; //!< The playing field.
    96 
    97             //TODO: Board is missing up to now
    9899    };
    99100}
  • code/branches/minigame4DHS14/src/modules/mini4Dgame/Mini4DgameCenterpoint.cc

    r10115 r10121  
    122122        {
    123123                this->board[(int)move.x][(int)move.y][(int)move.z][(int)move.w] = playerColor;
    124                 mini4DgamePlayerColor::color winner = this->getWinner();
    125                 if(winner != mini4DgamePlayerColor::none)
     124                Mini4DgameWinner winner = this->getWinner();
     125                if(winner.color_ != mini4DgamePlayerColor::none)
    126126                {
    127127                        Mini4Dgame->win(winner);
     
    130130    }
    131131
    132     mini4DgamePlayerColor::color Mini4DgameCenterpoint::getWinner()
     132    Mini4DgameWinner Mini4DgameCenterpoint::getWinner()
    133133    {
     134        Mini4DgameWinner winner;
     135                winner.color_ = mini4DgamePlayerColor::none;
     136
    134137        //check diagonals rows-columns-height-numbers
    135138                for(int i=1; i<4; i++)
     
    138141                                break;
    139142                        if(i==3)
    140                                 return this->board[0][0][0][0];
     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                        }
    141153                }
    142154                for(int i=1; i<4; i++)
     
    145157                                break;
    146158                        if(i==3)
    147                                 return this->board[3][0][0][0];
     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                        }
    148169                }
    149170                for(int i=1; i<4; i++)
     
    152173                                break;
    153174                        if(i==3)
    154                                 return this->board[0][3][0][0];
     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                        }
    155185                }
    156186                for(int i=1; i<4; i++)
     
    159189                                break;
    160190                        if(i==3)
    161                                 return this->board[0][0][3][0];
     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                        }
    162201                }
    163202                for(int i=1; i<4; i++)
     
    166205                                break;
    167206                        if(i==3)
    168                                 return this->board[0][0][0][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                        }
    169217                }
    170218                for(int i=1; i<4; i++)
     
    173221                                break;
    174222                        if(i==3)
    175                                 return this->board[3][3][0][0];
     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                        }
    176233                }
    177234                for(int i=1; i<4; i++)
     
    180237                                break;
    181238                        if(i==3)
    182                                 return this->board[3][0][3][0];
     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                        }
    183249                }
    184250                for(int i=1; i<4; i++)
     
    187253                                break;
    188254                        if(i==3)
    189                                 return this->board[3][0][0][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                        }
    190265                }
    191266
     
    198273                                        break;
    199274                                if(i==3)
    200                                         return this->board[0][0][0][l];
     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                                }
    201285                        }
    202286                        for(int i=1; i<4; i++)
     
    205289                                        break;
    206290                                if(i==3)
    207                                         return this->board[3][0][0][l];
     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                                }
    208301                        }
    209302                        for(int i=1; i<4; i++)
     
    212305                                        break;
    213306                                if(i==3)
    214                                         return this->board[0][3][0][l];
     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                                }
    215317                        }
    216318                        for(int i=1; i<4; i++)
     
    219321                                        break;
    220322                                if(i==3)
    221                                         return this->board[0][0][3][l];
     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                                }
    222333                        }
    223334                }
     
    231342                                        break;
    232343                                if(i==3)
    233                                         return this->board[0][0][l][0];
     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                                }
    234354                        }
    235355                        for(int i=1; i<4; i++)
     
    238358                                        break;
    239359                                if(i==3)
    240                                         return this->board[3][0][l][0];
     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                                }
    241370                        }
    242371                        for(int i=1; i<4; i++)
     
    245374                                        break;
    246375                                if(i==3)
    247                                         return this->board[0][3][l][0];
     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                                }
    248386                        }
    249387                        for(int i=1; i<4; i++)
     
    252390                                        break;
    253391                                if(i==3)
    254                                         return this->board[0][0][l][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                                }
    255402                        }
    256403                }
     
    264411                                        break;
    265412                                if(i==3)
    266                                         return this->board[0][l][0][0];
     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                                }
    267423                        }
    268424                        for(int i=1; i<4; i++)
     
    271427                                        break;
    272428                                if(i==3)
    273                                         return this->board[3][l][0][0];
     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                                }
    274439                        }
    275440                        for(int i=1; i<4; i++)
     
    278443                                        break;
    279444                                if(i==3)
    280                                         return this->board[0][l][3][0];
     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                                }
    281455                        }
    282456                        for(int i=1; i<4; i++)
     
    285459                                        break;
    286460                                if(i==3)
    287                                         return this->board[0][l][0][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                                }
    288471                        }
    289472                }
     
    297480                                        break;
    298481                                if(i==3)
    299                                         return this->board[l][0][0][0];
     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                                }
    300492                        }
    301493                        for(int i=1; i<4; i++)
     
    304496                                        break;
    305497                                if(i==3)
    306                                         return this->board[l][3][0][0];
     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                                }
    307508                        }
    308509                        for(int i=1; i<4; i++)
     
    311512                                        break;
    312513                                if(i==3)
    313                                         return this->board[l][0][3][0];
     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                                }
    314524                        }
    315525                        for(int i=1; i<4; i++)
     
    318528                                        break;
    319529                                if(i==3)
    320                                         return this->board[l][0][0][3];
    321                         }
    322                 }
    323 
    324                 //check diagonals rows-columns
     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
    325544                for(int k=0;k<4;k++){
    326545                for(int l=0;l<4;l++){
     546                        //rows-columns
    327547                        for(int i=1; i<4; i++)
    328548                                {
    329                                         if(this->board[i][i][k][l]==mini4DgamePlayerColor::none || this->board[0][0][l][0] != this->board[i][i][l][i])
     549                                        if(this->board[i][i][k][l]==mini4DgamePlayerColor::none || this->board[0][0][k][l] != this->board[i][i][k][l])
    330550                                                break;
    331551                                        if(i==3)
    332                                                 return this->board[0][0][l][0];
    333                                 }}}
    334         //-------------------------------------------------------------------------------------------------------
     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        }
    335746
    336747        //check rows
     
    343754                                   && this->board[2][j][k][l]==this->board[3][j][k][l])
    344755                                {
    345                                         return this->board[0][j][k][l];
     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;
    346764                                }
    347765                        }
     
    358776                                           && this->board[i][2][k][l]==this->board[i][3][k][l])
    359777                                {
    360                                 return this->board[i][0][k][l];
     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;
    361786                                }
    362787                        }
     
    373798                                                   && this->board[i][j][2][l]==this->board[i][j][3][l])
    374799                                {
    375                                         return this->board[i][j][0][l];
     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;
    376808                                }
    377809                        }
     
    388820                                                   && this->board[i][j][k][2]==this->board[i][j][k][3])
    389821                                {
    390                                         return this->board[i][j][k][0];
     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;
    391830                                }
    392831                        }
    393832                }
    394833        }
    395 
    396 
    397         return mini4DgamePlayerColor::none;
     834        return winner;
    398835    }
    399836}
  • code/branches/minigame4DHS14/src/modules/mini4Dgame/Mini4DgameCenterpoint.h

    r10115 r10121  
    4141#include "worldentities/StaticEntity.h"
    4242#include "mini4Dgame/Mini4DgamePrereqs.h"
     43#include "mini4Dgame/Mini4Dgame.h"
    4344
    4445namespace orxonox
     
    109110                    @param the position where to put the stone plus the player who makes the move
    110111            */
    111             bool isValidMove(const Vector4 move,const int playerColor);
     112            bool isValidMove(const Vector4 move);
    112113
    113114            /**
     
    115116                   @param the position where to put the stone plus the player who makes the move
    116117             */
    117             void makeMove(const Vector4 move, const int player);
     118            void makeMove(const Vector4 move, const mini4DgamePlayerColor::color playerColor);
    118119
    119120            /**
    120                 @brief searches the board if somebody has won
    121                                 @return the winner if somebody has won or mini4DgamePlayerColor::none if nobody has won so far
    122              */
    123             mini4DgamePlayerColor::color Mini4DgameCenterpoint::getWinner()
     121               @brief checks if somebody has won
     122               @return the winner with the winning fields or a winner with winner.color_ == mini4DgamePlayerColor::none if nobody has won so far.
     123            */
     124            Mini4DgameWinner Mini4DgameCenterpoint::getWinner();
    124125
    125126        private:
Note: See TracChangeset for help on using the changeset viewer.