Level.cpp

Go to the documentation of this file.

#include "Level.h"
#include "Game.h"
#include "Text.h"
#include "fns.h"
#include "Collision.h"
#include <GL/gl.h>
#include <algorithm>


Level::Level(string n, Condition winCond, Behavior loadBehave, Behavior updateBehave, Behavior endBehave, Behavior pBehave) : mName(n), mBackground(NULL), mWorldObjects(), mSprites(), Loaded(false), ToAdd(), ToRemove(), mMenus(), mMaxNumPlayers(2)
{
        mInitialBehavior = loadBehave;
        mMainBehavior = updateBehave;
        mUnloadBehavior = endBehave;
        mPauseBehavior = pBehave;
        mWinCondition = winCond;
}

Level::~Level()
{
        for (size_t i = 0; i < mWorldObjects.size(); ++i) {
                delete mWorldObjects[i];
        }
}

void Level::drawScene()
{
        glLoadIdentity();
        glClear(GL_COLOR_BUFFER_BIT);
        if (!Game::game()->Paused)
        {
                if(mBackground!=NULL)
                        mBackground->draw();

                for(unsigned int i=0,size=mWorldObjects.size();i<size;++i){
                        mWorldObjects[i]->draw();
                }
        }

        DrawMenus();

        DrawCollisions();
}

void Level::DrawMenus()
{
        //go through all our menus and try to draw them (they'll only draw if active)
        //revert to default texture
        glBindTexture(GL_TEXTURE_2D, 0);
}

void Level::DrawCollisions()
{
        if(Game::game()->ShowCollisions) {
                mBackground->drawCollisions();
                for (size_t i=0; i<mWorldObjects.size(); ++i) {
                        mWorldObjects[i]->drawCollisions();
                }
        }
}

void Level::LoadBG(std::string name)
{
        mBackground->load(name);
}

void Level::postEvent(SDL_Event event)
{
}

void Level::update() {
        if (Loaded)
        {
                if(!Game::game()->Focused)
                        SDL_Delay(1000);
                if (!Game::game()->Paused)
                {
                        //clear collisions
                        Collision::collider()->clear();
                        //sort worldObjects
                        sort(mWorldObjects.begin(),mWorldObjects.end(),[](WorldObject *a, WorldObject *b) { return *a < *b; });

                        if(mMainBehavior)
                                mMainBehavior();

                        if (mWinCondition())
                        {
                                unload();
                                return;
                        }
                        for(unsigned int i=0, size = mWorldObjects.size(); i<size; i++) {
                                mWorldObjects[i]->update();
                        }

                        for(unsigned int i=0, size = mWorldObjects.size(); i<size; i++) {
                                mWorldObjects[i]->runBehavior();
                        }
                        for(unsigned int i=0, size = ToRemove.size(); i<size; i++) {
                                        // Try to remove from mWorldObjects,
                                        // if failed see if it's currently pending add
                                        bool removed=false;
                                        foritr(ptr, mWorldObjects) {
                                                if(*ptr == ToRemove[i]) {
                                                        delete *ptr;
                                                        mWorldObjects.erase(ptr);
                                                        removed=true;
                                                        break;
                                                }
                                        }
                                        if(removed) {
                                                WorldObject* w = ToRemove[i];
                                                switch(w->getType())
                                                {
                                                        case WorldObject::SPRITE:
                                                                foritr(ptr, mSprites) {
                                                                        if(*ptr == w) {
                                                                                mSprites.erase(ptr);
                                                                                removed=true;
                                                                                break;
                                                                        }
                                                                }
                                                                break;
                                                        case WorldObject::PARTICLESYSTEM:
                                                                foritr(ptr, mParticleSystems) {
                                                                        if(*ptr == w) {
                                                                                mParticleSystems.erase(ptr);
                                                                                removed=true;
                                                                                break;
                                                                        }
                                                                }
                                                                break;
                                                        case WorldObject::MENU:
                                                                break;
                                                        default:
                                                                break;
                                                }
                                        } else{
                                                foritr(ptr, ToAdd) {
                                                        if(*ptr == ToRemove[i]) {
                                                                ToAdd.erase(ptr);
                                                                break;
                                                        }
                                                }
                                        }
                        }
                        ToRemove.clear();
                        for(unsigned int i=0, size = ToAdd.size(); i<size; i++) {
                                WorldObject* w = ToAdd[i];
                                mWorldObjects.push_back(w);
                                switch(w->getType())
                                {
                                        case WorldObject::SPRITE:
                                                mSprites.push_back((Sprite*)w);
                                                break;
                                        case WorldObject::MENU:
                                                break;
                                        case WorldObject::PARTICLESYSTEM:
                                                mParticleSystems.push_back((ParticleSystem*)w);
                                                break;
                                        default:
                                                cout<<"BAD BAD BAD "<<w->getType()<<" REMOVED"<<endl;
                                                break;
                                }
                        }
                        ToAdd.clear();
                        /*CollisionObject.Update();
                        foreach (WorldObject sp in mWorldObjects)
                        {
                        sp.DoCollisions();
                        }*/
                }
                else {
                        //Generic pause menu update function
                        if(mPauseBehavior)
                                mPauseBehavior();
                }
        }
        else {
        }
}

