European Air War - The Gen

Code: Select all

// Game State Arbitrator 
// the return values from each of the functions will redirect the program flow through the arbitrator
#define SETUPWINDOW      0
#define SETUPLIBRARY   1
#define ENTRYMENU      2
#define SETUPMENU      3
#define HOSTMENU      4
#define CLIENTMENU      5
#define GAMELOOP      6

int iGameState = 0;

do
{
   switch(iGameState){
      case SETUPWINDOW:
         iGameState = SetupWindow();
         break;
      case SETUPLIBRARY:
         iGameState = SetupLibrary();
         break;
      case ENTRYMENU:
         iGameState = EntryMenu();
         break;
      case SETUPMENU:
         iGameState = SetupMenu();
         break;
      case HOSTMENU:
         iGameState = HostMenu();
         break;
      case CLIENTMENU:
         iGameState = ClientMenu();
         break;
      case GAMELOOP:
         iGameState = GameLoop();
         break;
      default:
         iGameState = 99;
         CleanUp();
         break;
   }
}while(iGameState != 99);

Code: Select all

class CAbstractObject
{
public:
   //The update method which can be overwritten.
   virtual void Update ( void ) = 0;

        //The draw method which can be overwritten.
       virtual void Draw ( void ) = 0;

   //The initialize method which can be overwritten but also returns if successful or not.
   virtual int Initialize ( void ) = 0;

   //The end method which can be overwritten but also returns if successful or not.
   virtual int End ( void ) = 0;

   virtual ~CAbstractObject ( void ){}
};

Code: Select all

//Basic Room...
class CLevelOne : public CAbstractObject
{
public:
   //Update this object.
   void Update ( void )
   {

      //Add any object updates or room updates below----------
   }

        void Draw ( void ) {}

   //Initialize this object.
   int Initialize ( void )
   {
      R = CRoomHandler::Instance ( );

      //Add any object initializations below----------

      return 1;
   }

   //End this object.
   int End ( void )
   {
      //Add any other objects to delete below----------
      return 1;
   }

   //ctors and dtors... not really needed so much, but whatever
   CLevelOne( void ){}
   ~CLevelOne( void ){}

private:
        //Singleton to swap needed room data between rooms
   CRoomHandler *R;

   //Add objects in this room below----------
};

Code: Select all

class CRoomHandler : public CAbstractObject
{
public:

        //This doesn't even have to be am enumerator. Add more rooms here.
   enum ROOM_ID
   {
      NONE = 0,
      TITLE_SCREEN = 1,
      EXIT = 2,//Not really a room but useful to globally exit the game
      FIRST_LEVEL = 3
   };

   static CRoomHandler *Instance ( void )
   {
      if ( thisInstance == 0 )
      {  
         thisInstance = new CRoomHandler;
      }

      return thisInstance;
   }

   int Initialize ( void )
   {
      nextRoom = 0;
      thisRoom = 0;
      return 1;
   }

   int End ( void )
   {
      thisRoom = nextRoom = 0;

      return 1;
   }

   const ROOM_ID GetRoom ( void )
   {
      return ( ROOM_ID )thisRoom;
   }

   const ROOM_ID GetNextRoom ( void )
   {
      return ( ROOM_ID )nextRoom;
   }

   void SetNextRoom ( ROOM_ID pRoom )
   {
      nextRoom = pRoom;
   }

   void MakeThisRoomNextRoom ( void ) //Rooms have changed fine
   {
      thisRoom = nextRoom;
   }

   CAbstractObject *ActualRoom; //Make life easier. Make it public.

   CRoomHandler ( ){}
   CRoomHandler ( const CRoomHandler& );
   CRoomHandler& operator = ( const CRoomHandler& );
   ~CRoomHandler ( ){}

private:
   static CRoomHandler *thisInstance;
   int nextRoom, thisRoom;
};

Code: Select all

