Game.cpp

Go to the documentation of this file.

#include "Game.h"
#include "fns.h"
#include <string>
#include <iostream>
#include <SDL/SDL_opengl.h>
#include <SDL/SDL_ttf.h>
#include <time.h>
#include "Text.h"
#include "Collision.h"
#include "Input.h"
#include "Color.h"

using namespace std;

Game* Game::m_instance = NULL;

Game* Game::game() {
        if(!m_instance)
                m_instance = new Game;
        return m_instance;
}

Game::Game() : 
        Running(false),
        poll(false),
        mScreen(NULL), 
        ShowCollisions(false), 
        ShowFPS(false), 
        Paused(false),
        Focused(true),
        alwaysDraw(false),
        mCamera(),
        CurrentLevel(NULL), 
        CurrentSprite(NULL), 
        CurrentParticleSystem(NULL),
        CurrentParticle(NULL),
        CurrentText(NULL), 
        nextSecondTick(0), 
        nextDrawTick(0), 
        numFrames(0), 
        currentFPS(0), 
        avgFPS(0), 
        drawLoops(0),
        Language(English), 
        mLevels(map<string, Level*>()), 
        txtFPS(NULL)
{
        int screenwidth = 640;
        int screenheight = 480;

        if (SDL_Init(SDL_INIT_VIDEO) < 0) {
                cout<<"Couldn't initialize SDL: "<<SDL_GetError()<<endl;
                exit (1);
        }

        if(SDL_InitSubSystem(SDL_INIT_EVENTTHREAD)<0)
                cout<<"Couldn't initialize SDL: "<<SDL_GetError()<<endl;
        else 
                poll = true;

        atexit (SDL_Quit);
        // Initialize SDL_ttf library
        if (TTF_Init() != 0)
        {
                cout << "TTF_Init() Failed: " << TTF_GetError() << endl;
                SDL_Quit();
                exit(1);
        }
        atexit (TTF_Quit);

        /* Turn on double buffering with a 24bit Z buffer.
        * You may need to change this to 16 or 32 for your system */
        SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
        SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);

        SDL_WM_SetCaption("Ivan's Game", NULL);

        SDL_ShowCursor(0);

        resize(screenwidth, screenheight);

        srand(time(0)+SDL_GetTicks());

        SetStaticObjectValues();

        Input* keyboard = new Input();

        if(Input::updateJoysticks()){
                //tie each joystick to an input.
                for(int i=0,end=Input::getNumJoysticks(); i < end; ++i ) 
                {
                        Input* joy = new Input(true);
                }
        }

        LoadResources();

        /* Initialize FPS */
        for (int index = 0; index < FPSRANGE; index++)
        {
                FPSs[index] = 0;
        }
}

Game::~Game()
{
        foritr(i,mLevels){
                delete i->second;
        }
        delete txtFPS;
}

Level* Game::getCurrentLevel()
{
        return CurrentLevel;
}

string Game::getLevelKey()
{
        return CurrentLevel->getName();
}

void Game::setCurrentLevel(string name) {
        if(!CurrentLevel||CurrentLevel->getName()!=name) {
                Level* l = loadLevel(name);
                if(l)
                        CurrentLevel = l;
        }
        else
                cout<<"Level "<<name<<" does not exist."<<endl;
}

Level* Game::loadLevel(string name) {
        auto level = mLevels.find(name);
        if(level != mLevels.end()){
                LoadingLevel = level->second;
                level->second->load();
                LoadingLevel = NULL;
                return level->second;
        }
        cout<<"Level "<<name<<" does not exist."<<endl;
        return NULL;
}

int Game::getLevelCount()
{
        return mLevels.size();
}

void Game::run()
{
        Running = true;

        if(!CurrentLevel)
                setCurrentLevel("World");

        nextGameTick = SDL_GetTicks();
        int loops=0;

        while (Running) {
                SDL_Event event;

                loops=0;

                while( SDL_GetTicks() > nextGameTick && loops < MAX_FRAMESKIP){
                        //here because we don't really need to care about input outside of when we're going to update... and it's fast enough
                        if(poll)
                        {
                                while(SDL_PollEvent(&event))
                                        handleInput(event);
                        }
                        else
                        {
                                if (0 == SDL_WaitEvent(&event)) {
                                        std::cout<<"waiting"<<std::endl;
                                }
                                handleInput(event);
                        }

                        getCurrentLevel()->update();
                        nextGameTick += SKIP_TICKS;
                        loops++;
                }

                if(Game::game()->ShowFPS){
                        if(!txtFPS)
                                txtFPS = new Text("fps", "", 24, Color::WHITE, 600, 50, Point2D());
                        txtFPS->lines[0]=ToString<Uint32>(game()->getFPS());
                }

                //make sure the camera is where it needs to be
                mCamera.updatePos();

                draw();
        }
        getCurrentLevel()->unload();
        stopDrawTimer();

}

void Game::stop(){
        Running=false;
}

