[DX 9.0] WATERBALL - JEU COMPLET EN DX9 (STYLE ARKANOÏD)

/************************************************************************************************

                                *******************************
                               *  Commencé le 17 juillet 2003  *
                               *        par Heliopraetor       *
							   *			et NaOs 		   *
                                *******************************

Version : 1.1
Commentaires : 254.7Fps sur un AMD TBird 1.1 GHz, 512Mo DDR, G4 Ti4200 128Mo AGP 8x en cfg Release
				et une moyenne de 145 fps dans le jeu.
*************************************************************************************************/



//-----defines nécessaires
#define DIRECTINPUT_VERSION 0x0800
#define MAIN_FILE

//-----includes nécessaires
#include <windows.h>
#include "resource.h"
#include "Def.h"
#include "Mleaks.h"
#include "DXUtils.h"


//----------------------------------------------------------------------------------------------//
//																								//
//																								//
//																								//
//-----------------------------------------"Champ global"---------------------------------------//
//																								//
//																								//
//																								//
//----------------------------------------------------------------------------------------------//


//-----déclarations
extern LPD3DXFONT *g_FontList;					//liste de polices
extern void InitBonusTableAndBriquesTable();	//initialisation de la table des bonus et briques
extern void InitEffectsConstants();
extern int g_NumbOfFonts;						//nombre de polices
extern LPDIRECT3DTEXTURE9 g_BrickTex;


//-----instances de classes propres au jeu
CTexManager* g_CTM = NULL;					//gestionnaire de textures					*
CResManager* g_CRM = NULL;					//gestionnaire de fichiers ressources		*
CMusicManager *g_CMuM = NULL;				//gestionnaire de sons						*
CLevelsManager *g_CLM = NULL;				//gestionnaire du jeu						*
CMenuManager *g_CMM = NULL;					//gestionnaire du menu						*
CInputManager* g_CIM = NULL;				//gestionnaire de DirectInput				*
CLogsManager* g_CLogM = NULL;				//gestionnaire du fichier log WB.log		*
COptionsPanel* g_COPPtr = NULL;				//panneau des options						*
CRegManager* g_CReg = NULL;					//gestionnaire du registre					*
CCadre* g_Cadre = NULL;						//cadre de fond du jeu						*
CCurseur* g_Curseur = NULL;
LPSRenderArgs g_SA = NULL;					//structure de renseignement inter-classes	*
LPSFontProperties g_FontTab = NULL;			//propriétés des polices					*
CPrimitivesEngine* g_PrE = NULL;			//affichage des primitives					*


//----------------------------------------------------------------------------------------------//
//																								//
//																								//
//																								//
//--------------------------------Fonctions de suppression finale-------------------------------//
//																								//
//																								//
//																								//
//----------------------------------------------------------------------------------------------//
void DeleteTemporaryFiles()
{
	//------Suppression des éventuels fichiers du répertoire temporaire du jeu (.../_wbr)
	WIN32_FIND_DATA wData;
	HANDLE listing;
	char* tmp = NULL;
	tmp = new char[strlen(g_CRM->GetFilesDir())+4];
	strcpy(tmp,g_CRM->GetFilesDir());
	strcat(tmp,"*.*");
	listing = FindFirstFile(tmp, &wData);
	char buffer[256];
	if (listing != INVALID_HANDLE_VALUE)
	{
		do
			if(wData.cFileName[0] != '.')
			{
				sprintf(buffer,"%s%s",g_CRM->GetFilesDir(),wData.cFileName);
				DeleteFile(buffer);
			}
		while (FindNextFile(listing, &wData));
		FindClose(listing);
	}
	delete tmp;
}


