//main source code file. contains windows api code


#include <d3d9.h>
#include <d3dx9.h>
#include <ctime>
#include <cstdio>
#include "dxgraphics.h"
#include "game.h"



//window event callback function
LRESULT WINAPI WinProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
   switch(msg)
   {
      case WM_DESTROY:
         //release the DIrect3D Device
         if(d3ddev != NULL)
            d3ddev->Release();

         //release the direct3d object'
         if(d3d != NULL)
            d3d->Release();

         //call the "font end" shutdown function
         gameEnd(hWnd);

         //tell windows to kill this program
         PostQuitMessage(0);
         return 0;
   }

   return DefWindowProc(hWnd, msg, wParam, lParam);
}




//helper function to set up the window properties
ATOM MyRegisterClass(HINSTANCE hInstance)
{
   //create the window class structure
   WNDCLASSEX wc;
   wc.cbSize = sizeof(WNDCLASSEX);

   //fill the struct with info
   wc.style = CS_HREDRAW | CS_VREDRAW;
   wc.lpfnWndProc = (WNDPROC)WinProc;
   wc.cbClsExtra = 0;
   wc.cbWndExtra = 0;
   wc.hInstance = hInstance;
   wc.hIcon = NULL;
   wc.hCursor = LoadCursor(NULL, IDC_ARROW);
   wc.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
   wc.lpszMenuName = NULL;
   wc.lpszClassName = GAMETITLE;
   wc.hIconSm = NULL;

   //set up the window with the class info
   return RegisterClassEx(&wc);
}







