// Game.cpp: implementation of the CGame class.
//
//////////////////////////////////////////////////////////////////////

#include <stdio.h>
#include "Game.h"
#include "resource.h"


#define SCREEN_W		640
#define SCREEN_H		480
#define OFFSETX			100
#define OFFSETY			48
#define PLAYER1_STARTX	130
#define PLAYER1_STARTY	386
#define PLAYER2_STARTX	258
#define PLAYER2_STARTY	386


#define SAFE_RELEASE(x)		if(x){ x->Release(); x = NULL; }

CGame*	g_pGame;


inline int random( int min, int max )
{
	return (min + rand() % (max - min + 1));
}


void TRACE( LPCTSTR format, ... )
{
    char    buf[128];
    va_list vl;

    va_start(vl, format);
    sprintf(buf, format, vl);
    OutputDebugString( buf );
	va_end(vl);
}


void CGame::OutputText( int x, int y, LPCTSTR string )
{
	HDC hdc;
	if( m_pddsBackBuffer && 
		m_pddsBackBuffer->GetDC(&hdc) == DD_OK )
	{
		SetBkMode( hdc, TRANSPARENT );
		SetTextColor( hdc, RGB(255,255,0) );
		TextOut( hdc, x, y, string, lstrlen(string) );
		m_pddsBackBuffer->ReleaseDC( hdc );
	}
}


//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////


CGame::CGame()
{
	m_hInst = NULL;
	m_hWnd = NULL;
	m_bActive = FALSE;
	m_bShowStats = FALSE;
	m_bFullScreen = TRUE;
	m_bSingle = TRUE;

	m_pDD = NULL;
	m_pddsFrontBuffer = NULL;
	m_pddsBackBuffer = NULL;
	g_pGame = this;
}

CGame::~CGame()
{

}


LRESULT CALLBACK WndProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
{
	if( g_pGame )
		return g_pGame->MsgProc( hWnd, uMsg, wParam, lParam );
	
	return DefWindowProc( hWnd, uMsg, wParam, lParam );
}


