GameLevel.h

Go to the documentation of this file.

#ifndef _GAME_LEVEL_H_
#define _GAME_LEVEL_H_
 
#include "ObjectList.h"
#include "Object.h"
#include "ModelGameObject.h"
#include "Terrain.h"
#include "Camera.h"
#include "QuadTree.h"
#include "Music.h"
 
extern "C" {
  #include "luajit-2.1/lua.h"
  #include "luajit-2.1/lualib.h"
  #include "luajit-2.1/lauxlib.h"
}
 
#define MAX_LEVEL_OBJECTS 1024
 
#define TYPE_GAME_OBJECT 1
#define TYPE_GAME_TEXT   2
#define TYPE_GAME_SPRITE 3
 
class GameLevel {
  public:
    GameLevel(const unsigned int& lists);
    ~GameLevel();
 
    void updateLevel();
    void animateLevel();
    void prepareLevel();
    void drawLevel();
 
    bool loadLevel(const char* file);
    bool loadLevelFromBuffer(const char* buffer);
    void loadScript(const std::string& script);
 
    Object* findEnemyOfType(const int& typeId);
    float findDistance(Object* a, Object* b);
 
    void drawSky();
    bool checkComplete();
    void unloadLevel();
    void removeObjects();
 
    void postDraw();
 
    void updateTerrain(int &x, int &z, float &height, int &type, float &red, float &green, float &blue);
    void updateColor(int &x, int &z, float &red, float &green, float &blue);
 
    void getTerrainInfo(int &x, int &z, float &height, int &type, float &red, float &green, float &blue);
    void saveTerrain(const char*);
    void toggleGrid();
    void toggleBoundingBoxes();
    void toggleControlTriangles();
 
    void drawObjects();
    void drawObjectOutlines();
    void drawShadows(Vector*);
 
    void updateObjects(Vector*);
    void prepareObjects();
    void animateObjects(const float& elapsed);
 
    Object* addObject(const std::string& script, lua_State* L, const unsigned int& typeId);
 
    ObjectList* getObjects()         { return &objects_; }
    Terrain* getTerrain()            { return((Terrain*)terrain_); }
    Camera* getCamera()              { return((Camera*)camera_); }
    ModelGameObject* getPlayer()     { return((ModelGameObject*)player_); }
    Music* getMusic()                { return &music_; }
    void setCamera(Camera* camera)   {
      camera_           = camera;
      idToObjectMap_[0] = (Object*)camera_;
      camera_->setGameLevelId(0);
    }
 
    void setId(const int &id) { id_ = id; }
    int getId()               { return id_; }
 
    float getElapsedTime()                        { return elapsedTime_; }
    void setElapsedTime(const float &elapsedTime) { elapsedTime_ = elapsedTime; }
 
    void setComplete(const bool &isComplete)        { isComplete_ = isComplete; }
    std::string getMusicPath()                      { return musicPath_; }
    void setMusicPath(const std::string &musicPath) { musicPath_ = musicPath; }
    Vector* getLightDirection()                     { return &lightDirection_; }
 
    void setSkyBox(float[][3], const int&, const int&);
    void setLightDirection(const float &x, const float &y, const float &z) {
      lightDirection_.setVector(x, y, z);
      lightDirection_.normalize();
    }
 
    Object* getObjectFromId(const int &id) {
      return (id >= 0 && id < MAX_LEVEL_OBJECTS ? idToObjectMap_[id] : NULL);
    }
 
  private:
    unsigned int lists_;      // display lists used for rendering
 
    Vector lightDirection_;
 
    ModelGameObject* player_; // player object
    Object* camera_;          // camera
    Terrain *terrain_;        // Terrain for this level (if one is loaded)
 
    Music music_;
 
    ObjectList objects_;
    std::map <std::string, ObjectList> freeObjects_;
    Object* idToObjectMap_[MAX_LEVEL_OBJECTS];
    unsigned int numObjects_;
 
    // colors for sky box
    float bgcolor_[3][3];
 
    bool isComplete_;
 
    float elapsedTime_;
 
    QuadTree quadTree_;
    DisplayList displayList_;
 
    bool grid_;
    bool bboxes_;
    bool controlTriangles_;
 
    std::string musicPath_;
 
    int id_;
 
    lua_State* luaState_;
 
    bool prepLevelLoad(const char* luaCode);
    bool finishLevelLoad();
};
 
#endif