void Level::load() {
        clearData();
        if(mInitialBehavior)
                mInitialBehavior();


        //inint num of players
        unsigned int maxNumPlayers = getMaxNumPlayers();
        if(getNumPlayers() > maxNumPlayers){
                removePlayers(maxNumPlayers-getNumPlayers());
        }

        Loaded = true;
}

void Level::unload() {
        if(mUnloadBehavior)
                mUnloadBehavior();
        clearData();
        Loaded = false;
}

void Level::clearData() {

        //clear WorldObjects
        for(unsigned int i=0,size=mWorldObjects.size(); i<size; i++) {
                delete mWorldObjects[i];
        }
        mWorldObjects.clear();
        mSprites.clear();

        // clear collision data
        Collision::collider()->clear();
}

void Level::addObject(WorldObject* o) {
        ToAdd.push_back(o);
}

void Level::removeObject(WorldObject* o) {
        ToRemove.push_back(o);
}

void Level::removeAllSprites(string s) {
        vector<Sprite*> vec = findSprites(s); 
        foritr(sp,vec){
                ToRemove.push_back(*sp);
        }
}


void Level::removeAllParticleSystems(string s) {
        vector<ParticleSystem*> vec = findParticleSystems(s); 
        foritr(ps,vec){
                ToRemove.push_back(*ps);
        }
}

Sprite* Level::findSprite(string name) {
        for(unsigned int i=0, count=mSprites.size(); i < count; i++) {
                if(mSprites[i]->getName()==name) {
                        return mSprites[i];
                }
        }
        return NULL;
}

vector<Sprite*> Level::findSprites(string name, int count) {
        vector<Sprite*> retvals = vector<Sprite*>();
        for(unsigned int i=0, size = mSprites.size(); i < size; i++) {
                if(count>0 && retvals.size()==count)
                        return retvals;
                if(mSprites[i]->getName()==name)//find the sprite with the same name
                        retvals.push_back(mSprites[i]);
        }
        return retvals;//if a sprite wasn't found return empty
}

ParticleSystem* Level::findParticleSystem(string name) {
        for(unsigned int i=0, count=mParticleSystems.size(); i < count; i++) {
                if(mParticleSystems[i]->getName()==name) {
                        return mParticleSystems[i];
                }
        }
        return NULL;
}

vector<ParticleSystem*> Level::findParticleSystems(string name, int count) {
        vector<ParticleSystem*> retvals = vector<ParticleSystem*>();
        for(unsigned int i=0; i < mParticleSystems.size(); i++) {
                if(count>0 && retvals.size()==count)
                        return retvals;
                if(mParticleSystems[i]->getName()==name)//find the ParticleSystem with the same name
                        retvals.push_back(mParticleSystems[i]);
        }
        return retvals;//if a ParticleSystem wasn't found return empty
}

unsigned int Level::getNumPlayers(){ 
        return mPlayers.size();
}


unsigned int Level::getMaxNumPlayers(){
        return mMaxNumPlayers;
}

void Level::setMaxNumPlayers(unsigned int i){
        mMaxNumPlayers=i;
}

Player* Level::getPlayer(unsigned int index){
        return index < mPlayers.size() ? mPlayers[index] : NULL;
}

bool Level::addPlayer(Player* p){
        if(getNumPlayers()<mMaxNumPlayers)
        {
                mPlayers.push_back(p);
                return true;
        }
        return false;
}

bool Level::removePlayer(Player* p){
        foritr(player, mPlayers){
                if(*player == p){
                        mPlayers.erase(player);
                        return true;
                }
        }
        return false;
}

int Level::removePlayers(int count){
        unsigned int size = mPlayers.size();
        try{
                mPlayers.erase(mPlayers.begin()+size-count, mPlayers.end());
        }
        catch(exception e){
                cout<<e.what()<<endl;
        }
        return size - mPlayers.size();
}