Game.cpp

   1 #include <time.h>
   2 #include <iostream>
   3 #include <sstream>
   4 #include <assert.h>
   5 #include "SDLVideoOut.h"
   6 #include "Game.h"
   7 #include "luafuncs.h"
   8
   9 namespace botor
  10 {
  11
  12         SDLVideoOut *Game::video = 0;
  13         Map Game::map;
  14         Player Game::player;
  15
  16         lua_State *Game::LUA = 0;
  17
  18         std::map<std::string, ObjectClass> Game::objectTypes;
  19
  20
  21     Game::Game()
  22     {
  23         video = new SDLVideoOut( 800, 600, 32 );
  24
  25         LUA = lua_open();       //open scripting unit
  26
  27         luaopen_base( LUA );
  28
  29         LuaFuncs::Push( LUA );  //and load libraries
  30
  31     }
  32
  33     Game::~Game()
  34     {
  35         lua_close( LUA );
  36
  37         delete video;
  38     }
  39
  40     void Game::Initialize()
  41     {
  42
  43
  44
  45         Game::map.load( "map.txt" );
  46         Game::player.Teleport( 2,1 );
  47
  48         Game::map.Initialize();
  49
  50
  51     }
  52
  53     void Game::LoadContent()
  54     {
  55         LoadObjects();
  56     }
  57
  58     int Game::LoadObjects()
  59     {
  60         lua_State *L = lua_newthread( LUA );
  61
  62         int s = luaL_loadfile( L, "objects.lua" );
  63
  64         if( !s )
  65         {
  66                 s = lua_pcall( L, 0, 0, 0 );    //run file
  67                 if( s )
  68                 {
  69                         std::cout << "Error loading Objects:" << std::endl
  70                                 << lua_tostring( L, -1 ) << std::endl;
  71                         exit(1);
  72                 }
  73         }
  74         else
  75         {
  76                 std::cout << "Error loading file: objects.lua:" << std::endl;
  77                 exit(1);
  78         }
  79
  80         lua_getglobal( L, "objects" );
  81
  82         lua_pushnil( L );
  83
  84         while( lua_next( L, -2 ) )      //each object type
  85         {
  86
  87                 if( lua_istable( L, -1 ) )
  88                 {
  89                         ObjectClass temp;
  90
  91                         lua_pushnil( L );
  92
  93                         while( lua_next( L, -2 ) )
  94                         {
  95
  96                                 std::string key( lua_tostring( L, -2 ) );
  97
  98                                 if( key == "tile" )
  99                                 {
 100                                         temp.graphic = ObjectClass::GRA_TILE;
 101                                         temp.tile_id = lua_tonumber( L, -1 );
 102                                 }
 103                                 else if( key == "animation" )
 104                                 {
 105                                         temp.graphic = ObjectClass::GRA_ANIMATION;
 106
 107                                         lua_getfield( L, -1 ,"id" );
 108
 109                                         temp.tile_id = lua_tonumber( L, -1 );
 110
 111                                         lua_pop( L, 1 );
 112
 113                                         lua_getfield( L, -1, "length" );
 114
 115                                         temp.anim_length = lua_tonumber( L, -1 );
 116
 117                                         lua_pop( L, 1 );
 118
 119                                         lua_getfield( L, -1, "time" );
 120
 121                                         temp.anim_time = lua_tonumber( L, -1 );
 122
 123                                         lua_pop( L, 1 );
 124
 125                                         lua_getfield( L, -1, "loop" );
 126
 127                                         temp.anim_loop = (bool)lua_toboolean( L, -1 );
 128
 129                                         lua_pop( L, 1 );
 130
 131                                 }
 132                                 else if( key == "nuse" )
 133                                 {
 134
 135                                         if( lua_isstring( L, -1 ) )
 136                                         {
 137                                                 std::string nuse( lua_tostring( L, -1 ) );
 138
 139                                                 if( nuse == "Once" )
 140                                                         temp.nUse = ObjectClass::NUseOnce;
 141                                                 else if( nuse == "Multi" )
 142                                                         temp.nUse = ObjectClass::NUseMulti;
 143                                                 else if( nuse == "Drop" )
 144                                                         temp.nUse = ObjectClass::NUseDrop;
 145                                         }
 146                                         else
 147                                                 return luaL_error( L, "Not a string!" );
 148
 149                                 }
 150                                 else if( key == "Activation" )
 151                                 {
 152                                         if( lua_isfunction( L, -1 ) )
 153                                         {
 154                                                 temp.OnActivation = luaL_ref( L, LUA_REGISTRYINDEX );
 155                                                 lua_pushnil( L ); // so the pop doesn't get confused
 156                                         }
 157                                         else
 158                                                 return luaL_error( L, "Not a function!" );
 159                                 }
 160                                 else if( key == "PlayerOnTile" )
 161                                 {
 162                                         if( lua_isfunction( L, -1 ) )
 163                                         {
 164                                                 temp.OnPlayerOnTile = luaL_ref( L, LUA_REGISTRYINDEX );
 165                                                 lua_pushnil( L ); // so the pop doesn't get confused
 166                                         }
 167                                         else
 168                                                 return luaL_error( L, "Not a function!" );
 169                                 }
 170                                 else if( key == "Pickup" )
 171                                 {
 172                                         if( lua_isfunction( L, -1 ) )
 173                                         {
 174                                                 temp.OnPickup = luaL_ref( L, LUA_REGISTRYINDEX );
 175                                                 lua_pushnil( L ); // so the pop doesn't get confused
 176                                         }
 177                                         else
 178                                                 return luaL_error( L, "Not a function!" );
 179                                 }
 180                                 else if( key == "Drop" )
 181                                 {
 182                                         if( lua_isfunction( L, -1 ) )
 183                                         {
 184                                                 temp.OnDrop = luaL_ref( L, LUA_REGISTRYINDEX );
 185                                                 lua_pushnil( L ); // so the pop doesn't get confused
 186                                         }
 187                                         else
 188                                                 return luaL_error( L, "Not a function!" );
 189                                 }
 190
 191                                 lua_pop( L, 1 );
 192
 193                         }
 194
 195                         objectTypes[lua_tostring( L, -2 )] = temp;
 196
 197
 198                 }
 199
 200                 lua_pop( L, 1 );
 201
 202         }
 203
 204         return 0;
 205
 206
 207     }
 208
 209     void Game::DeInitialize()
 210     {
 211         Game::map.unload();
 212     }
 213
 214     void Game::Update()
 215     {
 216         SDL_Event event;
 217
 218         while( SDL_PollEvent( &event ) )
 219         {
 220                 HandleInput( &event );
 221                 Game::player.HandleInput( &event );
 222         }
 223
 224         if( Game::player.isAlive() )
 225         {
 226                 Game::map.Update();
 227                 Game::player.Update();
 228         }
 229
 230         if( Game::player.getLives() == 0 )
 231                 game_is_running = false;
 232
 233
 234     }
 235
 236     void Game::HandleInput( SDL_Event *event )
 237     {
 238         switch (event->type)
 239         {
 240                 // exit if the window is closed
 241                 case SDL_QUIT:
 242                 game_is_running = false;
 243                 break;
 244
 245                 // check for keypresses
 246                 case SDL_KEYDOWN:
 247                 {
 248                         // exit if ESCAPE is pressed
 249                         if (event->key.keysym.sym == SDLK_ESCAPE)
 250                         game_is_running = false;
 251                         break;
 252                 }
 253         } // end switch
 254     }
 255
 256     void Game::Draw()
 257     {
 258         std::stringstream status;
 259
 260         if( !Game::video )
 261                 return;
 262
 263         Game::video->Clear( Game::video->MapRGB( 255, 255, 255 ) );
 264
 265         Game::map.Draw( );
 266
 267         if(Game::player.isAlive())
 268                 Game::player.Draw( );
 269         else
 270                 Game::video->DrawString( "You are dead! Press [Enter] to continue!", 0, 0, 255, 0, 0 );
 271
 272         status << "Leben: " << Game::player.getLives() << " Pos: " << (int)Game::player.getMapX() << "/" << (int)Game::player.getMapY();
 273
 274         Game::video->DrawString( status.str().c_str(), 0, 20, 0, 0, 0 );
 275
 276
 277         Game::video->Flip();
 278
 279     }
 280
 281     void Game::run()
 282     {
 283         int loops;
 284
 285         LoadContent();
 286
 287
 288         Initialize();
 289
 290         game_is_running = true;
 291         clock_t nextUpdate = clock();
 292
 293         while( game_is_running )
 294         {
 295             loops = 0;
 296
 297             while( clock() > nextUpdate && loops < MAX_FRAMESKIP )
 298             {
 299                 Update();
 300
 301                 nextUpdate += SKIP_FRAMES;
 302
 303                 loops++;
 304             }
 305
 306             Draw();
 307
 308         }
 309
 310         DeInitialize();
 311
 312     }
 313
 314     SDLVideoOut *Game::getVideo()
 315     {
 316         return Game::video;
 317     }
 318
 319     Map *Game::getMap()
 320     {
 321         return &Game::map;
 322     }
 323
 324     Player *Game::getPlayer()
 325     {
 326         return &Game::player;
 327     }
 328
 329 }