Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
Jan 4, 2016, 11:23:59 AM (8 years ago)
Author:
landauf
Message:

moved maze-generator-code into separate class. made all static variables private members. this fixes a number of issues when reloading the hover game.

File:
1 copied

Legend:

Unmodified
Added
Removed

  • code/branches/presentationHS15/src/modules/hover/MazeGenerator.cc

    r11026 r11035  
    2828
    2929/**
    30     @file Hover.cc
    31     @brief Implementation of the Hover class. Sets up the whole Minigame
     30    @file MazeGenerator.cc
     31    @brief Implementation of the MazeGenerator class. Generates the maze.
    3232*/
    3333
    34 //#include "orxonox/worldentities/pawns/SpaceShip.h"
    35 #include "Hover.h"
    36 
    37 #include "HoverWall.h"
    38 #include "HoverFlag.h" 
    39 #include "core/CoreIncludes.h"
    40 
    41 #include <iostream>
    42 #include <string>
    43 #include <time.h>
    44 #include <stdlib.h>
    45 #include <memory.h>
    46 #include <stdint.h>
    47 #include <fstream>
     34#include "MazeGenerator.h"
     35
    4836#include <vector>
     37
     38#include "util/Output.h"
     39#include "util/Math.h"
    4940
    5041namespace orxonox
    5142{
    52     bool firstTick = true;
    53 
    54     //Levelcode represents the pitch: It's a 10x10 field.
    55     // 1 represents a Wall on the right side of this square
    56     // 2 represents a Wall on the top of this square
    57     // 3 represents 2 and 1 at the same time
    58     // Note: the levelcode is generated from the Maze-Generator functions at the beginning of the game
    59     int levelcode[10][10] =
    60         {
    61         { 0,0,0,0,0,0,0,0,0,0 },
    62         { 0,0,0,0,0,0,0,0,0,0 },
    63         { 0,0,0,0,0,0,0,0,0,0 },
    64         { 0,0,0,0,0,0,0,0,0,0 },
    65         { 0,0,0,0,0,0,0,0,0,0 },
    66         { 0,0,0,0,0,0,0,0,0,0 },
    67         { 0,0,0,0,0,0,0,0,0,0 },
    68         { 0,0,0,0,0,0,0,0,0,0 },
    69         { 0,0,0,0,0,0,0,0,0,0 },
    70         { 0,0,0,0,0,0,0,0,0,0 }
    71         };
    72 
    73     const int NumCells  = 10;
    74     unsigned char* g_Maze = new unsigned char[ NumCells* NumCells ];
    75 
    76     // current traversing position
    77     int g_PtX;
    78     int g_PtY;
    79 
    80     // return the current index in g_Maze
    81     int Hover::CellIdx()
    82     {
    83         return g_PtX + NumCells * g_PtY;
    84     }   
    85 
    86 
    87     int Hover::RandomInt()
    88     {
    89         return (rand() % NumCells);
    90     }
    91 
    92     int Hover::RandomInt4()
    93     {
    94         return (rand() % 4);
    95     }
    96 
    97 
    98     RegisterUnloadableClass(Hover);
    99 
    100 
    101 
    102 
    103 
    104 
    105 
    106     Hover::Hover(Context* context) : Gametype(context)
    107     {
    108        
    109         RegisterObject(Hover);
    110         this->setHUDTemplate("HoverHUD");
    111     }
    112 
    113 
    114 
    115     void Hover::tick(float dt)
    116     {
    117 
    118         SUPER(Hover, tick, dt);
    119 
    120 
    121 
    122 
    123         if(firstTick)
    124         {
    125 
    126             std::fill( g_Maze, g_Maze + NumCells * NumCells, 0 );
    127             g_PtX=0;
    128             g_PtY=0;
    129             GenerateMaze();
    130             RenderMaze();
    131             firstTick = false;
    132 
    133             //Outer Walls
    134             for(int i = 0; i<10; i++){
    135                 new HoverWall(origin_->getContext(), 0, i+1, 1);
    136                 new HoverWall(origin_->getContext(), 10, i+1, 1);
    137                 new HoverWall(origin_->getContext(), i+1, 0, 2);
    138                 new HoverWall(origin_->getContext(), i+1, 10, 2);
    139             }
    140 
    141             //Generate inner Walls according to levelcode
    142             for(int y=0; y<10; y++){
    143                 for(int x=0; x<10; x++){
    144                     switch(levelcode[y][x]){
    145                         case 1: new HoverWall(origin_->getContext(), x+1, 10-y, 1);
    146                                 break;
    147                         case 3: new HoverWall(origin_->getContext(), x+1, 10-y, 1);
    148                         case 2: new HoverWall(origin_->getContext(), x+1, 10-y, 0);
    149                         default: break;
    150                     }
    151 
    152 
    153                    
    154                 }   
    155             }
    156 
    157             //Generate 5 flags randomly
    158             for ( int i = 0; i < 5; i++ )
    159                 flagVector.push_back(new HoverFlag(origin_->getContext(), rand()%10, rand()%10));
    160 
    161             Flags_ = flagVector.size();
    162 
    163         }//firsttick end
    164 
    165         // Check if ship collided with one of the flags
    166         for ( unsigned int i = 0; i < flagVector.size(); i++ ){
    167             if(flagVector[i]->getCollided()){
    168                 flagVector[i]->destroyLater();
    169                 flagVector.erase (flagVector.begin()+i);
    170             }
    171         }
    172         Flags_ = flagVector.size();
    173 
    174 
    175 
    176     }
    177 
    178      int Hover::getFlags()
    179     {
    180 
    181         // Call start for the parent class.
    182         return Flags_;
    183     }   
    184 
    185     void Hover::start()
    186     {
    187 
    188         // Call start for the parent class.
    189         Gametype::start();
    190 
    191     }
    192 
    193 
    194     void Hover::end()
    195     {
    196         // DON'T CALL THIS!
    197         //      Deathmatch::end();
    198         // It will misteriously crash the game!
    199         // Instead startMainMenu, this won't crash.
    200         GSLevel::startMainMenu();
    201     }
    202 
    203 
    204 
    205 
    206     // Some definitions for the Maze-Generator
    207 
    208     //                   0  1  2  3  4  5  6  7  8
    209     //                      U  R     D           L
    210     int Heading_X[9] = { 0, 0,+1, 0, 0, 0, 0, 0,-1 };
    211     int Heading_Y[9] = { 0,-1, 0, 0,+1, 0, 0, 0, 0 };
    212     int Mask[9]      = {
    213                                 0,
    214                                 eDirection_Down | eDirection_Down << 4,
    215                                 eDirection_Left | eDirection_Left << 4,
    216                                 0,
    217                                 eDirection_Up | eDirection_Up << 4,
    218                                 0,
    219                                 0,
    220                                 0,
    221                                 eDirection_Right | eDirection_Right << 4
    222                             };
    223 
     43    MazeGenerator::MazeGenerator()
     44    {
     45        //levelcode_ represents the pitch: It's a 10x10 field.
     46        // 1 represents a Wall on the right side of this square
     47        // 2 represents a Wall on the top of this square
     48        // 3 represents 2 and 1 at the same time
     49        // Note: the levelcode_ is generated from the Maze-Generator functions at the beginning of the game
     50        this->levelcode_ = new int[ NUM_CELLS*NUM_CELLS ];;
     51        std::fill( levelcode_, levelcode_ + NUM_CELLS*NUM_CELLS, 0 );
     52
     53        this->maze_ = new unsigned char[ NUM_CELLS*NUM_CELLS ];
     54        std::fill( maze_, maze_ + NUM_CELLS*NUM_CELLS, 0 );
     55
     56        // current traversing position
     57        this->ptX_ = 0;
     58        this->ptY_ = 0;
     59
     60        //                  0  1  2  3  4  5  6  7  8
     61        //                     U  R     D           L
     62        int headingX[9] = { 0, 0,+1, 0, 0, 0, 0, 0,-1 };
     63        int headingY[9] = { 0,-1, 0, 0,+1, 0, 0, 0, 0 };
     64        int mask[9]     = {
     65                              0,
     66                              eDirection_Down | eDirection_Down << 4,
     67                              eDirection_Left | eDirection_Left << 4,
     68                              0,
     69                              eDirection_Up | eDirection_Up << 4,
     70                              0,
     71                              0,
     72                              0,
     73                              eDirection_Right | eDirection_Right << 4
     74                          };
     75
     76        std::copy(headingX, headingX + 9, this->headingX_);
     77        std::copy(headingY, headingY + 9, this->headingY_);
     78        std::copy(mask,     mask + 9,     this->mask_);
     79    }
    22480
    22581    /**
    … …  
    22783        Checks if Direction is valid (for Maze-Generator)
    22884    */
    229     bool Hover::IsDirValid( eDirection Dir )
    230     {
    231         int NewX = g_PtX + Heading_X[ Dir ];
    232         int NewY = g_PtY + Heading_Y[ Dir ];
    233 
    234         if ( !Dir || NewX < 0 || NewY < 0 || NewX >= NumCells || NewY >= NumCells ) return false;
    235 
    236         return !g_Maze[ NewX + NumCells * NewY ];
     85    bool MazeGenerator::isDirValid( eDirection Dir )
     86    {
     87        int NewX = ptX_ + headingX_[ Dir ];
     88        int NewY = ptY_ + headingY_[ Dir ];
     89
     90        if ( !Dir || NewX < 0 || NewY < 0 || NewX >= NUM_CELLS || NewY >= NUM_CELLS ) return false;
     91
     92        return !maze_[ NewX + NUM_CELLS * NewY ];
    23793    }
    23894
    … …  
    24197        Generates new Direction (for Maze-Generator)
    24298    */
    243     eDirection Hover::GetDirection()
    244     {
    245         eDirection Dir = eDirection( 1 << RandomInt4() );
     99    eDirection MazeGenerator::getDirection()
     100    {
     101        eDirection Dir = eDirection( 1 << randomInt4() );
    246102
    247103        while ( true )
    … …  
    249105            for ( int x = 0; x < 4; x++ )
    250106            {
    251                 if ( IsDirValid( Dir ) ) { return eDirection( Dir ); }
     107                if ( isDirValid( Dir ) ) { return eDirection( Dir ); }
    252108
    253109                Dir = eDirection( Dir << 1 );
    … …  
    256112            }
    257113
    258             Dir = eDirection( ( g_Maze[ CellIdx() ] & 0xf0 ) >> 4 );
     114            Dir = eDirection( ( maze_[ cellIdx() ] & 0xf0 ) >> 4 );
    259115
    260116            // nowhere to go
    261117            if ( !Dir ) return eDirection_Invalid;
    262118
    263             g_PtX += Heading_X[ Dir ];
    264             g_PtY += Heading_Y[ Dir ];
    265 
    266             Dir = eDirection( 1 << RandomInt4() );
     119            ptX_ += headingX_[ Dir ];
     120            ptY_ += headingY_[ Dir ];
     121
     122            Dir = eDirection( 1 << randomInt4() );
    267123        }
    268124    }
    … …  
    272128        Generates a Maze (for Maze-Generator)
    273129    */
    274     void Hover::GenerateMaze()
    275     {
    276 
    277         for ( eDirection Dir = GetDirection(); Dir != eDirection_Invalid; Dir = GetDirection() )
    278         {
    279             g_Maze[ CellIdx() ] |= Dir;
    280 
    281             g_PtX += Heading_X[ Dir ];
    282             g_PtY += Heading_Y[ Dir ];
    283 
    284             g_Maze[ CellIdx() ] = Mask[ Dir ];
     130    void MazeGenerator::generateMaze()
     131    {
     132
     133        for ( eDirection Dir = getDirection(); Dir != eDirection_Invalid; Dir = getDirection() )
     134        {
     135            maze_[ cellIdx() ] |= Dir;
     136
     137            ptX_ += headingX_[ Dir ];
     138            ptY_ += headingY_[ Dir ];
     139
     140            maze_[ cellIdx() ] = mask_[ Dir ];
    285141        }
    286142    } 
    … …  
    290146        Print Maze (for Debugging only)
    291147    */
    292     void Hover::MazeOut(){
    293         for ( int y = 0; y < NumCells; y++ )
    294         {
    295             for ( int x = 0; x < NumCells; x++ )
    296             {
    297                 char v = g_Maze[ y * NumCells + x ];
     148    void MazeGenerator::mazeOut(){
     149        for ( int y = 0; y < NUM_CELLS; y++ )
     150        {
     151            for ( int x = 0; x < NUM_CELLS; x++ )
     152            {
     153                char v = maze_[ y * NUM_CELLS + x ];
    298154                orxout()<<"[";
    299155                if ( ( v & eDirection_Up    ) ) orxout()<<"U";
    … …  
    314170    /**
    315171    @brief
    316         Print Levelcode (for Debugging only)
    317     */
    318     void Hover::LevelOut(){
    319         for ( int y = 0; y < NumCells; y++ )
    320         {
    321             for ( int x = 0; x < NumCells; x++ )
     172        Print levelcode_ (for Debugging only)
     173    */
     174    void MazeGenerator::levelOut(){
     175        for ( int y = 0; y < NUM_CELLS; y++ )
     176        {
     177            for ( int x = 0; x < NUM_CELLS; x++ )
    322178            {
    323179                orxout()<<"[";
    324                 if ( levelcode[x][y] < 2) orxout()<<"U";
    325                 else orxout()<<" ";
    326                 if ( levelcode[x][y] % 2 == 0) orxout()<<"R";
     180                if ( levelcode_[ y * NUM_CELLS + x ] < 2) orxout()<<"U";
     181                else orxout()<<" ";
     182                if ( levelcode_[ y * NUM_CELLS + x ] % 2 == 0) orxout()<<"R";
    327183                else orxout()<<" ";
    328184
    … …  
    337193    /**
    338194    @brief
    339         Generate Levelcode from Maze
    340     */
    341     void Hover::RenderMaze()
    342     {
    343         for ( int y = 0; y < NumCells; y++ )
    344         {
    345             for ( int x = 0; x < NumCells; x++ )
    346             {
    347                 char v = g_Maze[ y * NumCells + x ];
    348 
    349                 if ( !( v & eDirection_Up    ) && y >0) levelcode[y][x] |= 2;
    350                 if ( !( v & eDirection_Right ) && x <9) levelcode[y][x] |= 1;
     195        Generate levelcode_ from Maze
     196    */
     197    void MazeGenerator::renderMaze()
     198    {
     199        for ( int y = 0; y < NUM_CELLS; y++ )
     200        {
     201            for ( int x = 0; x < NUM_CELLS; x++ )
     202            {
     203                char v = maze_[ y * NUM_CELLS + x ];
     204
     205                if ( !( v & eDirection_Up    ) && y >0) levelcode_[ y * NUM_CELLS + x ] |= 2;
     206                if ( !( v & eDirection_Right ) && x <9) levelcode_[ y * NUM_CELLS + x ] |= 1;
    351207            }
    352208        }
    … …  
    357213
    358214                if(y == 3 && x != 7)
    359                     levelcode[y][x] &= 2;
     215                    levelcode_[ y * NUM_CELLS + x ] &= 2;
    360216                else if (x == 7 && y != 3)
    361                     levelcode[y][x] &= 1;
     217                    levelcode_[ y * NUM_CELLS + x ] &= 1;
    362218                else if(x != 7)
    363                     levelcode[y][x] = 0;
    364             }
    365         }
    366 
    367     }
    368 
    369 
    370 
     219                    levelcode_[ y * NUM_CELLS + x ] = 0;
     220            }
     221        }
     222
     223    }
     224
     225    // return the current index in maze_
     226    int MazeGenerator::cellIdx()
     227    {
     228        return ptX_ + NUM_CELLS * ptY_;
     229    }
     230
     231    int MazeGenerator::randomInt()
     232    {
     233        return (rand() % NUM_CELLS);
     234    }
     235
     236    int MazeGenerator::randomInt4()
     237    {
     238        return (rand() % 4);
     239    }
    371240}
Note: See TracChangeset for help on using the changeset viewer.