main.cpp

Go to the documentation of this file.

//
// Das Tank - Copyright (C) 2006, 2007 Windsor Schmidt <windsor@windsorworld.net>
//
// This program is free software; you can redistribute it and/or modify it
// under the terms of the GNU General Public License as published by the Free
// Software Foundation; either version 2 of the License, or (at your option)
// any later version.
//
// This program is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
// more details.
//
// You should have received a copy of the GNU General Public License along with
// this program; if not, write to the Free Software Foundation, Inc., 59 Temple
// Place, Suite 330, Boston, MA 02111-1307 USA
//


#ifndef STDAFX
#include "stdafx.h"
#endif

using namespace std;

GameState * DasGame; // main game state pointer

// globals for GUI and OpenGL
SDL_Surface* screen;
SDL_Event event;

//gcn::SDLInput* input;                                 // Input driver
gcn::OpenGLGraphics* graphics;                   // Graphics driver
gcn::OpenGLSDLImageLoader* imageLoader;   // For loading images
gcn::Gui* gui;                                                 // A Gui object - binds it all together
gcn::ImageFont* font_small;                      // small font
gcn::ImageFont* font_big;                        // big font

// default widgets (make them global)
gcn::Container* top;                             // A top level GUI container


int main(int argc, char **argv) 
{  
       int done;

       // try initializing the default device, at 44100hz stereo 16-bits
       if(ENABLE_SOUND)
       {
              // if not, then use 'NO SOUND' device.
              if(!BASS_Init(-1,44100,0,0,NULL)) BASS_Init(0,44100,0,0,NULL);
       }
       else BASS_Init(0,44100,0,0,NULL);

       // initialize SDL for video output
       if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_JOYSTICK) == -1) exit(1); // quit if this fails

       SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);

       // create OpenGL screen surface
       screen = SDL_SetVideoMode(SCREEN_WIDTH, SCREEN_HEIGHT, 0, SDL_HWSURFACE |
              SDL_HWACCEL |
              SDL_OPENGL    |
              RUN_FULLSCREEN);
       if(screen == NULL) // quit if that fails
       {
              SDL_Quit();
              exit(1);
       }

       // SDL configuration
       SDL_WM_SetCaption("Das Tank", NULL);
       SDL_ShowCursor(SDL_DISABLE);
       SDL_EnableUNICODE(1);


       // guichan initialization
       imageLoader = new gcn::OpenGLSDLImageLoader();
       gcn::Image::setImageLoader(imageLoader);

       graphics = new gcn::OpenGLGraphics();

       // tell OpenGL graphics how big the screen is
       graphics->setTargetPlane(SCREEN_WIDTH, SCREEN_HEIGHT);

       // container for gui elements
       top = new gcn::Container();

       // set the dimension of the top container to match the screen
       top->setDimension(gcn::Rectangle(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT));
       gui = new gcn::Gui();

       // set gui to use the SDLGraphics object
       gui->setGraphics(graphics);

       // set the top container
       gui->setTop(top);

       // load the image fonts
       font_small = new gcn::ImageFont("tex/font_small.bmp"," !\"#$^&`()*+,-./0123456789:;<=>?abcdefghijklmnopqrstuvwxyz");
       font_big = new gcn::ImageFont("tex/font_big.bmp"," !#+,-.0123456789:?ABCDEFGHIJKLMNOPQRSTUVWXYZ");

       // The global font is static and must be set.
       gcn::Widget::setGlobalFont(font_small);

       initWidgets(); // initialize gui widgets

       InitGL(SCREEN_WIDTH, SCREEN_HEIGHT); // Initialize OpenGL graphics

       InitTextures(); // load textures from disk

       InitSound(); // load sounds from disk

       InitCollision(); // load collision interaction matrices from disk

       // master game loop
       int menuSelection = MENUID_NULL;
       bool firstLoop = true;
       DasGame = new GameState();                

       //SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);

       while(menuSelection != MENUID_QUIT)
       {
              if(firstLoop == true) // first time in menu since being in-game
              {
                     PlayMusic(MUSICID_MENU); // start or restart menu music
                     firstLoop = false;
              }

              menuSelection = MainMenu(graphics, font_small);

              switch(menuSelection)
              {
              case MENUID_START:
                     StopMusic(MUSICID_MENU);

                     DasGame->World = InitGame(DasGame->iCurrentLevel); // load current level in to new world
                     PlayGame(DasGame->World);
                     KillGame(DasGame->World); // delete all world data structures

                     // advance levels and loop back to first level if already at the last
                     if(DasGame->bAutoAdvanceLevel) DasGame->iCurrentLevel++;
                     if(DasGame->iCurrentLevel > DasGame->iMaxLevel) DasGame->iCurrentLevel = 1;


                     firstLoop = true; // flag that we're fresh out of a game
                     break;
              case MENUID_OPTIONS:
                     OptionsMenu(graphics, font_small, DasGame);
                     break;
              case MENUID_HIGHSCORES:
                     HighScoreMenu(graphics, font_small);
                     break;
              case MENUID_CREDITS:
                     Credits(graphics, font_small);
                     break;
              case MENUID_QUIT:
                     break;
              }
       }
       // end of master game loop

       SDL_Quit();                 // Kill SDL and OpenGL
       BASS_Free();         // Kill BASS
       return 0;                   // Go home
}


