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 edited

Legend:

Unmodified
Added
Removed

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

    r11026 r11035  
    3232*/
    3333
    34 //#include "orxonox/worldentities/pawns/SpaceShip.h"
    3534#include "Hover.h"
    3635
    3736#include "HoverWall.h"
    3837#include "HoverFlag.h" 
     38#include "MazeGenerator.h"
    3939#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>
    48 #include <vector>
    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 
    9843    RegisterUnloadableClass(Hover);
    99 
    100 
    101 
    102 
    103 
    104 
    10544
    10645    Hover::Hover(Context* context) : Gametype(context)
    … …  
    10847       
    10948        RegisterObject(Hover);
     49
     50        this->origin_ = NULL;
     51        this->flags_ = 1;
     52        this->firstTick_ = true;
     53
    11054        this->setHUDTemplate("HoverHUD");
    11155    }
    11256
    113 
    114 
    11557    void Hover::tick(float dt)
    11658    {
    117 
    11859        SUPER(Hover, tick, dt);
    11960
     61        if(this->firstTick_)
     62        {
     63            this->firstTick_ = false;
    12064
     65            MazeGenerator generator;
     66            generator.generateMaze();
     67            generator.renderMaze();
    12168
    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;
     69            const int NUM_CELLS = generator.getNumCells();
     70            int* levelcode = generator.getLevelcode();
    13271
    13372            //Outer Walls
    134             for(int i = 0; i<10; i++){
     73            for(int i = 0; i<NUM_CELLS; i++){
    13574                new HoverWall(origin_->getContext(), 0, i+1, 1);
    136                 new HoverWall(origin_->getContext(), 10, i+1, 1);
     75                new HoverWall(origin_->getContext(), NUM_CELLS, i+1, 1);
    13776                new HoverWall(origin_->getContext(), i+1, 0, 2);
    138                 new HoverWall(origin_->getContext(), i+1, 10, 2);
     77                new HoverWall(origin_->getContext(), i+1, NUM_CELLS, 2);
    13978            }
    14079
    14180            //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);
     81            for(int y=0; y<NUM_CELLS; y++){
     82                for(int x=0; x<NUM_CELLS; x++){
     83                    switch(levelcode[ y * NUM_CELLS + x ]){
     84                        case 1: new HoverWall(origin_->getContext(), x+1, NUM_CELLS-y, 1);
    14685                                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);
     86                        case 3: new HoverWall(origin_->getContext(), x+1, NUM_CELLS-y, 1);
     87                        case 2: new HoverWall(origin_->getContext(), x+1, NUM_CELLS-y, 0);
    14988                        default: break;
    15089                    }
    151 
    152 
    153                    
    15490                }   
    15591            }
    … …  
    15793            //Generate 5 flags randomly
    15894            for ( int i = 0; i < 5; i++ )
    159                 flagVector.push_back(new HoverFlag(origin_->getContext(), rand()%10, rand()%10));
     95                flagVector_.push_back(new HoverFlag(origin_->getContext(), rand()%NUM_CELLS, rand()%NUM_CELLS));
    16096
    161             Flags_ = flagVector.size();
     97            flags_ = flagVector_.size();
    16298
    16399        }//firsttick end
    164100
    165101        // 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);
     102        for ( unsigned int i = 0; i < flagVector_.size(); i++ ){
     103            if(flagVector_[i]->getCollided()){
     104                flagVector_[i]->destroyLater();
     105                flagVector_.erase (flagVector_.begin()+i);
    170106            }
    171107        }
    172         Flags_ = flagVector.size();
    173 
    174 
    175 
     108        flags_ = flagVector_.size();
    176109    }
    177110
    178      int Hover::getFlags()
     111    int Hover::getFlags()
    179112    {
    180 
    181113        // Call start for the parent class.
    182         return Flags_;
     114        return flags_;
    183115    }   
    184116
    185117    void Hover::start()
    186118    {
    187 
    188119        // Call start for the parent class.
    189120        Gametype::start();
    190 
    191121    }
    192 
    193122
    194123    void Hover::end()
    … …  
    200129        GSLevel::startMainMenu();
    201130    }
    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 
    224 
    225     /**
    226     @brief
    227         Checks if Direction is valid (for Maze-Generator)
    228     */
    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 ];
    237     }
    238 
    239     /**
    240     @brief
    241         Generates new Direction (for Maze-Generator)
    242     */
    243     eDirection Hover::GetDirection()
    244     {
    245         eDirection Dir = eDirection( 1 << RandomInt4() );
    246 
    247         while ( true )
    248         {
    249             for ( int x = 0; x < 4; x++ )
    250             {
    251                 if ( IsDirValid( Dir ) ) { return eDirection( Dir ); }
    252 
    253                 Dir = eDirection( Dir << 1 );
    254 
    255                 if ( Dir > eDirection_Left ) { Dir = eDirection_Up; }
    256             }
    257 
    258             Dir = eDirection( ( g_Maze[ CellIdx() ] & 0xf0 ) >> 4 );
    259 
    260             // nowhere to go
    261             if ( !Dir ) return eDirection_Invalid;
    262 
    263             g_PtX += Heading_X[ Dir ];
    264             g_PtY += Heading_Y[ Dir ];
    265 
    266             Dir = eDirection( 1 << RandomInt4() );
    267         }
    268     }
    269 
    270     /**
    271     @brief
    272         Generates a Maze (for Maze-Generator)
    273     */
    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 ];
    285         }
    286     } 
    287    
    288     /**
    289     @brief
    290         Print Maze (for Debugging only)
    291     */
    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 ];
    298                 orxout()<<"[";
    299                 if ( ( v & eDirection_Up    ) ) orxout()<<"U";
    300                 else orxout()<<" ";
    301                 if ( ( v & eDirection_Right ) ) orxout()<<"R";
    302                 else orxout()<<" ";
    303                 if ( ( v & eDirection_Down  ) ) orxout()<<" ";
    304                 else orxout()<<" ";
    305                 if ( ( v & eDirection_Left  ) ) orxout()<<" ";
    306                 else orxout()<<" ";
    307                 orxout()<<"]";
    308             }
    309             orxout()<<endl;
    310         }
    311 
    312     }
    313 
    314     /**
    315     @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++ )
    322             {
    323                 orxout()<<"[";
    324                 if ( levelcode[x][y] < 2) orxout()<<"U";
    325                 else orxout()<<" ";
    326                 if ( levelcode[x][y] % 2 == 0) orxout()<<"R";
    327                 else orxout()<<" ";
    328 
    329                 orxout()<<" ";
    330                 orxout()<<" ";
    331                 orxout()<<"]";
    332             }
    333             orxout()<<endl;
    334         }
    335     }
    336 
    337     /**
    338     @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;
    351             }
    352         }
    353         for ( int y = 3; y < 7; y++ )
    354         {
    355             for ( int x = 3; x < 7; x++ )
    356             {
    357 
    358                 if(y == 3 && x != 7)
    359                     levelcode[y][x] &= 2;
    360                 else if (x == 7 && y != 3)
    361                     levelcode[y][x] &= 1;
    362                 else if(x != 7)
    363                     levelcode[y][x] = 0;
    364             }
    365         }
    366 
    367     }
    368 
    369 
    370 
    371131}
Note: See TracChangeset for help on using the changeset viewer.