void FreeAll()
{
	if( g_PrE )
		delete g_PrE;
	if( g_Cadre )			//fond d'écran
		delete g_Cadre;
	if( g_Curseur )			//curseur
		delete g_Curseur;
	if( g_CLM )				//levelsmanager
		delete g_CLM;
	if( g_CMM )				//menumanager
		delete g_CMM;
	if( g_CIM )				//inputmanager
		delete g_CIM;
	if( g_CMuM )			//musicmanager
		delete g_CMuM;
	if( g_CTM )				//texturemanager
		delete g_CTM;
	if( g_CReg )			//regmanager
		delete g_CReg;
	if( g_SA )				//structure de communication
		delete g_SA;

	if( g_FontList && g_FontTab)	//liste de polices
	{
		for (int i=0 ; i<g_NumbOfFonts ; i++)
			g_FontList[i]->Release();
		delete [] g_FontTab;
		delete [] g_FontList;
	}

	if( g_CRM )				//CRessourceManager
	{
		g_CRM->Delete(c_Tmp, NbWav);
		g_CRM->Delete(l_Tmp, NbBmp);

		for (int i=0 ; i<NbBmp ; i++) {delete l_Tmp[i];}
		for (i=0 ; i<NbWav ; i++) {delete c_Tmp[i];}
		delete [] c_Tmp;
		delete [] l_Tmp;

		DeleteTemporaryFiles();

		delete g_CRM;
	}

	//CLogManager à supprimer

	RELEASE(g_D3DXSprite); //
	RELEASE(g_Surf);	   //variables
	RELEASE(g_Device);	   //directx
	RELEASE(g_D3D);		   //
	g_CLogM->AddEvent("Instances supprimées - lancement de la suppression du loggeur");
	delete g_CLogM;
}


//----------------------------------------------------------------------------------------------//
//																								//
//																								//
//																								//
//---------------Fonction pour récupérer le Device en cas de basculement------------------------//
//																								//
//																								//
//																								//
//----------------------------------------------------------------------------------------------//
bool CheckDevice()
{
	HRESULT l_DeviceState = g_Device->TestCooperativeLevel();

	if( l_DeviceState == D3DERR_DEVICENOTRESET )
	{
		Sleep(100); //on alloue 100ms au systeme

//		g_CMM->DrawMsgBox();
		g_CTM->dr_UnloadAll();
		g_CMM->dr_Unload();
		g_CLM->dr_Unload();

		if( g_FontList )	//liste de polices
		{
			for (int i=0 ; i<g_NumbOfFonts ; i++)
				g_FontList[i]->Release();
			delete [] g_FontList;
		}

		RELEASE(g_D3DXSprite); //
		RELEASE(g_Surf);	   //variables

		HRESULT l_Res = g_Device->Reset(&g_d3dpp);

		if( l_Res != D3D_OK )
		{
			char l_Msg[256];
	
			switch(l_Res)
			{
				case D3DERR_DEVICELOST : strcpy(l_Msg,"Le device a été perdu !"); break;
				case D3DERR_DRIVERINTERNALERROR : strcpy(l_Msg,"Le driver a rencontré une erreur interne !"); break;
				case D3DERR_INVALIDCALL : strcpy(l_Msg,"L'appel à IDirect3DDevice9::Reset a été mal effectué !"); break;
				case D3DERR_OUTOFVIDEOMEMORY : strcpy(l_Msg,"Pas assez de mémoire vidéo !"); break;
				case E_OUTOFMEMORY : strcpy(l_Msg,"Pas assez de mémoire !"); break;
			}

			MessageBox(g_hDlg,l_Msg,"Erreur Fatale !",0+MB_ICONHAND);
		    return false;
		}

		//HYPER IMPORTANT POUR RE-RENDRE LES VERTEX
		g_Device->SetRenderState(D3DRS_ALPHATESTENABLE, true);
		g_Device->SetRenderState(D3DRS_ALPHAFUNC, D3DCMP_NOTEQUAL);
		g_Device->SetRenderState(D3DRS_ALPHAREF, 0x00);
		g_Device->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
		g_Device->SetRenderState(D3DRS_SRCBLEND,D3DBLEND_SRCALPHA);
		g_Device->SetRenderState(D3DRS_DESTBLEND,D3DBLEND_INVSRCALPHA);
		g_Device->SetTextureStageState(0,D3DTSS_ALPHAOP,D3DTOP_MODULATE);
		g_Device->SetTextureStageState(0,D3DTSS_ALPHAARG1,D3DTA_TEXTURE);
		g_Device->SetTextureStageState(0,D3DTSS_ALPHAARG2,D3DTA_DIFFUSE);
		//filtrage bilinéaire pour un effet d'antialiasing lors des distorsions des sprites
		//désactivation de la lumière (sinon les sprites seront noirs)
		g_Device->SetRenderState(D3DRS_LIGHTING, FALSE);
		g_Device->SetRenderState( D3DRS_CULLMODE,  D3DCULL_NONE);
		g_Device->SetVertexShader(NULL);

		HFONT l_TmpFont;
		g_FontList = new LPD3DXFONT[g_NumbOfFonts];

		for(int k=0 ; k<g_NumbOfFonts ; k++)
		{
			l_TmpFont = CreateFont( g_FontTab[k].m_Size,		//taille de la police : 10, 12, 16, etc
								  0, 0, 0,
								  g_FontTab[k].m_Flag,			//texte gras ou non
								  g_FontTab[k].m_Italic,		//italique : true ou false
								  g_FontTab[k].m_Underlined,    //souligné : true ou false
								  FALSE,
								  ANSI_CHARSET,
								  OUT_DEFAULT_PRECIS,
								  CLIP_DEFAULT_PRECIS,
								  ANTIALIASED_QUALITY,
								  VARIABLE_PITCH,
								  g_FontTab[k].m_Name);

			D3DXCreateFont( g_Device, l_TmpFont, &g_FontList[k] );
			DeleteObject( l_TmpFont );
		}

		g_Device->GetBackBuffer(0,0,D3DBACKBUFFER_TYPE_MONO,&g_Surf);
		D3DXCreateSprite( g_Device, &g_D3DXSprite );

		if( g_Surf == NULL )
		{
			g_CLogM->AddEvent("[ERREUR] Impossible de récupérer la surface de base !");
			return false;
		}

		if( g_D3DXSprite == NULL )
		{
			g_CLogM->AddEvent("[ERREUR] Impossible de récupérer l'objet D3DXSPRITE !");
			return false;
		}

		g_CLM->dr_Reload();
		g_CTM->dr_ReloadAll(g_SA->m_Time);
		g_CMM->dr_Reload();
		g_BrickTex = (*g_CTM)[GX_BRIQUES]->m_lpTexture;
	}
	return true;
}