int CGameModule::CheckLevels ( void )
{
   //Check to see if the message what sent out to change rooms.
   //If the current status of the room do not match
   //then that means we are changing rooms. This function
   //handles that task.

   int OK = 1;

   if( R->GetRoom ( ) != R->GetNextRoom ( ) )
   {
      R->ActualRoom->End ( );
      delete R->ActualRoom;
      R->ActualRoom = 0; //#define NULL 0... whatever

      /*
         The room handling and transitions go here. Make any modifications
         you want for your game!
      */

      switch ( R->GetNextRoom ( ) )
      {
         case CRoomHandler::NONE:
            R->ActualRoom = new CNone ( );
            break;
         case CRoomHandler::TITLE_SCREEN:
            R->ActualRoom = new CTitleScreen ( );
            break;
         case CRoomHandler::FIRST_LEVEL:
            R->ActualRoom = new CLevelOne( );
            break;
         case CRoomHandler::EXIT:
            R->ActualRoom = new CExit ( );
            isQuit = 1;
            break;
         default: //None of these rooms for some reason?! Error screen.
            R->ActualRoom = new CTransitionError ( );
            break;
      }
         
      R->MakeThisRoomNextRoom ( ); // thisRoom = nextRoom;
      OK = ( R->ActualRoom->Initialize ( ) && isQuit == 0 ); //Make sure exit wasn't called either
   }

   return OK; 
}

Code: Select all

//It would look like this
CRoomHandler *R;
R->ActualRoom->Update ( );
R->ActualRoom->Draw ( );

Code: Select all

/************************************************************
*All global structures and their "extern" prototypes go here*
************************************************************/
struct ProgramSettings
{
   int   iDesktopWidth;
   int   iDesktopHeight;
   int iGameWidth;
   int   iGameHeight;
   int   iGameColor;
   int   iGameZBuffer;
};
extern  struct ProgramSettings Program;

/*************************
*All global types go here*
*************************/
extern MSG msg;

/*******************************************
*All global class instance pointers go here*
*******************************************/
extern CTVEngine      *pEngine;//This is the main engine class. 
extern CTVInputEngine   *pInput; //Allow for keyboard/mouse input. 

/**********************
*All functions go here*
**********************/
extern void SetupLibrary(HWND Handle);
extern HWND SetupWindow(HINSTANCE hInstance, int nCmdShow);
extern void CleanUp(HINSTANCE hInstance);
extern LRESULT CALLBACK WindowProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);
extern int GameLoop(void);

/**********************************
*All external enumerations go here*
**********************************/
enum { iENTRYMENU, iSETUPMENU, iHOSTMENU, iCLIENTMENU, iGAMEPLAY, iFINISHED, iENDVALUE};//Used in program state arbitration.

Code: Select all

#include "externals.h"

/******************************
*All global structures go here*
******************************/
struct ProgramSettings Program;

/*************************
*All global types go here*
*************************/
MSG msg;

/*******************************************
*All global class instance pointers go here*
*******************************************/
CTVEngine      *pEngine; 
CTVInputEngine   *pInput; 

Code: Select all

#include "TV3D.h"
#include "globals.h"