Font* Game::getFont(  FontType t = Game::game()->Language, int s = 24){
        pair<FontType,int> key = pair<FontType,int>(t,s);
        map<pair<FontType, int>, Font*>::iterator it = mFonts.find(key);
        //if the font doesn't exist
        if (it == mFonts.end()) {
                //create it
                Font* f = new Font(t, s);
                mFonts[key] = f;
                return f;
        } else {
                Font* f = it->second;
                f->count++;
                return f;
        }
}

void Game::removeFont( FontType t = English, int s = 24){
        pair<FontType,int> key = pair<FontType,int>(t,s);
        map<pair<FontType, int>, Font*>::iterator it = mFonts.find(key);
        //if the font doesn't exist
        if (it != mFonts.end()) {
                Font* f = it->second;
                f->count--;
                if(f->count==0)
                        mFonts.erase(it);
        }
}

void Game::removeFont(Font* font){
        removeFont(font->type, font->size);
}

Texture* Game::getTexture(string filename, Texture* tex){
        auto  it = mTextures.find(filename);
        if(it != mTextures.end()){
                Texture* val = it->second;
                val->count++;
                return val; 
        }
        else{
                if(tex){
                        glGenTextures(1, &tex->image);
                        tex->count++;
                        mTextures[filename] = tex;
                        return tex;
                }
                else
                {
                        Texture* t = new Texture();
                        glGenTextures(1, &t->image);
                        t->count++;
                        mTextures[filename] = t;
                        return t;
                }
        }
}

void Game::removeTexture(string filename){
        auto  it = mTextures.find(filename);
        if(it != mTextures.end()){
                Texture* val = it->second;
                if(val->count--==1)
                {
                        glDeleteTextures(1, &val->image);
                        delete it->second;
                        mTextures.erase(it);
                }
        }
}

void Game::removeTexture(Texture* Texture){
        //auto  it = mTextures.find(Texture,);
}

void Game::addAnimation(Animation* anim) {
        mAnims.push_back(anim);
}

Animation* Game::getAnimation(string name) {
        for(int i=0, count=mAnims.size(); i < count; i++) {
                if(mAnims[i]->Name==name) {
                        return mAnims[i];
                }
        }
        //try loading if it's not there
        try{
                Animation* a = new Animation(name);
                addAnimation(a);
                return a;
        }
        catch(exception e){
                cout<<"Could not load "<<name<<" because:"<<e.what()<<endl;
        }
        return NULL;
}

void Game::removeAnimation(Animation* anim) {
        foritr(ptr, mAnims) {
                if(anim == *ptr) {
                        (*ptr)->clear();
                        mAnims.erase(ptr);
                        return;
                }
        }
}

void Game::addActor(string name, Actor actor) {
        mActors.insert(make_pair(name, actor));
}

void Game::removeActor(string name) {
        mActors.erase(name);
}

void Game::addObject(WorldObject* sp, Level* l){
        if(l)
                l->addObject(sp);
        else if(CurrentLevel)
                CurrentLevel->addObject(sp);
        else
                LoadingLevel->addObject(sp);
}

void Game::removeObject(WorldObject* sp, Level* l){
        if(l)
                l->removeObject(sp);
        else if(CurrentLevel)
                CurrentLevel->removeObject(sp);
        else
                LoadingLevel->removeObject(sp);
}

void Game::removeAllSprites(string name, Level* l){
        if(l)
                l->removeAllSprites(name);
        else if(CurrentLevel)
                CurrentLevel->removeAllSprites(name);
        else
                LoadingLevel->removeAllSprites(name);
}

void Game::removeAllParticleSystems(string name, Level* l){
        if(l)
                l->removeAllParticleSystems(name);
        else if(CurrentLevel)
                CurrentLevel->removeAllParticleSystems(name);
        else
                LoadingLevel->removeAllParticleSystems(name);
}

void Game::addLevel(Level* l){
        string name = l->getName();
        auto level = mLevels.find(name);
        if(level == mLevels.end() || mLevels.size() == 0){
                mLevels[name] = l;
        }
        else {
                cout<<"Level "<<name<<" already exists!"<<endl;
        }
}