//----------------------------------------------------------------------------------------------//
//																								//
//																								//
//																								//
//-----------------------------------Fonction de rendu de frame---------------------------------//
//																								//
//																								//
//																								//
//----------------------------------------------------------------------------------------------//
bool Update()
{
	static float CurrentTime = DXUtil_Timer(TIMER_GETABSOLUTETIME);

	bool DontPlay = (IsIconic(g_hDlg)||g_hDlg!=GetForegroundWindow());

	if( DXUtil_Timer(TIMER_GETABSOLUTETIME)-CurrentTime>0.015f )//64 fps ( 1/fps. calculé par 1/66 mais a cause des arrondis on a 64fps)
	{
		srand((unsigned int)timeGetTime());	//On réinitialise le hasard.

		//-----------Préparation des variables d'affichage------
		static float Timer = 0.0f;
		static float dwFrames = 0.0f;
		CurrentTime = DXUtil_Timer(TIMER_GETABSOLUTETIME);

		//-----------Préparation du device pour l'affichage-----
		if (!DontPlay)
		{
			if (!g_CLM->Is_Paused())
				DXUtil_Timer(TIMER_START);

			if( !CheckDevice() )
			{
				g_CLogM->AddEvent("[ERREUR] CheckDevice() a échoué");
				return false;
			}

			g_Device->Clear(NULL,NULL,D3DCLEAR_TARGET,D3DCOLOR_XRGB(0,0,0),1.0f,0);
			g_Device->BeginScene();


			//-----------Acquisition des données périphériques----------
			g_CIM->ActualiseState();
			g_SA->m_Time = DXUtil_Timer(TIMER_GETAPPTIME);
			g_SA->m_RealTime = CurrentTime;
			g_SA->m_LastChar = g_CIM->GetInputChar();
			g_SA->m_LeftButton = g_CIM->GetButtonsState(1);
			g_SA->m_RightButton = g_CIM->GetButtonsState(2);
			g_SA->m_x = g_CIM->GetBattleX();
			g_SA->m_y = g_CIM->GetBattleY();

			//------------Dessin et calcul d'une frame-------------
			g_Cadre->Draw();
			g_CLM->RenderFrame();
			if (!g_CMM->RenderFrame() )
				return false;

			//------------Calcul des FPS
			if( g_COPPtr->GetFps() )
			{
				dwFrames++;
				PrintText(g_FPS,0,0,D3DCOLOR_ARGB(255,0,255,64),WBF_IMPACT);
			}
		}
		//------------Verifie l'utilité d'une texture-----------
		if( CurrentTime - Timer > 1.0f )
		{
			g_CTM->Head_Reset();

			for(int i=0; i<g_ListSize ; i++)
			{
				STexture* l_TexTmp = g_CTM->Head_GetPointer();

				if( l_TexTmp && l_TexTmp->m_Loaded )	//Si texture chargée => vérifie temps
					if( CurrentTime - l_TexTmp->m_LastTimeUsed > 7.0f ) //7s
						g_CTM->Head_UnloadTexture();

				g_CTM->Head_Next();
			}
			//FPS
			sprintf(g_FPS,"%.2f",dwFrames / (CurrentTime - Timer));
			dwFrames = 0;
			Timer = CurrentTime;
		}

		/*char tmp[20];
		sprintf(tmp,"RealTime : %.1f",g_SA->m_RealTime);
		PrintText(tmp,5,300,D3DCOLOR_ARGB(255,0,255,64),WBF_IMPACT);
		sprintf(tmp,"Time : %.1f",g_SA->m_Time);
		PrintText(tmp,5,350,D3DCOLOR_ARGB(255,0,255,64),WBF_IMPACT);*/

		//-----------Affichage de la frame----------------------
		if (!DontPlay)
		{
			g_Device->EndScene();
			g_Device->Present(NULL,NULL,NULL,NULL);
		}
		else
		{
			DXUtil_Timer(TIMER_STOP);
			Sleep(100);
		}
	}
	return true;
}