int PlayGame(CWorld * ThisWorld)
{
       //PlayMusic(MUSICID_INGAME); // start music
       PlayLevelMusic(ThisWorld->musicFile);

       glClearColor(0.0f, 0.0f, 0.0f, 0.0f);

       int timer = 0;
       int victor = 0;

       // FPS variables
       int fps = 0;
       int frameCounter = 0;
       Uint32 timeStamp = 0;

       Uint32 iStartingTimeStamp = SDL_GetTicks();
       Uint32 iStartingTimeElapsed = 0;
       
       Uint32 EffectsTimer = SDL_GetTicks();
       Uint32 PhysicsTimer = SDL_GetTicks();
       Uint32 StartingTimer = SDL_GetTicks();

       CEffect * StartFX = NULL;
       Vector vGuyPos, vOffset;

       SDL_Event event; // use to store incoming events
       static char string[256]; // use to format / store HUD messages before printing

       ThisWorld->bGameOver = false; // signal that the game is still in progress

       while (ThisWorld->bGameOver == false)
       {
              // update 'frames per second' variable
              ThisWorld->iCurrentTime = SDL_GetTicks();

              if(ThisWorld->iCurrentTime >= timeStamp + 1000)
              {
                     timeStamp = ThisWorld->iCurrentTime;
                     fps = frameCounter;
                     frameCounter = 0;
              }
              frameCounter++;

              //ThisWorld->Player[0]->iInput[INPUT_FIRE] = false; // limit one fire per key-down
              //ThisWorld->Player[1]->iInput[INPUT_FIRE] = false;

              // get input events and transform them in to player input
              while(SDL_PollEvent(&event))
              {
                     if(ThisWorld->bTakeInput)
                     {
                            switch(event.type)
                            {
                                   // handle joystick input from players
                            case SDL_JOYBUTTONDOWN:
                                   if(event.jbutton.which == DasGame->iGreenPlayerJoystick) // player 1
                                   {
                                          switch(event.jbutton.button)
                                          {
                                          case 0:
                                                 ThisWorld->Player[1]->iInput[INPUT_FIRE] = true;
                                                 break;
                                          }
                                   }

                                   if(event.jbutton.which == DasGame->iBrownPlayerJoystick) // player 2
                                   {
                                          switch(event.jbutton.button)
                                          {
                                          case 0:
                                                 ThisWorld->Player[0]->iInput[INPUT_FIRE] = true;
                                                 break;
                                          }
                                   }
                                   break;

                            case SDL_JOYBUTTONUP: // a little redundant?
                                   if(event.jbutton.which == DasGame->iGreenPlayerJoystick) // player 1
                                   {
                                          switch(event.jbutton.button)
                                          {
                                          case 0:
                                                 ThisWorld->Player[1]->iInput[INPUT_FIRE] = false;
                                                 break;
                                          }
                                   }
                                   if(event.jbutton.which == DasGame->iBrownPlayerJoystick) // player 2
                                   {
                                          switch(event.jbutton.button)
                                          {
                                          case 0:
                                                 ThisWorld->Player[0]->iInput[INPUT_FIRE] = false;
                                                 break;
                                          }
                                   }
                                   break;

                            case SDL_JOYHATMOTION:
                                   if(event.jhat.which == DasGame->iGreenPlayerJoystick) // player 1
                                   {
                                          if(event.jhat.value & SDL_HAT_UP) ThisWorld->Player[1]->iInput[INPUT_UP] = true;
                                          else ThisWorld->Player[1]->iInput[INPUT_UP] = false;
                                          if(event.jhat.value & SDL_HAT_DOWN) ThisWorld->Player[1]->iInput[INPUT_DOWN] = true;
                                          else ThisWorld->Player[1]->iInput[INPUT_DOWN] = false;
                                          if(event.jhat.value & SDL_HAT_LEFT) ThisWorld->Player[1]->iInput[INPUT_LEFT] = true;
                                          else ThisWorld->Player[1]->iInput[INPUT_LEFT] = false;
                                          if(event.jhat.value & SDL_HAT_RIGHT) ThisWorld->Player[1]->iInput[INPUT_RIGHT] = true;
                                          else ThisWorld->Player[1]->iInput[INPUT_RIGHT] = false;
                                   }

                                   if(event.jhat.which == DasGame->iBrownPlayerJoystick) // player 2
                                   {
                                          if(event.jhat.value & SDL_HAT_UP) ThisWorld->Player[0]->iInput[INPUT_UP] = true;
                                          else ThisWorld->Player[0]->iInput[INPUT_UP] = false;
                                          if(event.jhat.value & SDL_HAT_DOWN) ThisWorld->Player[0]->iInput[INPUT_DOWN] = true;
                                          else ThisWorld->Player[0]->iInput[INPUT_DOWN] = false;
                                          if(event.jhat.value & SDL_HAT_LEFT) ThisWorld->Player[0]->iInput[INPUT_LEFT] = true;
                                          else ThisWorld->Player[0]->iInput[INPUT_LEFT] = false;
                                          if(event.jhat.value & SDL_HAT_RIGHT) ThisWorld->Player[0]->iInput[INPUT_RIGHT] = true;
                                          else ThisWorld->Player[0]->iInput[INPUT_RIGHT] = false;
                                   }
                                   break;

                                   // handle keyboard input from players
                            case SDL_KEYUP:
                                   switch(event.key.keysym.sym)
                                   {
                                   case SDLK_KP4:
                                          ThisWorld->Player[0]->iInput[INPUT_LEFT] = false;
                                          break;

                                   case SDLK_KP6:
                                          ThisWorld->Player[0]->iInput[INPUT_RIGHT] = false;
                                          break;

                                   case SDLK_KP5:
                                          ThisWorld->Player[0]->iInput[INPUT_DOWN] = false;
                                          break;

                                   case SDLK_KP8:
                                          ThisWorld->Player[0]->iInput[INPUT_UP] = false;
                                          break;

                                   case SDLK_RETURN:
                                          ThisWorld->Player[0]->iInput[INPUT_FIRE] = false;
                                          break;

                                   case SDLK_a:
                                          ThisWorld->Player[1]->iInput[INPUT_LEFT] = false;
                                          break;

                                   case SDLK_d:
                                          ThisWorld->Player[1]->iInput[INPUT_RIGHT] = false;
                                          break;

                                   case SDLK_s:
                                          ThisWorld->Player[1]->iInput[INPUT_DOWN] = false;
                                          break;

                                   case SDLK_w:
                                          ThisWorld->Player[1]->iInput[INPUT_UP] = false;
                                          break;

                                   case SDLK_TAB:
                                          ThisWorld->Player[1]->iInput[INPUT_FIRE] = false;
                                          break;
                                   }
                                   break;

                            case SDL_KEYDOWN: 
                                   switch(event.key.keysym.sym)
                                   {
                                   case SDLK_ESCAPE: // user pressed escape, so exit
                                          ThisWorld->bGameOver = true;
                                          break;

                                   case SDLK_KP4:
                                          ThisWorld->Player[0]->iInput[INPUT_LEFT] = true;
                                          break;

                                   case SDLK_KP6:
                                          ThisWorld->Player[0]->iInput[INPUT_RIGHT] = true;
                                          break;

                                   case SDLK_KP5:
                                          ThisWorld->Player[0]->iInput[INPUT_DOWN] = true;
                                          break;

                                   case SDLK_KP8:
                                          ThisWorld->Player[0]->iInput[INPUT_UP] = true;
                                          break;

                                   case SDLK_RETURN:
                                          ThisWorld->Player[0]->iInput[INPUT_FIRE] = true;
                                          break;

                                   case SDLK_a:
                                          ThisWorld->Player[1]->iInput[INPUT_LEFT] = true;
                                          break;

                                   case SDLK_d:
                                          ThisWorld->Player[1]->iInput[INPUT_RIGHT] = true;
                                          break;

                                   case SDLK_s:
                                          ThisWorld->Player[1]->iInput[INPUT_DOWN] = true;
                                          break;

                                   case SDLK_w:
                                          ThisWorld->Player[1]->iInput[INPUT_UP] = true;
                                          break;

                                   case SDLK_TAB:
                                          ThisWorld->Player[1]->iInput[INPUT_FIRE] = true;
                                          break;

                                   case SDLK_PAGEUP:
                                          ThisWorld->iRenderStyle = RENDERSTYLE_PERSPECTIVE;
                                          break;

                                   case SDLK_PAGEDOWN:
                                          ThisWorld->iRenderStyle = RENDERSTYLE_FLAT;
                                          break;
                                   }
                                   break;
                            }
                     }
              }

              if((SDL_GetTicks() - PhysicsTimer) > 10)
              {
                     PhysicsUpdate(ThisWorld); // update the state of the world
                     PhysicsTimer = SDL_GetTicks();
              }

              ProcessTileCollisions(ThisWorld); // process effects of tiles that players are on

              DoCollisions(ThisWorld); // process collisions and their effects

              RemoveDeadObjects(ThisWorld); // clean up after the mess

              UpdateAnimation(ThisWorld); // step animation frames

              DrawGLScene(ThisWorld);     // draw the game world (tiles and objects)

              if((SDL_GetTicks() - EffectsTimer) > 20)
              {
                     ThisWorld->UpdateEffects(40); // step the effects
                     EffectsTimer = SDL_GetTicks();
              }

              if((SDL_GetTicks() - StartingTimer) > 10)
              {
                     iStartingTimeElapsed ++;
              }

              // if just beginning this round, let players get ready with a countdown
              graphics->setFont(font_big);
              
              switch(ThisWorld->iStartingState)
              {
              case STARTINGSTATE_IDLE:
                     if(iStartingTimeElapsed > 1000)
                     {
                            PlaySound(SOUNDID_READY);
                            InitStripeAlpha();
                            ThisWorld->iStartingState = STARTINGSTATE_READY;

                            // make sure the little guy starts off in the right place relative to her tank
                            vOffset.y = -0.6;
                            vOffset.z = 0;
                            VRotate2D(DegreesToRadians(ThisWorld->Player[1]->fAngle), vOffset);
                            vGuyPos = ThisWorld->Player[1]->Position + vOffset;

                            StartFX = new CEffect(EFFECTID_TILEANIM);
                            StartFX->TAnim = new TileAnim(vGuyPos,ThisWorld->Player[1]->fAngle,6000,ANIMID_GREEN_HOP_IN,80,1,true);
                            ThisWorld->Player[1]->ParentWorld->AddEffect(StartFX);
                     }
                     break;

              case STARTINGSTATE_READY:

                     DrawStripe(.15,-.15,1);
                     graphics->_beginDraw();
                     graphics->drawText("READY",SCREEN_WIDTH/2,SCREEN_HEIGHT/2 - (font_big->getHeight() / 2),
                            gcn::Graphics::CENTER);
                     graphics->_endDraw();

                     if(iStartingTimeElapsed > 2500)
                     {
                            PlaySound(SOUNDID_SET);
                            InitStripeAlpha();
                            ThisWorld->iStartingState = STARTINGSTATE_SET;

                            // make sure the little guy starts off in the right place relative to her tank
                            vOffset.x = 0;
                            vOffset.y = 0.6;
                            vOffset.z = 0;
                            VRotate2D(DegreesToRadians(ThisWorld->Player[0]->fAngle), vOffset);
                            vGuyPos = ThisWorld->Player[0]->Position + vOffset;

                            StartFX = new CEffect(EFFECTID_TILEANIM);
                            StartFX->TAnim = new TileAnim(vGuyPos, ThisWorld->Player[0]->fAngle,3000,ANIMID_BROWN_HOP_IN,80,1,true);
                            ThisWorld->Player[0]->ParentWorld->AddEffect(StartFX);
                     }
                     break;

              case STARTINGSTATE_SET:

                     DrawStripe(.15,-.15,1);
                     graphics->_beginDraw();
                     graphics->drawText("SET",SCREEN_WIDTH/2,SCREEN_HEIGHT/2 - (font_big->getHeight() / 2),
                            gcn::Graphics::CENTER);
                     graphics->_endDraw();

                     if(iStartingTimeElapsed > 4000)
                     {
                            PlaySound(SOUNDID_GO);
                            InitStripeAlpha();
                            ThisWorld->iStartingState = STARTINGSTATE_GO;
                            ThisWorld->bTakeInput = true;
                     }
                     break;

              case STARTINGSTATE_GO:

                     DrawStripe(.15,-.15,1);
                     graphics->_beginDraw();
                     graphics->drawText("GO!!!",SCREEN_WIDTH/2,SCREEN_HEIGHT/2 - (font_big->getHeight() / 2),
                            gcn::Graphics::CENTER);
                     graphics->_endDraw();

                     if(iStartingTimeElapsed > 5500)
                     {
                            ThisWorld->iStartingState = STARTINGSTATE_RUN;
                     }
                     break;
              }

              // somebody won this game
              if(ThisWorld->iStartingState == STARTINGSTATE_VICTORY)
              {
                     if(timer == 0)
                     {
                            PlaySound(SOUNDID_VICTORY);
                            InitStripeAlpha();
                     }

                     if(timer>=0 && timer<5000)
                     {
                            switch(victor)
                            {
                            case 0:

                                   if(ThisWorld->Player[0]->iHealth > 0 && ThisWorld->Player[1]->iHealth <= 0) victor = 1;
                                   if(ThisWorld->Player[0]->iHealth <= 0 && ThisWorld->Player[1]->iHealth > 0) victor = 2;
                                   if(ThisWorld->Player[0]->iHealth <= 0 && ThisWorld->Player[1]->iHealth <= 0) victor = 3;
                                   break;

                            case 1:
                                   DrawStripe(.15,-.15,1);
                                   graphics->_beginDraw();
                                   graphics->drawText("BROWN TANK WINS!",
                                          SCREEN_WIDTH/2,SCREEN_HEIGHT/2 - (font_big->getHeight() / 2),
                                          gcn::Graphics::CENTER);
                                   graphics->_endDraw();
                                   break;

                            case 2:
                                   DrawStripe(.15,-.15,1);
                                   graphics->_beginDraw();
                                   graphics->drawText("GREEN TANK WINS!",
                                          SCREEN_WIDTH/2,SCREEN_HEIGHT/2 - (font_big->getHeight() / 2),
                                          gcn::Graphics::CENTER);
                                   graphics->_endDraw();
                                   break;

                            case 3:
                                   DrawStripe(.15,-.15,1);
                                   graphics->_beginDraw();
                                   graphics->drawText("TIE GAME!",
                                          SCREEN_WIDTH/2,SCREEN_HEIGHT/2 - (font_big->getHeight() / 2),
                                          gcn::Graphics::CENTER);
                                   graphics->_endDraw();
                                   break;
                            }
                     }

                     timer++;

                     if (timer == 5000) ThisWorld->bGameOver = true;
              }

              // draw the on-screen stats
              graphics->setFont(font_small);
              graphics->_beginDraw();

              sprintf_s(string, "%d", fps);
              graphics->drawText(string, 25, SCREEN_HEIGHT - font_big->getHeight() - 5, gcn::Graphics::LEFT);
              graphics->setFont(font_big);

              if(ThisWorld->Player[1]->iAmmo == -1)
              {
                     sprintf_s(string, "?", ThisWorld->Player[1]->iAmmo);
                     graphics->drawText(string, 20, 120, gcn::Graphics::LEFT);
              }
              else
              {
                     sprintf_s(string, "%d", ThisWorld->Player[1]->iAmmo);
                     graphics->drawText(string, 20, 120, gcn::Graphics::LEFT);

              }

              if(ThisWorld->Player[0]->iAmmo == -1)
              {
                     sprintf_s(string, "?", ThisWorld->Player[0]->iAmmo);
                     graphics->drawText(string, SCREEN_WIDTH - 120, 120, gcn::Graphics::LEFT);
              }
              else
              {
                     sprintf_s(string, "%d", ThisWorld->Player[0]->iAmmo);
                     graphics->drawText(string, SCREEN_WIDTH - 120, 120, gcn::Graphics::LEFT);

              }

              graphics->_endDraw();

              //debugText(NULL); // display last debug text message

              // swap buffers to display, since we're double buffered.
              SDL_GL_SwapBuffers();
       }

       // control passes here when the game is over

       StopMusic(MUSICID_INGAME); // stop playing music before returning to main menu

       return 0;
}


