C:/Documents and Settings/mtauraso/Desktop/proj3/projectX/Level.cpp

Go to the documentation of this file.

#include "Level.h"
#include "Screen.h"
#include "CommandManager.h"
#include "Object.h"
#include "Player.h"
#include "Control.h"
#include "Camera.h"
#include "Parser.h"

#include <io.h>
#include <iostream>
#include <sstream>
#include <cassert>

using namespace std;

Uint32 Level::WALKBEHIND = 0;
Uint32 Level::WALKINTO = 0;
Uint32 Level::WALKINFRONT = 0;
bool Level::_objectsLoaded = false;
map<Uint32,Sprite *> Level::TEXTURES;
map<Uint32,string> Level::OBJECTS;
Level *Level::_instance = NULL;

Level::Level()
:_cutScene(false),_score(0)
{
        loadObjects();
        

        _instance = this;
}


Level::~Level()
{
        for(int i=0; i<_objects.size(); i++)
                delete _objects[i];
        for(int i=0; i<_tiles.size(); i++)
                delete _tiles[i];
}

void Level::reset()
{
        for(int i=0; i<_objects.size(); i++)
                delete _objects[i];
        for(int i=0; i<_tiles.size(); i++)
                delete _tiles[i];

        _objects.clear();
        _tiles.clear();
        _drawnObjects.clear();
        _deleteQueue.clear();

        _ids.clear();

        while(!_addQueue.empty())
        {
                delete _addQueue.front();
                _addQueue.pop();
        }

        levelLoad(_filenamebase);

}

void Level::loadObjects()
{
        if(!_objectsLoaded) {
                readTextures("png");
                readTextures("txt");
                
                WALKBEHIND = loadPixelFile("levels/walkbehind_p.png");
                WALKINFRONT = loadPixelFile("levels/walkinfront_p.png");
                WALKINTO = loadPixelFile("levels/walkinto_p.png");

                readObjects("characters");
                readObjects("events");
                readObjects("cutscenes");
                readObjects("entities");
                //readTextures("bmp");
                _objectsLoaded = true;
        }
}

Uint32 Level::loadPixelFile(std::string filename)
{
        SDL_Surface *surface = glfuncs::instance()->load_image(filename);
        SDL_LockSurface(surface);
        Uint32 pixel=*((Uint32*)surface->pixels);
        SDL_UnlockSurface(surface);
        SDL_FreeSurface(surface);
        return pixel;
}

void Level::readObjects(std::string dir)
{
        struct _finddata_t file;
        intptr_t hFile;
        string extension = "txt";

        if( (hFile = _findfirst( (dir + "/*." + extension).c_str(), &file )) != -1L ) {
                do {
                        string filename(file.name);
                        
                        string end = filename.substr(filename.size() - 6,2);
                        if(end != "_p") {

                                filename = dir + "/" + filename;
                                //Sprite * sprite = new Sprite(filename, tileWidth, tileHeight);
                                string objFile = filename;

                                //filename.insert(filename.find("."),"_p");
                                filename.erase(filename.find("."),4);
                                filename += "_p.png";

                                SDL_Surface *surface = glfuncs::instance()->load_image(filename);
                                SDL_LockSurface(surface);
                                Uint32 pixel=*((Uint32*)surface->pixels);
                                
                                //cerr << (int) pixel << endl;

                                SDL_UnlockSurface(surface);
                                SDL_FreeSurface(surface);

                                OBJECTS[pixel] = objFile;
                        }
                        else
                                continue;
                }
                while( _findnext( hFile, &file ) == 0 );

                _findclose( hFile );
        }
}

void Level::readTextures(std::string extension)
{
        struct _finddata_t file;
        intptr_t hFile;

        if( (hFile = _findfirst( ("textures/*." + extension).c_str(), &file )) != -1L ) {
                do {
                        string filename(file.name);
                        
                        string end = filename.substr(filename.size() - 6,2);
                        if(end != "_p") {

                                filename = "textures/" + filename;
                                //Sprite * sprite = new Sprite(filename, tileWidth, tileHeight);
                                Sprite * sprite = Sprite::loadSprite(filename);

                                //filename.insert(filename.find("."),"_p");
                                filename.erase(filename.find("."),4);
                                filename += "_p.png";

                                SDL_Surface *surface = glfuncs::instance()->load_image(filename);
                                SDL_LockSurface(surface);
                                Uint32 pixel=*((Uint32*)surface->pixels);
                                
                                //cerr << (int) pixel << endl;

                                SDL_UnlockSurface(surface);
                                SDL_FreeSurface(surface);

                                TEXTURES[pixel] = sprite;
                        }
                        else
                                continue;
                }
                while( _findnext( hFile, &file ) == 0 );

                _findclose( hFile );
        }
}