//----------------------------------------------------------------------------------------------//
//																								//
//																								//
//																								//
//------------------------------Fonction de traitement des messages-----------------------------//
//																								//
//																								//
//																								//
//----------------------------------------------------------------------------------------------//
LRESULT CALLBACK WindowProcedure(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	switch (message)
	{
		/*case WM_CLOSE:
		case WM_DESTROY:
		case WM_ENDSESSION:
		case WM_QUIT:
			g_CallBoucle=false;
			break;*/
	default:
		break;
	}
	return DefWindowProc(hwnd, message, wParam, lParam);
}



//----------------------------------------------------------------------------------------------//
//																								//
//																								//
//																								//
//----------------------------------------Fonction WinMain--------------------------------------//
//																								//
//																								//
//																								//
//----------------------------------------------------------------------------------------------//
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpszArgument, int nCmdShow)
{
	//------Variables de gestion générale
	g_Instance = hInstance;
    MSG Msg;
	bool l_Abort = false;
	bool l_ExtractActionFailed=false;

#ifndef _DEBUG
	CSplashScreen::Run();
#endif

	//------Création d'un objet de gestion de logs
	g_CLogM = new CLogsManager(true,true,true,true,true,true,"WB.log");
	g_CLogM->AddEvent("CLogsManager créé");

	//------Création de la classe de fenêtre
    WNDCLASSEX wc;
    wc.hInstance = hInstance;
    wc.lpszClassName = szClassName;
    wc.lpfnWndProc = WindowProcedure;
    wc.style = 0/*CS_OWNDC*/;
    wc.cbSize = sizeof(WNDCLASSEX);
    wc.hIcon = LoadIcon(hInstance,MAKEINTRESOURCE(IDI_WATERBALL));
    wc.hIconSm = LoadIcon(hInstance,MAKEINTRESOURCE(IDI_WATERBALL));
    wc.hCursor = LoadCursor(NULL, IDC_ARROW);
    wc.lpszMenuName = NULL;
    wc.cbClsExtra = 0;
    wc.cbWndExtra = 0;
    wc.hbrBackground = (HBRUSH) GetStockObject(BLACK_BRUSH);
    if(!RegisterClassEx(&wc))
	{
/*#ifndef _DEBUG
		CSplashScreen::Exit();
#endif
		return 0;*/		//apparemment pas nécessaire : classe déjà enregistrée
		g_CLogM->AddEvent("Méthode RegisterClassEx échouée");
	}

	//création de l'interface de transmission des infos périphériques
	g_SA = new SRenderArgs;
	if( g_SA == NULL )
	{
		g_CLogM->AddEvent("Impossible de créer la structure d'arguments");
		l_Abort = true;
	}
	g_CLogM->AddEvent("Structure d'arguments créée");

	//------Chargement des paramètres à partir du registre
	int Res_X, Res_Y;
	g_CReg = new CRegManager();	//création du gestionnaire de registre
	if( g_CReg == NULL )
	{
		g_CLogM->AddEvent("Erreur dans l'initialisation du registre");
		FreeAll();
#ifndef _DEBUG
		CSplashScreen::Exit();
#endif
		return -1;	//si erreur on quitte
	}
	else
	{
		char l_MainKey[256];
		strcpy(l_MainKey,"Software\\Waterball\\");

		g_CReg->SetHK( HKEY_CURRENT_USER );
		g_CReg->SetKey( l_MainKey );

		g_CReg->SetValueName( "Res" );

		if (g_CReg->rGetInt() == -1)	//la clé registre n'existe pas !
		{
			//mise en place des valeurs par défault
			Res_X = 800;
			Res_Y = 600;
			g_SA->m_Zoom = 0.781f;
			g_TexQual=2;
			g_Skin=0;
			strcpy(g_SkinName,"Skins\\WaterData.wbr");

			//initialisation du registre
			g_CReg->SetValueName( "Res" );
			g_CReg->rWriteInt(g_ResolutionIs800);
			g_CReg->SetValueName( "Window" );
			g_CReg->rWriteInt(g_Windowed);
			g_CReg->SetValueName( "TexQuality" );
			g_CReg->rWriteInt(g_TexQual);
			g_CReg->SetValueName( "Volume" );
			g_CReg->rWriteInt(g_Volume);
			g_CReg->SetValueName( "Skin" );
			g_CReg->rWriteInt(g_Skin);
			g_CReg->SetValueName( "ShowFPS" );
			g_CReg->rWriteInt(
#ifdef _DEBUG 
								true 
#else 
								false 
#endif
								);
		}
		else							//le registre a déjà été initialisé
		{
			g_ResolutionIs800 = g_CReg->rGetInt()?true:false;

			if( g_ResolutionIs800 )
			{
				Res_X = 800;
				Res_Y = 600;
				g_SA->m_Zoom = 0.781f;
			}
			else
			{
				Res_X = 1024;
				Res_Y = 768;
				g_SA->m_Zoom = 1.0f;
			}

			g_CReg->SetValueName( "Window" );
			g_Windowed = g_CReg->rGetInt()?true:false;

			g_CReg->SetValueName( "TexQuality" );
			g_TexQual = g_CReg->rGetInt();

			g_CReg->SetValueName( "Volume" );
			g_Volume = g_CReg->rGetInt();

			g_CReg->SetValueName( "Skin" );
			g_Skin = g_CReg->rGetInt();

			switch(g_Skin)
			{
			case 1:
				strcpy(g_SkinName,"Skins\\MatrixData.wbr");
				break;
			case 2:
				strcpy(g_SkinName,"Skins\\DarkData.wbr");
				break;
			case 3:
				strcpy(g_SkinName,"Skins\\Skin4.wbr");
				break;
			default:
				strcpy(g_SkinName,"Skins\\WaterData.wbr");
			}
		}
	}

	//------Création de la fenêtre
	//initialisation de variables
	#ifdef _DEBUG
		#define CHOIX_AFF NULL
	#else
		#define CHOIX_AFF WS_POPUP
	#endif
    DWORD Flag;
	if( g_Windowed && Res_X==GetSystemMetrics(SM_CXSCREEN) )
		Flag = WS_CLIPCHILDREN | WS_CAPTION;
	else
		Flag = WS_CLIPCHILDREN;
	//création elle-même
    g_hDlg = CreateWindowEx(
           0,                   //Extended possibilites for variation
           szClassName,         //Classname
           szClassName,         //Title Text
           CHOIX_AFF | Flag ,	//default window
           0,					//Windows decides the position
           0,					//where the window ends up on the screen
           Res_X,               //The programs width
           Res_Y,               //and height in pixels
           NULL,				//The window is a child-window to desktop
           NULL,                //No menu
           hInstance,			//Program Instance handler
           NULL                 //No Window Creation data
           );
	//validation
	g_CLogM->AddEvent("Fenêtre créée");
	g_CLogM->AddEvent("Opérations registre effectuées");

	//-----Initialisation de l'extraction des ressources (sons et graphismes)
	g_CRM = new CResManager("UnAceV2.Dll","_wbr",true);
	if( g_CRM->GetErrValue() > 0 )
	{
		MessageBox(g_hDlg,"UnaceV2.dll non présente sur ce systeme !","Erreur fatale !",MB_ICONHAND);
		FreeAll();
#ifndef _DEBUG
		CSplashScreen::Exit();
#endif
		return -1;
	}

	//------Chargement du skin
	if( !FileExist(g_SkinName) )
	{
		MessageBox(g_hDlg,"Skin sélectionné inexistant !","Erreur fatale !",MB_ICONHAND);
		assert(1!=1);	//big problème

		strcpy(g_SkinName,"Skins\\WaterData.wbr"); //on met celui par defaut

		if( !FileExist(g_SkinName) )
		{
			MessageBox(g_hDlg,"Aucun skin présent !","Erreur fatale !",MB_ICONHAND);
			g_CLogM->AddEvent("! Erreur ! Aucun skin présent !");
			FreeAll();
#ifndef _DEBUG
			CSplashScreen::Exit();
#endif
			return -1;
		}
	}

	//------Extraction des ressources
	DeleteTemporaryFiles();
	g_CRM->SetArchiveName(g_SkinName);
		char *ptc=new char[7];	//petit codage express du password
		for (int f=0;f<6;f++)
			ptc[f]=0x60;
		int in=0;
		ptc[in++]+=4;
		ptc[in++]+=9;
		ptc[in++]+=5;
		ptc[in++]+=16;
		ptc[in++]+=16;
		ptc[in++]+=5;
		ptc[in]=NULL;
	g_CRM->SetArchivePassword(ptc);
		delete ptc;
	if( !g_CRM->Extract() )
		l_ExtractActionFailed=true;
	else
		g_CLogM->AddEvent("Ressources extraites");
	
	
	if (l_ExtractActionFailed)
	{
		MessageBox(g_hDlg,"Impossible d'extraire les ressources !","Erreur fatale !",MB_ICONHAND);
		FreeAll();
#ifndef _DEBUG
		CSplashScreen::Exit();
#endif
		return -1;
	}

	//------Test de la version de DirectX
	if( GetDXVersion() < 0x900 )
	{
		MessageBox(g_hDlg,"Ce jeu requiert une version 9, ou ultérieure, de DirectX pour fonctionner","Erreur fatale !",MB_ICONHAND);
		FreeAll();
#ifndef _DEBUG
		CSplashScreen::Exit();
#endif
		return -1;
	}
	g_CLogM->AddEvent("DirectX 9 supporté");

	//-----Initialisation de DirectGraphics pour DX9
#ifndef _DEBUG
	if( !InitDGraphics(1024,768,12+(g_TexQual*12),g_Windowed) )
#else
	if( !InitDGraphics(1024,768,24,true) )
#endif
	{
		l_Abort = true;
		MessageBox(g_hDlg,"Impossible d'initialiser DGraphics !","Erreur fatale !",MB_ICONHAND);
	}

	//-----Création et initialisation des polices
	g_FontTab = LoadFonts(g_FontTab,"FontList.wbf") ;
	if( g_FontTab == NULL )
	{
		l_Abort = true;
		MessageBox(g_hDlg,"Impossible d'initialiser les polices !","Erreur fatale !",MB_ICONHAND);
	}
	else
	{
		HFONT l_TmpFont;
		g_FontList = new LPD3DXFONT[g_NumbOfFonts];

		for(int k=0 ; k<g_NumbOfFonts ; k++)
		{
			l_TmpFont = CreateFont( g_FontTab[k].m_Size,		//taille de la police : 10, 12, 16, etc
								  0, 0, 0,
								  g_FontTab[k].m_Flag,			//texte gras ou non
								  g_FontTab[k].m_Italic,		//italique : true ou false
								  g_FontTab[k].m_Underlined,    //souligné : true ou false
								  FALSE,
								  ANSI_CHARSET,
								  OUT_DEFAULT_PRECIS,
								  CLIP_DEFAULT_PRECIS,
								  ANTIALIASED_QUALITY,
								  VARIABLE_PITCH,
								  g_FontTab[k].m_Name);

			D3DXCreateFont( g_Device, l_TmpFont, &g_FontList[k] );
			DeleteObject( l_TmpFont );
		}
	}

	//------------Initialisation du tableau pour la génération de bonus
	InitBonusTableAndBriquesTable();

	//---------Mise en place du support des primitives
	g_PrE = new CPrimitivesEngine(g_Device, &g_d3dpp);
	g_CLogM->AddEvent("Moteur de primitives initialisé");

	//-----Creation d'un objet pour gérer les textures-------
	g_CTM = new CTexManager(g_Device,&g_d3dpp);
	if( g_CTM->GetErrValue() > 0 )
	{
		MessageBox(g_hDlg,"Impossible d'initialiser le gestionnaire de textures !","Erreur fatale !",MB_ICONHAND);
		l_Abort = true;
	}

	//-----Création d'un objet pour gérer les sons-------
	g_CMuM = new CMusicManager();
	if( g_CMuM->GetErrValue() > 0 )
	{
		MessageBox(g_hDlg,"Impossible d'initialiser DMusic !","Erreur fatale !",MB_ICONHAND);
		l_Abort = true;
	}
	g_CLogM->AddEvent("DirectX 9 initialisé");

	//-----Réglage du volume et des sons
	if( g_Volume>-1 && g_Volume<12 )
		g_CMuM->SetVolume( g_Volume*100/11 );
	else
		g_CMuM->SetVolume( VOLUME_DEFAULT_IN_PERCENT );
	
	
	c_Tmp = new char*[NbWav];
	int l_Volume = 0;
	
	for (int w=0 ; w!=NbWav ; w++)
	{
		c_Tmp[w] = new char[strlen(g_CRM->GetFilesDir())+strlen(WavNames[w])+1];
		strcpy(c_Tmp[w],g_CRM->GetFilesDir());
		strcat(c_Tmp[w],WavNames[w]);

		if( w > 26 )
			l_Volume = 0;

		if( g_CMuM->AddToPlayList(c_Tmp[w],false,false,l_Volume) == -1 )
		{
		 l_Abort = true;

		 char l_Msg[256] = "Impossible de charger le son nommé ";
		 strcat(l_Msg,WavNames[w]);
		 g_CLogM->AddEvent(l_Msg);
		 MessageBox(g_hDlg,l_Msg,"Erreur Fatale !",0+MB_ICONHAND);
		}
	}

	if( !l_Abort )
		g_CLogM->AddEvent("Sons créés");


	//-------Création des textures-------------
	l_Tmp = new char*[NbBmp];
	float l_Time = DXUtil_Timer(TIMER_GETAPPTIME);
	for (int i=0 ; i!=NbBmp ; i++)
	{
		l_Tmp[i] = new char[strlen(g_CRM->GetFilesDir())+strlen(BmpNames[i])+1];
		strcpy(l_Tmp[i],g_CRM->GetFilesDir());
		strcat(l_Tmp[i],BmpNames[i]);

		if(	g_CTM->AddTexture(l_Tmp[i],l_Time,Coor[i][0],Coor[i][1]) == -1 )
		{
			char* l_ErrMsg;
			l_ErrMsg = new char[22 + strlen(BmpNames[i]) + 3];
			strcpy(l_ErrMsg,"Impossible de charger ");
			strcat(l_ErrMsg,BmpNames[i]);
			strcat(l_ErrMsg," !");

			MessageBox(g_hDlg,l_ErrMsg,"Erreur fatale !",MB_ICONHAND);
			delete [] l_ErrMsg;
			l_Abort = true;
		}
	}
    g_BrickTex = (*g_CTM)[GX_BRIQUES]->m_lpTexture;
	g_CLogM->AddEvent("Textures créées");
	
	//---------------------Création des éléments de jeu
	//création du fond
	g_Cadre = new CCadre(g_Device ,g_D3DXSprite ,&g_d3dpp);
	g_Curseur = new CCurseur(g_Device ,g_D3DXSprite ,&g_d3dpp);
	if( g_Cadre==NULL || g_Curseur==NULL )
	{
		MessageBox(g_hDlg,"Impossible d'initialiser le cadre ou le curseur !","Erreur fatale !",MB_ICONHAND);
		l_Abort = true;
	}
	//création du jeu
	g_CLM = new CLevelsManager(g_Device ,g_D3DXSprite ,&g_d3dpp, "Default.wbl");
	if( g_CLM->GetErrValue() > 0 )
	{
		MessageBox(g_hDlg,"Impossible d'initialiser le gestionnaire de niveau !","Erreur fatale !",MB_ICONHAND);
		l_Abort = true;
	}
	//création du menu
	g_CMM = new CMenuManager(g_Device ,g_D3DXSprite ,&g_d3dpp, "Default.wbs");
	if( g_CMM == NULL || g_CMM->GetErrValue() > 0 )
	{
		MessageBox(g_hDlg,"Impossible d'initialiser le gestionnaire de menu !","Erreur fatale !",MB_ICONHAND);
		l_Abort = true;
	}

	//Gestion des paramètres du registre
	g_COPPtr = g_CMM->GetPanelPtr();
	g_CReg->SetValueName( "ShowFPS" );
	if( g_COPPtr==NULL || g_CReg->rGetInt()==-1 )
	{
		MessageBox(g_hDlg,"Impossible d'initialiser un panel de contrôle !","Erreur fatale !",MB_ICONHAND);
		l_Abort  = true;
	}
	g_COPPtr->SetFps( g_CReg->rGetInt()?true:false );

	//-----Initialisation de DirectInput
	g_CIM = new CInputManager();
	if (g_CIM)
		if ( !g_CIM->Init(hInstance,g_Windowed) )
		{
			MessageBox(g_hDlg,"Impossible d'initialiser DInput !","Erreur fatale !",MB_ICONHAND);
			l_Abort = true;
		}

	//--------------------Si erreur il y a, quitter il faut alors...
	if( l_Abort )
	{
		g_CLogM->AddEvent("Une erreur s'est produite dans l'initialisation");
		FreeAll();
#ifndef _DEBUG
		CSplashScreen::Exit();
#endif
		return -1;
	}

	//------Dernières initialisations
	g_CLogM->AddEvent("Initialisation complète, lancement de la boucle de jeu");
	g_ListSize = g_CTM->GetSize();

#ifndef _DEBUG
	CSplashScreen::Exit();
#endif
    ShowWindow(g_hDlg, nCmdShow);
	SetForegroundWindow(g_hDlg);

	sprintf(g_ProgInfos,"- Waterball %.1f Built on %s at %s -",_version,_date,_time);

	g_CMuM->DSPlayNextMusic(true);
	
	//--------------------Boucle de jeu : c'est parti !!!!!!!!
	g_CallBoucle=true;
	while(g_CallBoucle && IsWindow(g_hDlg))
	{
//pour les erreurs non debug
#ifndef _DEBUG
		try{
#endif
			if( PeekMessage(&Msg, NULL, 0, 0, PM_NOREMOVE) )
			{
				if (Msg.message == WM_QUIT)
					g_CallBoucle=false;
				else
				{
	       			GetMessage(&Msg,NULL,0,0);
	       			//TranslateMessage(&Msg);
			   		//DispatchMessage(&Msg);
					WindowProcedure(g_hDlg,Msg.message,Msg.wParam,Msg.lParam);
				}
			}
			else
			{
				if( !Update() ) g_CallBoucle=false;
			}
//suite de "pour les erreurs non debug"
#ifndef _DEBUG
		}catch(...)
		{
			g_CLogM->AddEvent("Erreur dans la boucle de jeu");

			g_CallBoucle=false;
		}
#endif
	}
	g_CLogM->AddEvent("Boucle de jeu interrompue");

	//-----Suppressions finales
	FreeAll();
	DestroyWindow(g_hDlg);
	PostQuitMessage(0);
	UnregisterClass(szClassName,g_Instance);
    return Msg.wParam;					//on quitte proprement
}