CWorld * InitGame(int level)
{
       CWorld * ThisWorld = new CWorld;
       ThisWorld->iStartingState = STARTINGSTATE_IDLE;
       ThisWorld->bTakeInput = false; // freeze players until round starts

#ifdef DEBUG_IMPATIENT
       ThisWorld->iStartingState = STARTINGSTATE_RUN;
       ThisWorld->bTakeInput = true;
#endif

       ThisWorld->fZoomBias = 0.5;
       char string[256];

       sprintf_s(string, "lvl\\%d.lvl", level); // get level filename from level #
       
       ThisWorld->LoadLevel(string); // load level from disk

       // create a tank and insert in world as a player
       CObject * BrownTank;
       BrownTank = new CObject(TYPEID_TANK, ThisWorld);
       BrownTank->iHealth -= DasGame->iBrownHandicap;
       BrownTank->iTint = TINTID_ARMYBROWN;
       BrownTank->iDamageSound = SOUNDID_HIT;
       BrownTank->Position.x = 22;
       BrownTank->Position.y = 16;
       BrownTank->iNormalAnim = ANIMID_TANKROLL;
       BrownTank->iNormalAnimSpeed = 100;
       BrownTank->iRemovalEffects = 2;
       BrownTank->iRemovalEffect[0] = EFFECTID_TILEANIM;
       BrownTank->iRemovalEffect[1] = EFFECTID_PSYSTEM;
       BrownTank->iRemovalAnim = ANIMID_BROWNTANKEXPLODE;
       BrownTank->iRemovalAnimSpeed = 200;
       BrownTank->iLingerTime = 9000;
       BrownTank->fAngle = 180;
       BrownTank->fSubAngle = 180;

       ThisWorld->Player[0] = BrownTank;
       ThisWorld->AddObject(BrownTank);

       // create a tank and insert in world as a player
       CObject * GreenTank;
       GreenTank = new CObject(TYPEID_TANK, ThisWorld);
       GreenTank->iHealth -= DasGame->iGreenHandicap;
       GreenTank->iTint = TINTID_ARMYGREEN;
       GreenTank->iDamageSound = SOUNDID_HIT;
       GreenTank->Position.x = 10;
       GreenTank->Position.y = 16;
       GreenTank->iNormalAnim = ANIMID_TANKROLL;
       GreenTank->iNormalAnimSpeed = 500;
       GreenTank->iRemovalEffects = 2;
       GreenTank->iRemovalEffect[0] = EFFECTID_TILEANIM;
       GreenTank->iRemovalEffect[1] = EFFECTID_PSYSTEM;
       GreenTank->iRemovalAnim = ANIMID_GREENTANKEXPLODE;
       GreenTank->iRemovalAnimSpeed = 500;
       GreenTank->iLingerTime = 9000;

       ThisWorld->Player[1] = GreenTank;
       ThisWorld->AddObject(GreenTank);

       return ThisWorld;
}