//Entry point.
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
   //Get current desktop size.
   Program.iDesktopWidth = GetSystemMetrics(SM_CXSCREEN);
    Program.iDesktopHeight = GetSystemMetrics(SM_CYSCREEN);

   //Check for saved screen settings.
   char szTempBuffer [10];
   Program.iGameWidth   = GetPrivateProfileInt("ProgramSetup","GameWidth",800,".\\Redidit.set");
   Program.iGameHeight   = GetPrivateProfileInt("ProgramSetup","GameHeight",600,".\\Redidit.set");
   WritePrivateProfileString("ProgramSetup","GameWidth", _itoa(Program.iGameWidth, szTempBuffer, 10),".\\Redidit.set");//update info in case file does not exist
   WritePrivateProfileString("ProgramSetup","GameHeight", _itoa(Program.iGameHeight, szTempBuffer,10),".\\Redidit.set");

   //Create a window.
   HWND hWnd;
   hWnd = SetupWindow(hInstance, nCmdShow);

   //Setup game library.
   SetupLibrary(hWnd);

   /***********************************AT THIS POINT WE STILL HAVE TO PRELOAD EVERYTHING*****************************
      WE WILL MOVE THIS STEP INTO THE PROGRAM STATE ARBITRATION AND USE A FLAG IN "struct ProgramSettings Program" TO
      FLAG THAT IT IS LOADED SO IT DOES NOT GET LOADED TWICE.*/

   //Program state arbitration.
   int iProgramState = iGAMEPLAY;//Will start with game play entry, until menu code is integrated.

   do
   {
      switch(iProgramState)
      {
         case iENTRYMENU:
            //iProgramState = EntryMenu();
            break;
         case iSETUPMENU:
            //iProgramState = SetupMenu();
            break;
         case iHOSTMENU:
            //iProgramState = HostMenu();
            break;
         case iCLIENTMENU:
            //iProgramState = ClientMenu();
            break;
         case iGAMEPLAY:
            iProgramState = GameLoop();
            break;
         case iFINISHED:
            CleanUp(hInstance);//Unload everything.
            iProgramState = iENDVALUE;
            break;
         default://Something wrong if we get here.
            CleanUp(hInstance);//Unload everything.
            iProgramState = iENDVALUE;
      }
   }while(iProgramState < iENDVALUE);


   //Now for a clean exit.
   return msg.wParam;
}

LRESULT CALLBACK WindowProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch(message)
    {
        case WM_DESTROY:
            {
                PostQuitMessage(0);
                return 0;
            } break;
    }
    return DefWindowProc (hWnd, message, wParam, lParam);
}

Code: Select all

#include "TV3D.h"
#define NoKeyPressed 0

extern CTVScreen2DImmediate *p2D;
extern CTVTextureFactory    *pTextureFactory;
extern CTVScreen2DText      *pText;
extern CTVInputEngine      *pInput;
extern ProgramSettings      Program;


//#################### Background Class ###########################
class Background
{
   protected:
      int TextureId;
      cTV_TEXTURE Texture;
      float RealX1, RealY1, RealX2, RealY2;//Real screen values
   public:
      void BackgroundTexture(int);
      void BackgroundSizeUp(int, int);
      void BackgroundRender();
};

void Background::BackgroundTexture(int background_texture_id)
{
   TextureId = background_texture_id;
}

void Background::BackgroundSizeUp(int GameWidth, int GameHeight)
{
   //ScreenNormalisedHeight = GameHeight*(Texture.RealWidth / GameWidth);
   Texture   = pTextureFactory->GetTextureInfo( TextureId);
   RealY1   = ((GameHeight*(Texture.RealWidth / GameWidth)) - Texture.RealHeight) / 2;
   RealY2   = GameHeight - RealY1;
   RealX1   = 0;
   RealX2   = GameWidth;
}

void Background::BackgroundRender()
{
   p2D->Draw_Texture(TextureId, RealX1, RealY1, RealX2, RealY2, -1, -2, -2, -2, 0.0, 0.0, 1.0, 1.0);;  

}



//###################### Button Class #############################
class Button 
{
   protected:
      float X1, Y1, X2, Y2;//Normalised values
      float RealX1, RealY1, RealX2, RealY2;//Real screen values
      int UpTextureId, DownTextureId;
      int TextureToRender;
   public:
      Button(float,float,float,float);//X1, Y1, X2, Y2
      void Texture(int,int);//Texture Up ID, Texture Down ID.
      void SizeUp(int, int);//Screen width, Screen height
      int MouseToButton();//Returns a clicked validation
      void ButtonRender();
      //void ~Button();
};