Télécharger le zip

28 juillet 2004 10:27:35 :

Description plus précise du projet et de ses sources

26 août 2004 10:57:37 :

-------------Waterball------------- Changelog de la version 1.1 par rapport à la 1.0 AJOUT - Splash screen durant le chargement. AJOUT - Effet d'ondulation sur les images du menu. AJOUT - Informations sur l'executable dans la compilation AJOUT - Bonus Balle Multiple (nom officiel) (fonctionnement avec son et adaptation aux autres bonus). AJOUT - Gestion de trois musiques pour le jeu. FIX - Fondu pour une apparition moins brutale des crédits FIX - Meilleure gestion du volume. FIX - Boîte de dialogue de confirmation du changement des options à bon escient. FIX - Accélération du générique. FIX - Rectification des liens vers les dossiers PDF. FIX - Optimisation de certaines parties du code. FIX - Titre dans le menu "Crédit" comprennant à présent des informations sur l'executable. FIX - Bugs dans le titre de la section "Credits" FIX - On passe d'un rendu logiciel (D3DCREATE_SOFTWARE_VERTEXPROCESSING) à un rendu matériel (D3DCREATE_HARDWARE_VERTEXPROCESSING) => Qualité du rendu des vertex accrue (plus d'effet de confusion (ex: messagebox)) FIX - La méthode GetBackBuffer est correctement appelée : on a un pointeur valide sur le 1er backbuffer FIX - Les vagues sont adaptées pour les boutons petits : Petit Retour et Records. FIX - Conformation de l'indication score à la norme graphique. FIX - Bug de désactivation d'aimant et de balle folle. FIX - Réduction de la taille du skin matrix de 3 mo. FIX - Vérification complète de l'intégrité des fichiers ressources (images et +sons+). FIX - Bug de perte du device résolu à quasiment 100%

12 septembre 2004 20:57:20 :

Correction d'un sérieux bug ! On ne pouvait pas en avoir connaissance sous w2k (on développe dessous) car celui ci (et les windows de version supérieures) libére automatiquement toutes les ressources allouées pour le logiciel. Résultat, nous ne nous étions pas rendus comptes que lorsqu'on fermait WaterBall avec ALT+F4, RIEN N'ETAIT LIBERE.... donc assez embetant.

26 octobre 2004 17:06:29 :

Correction du bug qui empechait le jeu de se lancer et se produisait durant l'execution du splash screen