int KillGame(CWorld * ThisWorld)
{
       delete ThisWorld;

       return 0;
}


void initWidgets()
{
       top->setOpaque(false);
}

void debugText(const char * text)
{
       static char string[256];

       if(text == NULL)
       {
              graphics->setFont(font_small);
              graphics->_beginDraw();
              graphics->drawText(string,SCREEN_WIDTH/2,SCREEN_HEIGHT/2,gcn::Graphics::CENTER);
              graphics->_endDraw();
       }
       else
       {
              strcpy_s(string, text);
       }
}

float DegreesToRadians(float deg)
{
       return deg * PI / 180.0f;
}

float RadiansToDegrees(float rad)
{      
       return rad * 180.0f / PI;
}

int ToggleFullScreen(GameState * State)
{
       State->bFullScreen = !State->bFullScreen; // toggle the fullscreen state flag

       // initialize SDL for video output
       SDL_QuitSubSystem(SDL_INIT_VIDEO);
       
       if (SDL_InitSubSystem(SDL_INIT_VIDEO) == -1) return 1; // quit if this fails

       SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);

       // create OpenGL screen surface
       if(State->bFullScreen)
       {
              screen = SDL_SetVideoMode(SCREEN_WIDTH,SCREEN_HEIGHT,0,
                     SDL_HWSURFACE|SDL_HWACCEL|SDL_OPENGL|SDL_FULLSCREEN);
       }
       else
       {
              screen = SDL_SetVideoMode(SCREEN_WIDTH,SCREEN_HEIGHT,0, SDL_HWSURFACE|SDL_HWACCEL|SDL_OPENGL);
       }

       if(screen == NULL) // quit if that fails
       {
              SDL_Quit();
              return 1;
       }

       // SDL configuration
       SDL_WM_SetCaption("Das Tank", NULL);
       SDL_ShowCursor(SDL_DISABLE);

       // guichan initialization
       imageLoader = new gcn::OpenGLSDLImageLoader();
       gcn::Image::setImageLoader(imageLoader);

       graphics = new gcn::OpenGLGraphics();

       // tell OpenGL graphics how big the screen is
       graphics->setTargetPlane(SCREEN_WIDTH, SCREEN_HEIGHT);

       // container for gui elements
       top = new gcn::Container();

       // set the dimension of the top container to match the screen
       top->setDimension(gcn::Rectangle(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT));
       gui = new gcn::Gui();

       // set gui to use the SDLGraphics object
       gui->setGraphics(graphics);

       // set the top container
       gui->setTop(top);

       // load the image fonts
       font_small = new gcn::ImageFont("tex/font_small.bmp"," !\"#$^&`()*+,-./0123456789:;<=>?abcdefghijklmnopqrstuvwxyz");
       font_big = new gcn::ImageFont("tex/font_big.bmp"," !#+,-.0123456789:?ABCDEFGHIJKLMNOPQRSTUVWXYZ");

       // The global font is static and must be set.
       gcn::Widget::setGlobalFont(font_small);

       initWidgets(); // initialize gui widgets

       InitGL(SCREEN_WIDTH, SCREEN_HEIGHT); // Initialize OpenGL graphics
       
       InitTextures(); // initialize textures
       
       return 0;
}

 

Copyright Windsor Schmidt 2006 - All rights reserved.