//entry point for a windows program
int WINAPI WinMain(HINSTANCE hInstance,
               HINSTANCE hPrevInstance,
               LPSTR lpCmdLine,
               int nCmdShow)
{
   MSG msg;
   HWND hWnd;

   //register the class
   MyRegisterClass(hInstance);

   //set up the screen in windowed or fullscreen mode?
   DWORD style;

   if(FULLSCREEN)
      style = WS_EX_TOPMOST | WS_VISIBLE | WS_POPUP;
   else
      style = WS_OVERLAPPEDWINDOW;
   

   //create a new window
   hWnd = CreateWindow(
      GAMETITLE, //window class
      GAMETITLE, //title bar
      style, //windows style
      CW_USEDEFAULT, // x position of the window
      CW_USEDEFAULT, //y positin of the window
      1280, //width
      720, //height of the window
      NULL, //parent window
      NULL, //menu
      hInstance, //application instance
      NULL ); // window parameters

   //was there an error creating the window?
   if(!hWnd)
      return false;

   //display the window
   ShowWindow(hWnd, nCmdShow);
   UpdateWindow(hWnd);

   if(!Init_Direct3D(hWnd, SCREEN_WIDTH, SCREEN_HEIGHT, FULLSCREEN))
      return 0;

   //initialize the game
   if(!gameInit(hWnd))
   {
      MessageBoxA(hWnd, "Error initializing game", "Error", MB_OK);
      return 0;
   }

   //main message loop
   int done = 0;
   while(!done)
   {
      if(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
      {
         //look for quit message
         if(msg.message == WM_QUIT)
            done = 1;

         //decode and pass messages on to WndProc
         TranslateMessage(&msg);
         DispatchMessage(&msg);
      }

      else
         //process game loop (else prevents from running after window is closed)
         gameRun(hWnd);
   }

   return msg.wParam;

}

#ifndef GAME_H
#define GAME_H



#include <d3d9.h>
#include <d3dx9.h>
#include <d3dx9math.h>
#include <time.h>
#include <stdio.h>
#include <stdlib.h>

#include "dxgraphics.h"
#include "sprite.h"
#include "player.h"




//application title
#define GAMETITLE "Zombie Game"

//screen set up
#define FULLSCREEN 0 //0 = windowed, 1 = fullscreen
#define SCREEN_WIDTH 1280
#define SCREEN_HEIGHT 720

//function prototypes
int gameInit(HWND);
void gameRun(HWND);
void gameEnd(HWND);


#endif

#include "game.h"
#include "sprite.h"



//Sprite Texture Objects (Holds full sprite sheet bmp)
LPDIRECT3DTEXTURE9 main_character = NULL; //Sprite sheet for main character
SPRITE mainCharacter;
LPDIRECT3DSURFACE9 back;
LPD3DXSPRITE sprite_handler;

HRESULT result;

//timing variable
long start = GetTickCount();





//initialize the game
int gameInit(HWND hwnd)
{
   //set random number seed
      srand(time(NULL));

   //create sprite handler object
   result = D3DXCreateSprite(d3ddev, &sprite_handler);
   if(result != D3D_OK)
      return 0;


   //load the main character sprite sheet
   main_character = LoadTexture("mainCharacter.bmp", D3DCOLOR_XRGB(255, 0, 255));
   if(main_character == NULL)
      return 0;

   back = LoadSurface("background.bmp", NULL);

   //initializes the sprites properties
   mainCharacter.x = 100;
   mainCharacter.y = 150;
   mainCharacter.width = 64;
   mainCharacter.height = 64;
   mainCharacter.curframe = 0;
   mainCharacter.lastframe = 1;
   mainCharacter.animdelay = 8;
   mainCharacter.animcount = 0;
   mainCharacter.movex = 5;
   mainCharacter.movey = 0;

   return 1;
}



//the main game loop
void gameRun(HWND hwnd)
{
   //make sure the d3d device is valid
   if(d3ddev == NULL)
      return;

   //after short delay, ready for next frame?
   //this keeps the game running at a steady frame rate
   if(GetTickCount() - start >= 30)
   {
      //reset timing
      start = GetTickCount();
      
      //move the sprite
      mainCharacter.x += mainCharacter.movex;
      mainCharacter.y += mainCharacter.movey;

      //warp the sprite on the edges of the screen
      if(mainCharacter.x > SCREEN_WIDTH - mainCharacter.width)
         mainCharacter.x = 0;
      if(mainCharacter.x < 0)
         mainCharacter.x = SCREEN_WIDTH - mainCharacter.width;
      
      //has animation delay reached threshold?
      if(++mainCharacter.animcount > mainCharacter.animdelay)
      {
         //reset counter
         mainCharacter.animcount = 0;

         //animate the sprite
         if(++mainCharacter.curframe > mainCharacter.lastframe)
            mainCharacter.curframe = 0;
      }

   }

   //start rendering
   if(d3ddev->BeginScene())
   {
            //erase the entire backgoround
      d3ddev->StretchRect(back, NULL, backbuffer, NULL, D3DTEXF_NONE);

      //start sprite handler
      sprite_handler->Begin(D3DXSPRITE_ALPHABLEND);

      //create vector to update sprite position
      D3DXVECTOR3 position((float)mainCharacter.x, (float)mainCharacter.y, 0);

      //configure the rect for the source file
      RECT srcRect;
      int columns = 2;

      srcRect.left = (mainCharacter.curframe % columns) * mainCharacter.width;
      srcRect.top = (mainCharacter.curframe / columns) * mainCharacter.height;
      srcRect.right = srcRect.left + mainCharacter.width;
      srcRect.bottom = srcRect.top + mainCharacter.height;

      //draw the sprite
      sprite_handler->Draw(
         main_character,
         &srcRect,
         NULL,
         &position,
         D3DCOLOR_XRGB(255, 255, 255));

      //stop drawing
      sprite_handler->End();

      //stop rendering
      d3ddev->EndScene();
   }

   //display the back buffer on the screen
   d3ddev->Present(NULL, NULL, NULL, NULL);

}


void gameEnd(HWND hwnd)
{
   if(back != NULL)
      back->Release();

   if(sprite_handler != NULL)
      sprite_handler->Release();

      if(main_character != NULL)
      main_character->Release();
}

#ifndef SPRITE_H
#define SPRITE_H




//sprite structure
typedef struct
{
   int x, y;
   int width, height;
   int movex, movey;
   int curframe, lastframe;
   int animdelay, animcount;
} SPRITE;

//function prototypes
int Collision(SPRITE sprite1, SPRITE sprite2); //collision detection function



#endif

#include "sprite.h"
#include <Windows.h>
#include <d3d9.h>




//collision function. tests for collision
int Collision(SPRITE sprite1, SPRITE sprite2)
{
   RECT rect1;
   rect1.left = sprite1.x + 1;
   rect1.top = sprite1.y + 1;
   rect1.right = sprite1.x + sprite1.width - 1;
   rect1.bottom = sprite1.y + sprite1.height - 1;

   RECT rect2;
   rect2.left = sprite2.x + 1;
   rect2.top = sprite2.y + 1;
   rect2.right = sprite2.x + sprite2.width - 1;
   rect2.bottom = sprite2.y + sprite2.height -1;

   RECT dest;
   return IntersectRect(&dest, &rect1, &rect2);
}

#ifndef DXGRAPHICS_H
#define DXGRAPHICS_H




//function prototypes
int Init_Direct3D(HWND, int, int, int);
LPDIRECT3DSURFACE9 LoadSurface(char*, D3DCOLOR);
LPDIRECT3DTEXTURE9 LoadTexture(char*, D3DCOLOR);

//variable declarations
extern LPDIRECT3D9 d3d;
extern LPDIRECT3DDEVICE9 d3ddev;
extern LPDIRECT3DSURFACE9 backbuffer;

#endif

#include <d3d9.h>
#include <d3dx9.h>
#include "dxgraphics.h"

//variable declarations
LPDIRECT3D9 d3d = NULL;
LPDIRECT3DDEVICE9 d3ddev = NULL;
LPDIRECT3DSURFACE9 backbuffer = NULL;




int Init_Direct3D(HWND hwnd, int width, int height, int fullscreen)
{
   //initialize direct3d
   d3d = Direct3DCreate9(D3D_SDK_VERSION);
   if(d3d == NULL)
   {
      MessageBoxA(hwnd, "Error init-ing Direct3D", "Error", MB_OK);
      return 0;
   }

   D3DPRESENT_PARAMETERS d3dpp;
   ZeroMemory(&d3dpp, sizeof(d3dpp));

   d3dpp.Windowed = (!fullscreen);
   d3dpp.SwapEffect = D3DSWAPEFFECT_COPY;
   d3dpp.BackBufferFormat = D3DFMT_X8R8G8B8;
   d3dpp.BackBufferCount = 1;
   d3dpp.BackBufferWidth = width;
   d3dpp.BackBufferHeight = height;
   d3dpp.hDeviceWindow = hwnd;
   d3dpp.EnableAutoDepthStencil = TRUE;
   d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
   d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;

   //create the Direct3D device
   d3d->CreateDevice(
      D3DADAPTER_DEFAULT,
      D3DDEVTYPE_HAL,
      hwnd,
      D3DCREATE_SOFTWARE_VERTEXPROCESSING,
      &d3dpp,
      &d3ddev);

   if(d3ddev == NULL)
   {
      MessageBoxA(hwnd, "Error creating Direct3D device", "Error", MB_OK);
      return 0;
   }

   //clear the back buffer to black
   d3ddev->Clear(0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0, 0, 0), 1.0f, 0);

   //create pointer to the back buffer
   d3ddev->GetBackBuffer(0, 0, D3DBACKBUFFER_TYPE_MONO, &backbuffer);

   return 1;
}