void Level::levelLoad(std::string filenamebase)
{
        _filenamebase = filenamebase;

        levelTextureLoad(filenamebase);
        levelObjectLoad(filenamebase);
        levelSpecsLoad(filenamebase);


        //FIXME (Have the player object register this itself) 
        //This will require a text file for each level (which will have to be loaded here)
        //goudy1 is the id of the player
        _player = (Player *)_ids["goudy1"];

        Screen::instance()->registerFollowObj( (Object*)_player );
        Control::registerController((Object*)_player);

        //CommandManager::instance()->startPlaying("scripts/newDemo.txt");
        //CommandManager::instance()->startRecording();
}

void Level::levelSpecsLoad(std::string filenamebase)
{
        string specsFilename = filenamebase + ".txt";
        List *specsList = Parser::parse(specsFilename);

        List *specs = specsList;
        
        while(!specs->empty()) {
                List *current = specs->firstList();

                Object *object = getObject(current->firstString());
                object->load(current->rest());

                specs = specs->rest();
        }

        delete specsList;
}

void Level::levelObjectLoad(std::string filenamebase)
{
        string objFilename = filenamebase + "obj.bmp";
        SDL_Surface *surface = glfuncs::load_image(objFilename);
        SDL_LockSurface(surface);

        _height = surface->h*tileHeight;
        _width = surface->w*tileWidth;

        Uint32* objectPixels = (Uint32*)surface->pixels;

        //int maxoffset = surface->h*surface->w;
        for(int i=0; i < surface->h ; i++ ){
                for( int j=0 ; j < surface->w ;j++){

                        if(OBJECTS[objectPixels[i*surface->w+j]] != "")
                        {
                                Object* o = Object::loadObject(OBJECTS[objectPixels[i*surface->w+j]], j*tileWidth, i*tileHeight);
                                string id = o->id();
                                
                                //Append a number to the end of objects so we get EasyEnemy1, EasyEnemy2, ...
                                int i = 0;
                                do
                                {
                                        i++;
                                        stringstream num;
                                        num << i;
                                        o->setId(id+num.str());
                                        //map<string,Object *>::iterator j = _ids.find(o->id());

                                //}while (_ids.find(o->id()) != _ids.end());
                                } while(_ids[o->id()] != NULL);

                                cerr << o->id() << endl;

                                addObject(o, _objects);
                        }
                }
        }

        SDL_UnlockSurface(surface);
        SDL_FreeSurface(surface);
}


void Level::levelTextureLoad(std::string filenamebase)
{
        string texFilename = filenamebase + "tex.bmp";
        string colFilename = filenamebase + "col.bmp";
        string backFilename = filenamebase + "back.png";
        SDL_Surface *surface = glfuncs::load_image(texFilename);
        SDL_Surface* colSurface = glfuncs::load_image( colFilename );

        SDL_LockSurface(surface);
        SDL_LockSurface(colSurface);

        Tile* t = NULL;

        _height = surface->h*tileHeight;
        _width = surface->w*tileWidth;
        _tiles = vector< Tile* >( _height*_width, t );
        _background = new Background( backFilename, 0.5 );
        _background->setHeight( _height );
        _background->setWidth( _width );

        Uint32* texturePixels = (Uint32*)surface->pixels;
        Uint32* colPixels = (Uint32*)colSurface->pixels;
        Uint32 colPixel;


        //int maxoffset = surface->h*surface->w;
        for(int i=0; i < surface->h ; i++ ){
                for( int j=0 ; j < surface->w ;j++){
                        if(TEXTURES[texturePixels[i*surface->w+j]]!=NULL)
                        {
                                t = new Tile(   TEXTURES[texturePixels[i*surface->w+j]]->instance(), 
                                        true, j*tileWidth, i*tileHeight);

                                colPixel = colPixels[ i*colSurface->w + j ];
                                if( colPixel == Level::WALKBEHIND )
                                {
                                        t->setCollidable( false );
                                        t->setDepth( 5 );
                                } else if( colPixel == Level::WALKINFRONT )
                                {
                                        t->setCollidable( false );
                                        t->setDepth( -1 );
                                } else if( colPixel == Level::WALKINTO )
                                {
                                        t->setCollidable( true );
                                        t->setDepth( 0 );
                                }

                                registerTile( t, i, j );
                        }
                }
        }

        SDL_UnlockSurface(surface);
        SDL_UnlockSurface(colSurface);
        SDL_FreeSurface(surface);
        SDL_FreeSurface(colSurface);
}