LRESULT CGame::MsgProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
{
	switch( uMsg )
	{
	case WM_ACTIVATEAPP:
		if( m_bActive = (BOOL)wParam )
			m_DirectInput.Acquire();
		return 0;

	case WM_SETCURSOR:
		if( m_bFullScreen )
		{
			SetCursor( NULL );
			return TRUE;
		}
		break;

	case WM_CLOSE:
		PostQuitMessage(0);
		return 0;

	case WM_MOVE:
		m_bActive = TRUE;
		GetClientRect( hWnd, &m_rcWindow );
		ClientToScreen( hWnd, (LPPOINT)&m_rcWindow );
		ClientToScreen( hWnd, (LPPOINT)&m_rcWindow + 1 );
		return 0;
		
	case WM_MOVING:
		m_bActive = FALSE;
		break;

	case WM_KEYDOWN:
		switch( wParam )
		{
		case VK_ESCAPE:
			if( m_gameState == GS_ACTIVE )
				m_gameState = GS_SPLASH;
			else if( m_gameState == GS_SPLASH )
				PostQuitMessage(0);
			else if( m_gameState == GS_OVER )
				m_gameState = GS_SPLASH;
			break;

		case VK_F4:
			DDTerm();
			m_bFullScreen = !m_bFullScreen;
			DDInit();
			return 0;

		case VK_F5:
			m_bShowStats = !m_bShowStats;
			return 0;
			
		case VK_DOWN:
		case VK_UP:
			if( m_gameState == GS_SPLASH )
			{
				m_bSingle = !m_bSingle;
				return 0;
			}
			break;
		
		case VK_PRIOR:
			if( m_gameState == GS_ACTIVE && m_nLevel > 1 )
			{
				m_nLevel --;
				InitLevel();
			}
			break;
		case VK_NEXT:
			if( m_gameState == GS_ACTIVE )
			{
				m_nLevel ++;
				InitLevel();
			}
			break;

		case VK_RETURN:
			if( m_gameState == GS_SPLASH )
			{
				ResetGame();
				return 0;
			}
			else if( m_gameState == GS_ACTIVE && !m_bSingle )
			{
				if( m_player[0].m_nLife > 1 &&
					m_player[1].m_nLife <= 0 )
				{
					m_player[0].m_nLife --;
					m_player[1].m_nLife = 1;
					ResetPlayer( m_player[1] );
				}
				else if( m_player[1].m_nLife > 1 &&
						 m_player[0].m_nLife <= 0 )
				{
					m_player[1].m_nLife --;
					m_player[0].m_nLife = 1;
					ResetPlayer( m_player[0] );
				}
			}
			break;
		}
		break;
	}

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


BOOL CGame::Initialize( HINSTANCE hInst )
{
	m_hInst = hInst;

	if( !InitApplication() || 
		!DDInit() ||
		!InitGame() )
	{
		DDTerm();
		return FALSE;
	}

	return TRUE;
}


BOOL CGame::InitApplication()
{
	char szClassName[] = "BATTLECITY";
	char szTitle[] = "Battle City";

	WNDCLASS wc;
	wc.hInstance = m_hInst;
	wc.lpszClassName = szClassName;
	wc.lpfnWndProc = WndProc;
	wc.style = CS_DBLCLKS;
	wc.hIcon = LoadIcon( m_hInst, MAKEINTRESOURCE(IDI_TANK) );
	wc.hCursor = LoadCursor( NULL, IDC_ARROW );
	wc.lpszMenuName = NULL;
	wc.cbClsExtra = 0;
	wc.cbWndExtra = 0;
	wc.hbrBackground = (HBRUSH)GetStockObject( BLACK_BRUSH );

	if( !RegisterClass( &wc ) )
	{
		TRACE( "Error In RegisterClassEx\n" );
		return FALSE;
	}

	m_hWnd = CreateWindow( szClassName,
				szTitle,
				WS_OVERLAPPED | WS_MINIMIZEBOX | WS_SYSMENU,
				CW_USEDEFAULT,
				CW_USEDEFAULT,
				646, 505,
				NULL,
				NULL,
				m_hInst,
				NULL );
	if( !m_hWnd )
	{
		TRACE( "Error In CreateWindow\n" );
		return FALSE;
	}
				
	UpdateWindow( m_hWnd );
	ShowWindow( m_hWnd, SW_NORMAL );

	return TRUE;
}


int CGame::Run()
{
	MSG	msg;

    while( TRUE )
    {
        if (PeekMessage( &msg, NULL, 0, 0, PM_NOREMOVE))
        {
            if (!GetMessage( &msg, NULL, 0, 0))
                break;

            TranslateMessage(&msg); 
            DispatchMessage(&msg);
        }
        else if( m_bActive )
        {
			UpdateFrame();
        }
        else
            WaitMessage();
    }
	
	DDTerm();
	return msg.wParam;
}



BOOL CGame::DDInit()
{
	HRESULT hr;

	hr = DirectDrawCreate( NULL, &m_pDD, NULL );
	if( FAILED(hr) )
	{
		TRACE( "Error Create DirectDraw\n" );
		return FALSE;
	}

	if( m_bFullScreen )
		m_pDD->SetCooperativeLevel( m_hWnd, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN );
	else
		m_pDD->SetCooperativeLevel( m_hWnd, DDSCL_NORMAL );

	if( m_bFullScreen )
	{
		if( FAILED(m_pDD->SetDisplayMode( 640, 480, 16 )) )
		{
			TRACE( "Error SetDiaplayMode\n" );
			return FALSE;
		}
	}

	DDSURFACEDESC	ddsd;
	ZeroMemory( &ddsd, sizeof(ddsd) );
	ddsd.dwSize = sizeof(ddsd);
	ddsd.dwFlags = DDSD_CAPS;
	ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
	if( m_bFullScreen )
	{
		ddsd.dwFlags |= DDSD_BACKBUFFERCOUNT;
		ddsd.ddsCaps.dwCaps |= DDSCAPS_FLIP | DDSCAPS_COMPLEX;
		ddsd.dwBackBufferCount = 1;
	}
	hr = m_pDD->CreateSurface( &ddsd, &m_pddsFrontBuffer, NULL );
	if( FAILED(hr) )
	{
		TRACE( "Error Create Front Buffer\n" );
		return FALSE;
	}

	if( m_bFullScreen )
	{
		DDSCAPS ddscaps;
		ZeroMemory( &ddscaps, sizeof(ddscaps) );
		ddscaps.dwCaps = DDSCAPS_BACKBUFFER;
		m_pddsFrontBuffer->GetAttachedSurface( &ddscaps, &m_pddsBackBuffer );
	}
	else
		m_pddsBackBuffer = DDCreateSurface( SCREEN_W, SCREEN_H );

	if( !LoadBitmaps() )
		return FALSE;

	m_plane.BitBlt( m_pBmpList[0] );
	m_player[0].BitBlt( m_pBmpList[1], m_pBmpList[2], m_pBmpList[14], m_pBmpList[7] );
	m_player[1].BitBlt( m_pBmpList[9], m_pBmpList[2], m_pBmpList[14], m_pBmpList[7] );
	for( int i = 0; i < NUM_ENEMYS; i ++ )
		m_enemy[i].BitBlt( m_pBmpList[5], m_pBmpList[2], m_pBmpList[14], m_pBmpList[7] );
	for( i = 0; i < NUM_EXPLODES;  i ++ )
		m_explode[i].BitBlt( m_pBmpList[3], m_pBmpList[4] );
	m_bonus.BitBlt( m_pBmpList[6] );

	m_dwFillColor = DDColorMatch( m_pddsBackBuffer, RGB(128,128,128) );

	if( !m_bFullScreen )
	{
		SetWindowPos( m_hWnd, 0, 0, 0, 646, 505, SWP_NOMOVE | SWP_NOZORDER );
		m_rcWindow.right = m_rcWindow.left + 640;
		m_rcWindow.bottom = m_rcWindow.top + 480;
	}

	return TRUE;
}


//-----------------------------------------------------------------------------
// Name: DDLoadBitmap()
// Desc: Create a DirectDrawSurface from a bitmap resource.
//-----------------------------------------------------------------------------
LPDIRECTDRAWSURFACE CGame::DDLoadBitmap( LPCSTR szBitmap, int dx, int dy)
{
    HBITMAP                 hbm;
    BITMAP                  bm;
    DDSURFACEDESC			ddsd;
    LPDIRECTDRAWSURFACE		pdds;

    //
    //  Try to load the bitmap as a resource, if that fails, try it as a file
    //
    hbm = (HBITMAP) LoadImage(GetModuleHandle(NULL), szBitmap, IMAGE_BITMAP, dx,
                              dy, LR_CREATEDIBSECTION);
    if (hbm == NULL)
        hbm = (HBITMAP) LoadImage(NULL, szBitmap, IMAGE_BITMAP, dx, dy,
                                  LR_LOADFROMFILE | LR_CREATEDIBSECTION);
    if (hbm == NULL)
        return NULL;
    //
    // Get size of the bitmap
    //
    GetObject(hbm, sizeof(bm), &bm);
    //
    // Create a DirectDrawSurface for this bitmap
    //
    ZeroMemory(&ddsd, sizeof(ddsd));
    ddsd.dwSize = sizeof(ddsd);
    ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH;
    ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
    ddsd.dwWidth = bm.bmWidth;
    ddsd.dwHeight = bm.bmHeight;
    if (m_pDD->CreateSurface(&ddsd, &pdds, NULL) != DD_OK)
        return NULL;
    DDCopyBitmap(pdds, hbm, 0, 0, 0, 0);
    DeleteObject(hbm);
    return pdds;
}


HRESULT DDCopyBitmap( LPDIRECTDRAWSURFACE pdds, 
						HBITMAP hbm, int x, int y, 
						int dx, int dy)
{
    HDC                     hdcImage;
    HDC                     hdc;
    BITMAP                  bm;
    DDSURFACEDESC			ddsd;
    HRESULT                 hr;

    if (hbm == NULL || pdds == NULL)
        return E_FAIL;
    //
    // Make sure this surface is restored.
    //
    pdds->Restore();
    //
    // Select bitmap into a memoryDC so we can use it.
    //
    hdcImage = CreateCompatibleDC(NULL);
    if (!hdcImage)
        TRACE("createcompatible dc failed\n");
    SelectObject(hdcImage, hbm);
    //
    // Get size of the bitmap
    //
    GetObject(hbm, sizeof(bm), &bm);
    dx = dx == 0 ? bm.bmWidth : dx;     // Use the passed size, unless zero
    dy = dy == 0 ? bm.bmHeight : dy;
    //
    // Get size of surface.
    //
    ddsd.dwSize = sizeof(ddsd);
    ddsd.dwFlags = DDSD_HEIGHT | DDSD_WIDTH;
    pdds->GetSurfaceDesc(&ddsd);

    if ((hr = pdds->GetDC(&hdc)) == DD_OK)
    {
        StretchBlt(hdc, 0, 0, ddsd.dwWidth, ddsd.dwHeight, hdcImage, x, y,
                   dx, dy, SRCCOPY);
        pdds->ReleaseDC(hdc);
    }
    DeleteDC(hdcImage);
    return hr;
}


//-----------------------------------------------------------------------------
// Name: DDReLoadBitmap()
// Desc: Load a bitmap from a file or resource into a directdraw surface.
//       normaly used to re-load a surface after a restore.
//-----------------------------------------------------------------------------
HRESULT
DDReLoadBitmap(LPDIRECTDRAWSURFACE pdds, LPCSTR szBitmap)
{
    HBITMAP                 hbm;
    HRESULT                 hr;

    //
    //  Try to load the bitmap as a resource, if that fails, try it as a file
    //
    hbm = (HBITMAP) LoadImage(GetModuleHandle(NULL), szBitmap, IMAGE_BITMAP, 0,
                              0, LR_CREATEDIBSECTION);
    if (hbm == NULL)
        hbm = (HBITMAP) LoadImage(NULL, szBitmap, IMAGE_BITMAP, 0, 0,
                                  LR_LOADFROMFILE | LR_CREATEDIBSECTION);
    if (hbm == NULL)
    {
        OutputDebugString("handle is null\n");
        return E_FAIL;
    }
    hr = DDCopyBitmap(pdds, hbm, 0, 0, 0, 0);
    if (hr != DD_OK)
    {
        OutputDebugString("ddcopybitmap failed\n");
    }
    DeleteObject(hbm);
    return hr;
}


void CGame::DDTerm()
{
	for( int i = 0; i < NUM_BITMAPS; i ++ )
		SAFE_RELEASE( m_pBmpList[i] );	
	if( !m_bFullScreen )
		SAFE_RELEASE( m_pddsBackBuffer );
	SAFE_RELEASE( m_pddsFrontBuffer );
	SAFE_RELEASE( m_pDD );
}



void CGame::FlipScreen()
{
	HRESULT hr;
	
	if( m_bFullScreen )
		hr = m_pddsFrontBuffer->Flip( NULL, DDFLIP_WAIT );
	else
	{