LPDIRECT3DSURFACE9 LoadSurface(char* filename, D3DCOLOR transcolor)
{
   LPDIRECT3DSURFACE9 image = NULL;
   D3DXIMAGE_INFO info;
   HRESULT result;

   //get width and height from bitmap file
   result = D3DXGetImageInfoFromFile(filename, &info);
   if(result != D3D_OK)
      return NULL;

   //create surface
   result = d3ddev->CreateOffscreenPlainSurface(
      info.Width, //width of the surface
      info.Height, //height of the surface
      D3DFMT_X8R8G8B8, //surface format
      D3DPOOL_DEFAULT, //memory pool to use
      &image, //pointer to the surface
      NULL); //reserved(always NULL)

   if(result != D3D_OK)
      return NULL;

   //load surface from file into newly created surface
   result = D3DXLoadSurfaceFromFile(
      image, //destination surface
      NULL, //destionation pallatte
      NULL, //destionation rectangle
      filename, //source filename
      NULL, //source rectangle
      D3DX_DEFAULT, //controls how the image is filtered
      transcolor, //for transparency (0 for none)
      NULL); //source mage info(USUALLY NULL)

   //make sure the file was loaded okay
   if(result != D3D_OK)
      return NULL;

   return image;
}


LPDIRECT3DTEXTURE9 LoadTexture(char *filename, D3DCOLOR transcolor)
{
   //the texture poitner
   LPDIRECT3DTEXTURE9 texture = NULL;

   //the struct for reading bitmap file info
   D3DXIMAGE_INFO info;

   //standard Windows return value
   HRESULT result;

   //get width and height from bitmap file
   result = D3DXGetImageInfoFromFile(filename, &info);
   if(result != D3D_OK)
      return NULL;

   //create the new texture by loading a bitmap image file
   D3DXCreateTextureFromFileEx(
      d3ddev, //Drect3D device object
      filename, //bitmap filename
      info.Width, //bitmap image width
      info.Height, //bitmap image height
      1, //mip map levels(1 for no chain)
      D3DPOOL_DEFAULT, // the type of surface (standard)
      D3DFMT_UNKNOWN, //surface format (default)'
      D3DPOOL_DEFAULT, //memory class for the texture
      D3DX_DEFAULT, //image filter
      D3DX_DEFAULT, //mip filter
      transcolor, //color key for transparency
      &info, //bitmap file info
      NULL, //color palatte
      &texture); //destination texture

   //make sure the bitmap texture was loaded correctly
   if(result != D3D_OK)
      return NULL;

   return texture;
}