bool Level::update()
{
        Object* o;

        while( !_deleteQueue.empty() )
        {
                o = _deleteQueue.front();
                _deleteQueue.erase( remove( _deleteQueue.begin(), _deleteQueue.end(), o ), _deleteQueue.end() ); 
                deleteObject( o );

                if(o == this->_player)
                {
                        // this early return is important for dying to work properly
                        _player = NULL;
                        return false;
                }

        }

        while( !_addQueue.empty() )
        {
                o = _addQueue.front();
                addObject( o, _objects );
                _addQueue.pop();
        }

        CommandManager::instance()->startTimestep();

        Control::update();
        Screen::instance()->update();

        for( vector< Object* >::iterator i = _objects.begin(); i != _objects.end(); i++ )
        {
                (*i)->update();
        }
        return true;
}

void Level::draw()
{
        // Draw background
        _background->draw();

        // Draw all drawable objects
        for( vector< Object* >::iterator i = _drawnObjects.begin(); i != _drawnObjects.end(); i++ )
        {
                (*i)->draw();
        }

        drawHUD();

        if(_cutScene) {
                Screen::instance()->drawCutScene(_cutSceneText);
        }
}

void Level::drawHUD()
{
        SDL_Rect raster;

        Sprite *health = Sprite::loadSprite("sprites/health.png");
        Sprite *heart = Sprite::loadSprite("sprites/heart.png");

        raster.x = 5;
        raster.y = 5;

        health->draw(raster.x,raster.y,Sprite::SCREEN);

        raster.x += health->width() + 2;
        raster.y += 5;

        for(int i = 0; i < _player->getHealth(); i++) {
                heart->draw(raster.x,raster.y,Sprite::SCREEN);
                raster.x += heart->width() + 2;
        }

        glfuncs::instance()->glDisable(GL_TEXTURE_2D);
        raster.x = 710;
        raster.y = 30;
        glfuncs::instance()->glRasterPos2f(raster.x,raster.y);

        stringstream score;
        score << "Score: ";
        score << _score;
        glfuncs::instance()->glPrint(score.str());
        glfuncs::instance()->glEnable(GL_TEXTURE_2D);
}

// Schedule an object to be added to the level
void Level::registerObject( Object* o )
{
        _addQueue.push( o );
}

void Level::registerTile( Tile* t, int h, int w )
{
        if( t->collidable() )
                _tiles[ h*_width + w ] = t;

        // Add to _drawnObjects vector in depth sorted order
        vector< Object* >::iterator i = _drawnObjects.begin();
                
        while( i != _drawnObjects.end() && t->getDepth() > (*i)->getDepth() )
                i++;

        _drawnObjects.insert( i, t );
}

// Add the object to _drawnObjects, sorted in depth ordering,
// then add the object to vec for collision detection
void Level::addObject( Object* o, std::vector< Object* >& vec )
{
        // Add to collision detection vector
        vec.push_back( o );

        // Add to _drawnObjects vector in depth sorted order
        vector< Object* >::iterator i = _drawnObjects.begin();
                
        while( i != _drawnObjects.end() && o->getDepth() > (*i)->getDepth() )
                i++;

        _drawnObjects.insert( i, o );
        _ids[o->id()] = o;

        /*
        cerr << "Registering : " << endl;
        cerr << o->id() << endl;
        cerr << o->getDepth() << endl;
        cerr << j << endl << endl;
        */
}

Object *Level::getObject( std::string id )
{
        return _ids[id];
}

Level *Level::instance()
{
        if(!_instance)
                return new Level();
        else
                return _instance;
}

void Level::scheduleDelete( Object* o )
{
        _deleteQueue.push_back( o );
}

void Level::deleteObject( Object* o )
{
        _objects.erase( remove( _objects.begin(), _objects.end(), o ), _objects.end() ); 
        _drawnObjects.erase( remove( _drawnObjects.begin(), _drawnObjects.end(), o ), _drawnObjects.end() ); 
        delete o;
}


void Level::setCutScene(bool cutScene)
{
        _cutScene = cutScene;
}

Mix_Chunk* Level::getSound( std::string filename )
{
        assert( _sounds.find( filename ) != _sounds.end() );
        return _sounds[ filename ];
}

void Level::loadSound( std::string filename )
{
        // If the sound isn't already in the map, load it in
        if( _sounds.find( filename ) == _sounds.end() )
        {
                _sounds[ filename ] = Mix_LoadWAV( filename.c_str() );
        }
}

---