Button::Button(float x1, float y1, float x2, float y2)
{
   X1 = x1;
   Y1 = y1;
   X2 = x2;
   Y2 = y2;
}

void Button::Texture(int up_texture_id, int down_texture_id)
{
   UpTextureId = up_texture_id;
   DownTextureId = down_texture_id;
   TextureToRender = UpTextureId;// initialise with the UpTextureId
}


void Button::SizeUp(int GameWidth, int GameHeight)
{
   RealX1 = (X1*GameWidth);
   RealY1 = (Y1*GameWidth*0.56f + (GameHeight - GameWidth*0.56f)/2.0f);
   RealX2 = (X2*GameWidth);
   RealY2 = (Y2*GameWidth*0.56f + (GameHeight - GameWidth*0.56f)/2.0f);
}


int Button::MouseToButton()
{
   int X,Y,MouseLPressed;
   POINT MousePoint;

   if (!Program.iWindowedMode)//External flag
   {
      GetCursorPos(&MousePoint);
      X = (int)MousePoint.x;
      Y = (int)MousePoint.y;
   }
   else
      pInput->GetMousePosition ( &X, &Y);

   MouseLPressed = pInput->IsMouseButtonPressed(0);

   if ((X>(int)RealX1) && (X<(int)RealX2) && (Y>(int)RealY1) && (Y<(int)RealY2))
   {
      TextureToRender = DownTextureId;
      if(MouseLPressed)
         return(true);//Button is pressed
      else
         return(false);//Button is not pressed
   }
   else
   {
      TextureToRender = UpTextureId;
      return(false);//Cursor is not on the button
   }
}

void Button::ButtonRender()
{
   p2D->Draw_Texture(TextureToRender, RealX1, RealY1, RealX2, RealY2, -1, -2, -2, -2, 0.0, 0.0, 1.0, 1.0);
}



//###################### Input Class #############################
class Input
{
   protected:
      float X1, Y1, X2, Y2;//Normalised values
      float RealX1, RealY1, RealX2, RealY2;//Real screen values
      bool InputBoxActive;
      unsigned char KeyArray[255];
      int Color,ActiveColor, InactiveColor;
      int OldActiveKey, ActiveKey;
      int IDFont;
      int EntrySize;

   public:
      Input(float,float,float,float,int);//X1, Y1, X2, Y2.
      char CurrentText[255];
      void InputSizeUp(int, int);//Screen width, Screen height.
      void InputToInput();//Handles input to text window.
      void InputRender();//Renders the completed text box.
};



Input::Input(float x1, float y1, float x2, float y2, int entrysize)
{
   X1 = x1;
   Y1 = y1;
   X2 = x2;
   Y2 = y2;
   EntrySize = entrysize;
}

void Input::InputSizeUp(int GameWidth, int GameHeight)
{
   RealX1 = (X1*GameWidth);
   RealY1 = (Y1*GameWidth*0.56f + (GameHeight - GameWidth*0.56f)/2.0f);
   RealX2 = (X2*GameWidth);
   RealY2 = (Y2*GameWidth*0.56f + (GameHeight - GameWidth*0.56f)/2.0f);

   //Lets create our texture font, clear type AA.
   IDFont   = pText->TextureFont_Create("our_font_name_string", "Comic Sans MS", (RealY2 - RealY1)/2, false, false, true, false, true);
   InactiveColor = RGBA(0.5, 0.5, 0.5, 1);
   ActiveColor = RGBA(1, 0, 0, 1);
}