void Game::handleInput(SDL_Event event)
{
        switch (event.type) {
        case SDL_QUIT:
                Running = !Running;
                break;
        case SDL_ACTIVEEVENT:
                switch(event.active.state)
                {
                case SDL_APPMOUSEFOCUS:
                        //follow mouse if on window
                        FollowMouse = event.active.gain==1;
                        break;

                case SDL_APPINPUTFOCUS:
                        if(event.active.gain==1)
                        {
                                cout<<"Appinputfocus gained"<<endl;
                                Paused = false;
                                Focused = true;
                                Uint32 delta = SDL_GetTicks() - unfocusTime;
                                nextSecondTick+=delta;
                                nextDrawTick+=delta;
                                nextGameTick+=delta;
                        }
                        else
                        {
                                cout<<"inputfocus lost"<<endl;
                                Focused = false;
                                Paused=true;
                                unfocusTime = SDL_GetTicks();
                        }
                        break;

                case SDL_APPACTIVE:
                        if(event.active.gain==1)
                        {
                                cout<<"active gained"<<endl;
                                Paused = false;
                                Focused = true;
                                Uint32 delta = SDL_GetTicks() - unfocusTime;
                                nextSecondTick+=delta;
                                nextDrawTick+=delta;
                                nextGameTick+=delta;
                        }
                        else
                        {
                                cout<<"active lost"<<endl;
                                Focused = false;
                                Paused=true;
                                unfocusTime = SDL_GetTicks();
                        }
                        break;
                case SDL_APPINPUTFOCUS | SDL_APPACTIVE:
                        if(event.active.gain==1)
                        {
                                Paused = false;
                                Focused = true;
                                cout<<"Focus and input gained"<<endl;
                                Uint32 delta = SDL_GetTicks() - unfocusTime;
                                nextSecondTick+=delta;
                                nextDrawTick+=delta;
                                nextGameTick+=delta;
                        }
                        break;
                default:
                        cout<<"got something unexpected:"<<(int)event.active.state<<endl;
                        break;
                }
                break;

        case SDL_VIDEORESIZE :
                resize( event.resize.w, event.resize.h ) ;
                break ;

        case SDL_USEREVENT:
                //draw();
                break;

        case SDL_KEYDOWN: 
                {
                        Input::updateInputs(event);
                        break;
                }
        case SDL_KEYUP:
                {
                        std::cout<<"pressed:"<<event.key.keysym.sym<<std::endl;
                        switch(event.key.keysym.sym)
                        {
                        case SDLK_ESCAPE:
                                {
                                        Running=!Running;
                                        break;
                                }       
                        case SDLK_F11:
                                {
                                        ShowCollisions = !ShowCollisions;
                                        break;
                                }
                        case SDLK_F10:
                                {
                                        ShowFPS = !ShowFPS;
                                        break;
                                }
                        case SDLK_MINUS:
                                {
                                        mCamera.zoomOut(.1);
                                        break;
                                }
                        case SDLK_EQUALS:
                                {
                                        mCamera.zoomIn(.1);
                                        break;
                                }
                        case SDLK_0:
                                {
                                        mCamera.zoom(1);
                                        break;
                                }
                        }
                        Input::updateInputs(event);
                        break;
                }
        default: 
                // fallthrough if the key wasn't escape or control
                Input::updateInputs(event);
                break;
        }
}

void Game::draw(){
        if( Focused && (alwaysDraw || (SDL_GetTicks() > nextDrawTick && drawLoops < MAX_FRAMESKIP))){

                getCurrentLevel()->drawScene();
                nextDrawTick += drawInterval;
                if(txtFPS && ShowFPS)
                        txtFPS->draw();

                //get our fps data
                CalculateFramerate();
                SDL_GL_SwapBuffers();
        }
}

void Game::startDrawTimer(){
        if(SDL_InitSubSystem(SDL_INIT_TIMER)<0)
                cout<<"Couldn't initialize SDL: "<<SDL_GetError()<<endl;
        timer = SDL_AddTimer(drawInterval, pushUserEvent, NULL);
        if (!timer) {
                std::cout << "Timer creation failed" << std::endl;
                exit(3);
        }
}

void Game::stopDrawTimer()
{
        SDL_RemoveTimer(timer);
        SDL_QuitSubSystem(SDL_INIT_TIMER);
}

void Game::resize(int w = 640, int h = 480){
        mScreen = SDL_SetVideoMode(w, h, 32, SDL_OPENGL | SDL_RESIZABLE);
        if (!mScreen) {
                cout<<"Couldn't set video mode: "<<SDL_GetError()<<endl;
                exit (2);
        }

        // Set the OpenGL state after creating the context with SDL_SetVideoMode
        glClearColor (0.0, 0.0, 0.0, 0.0);

        // Need this to display a texture
        glEnable( GL_TEXTURE_2D ); 

        glViewport( 0, 0, w, h );

        glMatrixMode( GL_PROJECTION );
        glLoadIdentity();

        glOrtho( 0, w, h, 0, -1, 1 );

        glMatrixMode( GL_MODELVIEW );
        glEnable(GL_BLEND);
        glDepthFunc(GL_LEQUAL);
        glLoadIdentity();
}

Uint32 Game::pushUserEvent(Uint32 interval, void* data)
{
        SDL_Event event;
        SDL_UserEvent uevent = {
                SDL_USEREVENT, /* type */
                0, /* code */
                0, /* data1 */
                0 }; /* data2 */
                event.user = uevent;

                SDL_PushEvent(&event);

                return interval;
}

void Game::CalculateFramerate(){
        Uint32 startclock = SDL_GetTicks();

        numFrames++;

        if (startclock > nextSecondTick)
        {
                nextSecondTick = startclock + 1000;

                FPSs[currentFPS] = numFrames;
                numFrames = 0;

                if (currentFPS < FPSRANGE-1)
                        currentFPS++;
                else
                        currentFPS = 0;

                Uint32 frameTotal = 0;
                for (int index = 0; index < FPSRANGE; index++)
                {
                        frameTotal += FPSs[index];
                }

                avgFPS = frameTotal / FPSRANGE;
        }
}