void Input::InputToInput()
{
   char ASCIIFromKey[2];
   int X,Y,MouseLPressed;
   POINT MousePoint;


   if (!Program.iWindowedMode)//External flag
   {
      GetCursorPos(&MousePoint);
      X = (int)MousePoint.x;
      Y = (int)MousePoint.y;
   }
   else
      pInput->GetMousePosition ( &X, &Y);

   MouseLPressed = pInput->IsMouseButtonPressed(0);

   if(MouseLPressed)
   {
      if ((X>(int)RealX1) && (X<(int)RealX2) && (Y>(int)RealY1) && (Y<(int)RealY2))
         InputBoxActive = true;
      else 
         InputBoxActive = false;
   }

   OldActiveKey = ActiveKey;

   pInput->GetKeyPressedArray(KeyArray);

   if (InputBoxActive)
   {
      Color = ActiveColor;
      for(int loop=1; loop<255; loop++)
      {
         if (KeyArray[loop])
         {
            ActiveKey = loop;
            break;
         }
         else
         {
            ActiveKey = NoKeyPressed;
         }
      }

      if((ActiveKey != OldActiveKey) && (ActiveKey != NoKeyPressed))
      {
         ASCIIFromKey[0] = (char) pInput->GetASCIIFromKey((cCONST_TV_KEY) ActiveKey);
         ASCIIFromKey[1] = NULL;
         if (strlen(CurrentText) < EntrySize)//Maximum sized nt reached yet
         {
            if(((ASCIIFromKey[0]> 47) && (ASCIIFromKey[0] < 58)) || ((ASCIIFromKey[0]> 64) && (ASCIIFromKey[0] < 91)) || (ASCIIFromKey[0] == 46))
               strcat (CurrentText, ASCIIFromKey );
         }

         if ((ASCIIFromKey[0] == 8) && (strlen(CurrentText) > 0))//Backspace 8
            CurrentText[strlen(CurrentText) - 1] = NULL;

      }
   }
   else
      Color = InactiveColor;
}


void Input::InputRender()
{
      pText->Action_BeginText(true);
      p2D->Draw_Box(RealX1, RealY1, RealX2, RealY2, Color);//Draw a 2D box for the HOT zone. 
      pText->TextureFont_DrawText(CurrentText , RealX1, RealY1, RGBA(1, 1, 1, 1), IDFont);//Draw the font in our viewport.
      pText->Action_EndText();
}




//###################### Text Class #############################

class Text
{
   protected:
      float X1, Y1, X2, Y2;//Normalised values
      float RealX1, RealY1, RealX2, RealY2;//Real screen values
      char * Content;
      int Color;
      int IDFont;

   public:
      Text(float,float,float,float,char*);//X1, Y1, X2, Y2.
      void TextSizeUp(int, int);//Screen width, Screen height.
      void TextRender();//Renders the text.
};

Text::Text(float x1, float y1, float x2, float y2, char * content)
{
   X1 = x1;
   Y1 = y1;
   X2 = x2;
   Y2 = y2;
   Content = content;
}

void Text::TextSizeUp(int GameWidth, int GameHeight)
{
   RealX1 = (X1*GameWidth);
   RealY1 = (Y1*GameWidth*0.56f + (GameHeight - GameWidth*0.56f)/2.0f);
   RealX2 = (X2*GameWidth);
   RealY2 = (Y2*GameWidth*0.56f + (GameHeight - GameWidth*0.56f)/2.0f);

   //Lets create our texture font, clear type AA.
   IDFont   = pText->TextureFont_Create("our_font_name_string", "Comic Sans MS", (RealY2 - RealY1)/2, true, false, true, false, true);
   Color = RGBA(1.0, 1.0, 1.0, 1);
}

void Text::TextRender()
{
      pText->Action_BeginText(true);
      pText->TextureFont_DrawText(Content , RealX1, RealY1, Color, IDFont);//Draw the font in our viewport.
      pText->Action_EndText();
}

Code: Select all

struct ProgramSettings
{
   int         iWindowedMode;
   int         iDesktopWidth;
   int         iDesktopHeight;
   int         iGameWidth;
   int         iGameHeight;
   int         iGameColor;
   int         iGameZBuffer;
   int         iUseMusic;//If true then music will be used
   int         iMusicPlaying;//If true then music is looping and producing sound
   char      szMusicFile [128];//The file name stored in this variable will be used for the music
};