diff --git a/action.h b/action.h
new file mode 100644
index 0000000..4227fcf
--- /dev/null
+++ b/action.h
@@ -0,0 +1,16 @@
+
+
+extern
+BOOL Action(short action, short direct,
+            short &phase, short &step,
+            short &channel, short &icon, POINT &pos, short &posZ,
+            short &sound);
+
+extern
+BOOL Rotate (short &icon, short direct);
+
+extern
+int GetIconDirect(short icon);
+
+extern
+int GetAmplitude(short action);
diff --git a/blupi.cpp b/blupi.cpp
new file mode 100644
index 0000000..d65ca4a
--- /dev/null
+++ b/blupi.cpp
@@ -0,0 +1,155 @@
+// blupi.cpp
+//
+
+#define WIN32_LEAN_AND_MEAN
+
+#include <windows.h>
+#include <windowsx.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <mmsystem.h>
+#include "def.h"
+#include "resource.h"
+#include "ddutil.h"
+#include "pixmap.h"
+#include "sound.h"
+#include "decor.h"
+#include "movie.h"
+#include "button.h"
+#include "menu.h"
+#include "jauge.h"
+#include "event.h"
+#include "misc.h"
+
+// Define Globals
+
+#define NAME        "Blupi"
+#define TITLE       "Eggbert"
+
+
+// Variables Globals
+
+HWND		g_hWnd;					// handle � la fen�tre
+CEvent*		g_pEvent  = NULL;
+CPixmap*	g_pPixmap = NULL;		// pixmap principal
+CSound*		g_pSound  = NULL;		// sound principal
+CMovie*		g_pMovie  = NULL;		// movie principal
+CDecor*		g_pDecor  = NULL;
+char		g_CDPath[MAX_PATH];		// chemin d'acc�s au CD-Rom
+BOOL		g_bFullScreen = FALSE;	// FALSE si mode de test
+int			g_speedRate = 1;
+int			g_timerInterval = 50;	// inverval = 50ms
+int			g_mouseType = MOUSETYPEGRA;
+MMRESULT    g_updateTimer;			// timer g�n�ral
+BOOL		g_bActive = TRUE;		// is application active ?
+BOOL		g_bTermInit = FALSE;	// initialisation en cours
+
+UINT		g_lastPhase = 999;
+
+int GetNum(char *p)
+{
+    int     n = 0;
+
+    while ( *p >= '0' && *p <= '9' )
+    {
+        n *= 10;
+        n += (*p++)-'0';
+    }
+
+    return n;
+}
+
+BOOL ReadConfig (LPSTR lpCmdLine)
+{
+    FILE*       file    = NULL;
+    char        buffer[200];
+    char*       pText;
+    int         nb;
+
+    file = fopen("data\\config.def", "rb");
+    if ( file == NULL )   return FALSE;
+    nb = fread(buffer, sizeof(char), 200-1 file);
+    buffer[nb] = 0;
+    fclose(file);
+
+
+#if 0
+    pText = strstr(buffer, "CD-Rom=");
+    if ( pText == NULL )
+    {
+#if _DEMO 
+        GetCurrentDirectory(MAX_PATH, g_CDPath);
+        i = strlen (g_CDPath);
+        if ( i > 0 && g_CDPath [i-1] != '\\' )
+        {
+            g_CDPath[i++] = '\\';
+            g_CDPath[i] = 0;
+        }         
+#else
+        return FALSE;
+#endif
+	}
+	else
+	{
+		pText += 7;
+		i = 0;
+		while ( pText[i] != 0 && pText[i] != '\n' && pText[i] != '\r' )
+		{
+			g_CDPath[i] = pText[i];
+			i ++;
+		}
+		if ( i > 0 && g_CDPath[i-1] != '\\' )
+		{
+			g_CDPath[i++] = '\\';
+		}
+		g_CDPath[i] = 0;  // met le terminateur
+	}
+
+#if !_DEMO & !_EGAMES
+	if ( strstr(lpCmdLine, "-nocd") == NULL )
+	{
+		char		drive[10];
+
+		drive[0] = g_CDPath[0];
+		drive[1] = ':';
+		drive[2] = '\\';
+		drive[3] = 0;
+		nb = GetDriveType(drive);
+		if ( nb != DRIVE_CDROM )  return FALSE;
+	}
+#endif
+#endif
+
+	pText = strstr(buffer, "SpeedRate=");
+	if ( pText != NULL )
+	{
+		g_speedRate = GetNum(pText+10);
+		if ( g_speedRate < 1 )  g_speedRate = 1;
+		if ( g_speedRate > 2 )  g_speedRate = 2;
+	}
+
+	pText = strstr(buffer, "Timer=");
+	if ( pText != NULL )
+	{
+		g_timerInterval = GetNum(pText+6);
+		if ( g_timerInterval <   10 )  g_timerInterval =   10;
+		if ( g_timerInterval > 1000 )  g_timerInterval = 1000;
+	}
+
+	pText = strstr(buffer, "FullScreen=");
+	if ( pText != NULL )
+	{
+		g_bFullScreen = GetNum(pText+11);
+		if ( g_bFullScreen != 0 )  g_bFullScreen = 1;
+	}
+
+	pText = strstr(buffer, "MouseType=");
+	if ( pText != NULL )
+	{
+		g_mouseType = GetNum(pText+10);
+		if ( g_mouseType < 1 )  g_mouseType = 1;
+		if ( g_mouseType > 9 )  g_mouseType = 9;
+	}
+
+	return TRUE;
+}
\ No newline at end of file
diff --git a/button.cpp b/button.cpp
new file mode 100644
index 0000000..0e475e5
--- /dev/null
+++ b/button.cpp
@@ -0,0 +1,417 @@
+// Button.cpp
+//
+
+#include <windows.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <ddraw.h>
+#include "def.h"
+#include "pixmap.h"
+#include "sound.h"
+#include "decor.h"
+#include "button.h"
+#include "misc.h"
+
+
+
+//////////////////////////////////////////////////////////
+
+// Constructor
+
+CButton:CButton()
+{
+    m_type              = 0;
+    m_bEnable           = TRUE;
+    m_bHide             = FALSE;
+    m_state             = 0;
+    m_mouseState        = 0;
+    m_mbMenu            = 0;
+    m_nbToolTips        = 0;
+    m_selMenu           = 0;
+    m_bMouseDown        = FALSE;
+    m_bMinimizeRedraw   = FALSE;
+    m_bRedraw           = FALSE;
+}
+
+// Destructor
+
+CButton:~CButton()
+{
+}
+
+
+// Create a new Button
+
+BOOL CButton::Create(HWND hWnd, CPixmap *pPixmap, CSound *pSound,
+                     POINT pos, int type, BOOL bMinimizeRedraw,
+                     int *pMenu, int nbMenu,
+                     int *pToolTips, int nbToolTips,
+                     int region, UINT message)
+{
+    POINT iconDim;
+    int i, icon;
+
+    static int ttypes[] =
+    {
+        DIMBUTTONX,DIMBUTTONY,
+    };
+
+    if ( type < 0 || type > 0 ) return FALSE;
+
+    iconDim.x   = ttypes[type*2+0];
+    iconDim.y   = ttypes[type*2+1];
+
+    m_hWnd              = hWnd;
+    m_pPixmap           = pPixmap;
+    m_pSound            = pSound;
+    m_type              = type;
+	m_bMinimizeRedraw	= bMinimizeRedraw;
+	m_bEnable			= TRUE;
+	m_bHide				= FALSE;
+	m_message			= message;
+	m_pos				= pos;
+	m_dim				= iconDim;
+	m_nbMenu			= nbMenu;
+	m_nbToolTips		= nbToolTips;
+	m_selMenu			= 0;
+	m_state				= 0;
+	m_mouseState		= 0;
+	m_bMouseDown		= FALSE;
+	m_bRedraw			= TRUE;
+
+/* Do we need this yet?
+///////////////////////////////////////////////////
+	for ( i=0 ; i<nbMenu ; i++ )
+	{
+		icon = pMenu[i];
+
+		if ( region == 1 )  // palmiers ?
+		{
+			if ( icon ==  0 )  icon = 90;  // sol normal
+			if ( icon ==  1 )  icon = 91;  // sol inflammable
+			if ( icon ==  2 )  icon = 92;  // sol inculte
+			if ( icon ==  7 )  icon =  9;  // plante
+			if ( icon ==  8 )  icon = 10;  // arbre
+		}
+
+		if ( region == 2 )  // hiver ?
+		{
+			if ( icon ==  0 )  icon = 96;  // sol normal
+			if ( icon ==  1 )  icon = 97;  // sol inflammable
+			if ( icon ==  2 )  icon = 98;  // sol inculte
+			if ( icon ==  8 )  icon = 99;  // arbre
+		}
+
+		if ( region == 3 )  // sapin ?
+		{
+			if ( icon ==  0 )  icon = 102;  // sol normal
+			if ( icon ==  1 )  icon = 103;  // sol inflammable
+			if ( icon ==  2 )  icon = 104;  // sol inculte
+			if ( icon ==  8 )  icon = 105;  // arbre
+		}
+
+		m_iconMenu[i] = icon;
+	}
+
+	for ( i=0 ; i<nbToolTips ; i++ )
+	{
+		m_toolTips[i] = pToolTips[i];
+	}
+
+	return TRUE;
+/////////////////////////////////////////////////////
+*/
+}
+
+// Draw a button in its state
+
+void CButton::Draw()
+{
+	int			i;
+	POINT		pos;
+	RECT		rect;
+
+	if ( m_bMinimizeRedraw && !m_bRedraw ) return;
+	m_bRedraw = FALSE, m_bSomething = FALSE;
+
+	if ( m_bHide ) // Hidden button
+	{
+		pos.y 	   = m_pos.y;
+		pos.x	   = m_pos.x;
+		m_pPixmap->DrawPart(-1, CHBACK, m_pos, rect, 1); // Draw the background
+		return;
+	}
+
+	if( m_bEnable )
+	{
+		m_pPixmap->DrawIcon(-1, CHBUTTON+m_type, m_mousestatre, m_pos);
+	}
+	else
+	{
+		m_pPixmap->DrawIcon(-1, CHBUTTON+m_type, 4, m_pos);
+	}
+
+	if ( m_nbMenu == 0 ) return;
+
+	pos = m_pos;
+	if ( m_nbMenu > 0 )
+	{
+		m_pPixmap->DrawIcon(-1, CHBUTTON+m_type,
+							m_iconMenu[m_selMenu]+6, pos);
+	}
+
+	if ( m_nbMenu == 1 || !m_bEnable || !m_bMouseDown )	 return;
+
+	pos = m_pos;
+	pos.x += m_dim.x+2;
+	for ( i=0 ; i<m_nbMenu ; i++ )
+	{
+		m_pPixmap->DrawIcon(-1, CHBUTTON+m_type, i==m_selMenu?1:0, pos);
+		m_pPixmap->DrawIcon(-1, CHBUTTON+m_type, m_iconMenu[i]+6, pos);
+		pos.x += m_dim.x-1;
+	}
+}
+
+/*
+/Needed Yet?
+//////////////////////////////////////////////
+void CButton::Redraw()
+{
+	m_bRedraw = TRUE;
+}
+//////////////////////////////////////////////
+*/
+
+int CButton::GetState()
+{
+	return m_state;
+}
+
+void CButton::SetState(int state)
+{
+	if ( m_state	  != state ||
+		 m_mouseState != state )
+	{
+		m_bRedraw = TRUE;
+	}
+
+	m_state		 = state;
+	m_mouseState = state;
+}
+
+int CButton::GetMenu()
+{
+	return m_selMenu;
+}
+
+void CButton::SetMenu(int menu)
+{
+	if ( m_selMenu != menu )
+	{
+		m_bRedraw = TRUE;
+	}
+
+	m_selMenu = menu;
+}
+
+void CButton::SetEnable(BOOL bEnable)
+{
+	if ( m_bEnable != bEnable )
+	{
+		m_bRedraw = TRUE;
+	}
+
+	m_bEnable = bEnable;
+}
+
+
+/*
+// Needed Yet?
+/////////////////////////////////////////
+BOOL CButton::GetHide()
+{
+	return m_bHide;
+}
+/////////////////////////////////////////
+*/
+
+
+void CButton::SetHide(BOOL bHide)
+{
+	if ( m_bHide != bHide )
+	{
+		m_bRedraw = TRUE;
+	}
+
+	m_bHide = bHide;
+}
+
+BOOL CButton::TreatEvent(UINT message, WPARAM wParam, LPARAM lParam)
+{
+	POINT		pos;
+
+	if ( m_bHide || !m_bEnable ) return FALSE;
+
+	pos = ConvLongToPos(lParam);
+
+	switch( message )
+	{
+		case WM_LBUTTONDOWN:
+		case WM_RBUTTONDOWN;
+			if ( MouseDown(pos) )  return TRUE;
+			break;
+
+		case WM_MOUSEMOVE:
+			if ( MouseMove(pos) )  return TRUE;
+			break;
+		
+		case WM_LBUTTONUP:
+		case WM_RBUTTONUP:
+	    	if ( MouseUp(pos) )	  return FALSE;
+			break;
+	}
+
+	return FALSE;
+}
+
+// All buttons must receive the BUTTONUP event!
+
+// Indicates whether the mouse is over this button.
+
+BOOL CButton::MouseOnButton(POINT pos)
+{
+	return Detect(pos);
+}
+
+// Return the tooltips for a button, depending
+// on mouse position.
+
+int CButton::GetToolTips(POINT pos)
+{
+	int		 width = m_dim.x;
+	int		 rank;
+
+	if ( m_bHide || !m_bEnable ) return -1;
+
+	if ( m_nbMenu > 1 && m_bMouseDown ) // Drop-down submenu?
+	{
+		width += 2+(m_dim.x-1)*m_nbMenu;
+	}
+
+	if ( pos.x < m_pos.x		 ||
+	     pos.x > m_pos.x+width 	 ||
+		 pos.y < m_pos.y 		 ||
+		 pos.y > m_pos.y+m_dim.y )  return -1;
+    
+	rank = (pos.x=-(m_pos.x+2+1))/(m_dim.x-1);
+	if ( rank < 0 )	  rank = 0;
+	if ( rank > m_nbToolTips )  return -1;
+
+	if ( m_nbMenu > 1 )
+	{
+		if ( m_MouseDown && rank > 0 )
+		{
+			rank --;
+		}
+		else
+		{
+			rank = m_selMenu;
+		}
+	}
+
+	return m_toolTips[rank];
+}
+
+BOOL CButton::Detect(POINT pos)
+{
+	int		 width = m_dim.x;
+
+	if ( m_bHide || !m_bEnable ) 	return FALSE;
+
+	if ( m_nbMenu > 1 && m_bMouseDown )
+	{
+		width += 2+(m_dim.x-1)*m_nbMenu;
+	}
+
+	if ( pos.x < m_pos.x 		 ||
+		 pos.x > m_pos.x+width 	 ||
+		 pos.y < m_pos.y 		 ||
+		 pos.y > m_pos.y+m_dim.y )  return FALSE;
+	
+	return TRUE;
+}
+
+BOOL CButton::MouseDown(POINT pos)
+{
+	if ( !Detect(pos) )  return FALSE;
+
+	m_mouseState = 1;
+	m_bMouseDown = TRUE;
+	m_bRedraw	 = TRUE;
+	PostMessage(m_hWnd, WM_UPDATE, 0, 0);
+
+	m_pSound->PlayImage(SOUND_CLICK, pos);
+	return TRUE;
+}
+
+BOOL CButton::MouseMove(POINT pos)
+{
+	BOOL 	  bDetect;
+	int 	  iState, iMenu;
+
+	iState = m_mouseState;
+	iMenu  = m_selMenu;
+
+	bDetect = Detect(pos);
+
+	if ( m_bMouseDown )
+	{
+		if ( bDetect ) m_mouseState = 1;
+		else 		   m_mouseState = m_state;
+	}
+	else
+	{
+		if ( bDetect ) m_mouseState = m_state+2;
+		else		   m_mouseState = m_state;
+	}
+
+	if ( m_nbMenu > 1 &&
+		 m_bMouseDown &&
+		 pos.x > m_pos.x+m_dim.x+2 )
+	{
+		m_selMenu = (pos.x-(m_pos.x+m_dim.x+2))/(m_dim.x-1);
+		if ( m_selMenu >= m_nbMenu )
+		{
+			m_selMenu = m_nbMenu-1;
+		}
+	}
+
+	if ( iState != m_mouseState  ||
+		 iMenu  != m_selMenu 	 )
+	{
+		m_bRedraw = TRUE;
+		PostMessage(m_hWnd, WM_UPDATE, 0, 0);
+	}
+
+	return m_bMouseDown;
+}
+
+BOOL CButton::MouseUp(POINT pos)
+{
+	BOOL 	bDetect;
+
+	bDetect = Detect(pos);
+
+	m_mouseState = m_state;
+	m_bMouseDown = FALSE;
+	m_bRedraw 	 = TRUE;
+
+	if ( !bDetect )  return FALSE;
+
+	if ( m_message != -1 )
+	{
+		PostMessage(m_hWnd, m_message, 0, 0);
+	}
+
+	return TRUE;
+}
\ No newline at end of file
diff --git a/button.h b/button.h
new file mode 100644
index 0000000..b994e8e
--- /dev/null
+++ b/button.h
@@ -0,0 +1,61 @@
+
+
+class CButton
+{
+public:
+	CButton();
+	~CButton();
+
+	BOOL	Create(HWND hWnd, CPixmap *pPixmap, CSound *pSound,
+				   POINT pos, int type, BOOL bMinimizeRedraw,
+				   int *pMenu, int nbMenu,
+				   int *pTooltips, int nbToolTips,
+				   int region, UINT message);
+	void	Draw();
+	void	Redraw();
+
+	int		GetState();
+	void	SetState(int state);
+
+	int		GetMenu();
+	void	SetMenu(int menu);
+
+	BOOL	GetEnable();
+	void	SetEnable(BOOL bEnable);
+
+	BOOL	GetHide();
+	void	SetHide(BOOL bHide);
+
+	BOOL	TreatEvent(UINT message, WPARAM wParam, LPARAM lParam);
+	BOOL	MouseOnButton(POINT pos);
+	int		GetToolTips(POINT pos);
+
+	
+protected:
+	BOOL	Detect(POINT pos);
+	BOOL	MouseDown(POINT pos);
+	BOOL	MouseMove(POINT pos);
+	BOOL	MouseUp(POINT pos);
+
+protected:
+	HWND		m_hWnd;
+	CPixmap*	m_pPixmap;
+	CDecor*		m_pDecor;
+	CSound*		m_pSound;
+	int			m_type;			// type de bouton
+	BOOL		m_bEnable;		// TRUE si bouton actif
+	BOOL		m_bHide;		// TRUE si bouton cach�
+	UINT		m_message;		// message envoy� si bouton actionn�
+	POINT		m_pos;			// coin sup/gauche
+	POINT		m_dim;			// dimensions
+	int			m_state;		// 0=rel�ch�, 1=press�, +2=survoll�
+	int			m_mouseState;	// 0=rel�ch�, 1=press�, +2=survoll�
+	int			m_iconMenu[20];	// ic�nes du sous-menu
+	int			m_toolTips[20];	// info-bulles
+	int			m_nbMenu;		// nb de case du sous-menu
+	int			m_nbToolTips;	// nb d'info-bulles
+	int			m_selMenu;		// sous-menu s�lectionn�
+	BOOL		m_bMouseDown;	// TRUE -> bouton souris press�
+	BOOL		m_bMinimizeRedraw;
+	BOOL		m_bRedraw;		// TRUE -> doit �tre redessin�
+};
\ No newline at end of file
diff --git a/ddutil.cpp b/ddutil.cpp
new file mode 100644
index 0000000..7a35b2d
--- /dev/null
+++ b/ddutil.cpp
@@ -0,0 +1,415 @@
+/*==========================================================================
+ *
+ *  Copyright (C) 1995-1996 Microsoft Corporation. All Rights Reserved.
+ *
+ *  File:       ddutil.cpp
+ *  Content:    Routines for loading bitmap and palettes from resources
+ *
+ ***************************************************************************/
+#undef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#include <windowsx.h>
+#include <ddraw.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include "ddutil.h"
+#include "misc.h"
+
+
+// Le message :
+// First-chance exception in Blupi.exe (GDI32.DLL): 0xC0000005: Access Violation.
+// appara�t au endroits marqu�s par (@) ...
+
+BOOL g_bDebug = TRUE;
+
+void DDSetDebug(BOOL bDebug)
+{
+	g_bDebug = bDebug;
+}
+
+/*
+ *  DDConnectBitmap
+ *
+ *  create a DirectDrawSurface from a bitmap resource.
+ *
+ */
+extern "C" IDirectDrawSurface * DDConnectBitmap(IDirectDraw *pdd, HBITMAP hbm)
+{
+    BITMAP              bm;
+    DDSURFACEDESC       ddsd;
+    IDirectDrawSurface *pdds;
+	HRESULT				ddrval;
+
+    //
+    // get size of the bitmap
+    //
+    GetObject(hbm, sizeof(bm), &bm);      // get size of bitmap
+
+    //
+    // 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.ddsCaps.dwCaps = DDSCAPS_SYSTEMMEMORY;
+    ddsd.dwWidth        = bm.bmWidth;
+    ddsd.dwHeight       = bm.bmHeight;
+ 
+    ddrval = pdd->CreateSurface(&ddsd, &pdds, NULL);
+	if ( ddrval != DD_OK )
+	{
+		TraceErrorDD(ddrval, "", 0);
+		return NULL;
+	}
+
+    DDCopyBitmap(pdds, hbm, 0, 0, bm.bmWidth, bm.bmHeight);
+
+    return pdds;
+}
+
+/*
+ *  DDLoadBitmap
+ *
+ *  create a DirectDrawSurface from a bitmap resource.
+ *
+ */
+extern "C" IDirectDrawSurface * DDLoadBitmap(IDirectDraw *pdd, LPCSTR szBitmap, int dx, int dy)
+{
+    HBITMAP             hbm;
+    BITMAP              bm;
+    DDSURFACEDESC       ddsd;
+    IDirectDrawSurface *pdds;
+	HRESULT				ddrval;
+
+	if ( g_bDebug )  OutputDebug("DDLoadBitmap\n");
+    //
+    //  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 ( g_bDebug )  OutputDebug("DDLoadBitmap\n");
+    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
+    //
+	if ( g_bDebug )  OutputDebug("DDLoadBitmap: GetObject\n");
+    GetObject(hbm, sizeof(bm), &bm);      // get size of bitmap
+
+    //
+    // 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.ddsCaps.dwCaps = DDSCAPS_SYSTEMMEMORY;
+    ddsd.dwWidth        = bm.bmWidth;
+    ddsd.dwHeight       = bm.bmHeight;
+ 
+	if ( g_bDebug )  OutputDebug("DDLoadBitmap: CreateSurface\n");
+    ddrval = pdd->CreateSurface(&ddsd, &pdds, NULL);
+	if ( ddrval != DD_OK )
+	{
+		TraceErrorDD(ddrval, "", 0);
+		return NULL;
+	}
+
+    DDCopyBitmap(pdds, hbm, 0, 0, 0, 0);
+	if ( g_bDebug )  OutputDebug("DDLoadBitmap: DeleteObject\n");
+    DeleteObject(hbm);  // (@)
+
+	if ( g_bDebug )  OutputDebug("DDLoadBitmap: return\n");
+    return pdds;
+}
+
+/*
+ *  DDReLoadBitmap
+ *
+ *  load a bitmap from a file or resource into a directdraw surface.
+ *  normaly used to re-load a surface after a restore.
+ *
+ */
+HRESULT DDReLoadBitmap(IDirectDrawSurface *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)
+    {
+        if ( g_bDebug )  OutputDebug("handle is null\n");
+        return E_FAIL;
+    }
+
+    hr = DDCopyBitmap(pdds, hbm, 0, 0, 0, 0);
+    if (hr != DD_OK)
+    {
+        if ( g_bDebug )  OutputDebug("ddcopybitmap failed\n");
+    }
+
+
+    DeleteObject(hbm);
+    return hr;
+}
+
+/*
+ *  DDCopyBitmap
+ *
+ *  draw a bitmap into a DirectDrawSurface
+ *
+ */
+extern "C" HRESULT DDCopyBitmap(IDirectDrawSurface *pdds, HBITMAP hbm, int x, int y, int dx, int dy)
+{
+    HDC                 hdcImage;
+    HDC                 hdc;
+    BITMAP              bm;
+    DDSURFACEDESC       ddsd;
+    HRESULT             hr;
+
+	if ( g_bDebug )  OutputDebug("DDCopyBitmap\n");
+    if (hbm == NULL || pdds == NULL)
+        return E_FAIL;
+
+    //
+    // make sure this surface is restored.
+    //
+	if ( g_bDebug )  OutputDebug("DDCopyBitmap: Restore\n");
+    pdds->Restore();
+
+    //
+    //  select bitmap into a memoryDC so we can use it.
+    //
+	if ( g_bDebug )  OutputDebug("DDCopyBitmap: CreateCompatibleDC\n");
+    hdcImage = CreateCompatibleDC(NULL);
+    if (!hdcImage)
+        OutputDebug("createcompatible dc failed\n");
+	if ( g_bDebug )  OutputDebug("DDCopyBitmap: SelectObject\n");
+    SelectObject(hdcImage, hbm);
+
+    //
+    // get size of the bitmap
+    //
+	if ( g_bDebug )  OutputDebug("DDCopyBitmap: GetObject\n");
+    GetObject(hbm, sizeof(bm), &bm);    // get size of bitmap
+    dx = dx == 0 ? bm.bmWidth  : dx;    // use the passed size, unless zero
+    dy = dy == 0 ? bm.bmHeight : dy;
+
+    //
+    // get size of surface.
+    //
+	if ( g_bDebug )  OutputDebug("DDCopyBitmap: GetSurfaceDesc\n");
+    ddsd.dwSize = sizeof(ddsd);
+    ddsd.dwFlags = DDSD_HEIGHT | DDSD_WIDTH;
+    pdds->GetSurfaceDesc(&ddsd);
+
+	if ( g_bDebug )  OutputDebug("DDCopyBitmap: StretchBlt\n");
+    if ((hr = pdds->GetDC(&hdc)) == DD_OK)
+    {
+		if ( g_bDebug )  OutputDebug("DDCopyBitmap: StretchBlt-go\n");
+        StretchBlt(hdc, 0, 0, ddsd.dwWidth, ddsd.dwHeight, hdcImage, x, y, dx, dy, SRCCOPY);
+		if ( g_bDebug )  OutputDebug("DDCopyBitmap: ReleaseDC\n");
+        pdds->ReleaseDC(hdc);  // (@)
+    }
+
+	if ( g_bDebug )  OutputDebug("DDCopyBitmap: DeleteDC\n");
+    DeleteDC(hdcImage);
+
+    return hr;
+}
+
+//
+//  DDLoadPalette
+//
+//  Create a DirectDraw palette object from a bitmap resoure
+//
+//  if the resource does not exist or NULL is passed create a
+//  default 332 palette.
+//
+extern "C" IDirectDrawPalette * DDLoadPalette(IDirectDraw *pdd, LPCSTR szBitmap)
+{
+    IDirectDrawPalette* ddpal;
+    int                 i;
+    int                 n;
+    int                 fh;
+    HRSRC               h;
+    LPBITMAPINFOHEADER  lpbi;
+    PALETTEENTRY        ape[256];
+    RGBQUAD *           prgb;
+
+    //
+    // build a 332 palette as the default.
+    //
+    for (i=0; i<256; i++)
+    {
+        ape[i].peRed   = (BYTE)(((i >> 5) & 0x07) * 255 / 7);
+        ape[i].peGreen = (BYTE)(((i >> 2) & 0x07) * 255 / 7);
+        ape[i].peBlue  = (BYTE)(((i >> 0) & 0x03) * 255 / 3);
+        ape[i].peFlags = (BYTE)0;
+    }
+
+    //
+    // get a pointer to the bitmap resource.
+    //
+    if (szBitmap && (h = FindResource(NULL, szBitmap, RT_BITMAP)))
+    {
+		if ( g_bDebug )  OutputDebug("DDLoadPalette -a\n");
+        lpbi = (LPBITMAPINFOHEADER)LockResource(LoadResource(NULL, h));
+        if (!lpbi)
+            OutputDebug("lock resource failed\n");
+        prgb = (RGBQUAD*)((BYTE*)lpbi + lpbi->biSize);
+
+        if (lpbi == NULL || lpbi->biSize < sizeof(BITMAPINFOHEADER))
+            n = 0;
+        else if (lpbi->biBitCount > 8)
+            n = 0;
+        else if (lpbi->biClrUsed == 0)
+            n = 1 << lpbi->biBitCount;
+        else
+            n = lpbi->biClrUsed;
+
+        //
+        //  a DIB color table has its colors stored BGR not RGB
+        //  so flip them around.
+        //
+        for(i=0; i<n; i++ )
+        {
+            ape[i].peRed   = prgb[i].rgbRed;
+            ape[i].peGreen = prgb[i].rgbGreen;
+            ape[i].peBlue  = prgb[i].rgbBlue;
+            ape[i].peFlags = 0;
+        }
+    }
+    else if (szBitmap && (fh = _lopen(szBitmap, OF_READ)) != -1)
+    {
+		if ( g_bDebug )  OutputDebug("DDLoadPalette -b\n");
+        BITMAPFILEHEADER bf;
+        BITMAPINFOHEADER bi;
+
+        _lread(fh, &bf, sizeof(bf));
+        _lread(fh, &bi, sizeof(bi));
+        _lread(fh, ape, sizeof(ape));
+        _lclose(fh);
+
+        if (bi.biSize != sizeof(BITMAPINFOHEADER))
+            n = 0;
+        else if (bi.biBitCount > 8)
+            n = 0;
+        else if (bi.biClrUsed == 0)
+            n = 1 << bi.biBitCount;
+        else
+            n = bi.biClrUsed;
+
+        //
+        //  a DIB color table has its colors stored BGR not RGB
+        //  so flip them around.
+        //
+		//?
+		char s[50];
+		sprintf(s, "DDLoadPalette n=%d\n", n);
+		if ( g_bDebug )  OutputDebug(s);
+		//?
+        for(i=0; i<n; i++ )
+        {
+            BYTE r = ape[i].peRed;
+            ape[i].peRed  = ape[i].peBlue;
+            ape[i].peBlue = r;
+        }
+    }
+
+    pdd->CreatePalette(DDPCAPS_8BIT, ape, &ddpal, NULL);
+
+    return ddpal;
+}
+
+/*
+ * DDColorMatch
+ *
+ * convert a RGB color to a pysical color.
+ *
+ * we do this by leting GDI SetPixel() do the color matching
+ * then we lock the memory and see what it got mapped to.
+ */
+extern "C" DWORD DDColorMatch(IDirectDrawSurface *pdds, COLORREF rgb)
+{
+    COLORREF rgbT;
+    HDC hdc;
+    DWORD dw = CLR_INVALID;
+    DDSURFACEDESC ddsd;
+    HRESULT hres;
+
+    //
+    //  use GDI SetPixel to color match for us
+    //
+    if (rgb != CLR_INVALID && pdds->GetDC(&hdc) == DD_OK)
+    {
+        rgbT = GetPixel(hdc, 0, 0);             // save current pixel value
+        SetPixel(hdc, 0, 0, rgb);               // set our value
+        pdds->ReleaseDC(hdc);
+    }
+
+    //
+    // now lock the surface so we can read back the converted color
+    //
+    ddsd.dwSize = sizeof(ddsd);
+    while ((hres = pdds->Lock(NULL, &ddsd, 0, NULL)) == DDERR_WASSTILLDRAWING)
+        ;
+
+    if (hres == DD_OK)
+    {
+        dw  = *(DWORD *)ddsd.lpSurface;                     // get DWORD
+        dw &= (1 << ddsd.ddpfPixelFormat.dwRGBBitCount)-1;  // mask it to bpp
+        pdds->Unlock(NULL);
+    }
+
+    //
+    //  now put the color that was there back.
+    //
+    if (rgb != CLR_INVALID && pdds->GetDC(&hdc) == DD_OK)
+    {
+        SetPixel(hdc, 0, 0, rgbT);
+        pdds->ReleaseDC(hdc);
+    }
+
+    return dw;
+}
+
+/*
+ * DDSetColorKey
+ *
+ * set a color key for a surface, given a RGB.
+ * if you pass CLR_INVALID as the color key, the pixel
+ * in the upper-left corner will be used.
+ */
+extern "C" HRESULT DDSetColorKey(IDirectDrawSurface *pdds, COLORREF rgb)
+{
+    DDCOLORKEY          ddck;
+
+    ddck.dwColorSpaceLowValue  = DDColorMatch(pdds, rgb);
+    ddck.dwColorSpaceHighValue = ddck.dwColorSpaceLowValue;
+    return pdds->SetColorKey(DDCKEY_SRCBLT, &ddck);
+}
+
+extern "C" HRESULT DDSetColorKey2(IDirectDrawSurface *pdds, COLORREF rgb1,
+															COLORREF rgb2)
+{
+    DDCOLORKEY          ddck;
+
+    ddck.dwColorSpaceLowValue  = DDColorMatch(pdds, rgb1);
+    ddck.dwColorSpaceHighValue = DDColorMatch(pdds, rgb2);
+    return pdds->SetColorKey(DDCKEY_SRCBLT, &ddck);
+}
diff --git a/ddutil.h b/ddutil.h
new file mode 100644
index 0000000..8254ebf
--- /dev/null
+++ b/ddutil.h
@@ -0,0 +1,23 @@
+
+
+
+
+
+
+#ifdef _cplusplus
+extern "C" {
+#endif
+
+extern void DDSetDebug (BOOL bDebug);
+extern IDirectDrawSurface * DDConnectBitmap(IDirectDraw *pdd, HBITMAP hbm);
+extern IDirectDrawPalette * DDLoadPalette(IDirectDraw *pdd, LPCSTR szBitmap);
+extern IDirectDrawSurface * DDLoadBitmap(IDirectDraw *pdd, LPCSTR szBitmap, int dx, int dy);
+extern HRESULT              DDReLoadBitmap(IDirectDrawSurface *pdds, LPCSTR szBitmap);
+extern HRESULT              DDCopyBitmap(IDirectDrawSurface *pdds, HBITMAP hbm, int x, int y, int dx, int dy);
+extern DWORD                DDColorMatch(IDirectDrawSurface *pdds, COLORREF rgb);
+extern HRESULT              DDSetColorKey(IDirectDrawSurface *pdds, COLORREF rgb);
+extern HRESULT              DDSetColorKey2(IDirectDrawSurface *pdds, COLORREF rgb1, COLORREF rgb2);
+
+#ifdef __cplusplus
+}
+#endif  /* __cplusplus */
diff --git a/decor.cpp b/decor.cpp
new file mode 100644
index 0000000..a7ef3ea
--- /dev/null
+++ b/decor.cpp
@@ -0,0 +1,59 @@
+// CDecor.cpp
+//
+
+#include <windows.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <ddraw.h>
+#include "def.h"
+#include "resource.h"
+#include "pixmap.h"
+#include "sound.h"
+#include "decor.h"
+#include "action.h"
+#include "text.h"
+#include "misc.h"
+#include "fifo.h"
+#include "DECMOVE.h"
+
+
+////////////////////////////////////////////////////////////////////////////////
+
+
+
+#define TEXTDELAY       10
+
+// Constructor
+// Possibly incomplete
+
+CDecor::CDecor()
+{
+    m_hWnd   = NULL;
+    m_pSound = NULL;
+    m_pPixmap = NULL;
+
+    m_time = 0;
+    m_bAllMissions = FALSE;
+    m_bInvincible  = FALSE;
+    m_bShowSecret  = FALSE;
+    m_bAccessBuild = FALSE;
+    m_bNetPacked   = FALSE;
+    m_bNetMovePredict = TRUE;
+    m_bNetDebug = FALSE;
+    m_bMulti       = FALSE;
+    m_team = FALSE;
+    m_netPacketsSent = 0;
+    m_netPacketsSent2 = 0;
+    m_netPacketsRecieved = 0;
+    m_netPacketsRecieved2 = 0;
+
+    Init(CHFLOOR, 0);
+    BlupiFlush();
+    MoveFlush();
+    InitDrapeau();
+}
+
+CDecor::~CDecor()
+{
+    UndoClose();
+}
\ No newline at end of file
diff --git a/event.h b/event.h
new file mode 100644
index 0000000..8e7c421
--- /dev/null
+++ b/event.h
@@ -0,0 +1,220 @@
+// Event.h
+
+
+
+/////////////////////////////////////////////////////////////////////////////
+
+typedef struct
+{
+	UINT	message;
+	int		type;
+	int		iconMenu[20];
+	int		x, y;
+	int		toolTips[20];
+}
+Button;
+
+typedef struct
+{
+	UINT	phase;
+	char	backName[20];
+	BOOL	bCDrom;
+	Button	buttons[MAXBUTTON];
+}
+Phase;
+
+
+typedef struct
+{
+	short	majRev;
+	short	minRev;
+	short	bSchool;
+	short	bPrivate;
+	short	world;
+	short	skill;
+	short	reserve1[99];
+}
+DemoHeader;
+
+typedef struct
+{
+	int		time;
+	UINT	message;
+	WPARAM	wParam;
+	LPARAM	lParam;
+}
+DemoEvent;
+
+
+class CEvent
+{
+public:
+	CEvent();
+	~CEvent();
+
+	POINT	GetMousePos();
+	void	Create(HWND hWnd, CPixmap *pPixmap, CDecor *pDecor, CSound *pSound, CMovie *pMovie);
+	void	SetFullScreen(BOOL bFullScreen);
+	void	SetMouseType(int mouseType);
+	int		GetWorld();
+	int		GetPhysicalWorld();
+	int		GetImageWorld();
+	BOOL	IsHelpHide();
+	BOOL	ChangePhase(UINT phase);
+	void	MovieToStart();
+	UINT	GetPhase();
+	void	TryInsert();
+	void	RestoreGame();
+
+	int		GetButtonIndex(int button);
+	int		GetState(int button);
+	void	SetState(int button, int state);
+	BOOL	GetEnable(int button);
+	void	SetEnable(int button, BOOL bEnable);
+	BOOL	GetHide(int button);
+	void	SetHide(int button, BOOL bHide);
+	int		GetMenu(int button);
+	void	SetMenu(int button, int menu);
+
+	BOOL	DrawButtons();
+	int		MousePosToSprite(POINT pos);
+	void	MouseSprite(POINT pos);
+	void	WaitMouse(BOOL bWait);
+	void	HideMouse(BOOL bHide);
+	POINT	GetLastMousePos();
+	BOOL	TreatEvent(UINT message, WPARAM wParam, LPARAM lParam);
+	BOOL	TreatEventBase(UINT message, WPARAM wParam, LPARAM lParam);
+
+	void	DecorAutoShift(POINT pos);
+	
+	BOOL	StartMovie(char *pFilename);
+	void	StopMovie();
+	BOOL	IsMovie();
+
+	BOOL	FlipObject();
+
+	void	Read(int message);
+	void	Write(int message);
+
+	void	SetSpeed(int speed);
+	int		GetSpeed();
+	BOOL	GetPause();
+	BOOL	IsShift();
+
+	void	DemoStep();
+	void	DebugDisplay(char m);
+
+	void	IntroStep();
+
+protected:
+	void	DrawTextCenter(int res, int x, int y, int font=0);
+	BOOL	CreateButtons();
+	BOOL	EventButtons(UINT message, WPARAM wParam, LPARAM lParam);
+	BOOL	MouseOnButton(POINT pos);
+	int		SearchPhase(UINT phase);
+	void	DecorShift(int dx, int dy);
+
+	BOOL	PlayDown(POINT pos, int fwKeys);
+	BOOL	PlayMove(POINT pos, int fwKeys);
+	BOOL	PlayUp(POINT pos, int fwKeys);
+	void	ChangeButtons(int message);
+
+	void	BuildFloor(POINT cel, int insIcon);
+	void	BuildWater(POINT cel, int insIcon);
+	BOOL	BuildDown(POINT pos, int fwKeys, BOOL bMix=TRUE);
+	BOOL	BuildMove(POINT pos, int fwKeys);
+	BOOL	BuildUp(POINT pos, int fwKeys);
+
+	void	PrivateLibelle();
+	BOOL	ReadLibelle(int world, BOOL bSchool, BOOL bHelp);
+	BOOL	WriteInfo();
+	BOOL	ReadInfo();
+
+	void	DemoRecStart();
+	void	DemoRecStop();
+	BOOL	DemoPlayStart();
+	void	DemoPlayStop();
+	void	DemoRecEvent(UINT message, WPARAM wParam, LPARAM lParam);
+
+protected:
+    int         m_speed;
+    int         m_exercice;
+    int         m_mission;
+    int         m_private;
+    int         m_maxMission;
+    int         m_phase;
+    int         m_index;
+    BOOL        m_bSchool;
+    BOOL        m_bPrivate;
+    BOOL        m_bAccesBuild;
+    BOOL        m_bFullScreen;
+    int         m_mouseType;
+    HWND        m_hWnd;
+    CPixmap*    m_pPixmap;
+    CDecor*     m_pDecor;
+    CSound*     m_pSound;
+    CMovie*		m_pMovie;
+	char		m_movieToStart[MAX_PATH];
+	int			m_phaseAfterMovie;
+	CButton		m_buttons[MAXBUTTON];
+	int			m_lastFloor[MAXBUTTON];
+	int			m_lastObject[MAXBUTTON];
+	int			m_lastHome[MAXBUTTON];
+	BOOL		m_bRunMovie;
+	BOOL		m_bBuildModify;
+	CJauge		m_jauges[2];
+	CMenu		m_menu;
+	BOOL		m_bMenu;
+	POINT		m_menuPos;
+	int			m_menuNb;
+	int			m_menuButtons[MAXBUTTON];
+	int			m_menuErrors[MAXBUTTON];
+	int			m_menuPerso;
+	POINT		m_menuCel;
+	POINT		m_oldMousePos;
+	BOOL		m_bMousePress;
+	BOOL		m_bMouseDown;
+	BOOL		m_bHili;
+	int			m_fileWorld[10];
+	int			m_fileTime[10];
+	POINT		m_posToolTips;
+	char		m_textToolTips[50];
+	int			m_mouseSprite;
+	BOOL		m_bFillMouse;
+	BOOL		m_bWaitMouse;
+	BOOL		m_bHideMouse;
+	BOOL		m_bShowMouse;
+	int			m_rankCheat;
+	int			m_posCheat;
+	BOOL		m_bMovie;
+	BOOL		m_bSpeed;
+	BOOL		m_bHelp;
+	BOOL		m_bAllMissions;
+	BOOL		m_bChangeCheat;
+	int			m_scrollSpeed;
+	BOOL		m_bPause;
+	BOOL		m_bShift;
+	int			m_shiftPhase;
+	POINT		m_shiftVector;
+	POINT		m_shiftOffset;
+	char		m_libelle[1000];
+    char        m_filenameBuffer[100][256];
+	int			m_tryPhase;
+	int			m_tryInsertCount;
+	POINT		m_posInfoButton;
+	POINT		m_posHelpButton;
+	BOOL		m_bHiliInfoButton;
+	BOOL		m_bHiliHelpButton;
+	BOOL		m_bInfoHelp;
+	BOOL		m_bDemoRec;
+	BOOL		m_bDemoPlay;
+	DemoEvent*	m_pDemoBuffer;
+	int			m_demoTime;
+    int         m_input;
+	int			m_demoIndex;
+	int			m_demoEnd;
+	int			m_demoNumber;
+	BOOL		m_bCtrlDown;
+	POINT		m_debugPos;
+	int			m_introTime;
+};
\ No newline at end of file
diff --git a/fifo.h b/fifo.h
new file mode 100644
index 0000000..a74371b
--- /dev/null
+++ b/fifo.h
@@ -0,0 +1,33 @@
+
+#pragma once
+
+
+
+
+
+
+typedef struct
+{
+    long       pos;
+    long       dist;
+}
+Element;
+
+
+
+
+class CPileTriee
+{
+private:
+    long        m_taille;
+    long        m_max;
+    long        m_out;
+    Element*    m_data;
+
+public:
+    CPileTriee(long taille);
+    ~CPileLTriee();
+
+    void        put(long pos, long dist);
+    long        get();
+};
\ No newline at end of file
diff --git a/jauge.h b/jauge.h
new file mode 100644
index 0000000..d77ac8d
--- /dev/null
+++ b/jauge.h
@@ -0,0 +1,41 @@
+// Jauge.h
+
+
+
+//////////////////////////////////////////////////////////////////////////
+
+class CJauge
+{
+public:
+    CJauge();
+    ~CJauge();
+
+    BOOL    Create(HWND hWnd, CPixmap *pPixmap, CSound *pSound,
+                   POINT pos, int type, BOOL bMinimizeRedraw);
+    void    Draw();
+    void    Redraw();
+
+    void    SetLevel(int level);
+    void    SetType(int type);
+
+    BOOL    GetHide();
+    void    SetHide(BOOL bHide);
+
+    POINT   GetPos();
+    void    SetRedraw();
+
+protected:
+    HWND        m_hWnd;
+    CPixmap*    m_pPixmap;
+    CDecor*     m_pDecor;
+    CSound*     m_pSound;
+    BOOL        m_bHide;
+    POINT       m_pos;
+    POINT       m_dim;
+    int         m_type;
+    int         m_level;
+    BOOL        m_bMinimizeRedraw;
+    BOOL        m_bRedraw;
+};
+
+/////////////////////////////////////////////////////////////////////////
\ No newline at end of file
diff --git a/menu.h b/menu.h
new file mode 100644
index 0000000..9008f80
--- /dev/null
+++ b/menu.h
@@ -0,0 +1,48 @@
+// Menu.h
+
+
+
+//////////////////////////////////////////////////////////////////////
+
+class CMenu
+{
+public:
+    CMenu();
+    ~CMenu();
+
+    BOOL    Create(HWND hWnd, CPixmap *pPixmap, CSound *pSound,
+                   POINT pos, int nbm, int *pButtons, int *pErrors,
+                   int perso);
+    void    Update(int nb, int *pButtons, int *pErrors);
+    void    Delete();
+    void    Draw();
+    int     GetSel();
+    int     GetRank();
+    BOOL    IsError();
+    BOOL    IsExist();
+    void    Message();
+
+    BOOL    TreatEvent(UINT message, WPARAM wParam, LPARAM lPararm);
+
+protected:
+    int     Detect(POINT pos);
+    BOOL    MouseDown(POINT pos);
+    BOOL    MouseMove(POINT pos);
+    BOOL    MouseUp(POINT pos);
+
+protected:
+    HWND         m_hWnd;
+    CPixmap*     m_pPixmap;
+    CDecor*      m_pDecor;
+    CSound*      m_pSound;
+    POINT        m_pos;
+    POINT        m_dim;
+    int          m_nbButtons;
+    POINT        m_nbCel;
+    int          m_perso;
+    int          m_buttons[MAXBUTTON];
+    int          m_errors[MAXBUTTON];
+    UINT         m_messages[MAXBUTTON];
+    int          m_selRank;
+    POINT        m_mousePos;
+};
\ No newline at end of file
diff --git a/misc.h b/misc.h
new file mode 100644
index 0000000..d27c6ae
--- /dev/null
+++ b/misc.h
@@ -0,0 +1,19 @@
+// misc.h
+//
+
+extern void InitHInstance(HINSTANCE hInstance);
+extern void OutputDebug(char *pMessage);
+extern void LoadString(UINT nID, char *pBuffer, int lgBuffer);
+extern void ChangeSprite(int sprite);
+
+extern POINT ConvLongToPos(LPARAM lParam);
+
+extern void InitRandom();
+extern int  Random(int min, int max);
+
+extern void GetCurrentDir(char *pName, int lg);
+extern void AddCDPath(char *pFilename);
+extern void AddUserPath(char *pFilename);
+
+extern void TraceErrorDD(HRESULT hErr, char *sFile, int nLine);
+extern void TraceErrorDS(HRESULT hErr, char *sFile, int nLine);
diff --git a/movie.cpp b/movie.cpp
new file mode 100644
index 0000000..4429826
--- /dev/null
+++ b/movie.cpp
@@ -0,0 +1,298 @@
+// movie.cpp
+//
+
+#include <windows.h>
+#include <windowsx.h>
+#include <commdlg.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <direct.h>
+#include <mmsystem.h>		
+#include <digitalv.h>		
+#include "def.h"
+#include "movie.h"
+#include "misc.h"
+
+
+//----------------------------------------------------------------------------
+
+#define AVI_VIDEO "avivideo"
+
+#define IDM_PLAY   10
+#define IDM_RPLAY  11
+
+//----------------------------------------------------------------------------
+
+// Initialize avi libraries.
+
+BOOL CMovie::initAVI()
+{
+	MCI_DGV_OPEN_PARMS	mciOpen;
+		
+	// set up the open parameters
+	mciOpen.dwCallback 		 = 0L;
+	mciOpen.wDeviceID 		 = 0;
+	mciOpen.lpstrDeviceType  = AVI_VIDEO;
+	mciOpen.lpstrElementName = NULL;
+	mciOpen.lpstrAlias 		 = NULL;
+	mciOpen.dwStyle 		 = 0;
+	mciOpen.hWndParent 		 = NULL;
+		
+	// try to open the driver
+	return (mciSendCommand(0, MCI_OPEN, (DWORD)(MCI_OPEN_TYPE),
+                           (DWORD)(LPMCI_DGV_OPEN_PARMS)&mciOpen) == 0);
+}
+
+// Closes the opened AVI file and the opened device type.                                               |
+
+void CMovie::termAVI()
+{
+	MCIDEVICEID        mciID;
+	MCI_GENERIC_PARMS  mciClose;
+	
+	// Get the device ID for the opened device type and then close
+	// the device type.
+	mciID = mciGetDeviceID(AVI_VIDEO);
+	mciSendCommand(mciID, MCI_CLOSE, 0L,
+                   (DWORD)(LPMCI_GENERIC_PARMS)&mciClose);
+}
+
+
+// Sets the movie rectange <rcMovie> to be
+// centered within the app's window.
+
+void CMovie::positionMovie(HWND hWnd, RECT rect)
+{
+	// reposition the playback (child) window
+	MoveWindow(m_hwndMovie,
+			   rect.left, rect.top,
+			   rect.right, rect.bottom, TRUE);
+}
+
+// Close the movie and anything associated with it.					|
+// This function clears the <m_fPlaying> and <m_fMovieOpen> flags	|
+
+void CMovie::fileCloseMovie(HWND hWnd)
+{
+	MCI_GENERIC_PARMS  mciGeneric;
+
+	mciSendCommand(m_wMCIDeviceID, MCI_CLOSE, 0L,
+				   (DWORD)(LPMCI_GENERIC_PARMS)&mciGeneric);
+
+	m_fPlaying   = FALSE;	// can't be playing any longer
+	m_fMovieOpen = FALSE;	// no more movies open
+	
+	// cause a total repaint to occur
+	InvalidateRect(hWnd, NULL, TRUE);
+	UpdateWindow(hWnd);
+}
+
+
+// Open an AVI movie. Use CommDlg open box to
+// open and then handle the initialization to
+// show the movie and position it properly.  Keep
+// the movie paused when opened.
+// Sets <m_fMovieOpen> on success.
+
+BOOL CMovie::fileOpenMovie(HWND hWnd, RECT rect, char *pFilename)
+{
+	MCI_DGV_OPEN_PARMS		mciOpen;
+	MCI_DGV_WINDOW_PARMS	mciWindow;
+	MCI_DGV_STATUS_PARMS	mciStatus;
+	char					string[MAX_PATH];
+
+	if ( pFilename[1] == ':' )  // nom complet "D:\REP..." ?
+	{
+		strcpy(string, pFilename);
+	}
+	else
+	{
+		GetCurrentDir(string, MAX_PATH-30);
+		strcat(string, pFilename);
+	}
+
+	// we got a filename, now close any old movie and open the new one.					*/
+	if ( m_fMovieOpen )  fileCloseMovie(hWnd);	
+
+	// we have a .AVI movie to open, use MCI
+	// set up the open parameters
+	mciOpen.dwCallback       = 0L;
+	mciOpen.wDeviceID        = 0;
+	mciOpen.lpstrDeviceType  = NULL;
+	mciOpen.lpstrElementName = string;
+	mciOpen.lpstrAlias       = NULL;
+	mciOpen.dwStyle          = WS_CHILD;
+	mciOpen.hWndParent       = hWnd;
+
+	// try to open the file
+	if ( mciSendCommand(0, MCI_OPEN,
+				(DWORD)(MCI_OPEN_ELEMENT|MCI_DGV_OPEN_PARENT|MCI_DGV_OPEN_WS),
+				(DWORD)(LPMCI_DGV_OPEN_PARMS)&mciOpen) == 0 )
+	{
+		// we opened the file o.k., now set up to play it.
+		m_wMCIDeviceID = mciOpen.wDeviceID;	// save ID
+		m_fMovieOpen = TRUE;	 // a movie was opened
+
+		// show the playback window
+		mciWindow.dwCallback = 0L;
+		mciWindow.hWnd       = NULL;
+		mciWindow.nCmdShow   = SW_SHOW;
+		mciWindow.lpstrText  = (LPSTR)NULL;
+//		mciSendCommand(m_wMCIDeviceID, MCI_WINDOW,
+//					   MCI_DGV_WINDOW_STATE,
+//					   (DWORD)(LPMCI_DGV_WINDOW_PARMS)&mciWindow);
+
+		// get the window handle
+		mciStatus.dwItem = MCI_DGV_STATUS_HWND;
+		mciSendCommand(m_wMCIDeviceID,
+					   MCI_STATUS, MCI_STATUS_ITEM,
+					   (DWORD)(LPMCI_STATUS_PARMS)&mciStatus);
+		m_hwndMovie = (HWND)mciStatus.dwReturn;
+
+		// now get the movie centered
+		positionMovie(hWnd, rect);
+
+		// cause an update to occur
+		InvalidateRect(hWnd, NULL, FALSE);
+		UpdateWindow(hWnd);
+
+		return TRUE;
+	}
+	else
+	{
+		// generic error for open
+		m_fMovieOpen = FALSE;
+
+		return FALSE;
+	}
+}
+
+// Play/pause the movie depending on the state
+// of the <m_fPlaying> flag.			|
+// This function sets the <m_fPlaying> flag appropriately when done|
+
+void CMovie::playMovie(HWND hWnd, int nDirection)
+{
+	m_fPlaying = !m_fPlaying;	// swap the play flag
+
+	if( !nDirection )
+		m_fPlaying = FALSE;	// wDirection == NULL means PAUSE
+
+	// play/pause the AVI movie
+	if ( m_fPlaying )
+	{
+		DWORD			dwFlags;
+		MCI_DGV_PLAY_PARMS	mciPlay;
+		
+		// init to play all
+		mciPlay.dwCallback = MAKELONG(hWnd,0);
+		mciPlay.dwFrom = mciPlay.dwTo = 0;
+		dwFlags = MCI_NOTIFY;
+		if ( nDirection == IDM_RPLAY )
+			dwFlags |= MCI_DGV_PLAY_REVERSE;
+		
+		mciSendCommand(m_wMCIDeviceID, MCI_PLAY, dwFlags,
+		               (DWORD)(LPMCI_DGV_PLAY_PARMS)&mciPlay);
+	}
+	else
+	{
+		MCI_DGV_PAUSE_PARMS	mciPause;
+	
+		// tell it to pause
+		mciSendCommand(m_wMCIDeviceID,MCI_PAUSE,0L,
+                      (DWORD)(LPMCI_DGV_PAUSE_PARMS)&mciPause);
+	}
+}
+
+
+//----------------------------------------------------------------------------
+
+
+// Constructeur.
+
+CMovie::CMovie()
+{
+	m_bEnable      = FALSE;
+	m_wMCIDeviceID = 0;
+	m_fPlaying     = FALSE;
+	m_fMovieOpen   = FALSE;
+}
+
+// Destructeur.
+
+CMovie::~CMovie()
+{
+	termAVI();
+}
+
+// Ouvre la librairie avi.
+
+BOOL CMovie::Create()
+{
+#if _EGAMES
+	m_bEnable = FALSE;
+	return FALSE;
+#else
+	if ( initAVI() )
+	{
+		m_bEnable = TRUE;
+		return TRUE;
+	}
+	else
+	{
+		m_bEnable = FALSE;
+		return FALSE;
+	}
+#endif
+}
+
+// Retourne l'�tat de DirectMovie.
+
+BOOL CMovie::GetEnable()
+{
+	return m_bEnable;
+}
+
+// Indique si un film existe.
+
+BOOL CMovie::IsExist(char *pFilename)
+{
+	char	string[MAX_PATH];
+	FILE*	file;
+
+	if ( pFilename[1] == ':' )  // nom complet "D:\REP..." ?
+	{
+		strcpy(string, pFilename);
+	}
+	else
+	{
+		GetCurrentDir(string, MAX_PATH-30);
+		strcat(string, pFilename);
+	}
+
+	file = fopen(string, "rb");
+	if ( file == NULL )  return FALSE;
+
+	fclose(file);
+	return TRUE;
+}
+
+// Montre un film avi.
+
+BOOL CMovie::Play(HWND hWnd, RECT rect, char *pFilename)
+{
+	if ( !m_bEnable )  return FALSE;
+	if ( !fileOpenMovie(hWnd, rect, pFilename) )  return FALSE;
+	playMovie(hWnd, IDM_PLAY);
+
+	return TRUE;
+}
+
+// Stoppe le film avi.
+
+void CMovie::Stop(HWND hWnd)
+{
+	if ( !m_bEnable )  return;
+	fileCloseMovie(hWnd);
+}
diff --git a/movie.h b/movie.h
new file mode 100644
index 0000000..3cc3fd6
--- /dev/null
+++ b/movie.h
@@ -0,0 +1,30 @@
+// movie.h
+//
+
+class CMovie
+{
+public:
+    CMovie();
+    ~CMovie();
+
+    BOOL    Create();
+    BOOL    GetEnable();
+    BOOL    IsExist(char *pFilename);
+    BOOL    Play(HWND hWnd, RECT rect, char *pFilename);
+    void    Stop(HWND hWnd);
+
+protected:
+    void    playMovie(HWND hWnd, int nDirection);
+    BOOL    fileOpenMovie(HWND hWnd, RECT rect, char *pFilename);
+    void    fileCloseMovie(HWND hWnd);
+    void    positionMovie(HWND hWnd, RECT rect);
+    void    termAVI();
+    BOOL    initAVI();
+
+protected:
+    BOOL        m_bEnable;
+    MCIDEVICEID m_wMCIDeviceID;
+    HWND        m_hwndMovie;
+    BOOL        m_fPlaying;
+    BOOL        m_fMovieOpen;
+};
\ No newline at end of file
diff --git a/pixmap.cpp b/pixmap.cpp
new file mode 100644
index 0000000..ed20619
--- /dev/null
+++ b/pixmap.cpp
@@ -0,0 +1,1414 @@
+// CPixmap.cpp
+//
+
+#include <windows.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <ddraw.h>
+#include "def.h"
+#include "pixmap.h"
+#include "misc.h"
+#include "ddutil.h"
+
+
+
+/////////////////////////////////////////////////////////////////////////////
+
+
+// Constructeur.
+
+CPixmap::CPixmap()
+{
+	int		i;
+	
+	m_bFullScreen  = FALSE;
+	m_mouseType    = MOUSETYPEGRA;
+	m_bDebug       = TRUE;
+	m_bPalette     = TRUE;
+
+	m_mouseSprite  = SPRITE_WAIT;
+	MouseHotSpot();
+	m_mousePos.x   = LXIMAGE/2;
+	m_mousePos.y   = LYIMAGE/2;
+	m_mouseBackPos = m_mousePos;
+	m_bMouseBack   = FALSE;
+	m_bMouseShow   = TRUE;
+	m_bBackDisplayed = FALSE;
+
+	m_lpDD         = NULL;
+	m_lpDDSPrimary = NULL;
+	m_lpDDSBack    = NULL;
+	m_lpDDSMouse   = NULL;
+	m_lpDDPal      = NULL;
+	m_lpClipper    = NULL;
+
+	for ( i=0 ; i<MAXIMAGE ; i++ )
+	{
+		m_lpDDSurface[i] = NULL;
+	}
+
+	// initialize special effects structure
+	ZeroMemory(&m_DDbltfx, sizeof(m_DDbltfx));
+	m_DDbltfx.dwSize = sizeof(m_DDbltfx);   
+}
+
+// Destructeur.
+
+CPixmap::~CPixmap()
+{
+	int		i;
+
+    if ( m_lpDD != NULL )
+    {
+        if ( m_lpDDSPrimary != NULL )
+        {
+            m_lpDDSPrimary->Release();
+            m_lpDDSPrimary = NULL;
+        }
+
+		if ( m_lpDDSBack != NULL )
+		{
+			m_lpDDSBack->Release();
+			m_lpDDSBack = NULL;
+		}
+
+		if ( m_lpDDSMouse != NULL )
+		{
+			m_lpDDSMouse->Release();
+			m_lpDDSMouse = NULL;
+		}
+
+        if ( m_lpDDPal != NULL )
+        {
+            m_lpDDPal->Release();
+            m_lpDDPal = NULL;
+        }
+
+		for ( i=0 ; i<MAXIMAGE ; i++ )
+		{
+			if ( m_lpDDSurface[i] != NULL )
+			{
+				m_lpDDSurface[i]->Release();
+				m_lpDDSurface[i]= NULL;
+			}
+		}
+
+		if ( m_lpClipper != NULL )
+		{
+			m_lpClipper->Release();
+			m_lpClipper = NULL;
+		}
+
+        m_lpDD->Release();
+        m_lpDD = NULL;
+    }
+}
+
+
+void CPixmap::SetDebug(BOOL bDebug)
+{
+	m_bDebug = bDebug;
+	DDSetDebug(bDebug);
+}
+
+
+// Cr�e l'objet DirectDraw principal.
+// Retourne FALSE en cas d'erreur.
+
+BOOL CPixmap::Create(HWND hwnd, POINT dim,
+					 BOOL bFullScreen, int mouseType)
+{
+	DDSURFACEDESC		ddsd;
+	HRESULT				ddrval;
+	POINT				pos;
+
+	m_hWnd        = hwnd;
+	m_bFullScreen = bFullScreen;
+	m_mouseType   = mouseType;
+	m_dim         = dim;
+
+	if ( m_mouseType == MOUSETYPEGRA )
+	{
+		// Cache d�finitivement la vilaine souris Windows.
+		ShowCursor(FALSE);
+
+		pos = m_mousePos;
+		ClientToScreen(m_hWnd, &pos);
+		SetCursorPos(pos.x, pos.y);  // met la souris au centre
+	}
+
+	m_clipRect.left   = 0;
+	m_clipRect.top    = 0;
+	m_clipRect.right  = dim.x;
+	m_clipRect.bottom = dim.y;
+
+	// Create the main DirectDraw object
+    ddrval = DirectDrawCreate(NULL, &m_lpDD, NULL);
+    if ( ddrval != DD_OK )
+    {
+		OutputDebug("Fatal error: DirectDrawCreate\n");
+        return FALSE;
+    }
+
+    // Get exclusive mode.
+	if ( m_bFullScreen )
+	{
+		ddrval = m_lpDD->SetCooperativeLevel(hwnd, DDSCL_EXCLUSIVE|DDSCL_FULLSCREEN);
+	}
+	else
+	{
+	    ddrval = m_lpDD->SetCooperativeLevel(hwnd, DDSCL_NORMAL);
+	}
+    if ( ddrval != DD_OK )
+    {
+		OutputDebug("Fatal error: SetCooperativeLevel\n");
+        return FALSE;
+    }
+
+    // Set the video mode to 640x480x8.
+	if ( m_bFullScreen )
+	{
+		ddrval = m_lpDD->SetDisplayMode(dim.x, dim.y, 8);
+		if ( ddrval != DD_OK )
+		{
+			OutputDebug("Fatal error: SetDisplayMode\n");
+			return FALSE;
+		}
+	}
+
+    // Create the primary surface with 1 back buffer.
+	ZeroMemory(&ddsd, sizeof(ddsd));
+    ddsd.dwSize         = sizeof(ddsd);
+    ddsd.dwFlags        = DDSD_CAPS;
+	ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
+
+    ddrval = m_lpDD->CreateSurface(&ddsd, &m_lpDDSPrimary, NULL);
+    if ( ddrval != DD_OK )
+    {
+		TraceErrorDD(ddrval, "pixmap", 0);
+		OutputDebug("Fatal error: CreateSurface\n");
+        return FALSE;
+    }
+	
+	// Create the back buffer.
+	ZeroMemory(&ddsd, sizeof(ddsd));
+	ddsd.dwSize         = sizeof(ddsd);
+	ddsd.dwFlags        = DDSD_CAPS|DDSD_HEIGHT|DDSD_WIDTH;
+//?	ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
+	ddsd.ddsCaps.dwCaps = DDSCAPS_SYSTEMMEMORY;
+	ddsd.dwWidth        = dim.x;
+	ddsd.dwHeight       = dim.y;
+
+	ddrval = m_lpDD->CreateSurface(&ddsd, &m_lpDDSBack, NULL);
+	if ( ddrval != DD_OK )
+	{
+		TraceErrorDD(ddrval, "pixmap", 0);
+		OutputDebug("Fatal error: CreateBackSurface\n");
+		return FALSE;
+	}
+
+	// Create the mouse buffer.
+	ZeroMemory(&ddsd, sizeof(ddsd));
+	ddsd.dwSize         = sizeof(ddsd);
+	ddsd.dwFlags        = DDSD_CAPS|DDSD_HEIGHT|DDSD_WIDTH;
+//?	ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
+	ddsd.ddsCaps.dwCaps = DDSCAPS_SYSTEMMEMORY;
+	ddsd.dwWidth        = DIMBLUPIX;
+	ddsd.dwHeight       = DIMBLUPIY;
+
+	ddrval = m_lpDD->CreateSurface(&ddsd, &m_lpDDSMouse, NULL);
+	if ( ddrval != DD_OK )
+	{
+		TraceErrorDD(ddrval, "pixmap", 0);
+		OutputDebug("Fatal error: CreateMouseSurface\n");
+		return FALSE;
+	}
+
+	// Create a DirectDrawClipper object. The object enables clipping to the 
+	// window boundaries in the IDirectDrawSurface::Blt function for the 
+	// primary surface.
+	if ( !m_bFullScreen )
+	{
+		ddrval = m_lpDD->CreateClipper(0, &m_lpClipper, NULL);
+		if ( ddrval != DD_OK )
+		{
+			TraceErrorDD(ddrval, "pixmap", 0);
+			OutputDebug("Can't create clipper\n");
+			return FALSE;
+		}
+
+		ddrval = m_lpClipper->SetHWnd(0, hwnd);
+		if ( ddrval != DD_OK )
+		{
+			TraceErrorDD(ddrval, "pixmap", 0);
+			OutputDebug("Can't set clipper window handle\n");
+			return FALSE;
+		}
+
+		ddrval = m_lpDDSPrimary->SetClipper(m_lpClipper);
+		if ( ddrval != DD_OK )
+		{
+			TraceErrorDD(ddrval, "pixmap", 0);
+			OutputDebug("Can't attach clipper to primary surface\n");
+			return FALSE;
+		}
+    }
+
+    return TRUE;
+}
+
+// Lib�re les bitmaps.
+
+BOOL CPixmap::Flush()
+{
+	return TRUE;
+}
+
+// Restitue les bitmaps.
+
+BOOL CPixmap::Restore()
+{
+	RestoreAll();
+	return TRUE;
+}
+
+// Initialise la palette syst�me.
+
+BOOL CPixmap::InitSysPalette()
+{
+    HDC			hdc;
+	int			caps;
+
+    hdc = CreateCompatibleDC(NULL);
+    if ( hdc == NULL )  return FALSE;
+
+	if ( !m_bFullScreen )
+	{
+		caps = GetDeviceCaps(hdc, SIZEPALETTE);
+		if ( caps == 0 )  m_bPalette = FALSE;
+		else              m_bPalette = TRUE;
+	}
+
+	GetSystemPaletteEntries(hdc, 0, 256, m_sysPal);
+    DeleteDC(hdc);
+	return TRUE;
+}
+
+// Indique si l'on utilise une palette.
+
+BOOL CPixmap::IsPalette()
+{
+	return m_bPalette;
+}
+
+
+// Rempli une zone rectangulaire avec une couleur uniforme.
+
+void CPixmap::Fill(RECT rect, COLORREF color)
+{
+	// � faire si n�cessaire ...
+}
+
+
+// Restore all lost objects.
+
+HRESULT CPixmap::RestoreAll()
+{
+	if ( m_bDebug )  OutputDebug("CPixmap::RestoreAll\n");
+	int			i;
+	HRESULT     ddrval;
+
+	if ( m_lpDDSPrimary && m_lpDDSPrimary->IsLost() )
+	{
+		ddrval = m_lpDDSPrimary->Restore();
+//		if( ddrval != DD_OK )  return ddrval;
+	}
+
+	if ( m_lpDDSBack && m_lpDDSBack->IsLost() )
+	{
+		ddrval = m_lpDDSBack->Restore();
+//		if( ddrval != DD_OK )  return ddrval;
+	}
+
+	if ( m_lpDDSMouse && m_lpDDSMouse->IsLost() )
+	{
+		ddrval = m_lpDDSMouse->Restore();
+//		if( ddrval != DD_OK )  return ddrval;
+	}
+
+	for ( i=0 ; i<MAXIMAGE ; i++ )
+	{
+		if ( m_lpDDSurface[i] && m_lpDDSurface[i]->IsLost() )
+		{
+			ddrval = m_lpDDSurface[i]->Restore();
+			if( ddrval == DD_OK )
+			{
+				DDReLoadBitmap(m_lpDDSurface[i], m_filename[i]);
+			}
+		}
+	}
+	return DD_OK;
+}
+
+// Effectue un appel BltFast.
+// Les modes sont 0=transparent, 1=opaque.
+
+HRESULT CPixmap::BltFast(int chDst, int channel,
+						 POINT dst, RECT rcRect, int mode)
+{
+	DWORD		dwTrans;
+    HRESULT		ddrval;
+	int			limit;
+
+	if ( mode == 0 )  dwTrans = DDBLTFAST_SRCCOLORKEY;
+	else              dwTrans = DDBLTFAST_NOCOLORKEY;
+
+	// Effectue un peu de clipping.
+	if ( dst.x < m_clipRect.left )
+	{
+		rcRect.left += m_clipRect.left-dst.x;
+		dst.x = m_clipRect.left;
+	}
+	limit = (m_clipRect.right-dst.x)+rcRect.left;
+	if ( rcRect.right > limit )
+	{
+		rcRect.right = limit;
+	}
+	if ( dst.y < m_clipRect.top )
+	{
+		rcRect.top += m_clipRect.top-dst.y;
+		dst.y = m_clipRect.top;
+	}
+	limit = (m_clipRect.bottom-dst.y)+rcRect.top;
+	if ( rcRect.bottom > limit )
+	{
+		rcRect.bottom = limit;
+	}
+
+	if ( rcRect.left >= rcRect.right ||
+		 rcRect.top  >= rcRect.bottom )  return DD_OK;
+
+    while( TRUE )
+    {
+		if ( chDst < 0 )
+		{
+			ddrval = m_lpDDSBack->BltFast(dst.x, dst.y,
+										  m_lpDDSurface[channel],
+										  &rcRect, dwTrans);
+		}
+		else
+		{
+			ddrval = m_lpDDSurface[chDst]->BltFast(dst.x, dst.y,
+										  m_lpDDSurface[channel],
+										  &rcRect, dwTrans);
+		}
+        if ( ddrval == DD_OK )  break;
+        
+        if ( ddrval == DDERR_SURFACELOST )
+        {
+            ddrval = RestoreAll();
+            if ( ddrval != DD_OK )  break;
+        }
+
+        if ( ddrval != DDERR_WASSTILLDRAWING )  break;
+    }
+
+	return ddrval;
+}
+
+// Effectue un appel BltFast.
+// Les modes sont 0=transparent, 1=opaque.
+
+HRESULT CPixmap::BltFast(LPDIRECTDRAWSURFACE lpDD,
+						 int channel, POINT dst, RECT rcRect, int mode)
+{
+	DWORD		dwTrans;
+    HRESULT		ddrval;
+
+	if ( mode == 0 )  dwTrans = DDBLTFAST_SRCCOLORKEY;
+	else              dwTrans = DDBLTFAST_NOCOLORKEY;
+
+    while( TRUE )
+    {
+		ddrval = lpDD->BltFast(dst.x, dst.y,
+							   m_lpDDSurface[channel],
+							   &rcRect, dwTrans);
+        if ( ddrval == DD_OK )  break;
+        
+        if ( ddrval == DDERR_SURFACELOST )
+        {
+            ddrval = RestoreAll();
+            if ( ddrval != DD_OK )  break;
+        }
+
+        if ( ddrval != DDERR_WASSTILLDRAWING )  break;
+    }
+
+	return ddrval;
+}
+
+
+// Sauve toute la palette de couleurs.
+
+BOOL CPixmap::SavePalette()
+{
+    HRESULT     ddrval;
+
+	if ( m_lpDDPal == NULL )  return FALSE;
+
+    ddrval = m_lpDDPal->GetEntries(0, 0, 256, m_pal);
+
+	if ( ddrval != DD_OK )  return FALSE;
+	return TRUE;
+}
+
+// Restitue toute la palette de couleurs.
+
+BOOL CPixmap::RestorePalette()
+{
+    HRESULT     ddrval;
+
+    ddrval = m_lpDDPal->SetEntries(0, 0, 256, m_pal);
+
+	if ( ddrval != DD_OK )  return FALSE;
+	return TRUE;
+}
+
+// Cherche une couleur dans la palette principale.
+// En mode plein �cran, il faut chercher dans la palette
+// correspondant aux images (obtenue avec SavePalette),
+// alors qu'en mode fen�tre, il faut chercher dans la
+// palette syst�me (obtenue avec InitSysPalette) !!!
+
+int CPixmap::SearchColor(int red, int green, int blue)
+{
+	int		i, j, delta, min;
+
+	if ( m_bFullScreen )
+	{
+		for ( i=0 ; i<256 ; i++ )
+		{
+			if ( red   == m_pal[i].peRed   &&
+				 green == m_pal[i].peGreen &&
+				 blue  == m_pal[i].peBlue  )  return i;
+		}
+
+		// Cherche la couleur la plus proche.
+		min = 10000;
+		j   = -1;
+		for ( i=0 ; i<256 ; i++ )
+		{
+			delta = abs(red   - m_pal[i].peRed  )+
+					abs(green - m_pal[i].peGreen)+
+					abs(blue  - m_pal[i].peBlue );
+
+			if ( delta < min )
+			{
+				min = delta;
+				j = i;
+			}
+		}
+	}
+	else
+	{
+		if ( m_bPalette )
+		{
+			for ( i=0 ; i<256 ; i++ )
+			{
+				if ( red   == m_sysPal[i].peRed   &&
+					 green == m_sysPal[i].peGreen &&
+					 blue  == m_sysPal[i].peBlue  )  return i;
+			}
+
+			// Cherche la couleur la plus proche.
+			min = 10000;
+			j   = -1;
+			for ( i=0 ; i<256 ; i++ )
+			{
+				delta = abs(red   - m_sysPal[i].peRed  )+
+						abs(green - m_sysPal[i].peGreen)+
+						abs(blue  - m_sysPal[i].peBlue );
+
+				if ( delta < min )
+				{
+					min = delta;
+					j = i;
+				}
+			}
+		}
+		else
+		{
+			j  =  (blue >>3)     &0x001F;
+			j |= ((green>>2)<< 5)&0x07E0;
+			j |= ((red  >>3)<<11)&0xF800;  // mode 5-6-5
+//?			j  =  (blue >>3)     &0x001F;
+//?			j |= ((green>>3)<< 5)&0x03E0;
+//?			j |= ((red  >>3)<<10)&0x7C00;  // mode 5-5-5
+		}
+	}
+	return j;
+}
+
+
+// Cache une image contenant des ic�nes.
+
+BOOL CPixmap::Cache(int channel, char *pFilename, POINT totalDim, POINT iconDim,
+					BOOL bUsePalette)
+{
+    HRESULT     ddrval;
+
+	if ( channel < 0 || channel >= MAXIMAGE )  return FALSE;
+
+	if ( m_lpDDSurface[channel] != NULL )
+	{
+		Flush(channel);
+	}
+
+    // Create and set the palette.
+	if ( bUsePalette )
+	{
+		if ( m_bDebug )  OutputDebug("Use palette\n");
+		if ( m_lpDDPal != NULL )
+		{
+			if ( m_bDebug )  OutputDebug("Release palette\n");
+			m_lpDDPal->Release();
+			m_lpDDPal = NULL;
+		}
+
+		m_lpDDPal = DDLoadPalette(m_lpDD, pFilename);
+
+		if ( m_lpDDPal )
+		{
+			if ( m_bDebug )  OutputDebug("Set palette\n");
+			m_lpDDSPrimary->SetPalette(NULL);  // indispensable !
+			ddrval = m_lpDDSPrimary->SetPalette(m_lpDDPal);
+			if ( ddrval != DD_OK )
+			{
+				TraceErrorDD(ddrval, pFilename, 1);
+			}
+		}
+	}
+
+    // Create the offscreen surface, by loading our bitmap.
+    m_lpDDSurface[channel] = DDLoadBitmap(m_lpDD, pFilename, 0, 0);
+
+    if ( m_lpDDSurface[channel] == NULL )
+    {
+		OutputDebug("Fatal error: DDLoadBitmap\n");
+        return FALSE;
+    }
+
+    // Set the color key to white
+	if ( m_bDebug )  OutputDebug("DDSetColorKey\n");
+    DDSetColorKey(m_lpDDSurface[channel], RGB(255,255,255));  // blanc
+	
+	strcpy(m_filename[channel], pFilename);
+
+	m_totalDim[channel] = totalDim;
+	m_iconDim[channel]  = iconDim;
+
+	return TRUE;
+}
+
+// Cache une image globale.
+
+BOOL CPixmap::Cache(int channel, char *pFilename, POINT totalDim, BOOL bUsePalette)
+{
+	POINT		iconDim;
+
+	if ( channel < 0 || channel >= MAXIMAGE )  return FALSE;
+
+	iconDim.x = 0;
+	iconDim.y = 0;
+
+	return Cache(channel, pFilename, totalDim, iconDim, bUsePalette);
+}
+
+// Cache une image provenant d'un bitmap.
+
+BOOL CPixmap::Cache(int channel, HBITMAP hbm, POINT totalDim)
+{
+	if ( channel < 0 || channel >= MAXIMAGE )  return FALSE;
+
+	if ( m_lpDDSurface[channel] != NULL )
+	{
+		Flush(channel);
+	}
+
+    // Create the offscreen surface, by loading our bitmap.
+    m_lpDDSurface[channel] = DDConnectBitmap(m_lpDD, hbm);
+
+    if ( m_lpDDSurface[channel] == NULL )
+    {
+		OutputDebug("Fatal error: DDLoadBitmap\n");
+        return FALSE;
+    }
+
+    // Set the color key to white
+    DDSetColorKey(m_lpDDSurface[channel], RGB(255,255,255));  // blanc
+	
+	m_totalDim[channel] = totalDim;
+	m_iconDim[channel]  = totalDim;
+
+	return TRUE;
+}
+
+// Purge une image.
+
+void CPixmap::Flush(int channel)
+{
+	if ( channel < 0 || channel >= MAXIMAGE )  return;
+	if (  m_lpDDSurface[channel] == NULL )     return;
+
+	m_lpDDSurface[channel]->Release();
+	m_lpDDSurface[channel]= NULL;
+}
+
+// D�finition de la couleur transparente.
+
+void CPixmap::SetTransparent(int channel, COLORREF color)
+{
+	if ( channel < 0 || channel >= MAXIMAGE )  return;
+	if (  m_lpDDSurface[channel] == NULL )     return;
+
+    DDSetColorKey(m_lpDDSurface[channel], color);
+	m_colorSurface[2*channel+0] = color;
+	m_colorSurface[2*channel+1] = color;
+}
+
+// D�finition de la couleur transparente.
+
+void CPixmap::SetTransparent2(int channel, COLORREF color1, COLORREF color2)
+{
+	if ( channel < 0 || channel >= MAXIMAGE )  return;
+	if (  m_lpDDSurface[channel] == NULL )     return;
+
+    DDSetColorKey2(m_lpDDSurface[channel], color1, color2);
+	m_colorSurface[2*channel+0] = color1;
+	m_colorSurface[2*channel+1] = color2;
+}
+
+
+// Modifie la r�gion de clipping.
+
+void CPixmap::SetClipping(RECT clip)
+{
+	m_clipRect = clip;
+}
+
+// Retourne la r�gion de clipping.
+
+RECT CPixmap::GetClipping()
+{
+	return m_clipRect;
+}
+
+
+// Teste si un point fait partie d'une ic�ne.
+
+BOOL CPixmap::IsIconPixel(int channel, int rank, POINT pos)
+{
+	int			nbx, nby;
+    COLORREF	rgb;
+    HDC			hDC;
+
+	if ( channel < 0 || channel >= MAXIMAGE )  return FALSE;
+	if (  m_lpDDSurface[channel] == NULL )     return FALSE;
+
+	if ( m_iconDim[channel].x == 0 ||
+		 m_iconDim[channel].y == 0 )  return FALSE;
+
+	nbx = m_totalDim[channel].x / m_iconDim[channel].x;
+	nby = m_totalDim[channel].y / m_iconDim[channel].y;
+
+	if ( rank < 0 || rank >= nbx*nby )  return FALSE;
+
+	pos.x += (rank%nbx)*m_iconDim[channel].x;
+	pos.y += (rank/nbx)*m_iconDim[channel].y;
+
+	if ( m_lpDDSurface[channel]->GetDC(&hDC) != DD_OK )  return FALSE;
+	rgb = GetPixel(hDC, pos.x, pos.y);
+	m_lpDDSurface[channel]->ReleaseDC(hDC);
+
+	if ( rgb == m_colorSurface[2*channel+0] ||
+		 rgb == m_colorSurface[2*channel+1] )  return FALSE;
+
+	return TRUE;
+}
+
+
+// Dessine une partie d'image rectangulaire.
+// Les modes sont 0=transparent, 1=opaque.
+
+BOOL CPixmap::DrawIcon(int chDst, int channel, int rank, POINT pos,
+					   int mode, BOOL bMask)
+{
+	int			nbx, nby;
+	RECT		rect;
+	HRESULT		ddrval;
+	COLORREF	oldColor1, oldColor2;
+
+	if ( channel < 0 || channel >= MAXIMAGE )  return FALSE;
+	if (  m_lpDDSurface[channel] == NULL )     return FALSE;
+
+	if ( m_iconDim[channel].x == 0 ||
+		 m_iconDim[channel].y == 0 )  return FALSE;
+
+	nbx = m_totalDim[channel].x / m_iconDim[channel].x;
+	nby = m_totalDim[channel].y / m_iconDim[channel].y;
+
+	if ( rank < 0 || rank >= nbx*nby )  return FALSE;
+
+	rect.left   = (rank%nbx)*m_iconDim[channel].x;
+	rect.top    = (rank/nbx)*m_iconDim[channel].y;
+	rect.right  = rect.left + m_iconDim[channel].x;
+	rect.bottom = rect.top  + m_iconDim[channel].y;
+
+	oldColor1 = m_colorSurface[2*channel+0];
+	oldColor2 = m_colorSurface[2*channel+1];
+	if ( bMask )  SetTransparent(channel, RGB(255,255,255));  // blanc
+	ddrval = BltFast(chDst, channel, pos, rect, mode);
+	if ( bMask )  SetTransparent2(channel, oldColor1, oldColor2);
+
+	if ( ddrval != DD_OK )  return FALSE;
+	return TRUE;
+}
+
+// Dessine une partie d'image rectangulaire.
+// Les modes sont 0=transparent, 1=opaque.
+//
+// Correspondances in,out :
+//	 0,0	 2,1	...
+//	 1,16	 3,17
+//
+//	32,32	34,33
+//	33,48	35,49
+
+BOOL CPixmap::DrawIconDemi(int chDst, int channel, int rank, POINT pos,
+						   int mode, BOOL bMask)
+{
+	int			nbx, nby;
+	RECT		rect;
+	HRESULT		ddrval;
+	COLORREF	oldColor1, oldColor2;
+
+	if ( channel < 0 || channel >= MAXIMAGE )  return FALSE;
+	if (  m_lpDDSurface[channel] == NULL )     return FALSE;
+
+	if ( m_iconDim[channel].x == 0 ||
+		 m_iconDim[channel].y == 0 )  return FALSE;
+
+	nbx = m_totalDim[channel].x /  m_iconDim[channel].x;
+	nby = m_totalDim[channel].y / (m_iconDim[channel].y/2);
+
+	rank = (rank/32)*32+((rank%32)/2)+((rank%2)*16);
+
+	if ( rank < 0 || rank >= nbx*nby )  return FALSE;
+
+	rect.left   = (rank%nbx)* m_iconDim[channel].x;
+	rect.top    = (rank/nbx)*(m_iconDim[channel].y/2);
+	rect.right  = rect.left + m_iconDim[channel].x;
+	rect.bottom = rect.top  +(m_iconDim[channel].y/2);
+
+	oldColor1 = m_colorSurface[2*channel+0];
+	oldColor2 = m_colorSurface[2*channel+1];
+	if ( bMask )  SetTransparent(channel, RGB(255,255,255));  // blanc
+	ddrval = BltFast(chDst, channel, pos, rect, mode);
+	if ( bMask )  SetTransparent2(channel, oldColor1, oldColor2);
+
+	if ( ddrval != DD_OK )  return FALSE;
+	return TRUE;
+}
+
+// Dessine une partie d'image rectangulaire.
+// Les modes sont 0=transparent, 1=opaque.
+
+BOOL CPixmap::DrawIconPart(int chDst, int channel, int rank, POINT pos,
+						   int startY, int endY,
+						   int mode, BOOL bMask)
+{
+	int			nbx, nby;
+	RECT		rect;
+	HRESULT		ddrval;
+	COLORREF	oldColor1, oldColor2;
+
+	if ( channel < 0 || channel >= MAXIMAGE )  return FALSE;
+	if (  m_lpDDSurface[channel] == NULL )     return FALSE;
+
+	if ( m_iconDim[channel].x == 0 ||
+		 m_iconDim[channel].y == 0 )  return FALSE;
+
+	nbx = m_totalDim[channel].x / m_iconDim[channel].x;
+	nby = m_totalDim[channel].y / m_iconDim[channel].y;
+
+	if ( rank < 0 || rank >= nbx*nby )  return FALSE;
+
+	rect.left   = (rank%nbx)*m_iconDim[channel].x;
+	rect.top    = (rank/nbx)*m_iconDim[channel].y;
+	rect.right  = rect.left + m_iconDim[channel].x;
+	rect.bottom = rect.top  + endY;
+
+	pos.y    += startY;
+	rect.top += startY;
+
+	oldColor1 = m_colorSurface[2*channel+0];
+	oldColor2 = m_colorSurface[2*channel+1];
+	if ( bMask )  SetTransparent(channel, RGB(255,255,255));  // blanc
+	ddrval = BltFast(chDst, channel, pos, rect, mode);
+	if ( bMask )  SetTransparent2(channel, oldColor1, oldColor2);
+
+	if ( ddrval != DD_OK )  return FALSE;
+	return TRUE;
+}
+
+// Dessine une partie d'image n'importe o�.
+// Les modes sont 0=transparent, 1=opaque.
+
+BOOL CPixmap::DrawPart(int chDst, int channel, POINT dest, RECT rect,
+					   int mode, BOOL bMask)
+{
+	HRESULT		ddrval;
+	COLORREF	oldColor1, oldColor2;
+
+	if ( channel < 0 || channel >= MAXIMAGE )  return FALSE;
+	if (  m_lpDDSurface[channel] == NULL )     return FALSE;
+
+	oldColor1 = m_colorSurface[2*channel+0];
+	oldColor2 = m_colorSurface[2*channel+1];
+	if ( bMask )  SetTransparent(channel, RGB(255,255,255));  // blanc
+	ddrval = BltFast(chDst, channel, dest, rect, mode);
+	if ( bMask )  SetTransparent2(channel, oldColor1, oldColor2);
+
+	if ( ddrval != DD_OK )  return FALSE;
+	return TRUE;
+}
+
+// Dessine une partie d'image rectangulaire.
+// Les modes sont 0=transparent, 1=opaque.
+
+BOOL CPixmap::DrawImage(int chDst, int channel, RECT rect, int mode)
+{
+	POINT		dst;
+	HRESULT		ddrval;
+
+	if ( channel < 0 || channel >= MAXIMAGE )  return FALSE;
+	if (  m_lpDDSurface[channel] == NULL )     return FALSE;
+
+	dst.x = rect.left;
+	dst.y = rect.top;
+
+	ddrval = BltFast(chDst, channel, dst, rect, mode);
+
+	if ( ddrval != DD_OK )  return FALSE;
+
+	if ( channel == CHBACK )
+	{
+		MouseBackSave();  // sauve ce qui sera sous la souris
+		m_bBackDisplayed = FALSE;
+	}
+
+	return TRUE;
+}
+
+
+// Construit une ic�ne en utilisant un masque.
+
+BOOL CPixmap::BuildIconMask(int channelMask, int rankMask,
+							int channel, int rankSrc, int rankDst)
+{
+	int			nbx, nby;
+	POINT		posDst;
+	RECT		rect;
+	HRESULT		ddrval;
+
+	if ( channel < 0 || channel >= MAXIMAGE )  return FALSE;
+	if (  m_lpDDSurface[channel] == NULL )     return FALSE;
+
+	if ( m_iconDim[channel].x == 0 ||
+		 m_iconDim[channel].y == 0 )  return FALSE;
+
+	nbx = m_totalDim[channel].x / m_iconDim[channel].x;
+	nby = m_totalDim[channel].y / m_iconDim[channel].y;
+
+	if ( rankSrc < 0 || rankSrc >= nbx*nby )  return FALSE;
+	if ( rankDst < 0 || rankDst >= nbx*nby )  return FALSE;
+
+	rect.left   = (rankSrc%nbx)*m_iconDim[channel].x;
+	rect.top    = (rankSrc/nbx)*m_iconDim[channel].y;
+	rect.right  = rect.left + m_iconDim[channel].x;
+	rect.bottom = rect.top  + m_iconDim[channel].y;
+	posDst.x    = (rankDst%nbx)*m_iconDim[channel].x;
+	posDst.y    = (rankDst/nbx)*m_iconDim[channel].y;
+	ddrval = BltFast(m_lpDDSurface[channel], channel, posDst, rect, 1);
+	if ( ddrval != DD_OK )  return FALSE;
+
+	if ( m_iconDim[channelMask].x == 0 ||
+		 m_iconDim[channelMask].y == 0 )  return FALSE;
+
+	nbx = m_totalDim[channelMask].x / m_iconDim[channelMask].x;
+	nby = m_totalDim[channelMask].y / m_iconDim[channelMask].y;
+
+	if ( rankMask < 0 || rankMask >= nbx*nby )  return FALSE;
+
+	rect.left   = (rankMask%nbx)*m_iconDim[channelMask].x;
+	rect.top    = (rankMask/nbx)*m_iconDim[channelMask].y;
+	rect.right  = rect.left + m_iconDim[channelMask].x;
+	rect.bottom = rect.top  + m_iconDim[channelMask].y;
+	ddrval = BltFast(m_lpDDSurface[channel], channelMask, posDst, rect, 0);
+	if ( ddrval != DD_OK )  return FALSE;
+
+	return TRUE;
+}
+
+
+// Affiche le pixmap � l'�cran.
+// Retourne FALSE en cas d'erreur.
+
+BOOL CPixmap::Display()
+{
+	HRESULT		ddrval;
+	RECT		DestRect, MapRect;
+
+	m_bBackDisplayed = TRUE;
+
+	// Get screen coordinates of client window for blit
+	GetClientRect(m_hWnd, &DestRect);
+	ClientToScreen(m_hWnd, (LPPOINT)&DestRect);
+	ClientToScreen(m_hWnd, (LPPOINT)&DestRect+1);
+	
+	MapRect.left   = 0;
+	MapRect.top    = 0;
+	MapRect.right  = m_dim.x;
+	MapRect.bottom = m_dim.y;
+
+	// do the blit from back surface
+	ddrval = m_lpDDSPrimary->Blt
+				(
+					&DestRect,		// destination rect
+					m_lpDDSBack,
+					&MapRect,		// source rect     
+					DDBLT_WAIT,
+					&m_DDbltfx
+				);
+    if ( ddrval == DDERR_SURFACELOST )
+    {
+        ddrval = RestoreAll();
+    }
+	if ( ddrval != DD_OK )  return FALSE;
+	return TRUE;
+}
+
+
+// Positionne la souris et change le lutin.
+
+void CPixmap::SetMousePosSprite(POINT pos, int sprite, BOOL bDemoPlay)
+{
+	if ( m_mousePos.x == pos.x &&
+		 m_mousePos.y == pos.y &&
+		 m_mouseSprite == sprite )  return;
+
+	m_mousePos    = pos;
+	m_mouseSprite = sprite;
+	MouseHotSpot();
+
+	if ( !bDemoPlay )
+	{
+		MouseUpdate();
+	}
+}
+
+// Positionne la souris.
+
+void CPixmap::SetMousePos(POINT pos, BOOL bDemoPlay)
+{
+	if ( m_mousePos.x == pos.x &&
+		 m_mousePos.y == pos.y )  return;
+
+	m_mousePos = pos;
+
+	if ( !bDemoPlay )
+	{
+		MouseUpdate();
+	}
+}
+
+// Change le lutin de la souris.
+
+void CPixmap::SetMouseSprite(int sprite, BOOL bDemoPlay)
+{
+	if ( m_mouseSprite == sprite )  return;
+
+	m_mouseSprite = sprite;
+	MouseHotSpot();
+
+	if ( !bDemoPlay )
+	{
+		MouseUpdate();
+	}
+}
+
+// Montre ou cache la souris.
+
+void CPixmap::MouseShow(BOOL bShow)
+{
+	m_bMouseShow = bShow;
+}
+
+// Met � jour le dessin de la souris.
+
+void CPixmap::MouseUpdate()
+{
+	RECT	oldRect, newRect, rcRect;
+
+	if ( m_lpDDSurface[CHBLUPI] == NULL )  return;
+	if ( m_mouseType != MOUSETYPEGRA )  return;
+	if ( m_mouseSprite == SPRITE_EMPTY )  return;
+	if ( !m_bMouseShow )  return;
+
+	oldRect.left   = m_mouseBackPos.x;
+	oldRect.top    = m_mouseBackPos.y;
+	oldRect.right  = m_mouseBackPos.x + DIMBLUPIX;
+	oldRect.bottom = m_mouseBackPos.y + DIMBLUPIY;
+
+	newRect.left   = m_mousePos.x - m_mouseHotSpot.x;
+	newRect.top    = m_mousePos.y - m_mouseHotSpot.y;
+	newRect.right  = newRect.left + DIMBLUPIX;
+	newRect.bottom = newRect.top  + DIMBLUPIY;
+
+	MouseBackRestore();  // enl�ve la souris dans m_lpDDSBack
+	MouseBackDraw();     // dessine la souris dans m_lpDDSBack
+
+	if ( m_bBackDisplayed )
+	{
+		if ( IntersectRect(&rcRect, &oldRect, &newRect) )
+		{
+			UnionRect(&rcRect, &oldRect, &newRect);
+			MouseQuickDraw(rcRect);
+		}
+		else
+		{
+			MouseQuickDraw(oldRect);
+			MouseQuickDraw(newRect);
+		}
+	}
+}
+
+// Dessine rapidement la souris dans l'�cran.
+// Il s'agit en fait de dessiner un petit morceau rectangulaire
+// de m_lpDDSBack dans l'�cran.
+
+BOOL CPixmap::MouseQuickDraw(RECT rect)
+{
+	HRESULT		ddrval;
+	RECT		DestRect;
+
+	if ( rect.left   < 0       )  rect.left   = 0;
+	if ( rect.right  > LXIMAGE )  rect.right  = LXIMAGE;
+	if ( rect.top    < 0       )  rect.top    = 0;
+	if ( rect.bottom > LYIMAGE )  rect.bottom = LYIMAGE;
+
+	// Get screen coordinates of client window for blit
+	DestRect = rect;
+	ClientToScreen(m_hWnd, (LPPOINT)&DestRect);
+	ClientToScreen(m_hWnd, (LPPOINT)&DestRect+1);
+	
+	// do the blit from back surface
+	ddrval = m_lpDDSPrimary->Blt
+				(
+					&DestRect,		// destination rect
+					m_lpDDSBack,
+					&rect,			// source rect     
+					DDBLT_WAIT,
+					&m_DDbltfx
+				);
+    if ( ddrval == DDERR_SURFACELOST )
+    {
+        ddrval = RestoreAll();
+    }
+	if ( ddrval != DD_OK )  return FALSE;
+	return TRUE;
+}
+
+// Invalide la copie sous la souris.
+
+void CPixmap::MouseInvalidate()
+{
+	m_bMouseBack = FALSE;
+}
+
+// Enl�ve la souris dans m_lpDDSBack.
+
+void CPixmap::MouseBackClear()
+{
+	if ( m_mouseType != MOUSETYPEGRA )  return;
+	MouseBackRestore();  // enl�ve la souris dans m_lpDDSBack
+}
+
+// Dessine la souris dans m_lpDDSBack.
+
+void CPixmap::MouseBackDraw()
+{
+	POINT	dst;
+	RECT	rcRect;
+
+	if ( m_lpDDSurface[CHBLUPI] == NULL )  return;
+	if ( m_mouseType != MOUSETYPEGRA )  return;
+	if ( m_mouseSprite == SPRITE_EMPTY )  return;
+	if ( !m_bMouseShow )  return;
+
+	MouseBackSave();  // sauve ce qui sera sous la souris
+
+	dst.x  = m_mousePos.x - m_mouseHotSpot.x;
+	dst.y  = m_mousePos.y - m_mouseHotSpot.y;
+	rcRect = MouseRectSprite();
+
+	if ( dst.x < 0 )
+	{
+		rcRect.left -= dst.x;
+		dst.x = 0;
+	}
+	if ( dst.x+DIMBLUPIX > LXIMAGE )
+	{
+		rcRect.right -= (dst.x+DIMBLUPIX)-LXIMAGE;
+	}
+	if ( dst.y < 0 )
+	{
+		rcRect.top -= dst.y;
+		dst.y = 0;
+	}
+	if ( dst.y+DIMBLUPIY > LYIMAGE )
+	{
+		rcRect.bottom -= (dst.y+DIMBLUPIY)-LYIMAGE;
+	}
+
+	// Dessine le lutin dans m_lpDDSBack.
+	BltFast(m_lpDDSBack, CHBLUPI, dst, rcRect, 0);
+}
+
+// Sauve le fond sous la souris.
+// m_lpDDSMouse <- m_lpDDSBack
+
+void CPixmap::MouseBackSave()
+{
+    HRESULT		ddrval;
+	POINT		dst;
+	RECT		rcRect;
+
+	if ( m_lpDDSurface[CHBLUPI] == NULL )  return;
+	if ( m_mouseType != MOUSETYPEGRA )  return;
+	if ( m_mouseSprite == SPRITE_EMPTY )  return;
+	if ( !m_bMouseShow )  return;
+
+	m_mouseBackPos.x = m_mousePos.x - m_mouseHotSpot.x;
+	m_mouseBackPos.y = m_mousePos.y - m_mouseHotSpot.y;
+	m_bMouseBack = TRUE;
+
+	dst.x = 0;
+	dst.y = 0;
+
+	rcRect.left   = m_mouseBackPos.x;
+	rcRect.top    = m_mouseBackPos.y;
+	rcRect.right  = m_mouseBackPos.x + DIMBLUPIX;
+	rcRect.bottom = m_mouseBackPos.y + DIMBLUPIY;
+
+	if ( rcRect.left < 0 )
+	{
+		dst.x -= rcRect.left;
+		rcRect.left = 0;
+	}
+	if ( rcRect.right > LXIMAGE )
+	{
+		rcRect.right = LXIMAGE;
+	}
+	if ( rcRect.top < 0 )
+	{
+		dst.y -= rcRect.top;
+		rcRect.top = 0;
+	}
+	if ( rcRect.bottom > LYIMAGE )
+	{
+		rcRect.bottom = LYIMAGE;
+	}
+
+    while( TRUE )
+    {
+		ddrval = m_lpDDSMouse->BltFast(dst.x, dst.y,
+									   m_lpDDSBack,
+									   &rcRect, DDBLTFAST_NOCOLORKEY);
+        if ( ddrval == DD_OK )  break;
+        
+        if ( ddrval == DDERR_SURFACELOST )
+        {
+            ddrval = RestoreAll();
+            if ( ddrval != DD_OK )  break;
+        }
+
+        if ( ddrval != DDERR_WASSTILLDRAWING )  break;
+    }
+}
+
+// Restitue le fond sous la souris.
+// m_lpDDSBack <- m_lpDDSMouse
+
+void CPixmap::MouseBackRestore()
+{
+    HRESULT		ddrval;
+	POINT		dst;
+	RECT		rcRect;
+
+	if ( m_lpDDSurface[CHBLUPI] == NULL )  return;
+	if ( !m_bMouseBack )  return;
+
+	dst.x = m_mouseBackPos.x;
+	dst.y = m_mouseBackPos.y;
+
+	rcRect.left   = 0;
+	rcRect.top    = 0;
+	rcRect.right  = DIMBLUPIX;
+	rcRect.bottom = DIMBLUPIY;
+
+	if ( dst.x < 0 )
+	{
+		rcRect.left -= dst.x;
+		dst.x = 0;
+	}
+	if ( dst.x+DIMBLUPIX > LXIMAGE )
+	{
+		rcRect.right -= (dst.x+DIMBLUPIX)-LXIMAGE;
+	}
+	if ( dst.y < 0 )
+	{
+		rcRect.top -= dst.y;
+		dst.y = 0;
+	}
+	if ( dst.y+DIMBLUPIY > LYIMAGE )
+	{
+		rcRect.bottom -= (dst.y+DIMBLUPIY)-LYIMAGE;
+	}
+
+    while( TRUE )
+    {
+		ddrval = m_lpDDSBack->BltFast(dst.x, dst.y,
+									  m_lpDDSMouse,
+									  &rcRect, DDBLTFAST_NOCOLORKEY);
+        if ( ddrval == DD_OK )  break;
+        
+        if ( ddrval == DDERR_SURFACELOST )
+        {
+            ddrval = RestoreAll();
+            if ( ddrval != DD_OK )  break;
+        }
+
+        if ( ddrval != DDERR_WASSTILLDRAWING )  break;
+    }
+}
+
+// Affiche le contenu de m_lpDDSMouse dans le
+// coin sup/gauche.
+
+void CPixmap::MouseBackDebug()
+{
+	HRESULT		ddrval;
+	RECT		DestRect, MapRect;
+
+	// Get screen coordinates of client window for blit
+	GetClientRect(m_hWnd, &DestRect);
+	ClientToScreen(m_hWnd, (LPPOINT)&DestRect);
+	ClientToScreen(m_hWnd, (LPPOINT)&DestRect+1);
+	
+	MapRect.left   = 0;
+	MapRect.top    = 0;
+	MapRect.right  = DIMBLUPIX;
+	MapRect.bottom = DIMBLUPIY;
+
+	DestRect.right  = DestRect.left + DIMBLUPIX;
+	DestRect.bottom = DestRect.top  + DIMBLUPIY;
+
+	// do the blit from back surface
+	ddrval = m_lpDDSPrimary->Blt
+				(
+					&DestRect,		// destination rect
+					m_lpDDSMouse,
+					&MapRect,		// source rect     
+					DDBLT_WAIT,
+					&m_DDbltfx
+				);
+    if ( ddrval == DDERR_SURFACELOST )
+    {
+        ddrval = RestoreAll();
+    }
+}
+
+// Retourne le rectangle correspondant au sprite
+// de la souris dans CHBLUPI.
+
+RECT CPixmap::MouseRectSprite()
+{
+	int		rank, nbx;
+	RECT	rcRect;
+
+	rank = 348;
+	if ( m_mouseSprite == SPRITE_ARROW   )  rank = 348;
+	if ( m_mouseSprite == SPRITE_POINTER )  rank = 349;
+	if ( m_mouseSprite == SPRITE_MAP     )  rank = 350;
+	if ( m_mouseSprite == SPRITE_WAIT    )  rank = 351;
+	if ( m_mouseSprite == SPRITE_FILL    )  rank = 352;
+	if ( m_mouseSprite == SPRITE_ARROWL  )  rank = 353;
+	if ( m_mouseSprite == SPRITE_ARROWR  )  rank = 354;
+	if ( m_mouseSprite == SPRITE_ARROWU  )  rank = 355;
+	if ( m_mouseSprite == SPRITE_ARROWD  )  rank = 356;
+	if ( m_mouseSprite == SPRITE_ARROWDL )  rank = 357;
+	if ( m_mouseSprite == SPRITE_ARROWDR )  rank = 358;
+	if ( m_mouseSprite == SPRITE_ARROWUL )  rank = 359;
+	if ( m_mouseSprite == SPRITE_ARROWUR )  rank = 360;
+
+	nbx = m_totalDim[CHBLUPI].x / m_iconDim[CHBLUPI].x;
+
+	rcRect.left   = (rank%nbx)*m_iconDim[CHBLUPI].x;
+	rcRect.top    = (rank/nbx)*m_iconDim[CHBLUPI].y;
+	rcRect.right  = rcRect.left+m_iconDim[CHBLUPI].x;
+	rcRect.bottom = rcRect.top +m_iconDim[CHBLUPI].y;
+
+	return rcRect;
+}
+
+// Initialise le hot spot selon le sprite en cours.
+
+void CPixmap::MouseHotSpot()
+{
+	int		rank;
+
+	static int table_mouse_hotspot[14*2] =
+	{
+		30, 30,		// SPRITE_ARROW
+		20, 15,		// SPRITE_POINTER
+		31, 26,		// SPRITE_MAP
+		25, 14,		// SPRITE_ARROWU
+		24, 35,		// SPRITE_ARROWD
+		15, 24,		// SPRITE_ARROWL
+		35, 24,		// SPRITE_ARROWR
+		18, 16,		// SPRITE_ARROWUL
+		32, 18,		// SPRITE_ARROWUR
+		17, 30,		// SPRITE_ARROWDL
+		32, 32,		// SPRITE_ARROWDR
+		30, 30,		// SPRITE_WAIT
+		30, 30,		// SPRITE_EMPTY
+		21, 51,		// SPRITE_FILL
+	};
+
+	if ( m_mouseSprite >= SPRITE_ARROW &&
+		 m_mouseSprite <= SPRITE_FILL  )
+	{
+		rank = m_mouseSprite - SPRITE_ARROW;  // rank <- 0..n
+
+		m_mouseHotSpot.x = table_mouse_hotspot[rank*2+0];
+		m_mouseHotSpot.y = table_mouse_hotspot[rank*2+1];
+	}
+	else
+	{
+		m_mouseHotSpot.x = 0;
+		m_mouseHotSpot.y = 0;
+	}
+}
+
+
diff --git a/pixmap.h b/pixmap.h
new file mode 100644
index 0000000..32816f6
--- /dev/null
+++ b/pixmap.h
@@ -0,0 +1,111 @@
+// CPixmap.h
+
+#pragma once
+
+#include <ddraw.h>
+
+/////////////////////////////////////////////////////////////
+
+#define MAXIMAGE    100
+
+
+class CPixmap
+{
+public:
+    CPixmap();
+    ~CPixmap();
+
+    void    SetDebug(BOOL bDebug);
+
+    BOOL    Create(HWND hwnd, POINT dim, BOOL bFullScreen, int mouseType);
+    BOOL    Flush();
+    BOOL    Restore();
+    BOOL    InitSysPalette();
+    BOOL    IsPalette();
+    void    Fill(RECT rect, COLORREF color);
+
+    BOOL    SavePalette();
+    BOOL    RestorePalette();
+    int     SearchColor(int red, int green, int blue);
+    BOOL    Cache(int channel, char *pFilename, POINT totalDim, POINT iconDim, BOOL bUsePalette);
+    BOOL    Cache(int channel, char *pFilename, POINT totalDim, BOOL bUsePalette);
+    BOOL    Cache(int channel, HBITMAP hbm, POINT totalDim);
+    void    Flush(int channel);
+    void    SetTransparent(int channel, COLORREF color);
+    void    SetTransparent2(int channel, COLORREF color1, COLORREF color2);
+    void    SetClipping(RECT clip);
+    RECT    GetClipping();
+
+    BOOL    IsIconPixel(int channel, int rank, POINT pos);
+
+    BOOL    DrawIcon(int chDst, int channel, int rank, POINT pos, int mode=0, BOOL bMask=FALSE);
+    BOOL	DrawIconDemi(int chDst, int channel, int rank, POINT pos, int mode=0, BOOL bMask=FALSE);
+	BOOL	DrawIconPart(int chDst, int channel, int rank, POINT pos, int startY, int endY, int mode=0, BOOL bMask=FALSE);
+	BOOL	DrawPart(int chDst, int channel, POINT dest, RECT rect, int mode=0, BOOL bMask=FALSE);
+	BOOL	DrawImage(int chDst, int channel, RECT rect, int mode=0);
+
+	BOOL	BuildIconMask(int channelMask, int rankMask,
+						  int channel, int rankSrc, int rankDst);
+	
+	BOOL	Display();
+
+	void	SetMousePosSprite(POINT pos, int sprite, BOOL bDemoPlay);
+	void	SetMousePos(POINT pos, BOOL bDemoPlay);
+	void	SetMouseSprite(int sprite, BOOL bDemoPlay);
+	void	MouseShow(BOOL bShow);
+	void	MouseInvalidate();
+	void	MouseBackClear();
+	void	MouseBackDraw();
+
+protected:
+	HRESULT	RestoreAll();
+	HRESULT	BltFast(int chDst, int channel, POINT dst, RECT rcRect, int mode);
+	HRESULT	BltFast(LPDIRECTDRAWSURFACE lpDD,
+					int channel, POINT dst, RECT rcRect, int mode);
+
+	void	MouseUpdate();
+	BOOL	MouseQuickDraw(RECT rect);
+	void	MouseBackSave();
+	void	MouseBackRestore();
+	void	MouseBackDebug();
+	RECT	MouseRectSprite();
+	void	MouseHotSpot();
+
+protected:
+    BOOL                   m_bFullScreen;
+    BOOL                   m_bBenchmarkSuccess;
+    BOOL                   m_bTrueColor;
+    BOOL                   m_bTrueColorDecor;
+    BOOL                   m_field5_0x14; //Need to figure out
+    BOOL                   m_field5_0x18; //Need to figure out
+    int                    m_mouseType;
+    BOOL                   m_bDebug;
+    BOOL                   m_bPalette;
+    HWND                   m_hWnd;
+    POINT                  m_dim;
+    RECT                   m_clipRect;
+
+    POINT                  m_mousePos;
+    int                    m_mouseSprite;
+    POINT                  m_mouseHotSpot;
+    POINT                  m_mouseBackPos;
+    BOOL                   m_bMouseBack;
+    BOOL                   m_bMouseShow;
+    BOOL                   m_bBackDisplayed;
+
+    LPDIRECTDRAW           m_lpDD;
+    LPDIRECTDRAWSURFACE    m_lpDDSPrimary;
+    LPDIRECTDRAWSURFACE    m_lpDDSBack;
+    LPDIRECTDRAWSURFACE    m_lpDDSMouse;
+    LPDIRECTDRAWPALETTE    m_lpDDPal;
+    LPDIRECTDRAWSURFACE    m_lpDDSurface[MAXIMAGE];
+    LPDIRECTDRAWCLIPPER    m_lpClipper;
+    PALETTEENTRY           m_pal[256];
+    PALETTEENTRY           m_sysPal[256];
+    COLORREF               m_colorSurface[2*MAXIMAGE];
+
+    char                   m_filename[MAXIMAGE][20];
+    POINT                  m_totalDim[MAXIMAGE];
+    POINT                  m_iconDim[MAXIMAGE];
+    DDBLTFX                m_DDbltfx
+}
\ No newline at end of file
diff --git a/sound.cpp b/sound.cpp
new file mode 100644
index 0000000..414f9a4
--- /dev/null
+++ b/sound.cpp
@@ -0,0 +1,648 @@
+// sound.cpp
+//
+
+#include <dsound.h>
+#include <stdio.h>
+#include "sound.h"
+#include "misc.h"
+#include "def.h"
+#include "resource.h"
+
+
+/////////////////////////////////////////////////////////////////////////////
+
+
+
+// The following macro are used for proper error handling for DirectSound.
+#define TRY_DS(exp) { { HRESULT rval = exp; if (rval != DS_OK) { TraceErrorDS(rval, __FILE__, __LINE__); return FALSE; } } }
+
+
+struct WaveHeader
+{
+    BYTE        RIFF[4];          // "RIFF"
+    DWORD       dwSize;           // Size of data to follow
+    BYTE        WAVE[4];          // "WAVE"
+    BYTE        fmt_[4];          // "fmt "
+    DWORD       dw16;             // 16
+    WORD        wOne_0;           // 1
+    WORD        wChnls;           // Number of Channels
+    DWORD       dwSRate;          // Sample Rate
+    DWORD       BytesPerSec;      // Sample Rate
+    WORD        wBlkAlign;        // 1
+    WORD        BitsPerSample;    // Sample size
+    BYTE        DATA[4];          // "DATA"
+    DWORD       dwDSize;          // Number of Samples
+};
+
+
+
+
+// Creates a DirectSound buffer.
+
+BOOL CSound::CreateSoundBuffer(int dwBuf, DWORD dwBufSize, DWORD dwFreq, DWORD dwBitsPerSample, DWORD dwBlkAlign, BOOL bStereo)
+{
+    PCMWAVEFORMAT	pcmwf;
+    DSBUFFERDESC	dsbdesc;
+    
+    // Set up wave format structure.
+    memset( &pcmwf, 0, sizeof(PCMWAVEFORMAT) );
+    pcmwf.wf.wFormatTag      = WAVE_FORMAT_PCM;      
+    pcmwf.wf.nChannels       = bStereo ? 2 : 1;
+    pcmwf.wf.nSamplesPerSec  = dwFreq;
+    pcmwf.wf.nBlockAlign     = (WORD)dwBlkAlign;
+    pcmwf.wf.nAvgBytesPerSec = pcmwf.wf.nSamplesPerSec * pcmwf.wf.nBlockAlign;
+    pcmwf.wBitsPerSample     = (WORD)dwBitsPerSample;
+
+    // Set up DSBUFFERDESC structure.
+    memset(&dsbdesc, 0, sizeof(DSBUFFERDESC));  // Zero it out. 
+    dsbdesc.dwSize           = sizeof(DSBUFFERDESC);
+    dsbdesc.dwFlags          = DSBCAPS_CTRLFREQUENCY | DSBCAPS_CTRLPAN | DSBCAPS_CTRLVOLUME;
+    dsbdesc.dwBufferBytes    = dwBufSize; 
+    dsbdesc.lpwfxFormat      = (LPWAVEFORMATEX)&pcmwf;
+
+    TRY_DS(m_lpDS->CreateSoundBuffer(&dsbdesc, &m_lpDSB[dwBuf], NULL))
+    return TRUE;
+}
+
+// Reads in data from a wave file.
+
+BOOL CSound::ReadData(LPDIRECTSOUNDBUFFER lpDSB, FILE* pFile, DWORD dwSize, DWORD dwPos) 
+{
+    // Seek to correct position in file (if necessary)
+    if ( dwPos != 0xffffffff ) 
+    {
+        if ( fseek(pFile, dwPos, SEEK_SET) != 0 ) 
+        {
+            return FALSE;
+        }
+    }
+
+    // Lock data in buffer for writing
+    LPVOID	pData1;
+    DWORD	dwData1Size;
+    LPVOID	pData2;
+    DWORD	dwData2Size;
+    HRESULT	rval;
+
+    rval = lpDSB->Lock(0, dwSize, &pData1, &dwData1Size, &pData2, &dwData2Size, DSBLOCK_FROMWRITECURSOR);
+    if ( rval != DS_OK )
+    {
+        return FALSE;
+    }
+
+    // Read in first chunk of data
+    if ( dwData1Size > 0 ) 
+    {
+        if ( fread(pData1, dwData1Size, 1, pFile) != 1 ) 
+        {          
+                        char holder[256];
+                        wsprintf(holder,"Data1 : %d, dwdata: %d, pFile: %d",pData1,dwData1Size,pFile);
+                        OutputDebug(holder);
+            return FALSE;
+        }
+    }
+
+    // read in second chunk if necessary
+    if ( dwData2Size > 0 ) 
+    {
+        if ( fread(pData2, dwData2Size, 1, pFile) != 1 ) 
+        {
+            return FALSE;
+        }
+    }
+
+    // Unlock data in buffer
+    rval = lpDSB->Unlock(pData1, dwData1Size, pData2, dwData2Size);
+    if ( rval != DS_OK )
+    {
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+// Creates a DirectSound buffer from a wave file.
+
+BOOL CSound::CreateBufferFromWaveFile(int dwBuf, char *pFileName)
+{
+    // Open the wave file       
+    FILE* pFile = fopen(pFileName, "rb");
+    if ( pFile == NULL ) return FALSE;
+
+    // Read in the wave header          
+    WaveHeader wavHdr;
+    if ( fread(&wavHdr, sizeof(wavHdr), 1, pFile) != 1 ) 
+    {
+        fclose(pFile);
+        return NULL;
+    }
+
+    // Figure out the size of the data region
+    DWORD dwSize = wavHdr.dwDSize;
+
+    // Is this a stereo or mono file?
+    BOOL bStereo = wavHdr.wChnls > 1 ? TRUE : FALSE;
+
+    // Create the sound buffer for the wave file
+    if ( !CreateSoundBuffer(dwBuf, dwSize, wavHdr.dwSRate,
+							wavHdr.BitsPerSample, wavHdr.wBlkAlign, bStereo) )
+    {
+        // Close the file
+        fclose(pFile);
+        
+        return FALSE;
+    }
+
+    // Read the data for the wave file into the sound buffer
+    if ( !ReadData(m_lpDSB[dwBuf], pFile, dwSize, sizeof(wavHdr)) )
+    {
+        fclose(pFile);
+        return FALSE;
+    }
+
+    // Close out the wave file
+    fclose(pFile);
+
+    return TRUE;
+}
+
+// Stops all sounds.
+
+BOOL CSound::StopAllSounds()
+{
+    // Make sure we have a valid sound buffer
+    for (int i = 0; i < MAXSOUND; i ++)
+    {
+        if ( m_lpDSB[i] )
+        {
+            DWORD dwStatus;
+            TRY_DS(m_lpDSB[i]->GetStatus(&dwStatus));
+
+            if ( (dwStatus & DSBSTATUS_PLAYING) == DSBSTATUS_PLAYING )
+            {
+                TRY_DS(m_lpDSB[i]->Stop())
+            }
+        }
+    }
+
+    return TRUE;
+}
+
+// Plays a sound using direct sound.
+
+BOOL CSound::PlaySoundDS(DWORD dwSound, DWORD dwFlags)
+{
+    // Make sure the sound is valid
+    if ( dwSound >= MAXSOUND )  return FALSE;    
+
+    // Make sure we have a valid sound buffer
+    if ( m_lpDSB[dwSound] )
+    {
+        DWORD dwStatus;
+        TRY_DS(m_lpDSB[dwSound]->GetStatus(&dwStatus));
+
+        if ( (dwStatus & DSBSTATUS_PLAYING) != DSBSTATUS_PLAYING )
+        {
+            // Play the sound
+           TRY_DS(m_lpDSB[dwSound]->Play(0, 0, dwFlags));
+        }
+    }
+
+    return TRUE;
+}
+
+
+
+/////////////////////////////////////////////////////////////////////////////
+
+
+// Modifie le volume midi.
+// Le volume est compris entre 0 et 20 !
+
+void InitMidiVolume(int volume)
+{
+	int				nb, i, n;
+	MMRESULT		result;
+	HMIDIOUT		hmo = 0;
+
+	static int table[21] =
+	{
+		0x00000000,
+		0x11111111,
+		0x22222222,
+		0x33333333,
+		0x44444444,
+		0x55555555,
+		0x66666666,
+		0x77777777,
+		0x88888888,
+		0x99999999,
+		0xAAAAAAAA,
+		0xBBBBBBBB,
+		0xCCCCCCCC,
+		0xDDDDDDDD,
+		0xEEEEEEEE,
+		0xF222F222,
+		0xF555F555,
+		0xF777F777,
+		0xFAAAFAAA,
+		0xFDDDFDDD,
+		0xFFFFFFFF,
+	};
+
+	if ( volume < 0         )  volume = 0;
+	if ( volume > MAXVOLUME )  volume = MAXVOLUME;
+
+	nb = midiOutGetNumDevs();
+	for ( i=0 ; i<nb ; i++ )
+	{
+		result = midiOutOpen((LPHMIDIOUT)&hmo, i, 0L, 0L, 0L);
+		if ( result != MMSYSERR_NOERROR )
+		{
+			continue;
+		}
+
+		result = midiOutSetVolume(hmo, table[volume]);
+		if ( result != MMSYSERR_NOERROR )
+		{
+			n = 1;
+		}
+		midiOutClose(hmo);
+		hmo = 0;
+	}
+}
+
+
+/////////////////////////////////////////////////////////////////////////////
+
+
+// Constructeur.
+
+CSound::CSound()
+{
+	int		i;
+	
+	m_bEnable         = FALSE;
+	m_bState          = FALSE;
+	m_MidiDeviceID    = 0;
+	m_MIDIFilename[0] = 0;
+	m_audioVolume     = 20;
+	m_midiVolume      = 15;
+	m_lastMidiVolume  = 0;
+	m_nbSuspendSkip   = 0;
+
+	m_lpDS = NULL;
+
+	for ( i=0 ; i<MAXSOUND ; i++ )
+	{
+		m_lpDSB[i] = NULL;
+	}
+
+	for ( i=0 ; i<MAXBLUPI ; i++ )
+	{
+		m_channelBlupi[i] = -1;
+	}
+}
+
+// Destructeur.
+
+CSound::~CSound()
+{
+	int		i;
+
+	if ( m_bEnable )
+	{
+		InitMidiVolume(15);  // remet un volume moyen !
+	}
+
+	for ( i=0 ; i<MAXSOUND ; i++ )
+	{
+		if ( m_lpDSB[i] != NULL )
+		{
+//?			m_lpDSB[i]->Release();
+			m_lpDSB[i]= NULL;
+		}
+	}
+
+	if ( m_lpDS != NULL )
+	{
+		m_lpDS->Release();
+		m_lpDS = NULL;
+	}
+}
+
+
+// Initialisation de DirectSound.
+
+BOOL CSound::Create(HWND hWnd)
+{
+	if ( !DirectSoundCreate(NULL, &m_lpDS, NULL) == DS_OK )
+	{
+		OutputDebug("Fatal error: DirectSoundCreate\n");
+		m_bEnable = FALSE;
+		return FALSE;
+	}
+
+	m_lpDS->SetCooperativeLevel(hWnd, DSSCL_NORMAL);
+	m_bEnable = TRUE;
+	m_hWnd    = hWnd;
+	return TRUE;
+}
+
+
+// Retourne l'�tat de DirectSound.
+
+BOOL CSound::GetEnable()
+{
+	return m_bEnable;
+}
+
+
+// Enclenche ou d�clenche le son.
+
+void CSound::SetState(BOOL bState)
+{
+	m_bState = bState;
+}
+
+
+// Gestion des volumes audio (.wav) et midi (.mid).
+
+void CSound::SetAudioVolume(int volume)
+{
+	m_audioVolume = volume;
+}
+
+int CSound::GetAudioVolume()
+{
+	if ( !m_bEnable )  return 0;
+	return m_audioVolume;
+}
+
+void CSound::SetMidiVolume(int volume)
+{
+	m_midiVolume = volume;
+}
+
+int CSound::GetMidiVolume()
+{
+	if ( !m_bEnable )  return 0;
+	return m_midiVolume;
+}
+
+
+// Cache tous les ficheirs son (.wav).
+
+void CSound::CacheAll()
+{
+	int			i;
+	char		name[50];
+
+	if ( !m_bEnable )  return;
+
+	for ( i=0 ; i<MAXSOUND ; i++ )
+	{
+		sprintf(name, "sound\\sound%.3d.blp", i);
+		if ( !Cache(i, name) )  break;
+	}
+}
+
+// Charge un fichier son (.wav).
+	
+BOOL CSound::Cache(int channel, char *pFilename)
+{
+	if ( !m_bEnable )  return FALSE;
+	if ( channel < 0 || channel >= MAXSOUND )  return FALSE;
+
+	if ( m_lpDSB[channel] != NULL )
+	{
+		Flush(channel);
+	}
+	
+	return CreateBufferFromWaveFile(channel, pFilename);
+}
+
+// D�charge un son.
+
+void CSound::Flush(int channel)
+{
+	if ( !m_bEnable )  return;
+	if ( channel < 0 || channel >= MAXSOUND )  return;
+
+	if ( m_lpDSB[channel] != NULL )
+	{
+		m_lpDSB[channel]->Release();
+		m_lpDSB[channel]= NULL;
+	}
+}
+
+// Fait entendre un son.
+// Le volume est compris entre 0 (max) et -10000 (silence).
+// Le panoramique est compris entre -10000 (gauche), 0 (centre)
+// et +10000 (droite).
+
+BOOL CSound::Play(int channel, int volume, int pan)
+{
+	if ( !m_bEnable )  return TRUE;
+	if ( !m_bState || m_audioVolume == 0 )  return TRUE;
+
+	volume -= (MAXVOLUME-m_audioVolume)*((10000/4)/MAXVOLUME);
+
+//?	if ( volume == -10000 )  return TRUE;
+	if ( volume <= -10000/4 )  return TRUE;
+
+	if ( channel < 0 || channel >= MAXSOUND )  return FALSE;
+	if ( m_lpDSB[channel] == NULL )            return FALSE;
+
+	m_lpDSB[channel]->SetVolume(volume);
+	m_lpDSB[channel]->SetPan(pan);
+	m_lpDSB[channel]->Play(0, 0, 0);
+
+	return TRUE;
+}
+
+// Fait entendre un son dans une image.
+// Si rank != -1, il indique le rang du blupi dont il faudra
+// �ventuellement stopper le dernier son en cours !
+
+BOOL CSound::PlayImage(int channel, POINT pos, int rank)
+{
+	int		stopCh, volumex, volumey, volume, pan;
+
+	if ( rank >= 0 && rank < MAXBLUPI )
+	{
+		stopCh = m_channelBlupi[rank];
+		if ( stopCh >= 0 && m_lpDSB[stopCh] != NULL )
+		{
+			m_lpDSB[stopCh]->Stop();  // stoppe le son pr�c�dent
+			m_lpDSB[stopCh]->SetCurrentPosition(0);
+		}
+
+		m_channelBlupi[rank] = channel;
+	}
+
+//?	pan = (int)(((long)pos.x*20000L)/LXIMAGE)-10000L;
+//?	pan = (int)(((long)pos.x*10000L)/LXIMAGE)-5000L;
+	pan = (int)(((long)pos.x*5000L)/LXIMAGE)-2500L;
+
+	volumex = 0;  // volume maximum
+	if ( pos.x < 0 )
+	{
+		volumex = (pos.x*2500)/LXIMAGE;
+	}
+	if ( pos.x > LXIMAGE )
+	{
+		pos.x -= LXIMAGE;
+		volumex = (-pos.x*2500)/LXIMAGE;
+	}
+	if ( volumex < -10000 )  volumex = -10000;
+
+	volumey = 0;  // volume maximum
+	if ( pos.y < 0 )
+	{
+		volumey = (pos.y*2500)/LYIMAGE;
+	}
+	if ( pos.y > LYIMAGE )
+	{
+		pos.y -= LYIMAGE;
+		volumey = (-pos.y*2500)/LYIMAGE;
+	}
+	if ( volumey < -10000 )  volumey = -10000;
+
+	if ( volumex < volumey )  volume = volumex;
+	else                      volume = volumey;
+
+	return Play(channel, volume, pan);
+}
+
+
+// Uses MCI to play a MIDI file. The window procedure
+// is notified when playback is complete.
+
+BOOL CSound::PlayMusic(HWND hWnd, LPSTR lpszMIDIFilename)
+{
+	MCI_OPEN_PARMS	mciOpenParms;
+	MCI_PLAY_PARMS	mciPlayParms;
+	DWORD			dwReturn;
+	char			string[MAX_PATH];
+
+	if ( !m_bEnable )  return TRUE;
+	if ( m_midiVolume == 0 )  return TRUE;
+	InitMidiVolume(m_midiVolume);
+	m_lastMidiVolume = m_midiVolume;
+
+	if ( lpszMIDIFilename[1] == ':' )  // nom complet "D:\REP..." ?
+	{
+		strcpy(string, lpszMIDIFilename);
+	}
+	else
+	{
+		GetCurrentDir(string, MAX_PATH-30);
+		strcat(string, lpszMIDIFilename);
+	}
+
+	// Open the device by specifying the device and filename.
+	// MCI will attempt to choose the MIDI mapper as the output port.
+	mciOpenParms.lpstrDeviceType = "sequencer";
+	mciOpenParms.lpstrElementName = string;
+	dwReturn = mciSendCommand(NULL,
+							  MCI_OPEN,
+							  MCI_OPEN_TYPE|MCI_OPEN_ELEMENT,
+							  (DWORD)(LPVOID)&mciOpenParms);
+	if ( dwReturn != 0 )
+	{
+		OutputDebug("PlayMusic-1\n");
+		mciGetErrorString(dwReturn, string, 128);
+		OutputDebug(string);
+		// Failed to open device. Don't close it; just return error.
+		return FALSE;
+	}
+
+	// The device opened successfully; get the device ID.
+	m_MidiDeviceID = mciOpenParms.wDeviceID;
+
+	// Begin playback. 
+	mciPlayParms.dwCallback = (DWORD)hWnd;
+	dwReturn = mciSendCommand(m_MidiDeviceID,
+							  MCI_PLAY,
+							  MCI_NOTIFY, 
+							  (DWORD)(LPVOID)&mciPlayParms);
+	if ( dwReturn != 0 )
+	{
+		OutputDebug("PlayMusic-2\n");
+		mciGetErrorString(dwReturn, string, 128);
+		OutputDebug(string);
+		StopMusic();
+		return FALSE;
+	}
+
+	strcpy(m_MIDIFilename, lpszMIDIFilename);
+
+	return TRUE;
+}
+
+// Restart the MIDI player.
+
+BOOL CSound::RestartMusic()
+{
+	OutputDebug("RestartMusic\n");
+	if ( !m_bEnable )  return TRUE;
+	if ( m_midiVolume == 0 )  return TRUE;
+	if ( m_MIDIFilename[0] == 0 )  return FALSE;
+
+	return PlayMusic(m_hWnd, m_MIDIFilename);
+}
+
+// Shuts down the MIDI player.
+
+void CSound::SuspendMusic()
+{
+	if ( !m_bEnable )  return;
+
+	if ( m_nbSuspendSkip != 0 )
+	{
+		m_nbSuspendSkip --;
+		return;
+	}
+
+	if ( m_MidiDeviceID && m_midiVolume != 0 )
+	{
+		mciSendCommand(m_MidiDeviceID, MCI_CLOSE, 0, NULL);
+	}
+	m_MidiDeviceID = 0;
+}
+
+// Shuts down the MIDI player.
+
+void CSound::StopMusic()
+{
+	SuspendMusic();
+	m_MIDIFilename[0] = 0;
+}
+
+// Retourne TRUE si une musique est en cours.
+
+BOOL CSound::IsPlayingMusic()
+{
+	return (m_MIDIFilename[0] != 0);
+}
+
+// Adapte le volume de la musique en cours, si n�cessaire.
+
+void CSound::AdaptVolumeMusic()
+{
+	if ( m_midiVolume != m_lastMidiVolume )
+	{
+		InitMidiVolume(m_midiVolume);
+		m_lastMidiVolume = m_midiVolume;
+		RestartMusic();
+	}
+}
+
+// Indique le nombre de suspend � sauter.
+
+void CSound::SetSuspendSkip(int nb)
+{
+	m_nbSuspendSkip = nb;
+}
+
diff --git a/sound.h b/sound.h
new file mode 100644
index 0000000..1b15a51
--- /dev/null
+++ b/sound.h
@@ -0,0 +1,65 @@
+// sound.h
+//
+
+#pragma once
+
+#include <dsound.h>
+#include <stdio.h>
+
+
+///////////////////////////////////////////////////////////////////////////
+
+#define MAXSOUND    100
+#define MAXVOLUME   20
+#define MAXBLUPI    100
+
+class CSound
+{
+public:
+    CSound();
+    ~CSound();
+
+    BOOL Create(HWND hWnd);
+    void SetState(BOOL bState);
+    BOOL GetEnable();
+
+    void SetAudioVolume(int volume);
+    int  GetAudioVolume();
+    void SetMidiVolume(int volume);
+    int  GetMidiVolume();
+
+    void CacheAll();
+    BOOL Cache(int channel, char *pFilename);
+    void Flush(int channel);
+
+    BOOL Play (int channel, int volume=0, int pan=0);
+    BOOL PlayImage(int channel, POINT pos, int rank=-1);
+    BOOL PlayMusic(HWND hWnd, LPSTR lpszMIDIFilename);
+    BOOL RestartMusic();
+    void SuspendMusic();
+    void StopMusic();
+    BOOL IsPlayingMusic();
+    void AdaptVolumeMusic();
+    void SetSuspendSkip(int nb);
+
+protected:
+    BOOL CreateSoundBuffer(int dwBuf, DWORD dwBufSize, DWORD dwFreq, DWORD dwBitsPerSample, DWORD dwBlkAlign, BOOL bStereo);
+    BOOL ReadData(LPDIRECTSOUNDBUFFER lpDSB, FILE* pFile, DWORD dwSize, DWORD dwPos);
+    BOOL CreateBufferFromWaveFile(int dwBuf, char *pFileName);
+    BOOL StopAllSounds();
+    BOOL PlaySoundDS(DWORD dwSound, DWORD dwFlags);
+
+protected:
+    HWND                    m_hWnd;
+    BOOL                    m_bEnable;
+    BOOL                    m_bState;
+    LPDIRECTSOUND           m_lpDS;
+    LPDIRECTSOUNDBUFFER     m_lpDSB[MAXSOUND];
+    short                   m_channelBlupi[MAXBLUPI];
+    UINT                    m_MidiDeviceID;
+    char                    m_MIDIFilename[50];
+    int                     m_audioVolume;
+    int                     m_midiVolume;
+    int                     m_lastMidiVolume;
+    int                     m_nbSuspendSkip;    
+};
\ No newline at end of file
diff --git a/text.cpp b/text.cpp
new file mode 100644
index 0000000..93b7f45
--- /dev/null
+++ b/text.cpp
@@ -0,0 +1,346 @@
+// Text.cpp
+
+#include <windows.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <ddraw.h>
+#include "def.h"
+#include "pixmap.h"
+#include "text.h"
+
+
+/////////////////////////////////////////////////////////////////////////////
+
+
+// Retourne l'offset pour un caract�re donn�.
+
+int GetOffset(char c)
+{
+	int		i;
+
+	static unsigned char table_accents[15] =
+	{
+		0xFC, 0xE0, 0xE2, 0xE9, 0xE8, 0xEB, 0xEA, 0xEF,
+		0xEE, 0xF4, 0xF9, 0xFB, 0xE4, 0xF6, 0xE7
+	};
+
+	for ( i=0 ; i<15 ; i++ )
+	{
+		if ( (unsigned char)c == table_accents[i] )
+		{
+			return 15+i;
+		}
+	}
+	if ( c<0 || c>128 )  return 1;  // carr�
+
+	return c;
+}
+
+// Retourne la longueur d'un caract�re.
+
+int GetCharWidth(char c, int font)
+{
+	static unsigned char table_width[128] =
+	{
+		9,10,10,10,10,10,10,10,10,10,10,10,10,10,10,8,
+		9,9,8,8,8,8,5,5,8,8,8,9,8,8,10,10,
+		5,6,9,13,11,12,12,6,6,6,12,12,5,9,6,9,
+		8,8,9,9,8,9,8,8,9,9,6,6,8,9,10,11,
+		12,8,9,9,9,8,8,8,9,4,8,9,8,10,9,9,
+		8,9,8,9,10,8,9,11,9,8,10,7,10,7,13,13,
+		9,9,8,8,8,8,6,8,8,4,6,8,4,12,8,8,
+		8,8,7,6,7,8,8,10,8,8,7,6,6,6,10,0,
+	};
+
+	static unsigned char table_width_little[128] =
+	{
+		6,6,6,6,6,6,6,6,6,6,6,6,5,6,6,7,
+		6,6,6,6,6,6,3,3,6,6,6,6,6,6,5,5,
+		3,3,5,8,5,11,9,3,4,4,6,6,3,4,3,6,
+		5,5,5,5,5,5,5,5,5,5,3,3,7,6,7,6,
+		9,8,6,7,7,5,5,8,7,2,4,7,5,10,7,8,
+		6,8,7,6,6,6,8,12,7,6,6,3,5,3,6,8,
+		4,6,6,6,6,6,4,6,6,2,3,5,2,10,6,6,
+		6,6,3,5,3,6,6,8,6,6,5,4,6,4,7,0,
+	};
+
+	if ( font == FONTLITTLE )
+	{
+		return table_width_little[GetOffset(c)];
+	}
+	else
+	{
+		return table_width[GetOffset(c)]-1;
+	}
+}
+
+// Affiche un texte.
+
+void DrawText(CPixmap *pPixmap, POINT pos, char *pText, int font)
+{
+	int		rank;
+
+	if ( font == FONTLITTLE )
+	{
+		while ( *pText != 0 )
+		{
+			rank = GetOffset(*pText);
+			pPixmap->DrawIcon(-1, CHLITTLE, rank, pos);
+
+			pos.x += GetCharWidth(*pText++, font);
+		}
+	}
+	else
+	{
+		while ( *pText != 0 )
+		{
+			rank = GetOffset(*pText);
+			rank += 128*font;
+			pPixmap->DrawIcon(-1, CHTEXT, rank, pos);
+
+			pos.x += GetCharWidth(*pText++, font);
+		}
+	}
+}
+
+// Affiche un texte pench�.
+
+void DrawTextPente(CPixmap *pPixmap, POINT pos, char *pText,
+				   int pente, int font)
+{
+	int		rank, lg, rel, start;
+
+	start = pos.y;
+	rel = 0;
+	while ( *pText != 0 )
+	{
+		rank = GetOffset(*pText);
+		rank += 128*font;
+		pPixmap->DrawIcon(-1, CHTEXT, rank, pos);
+
+		lg = GetCharWidth(*pText++, font);
+		rel += lg;
+		pos.x += lg;
+		pos.y = start + rel/pente;
+	}
+}
+
+// Affiche un pav� de texte.
+// Une ligne vide est affich�e avec un demi interligne !
+// Si part != -1, n'affiche que les lignes qui commencent
+// par "n|", avec n=part.
+
+void DrawTextRect(CPixmap *pPixmap, POINT pos, char *pText,
+				  int pente, int font, int part)
+{
+	char		text[100];
+	char*		pDest;
+	int			itl;
+
+	if ( font == FONTLITTLE )  itl = DIMLITTLEY;
+	else                       itl = DIMTEXTY;
+
+	while ( *pText != 0 )
+	{
+		pDest = text;
+		while ( *pText != 0 && *pText != '\r' && *pText != '\n' )
+		{
+			*pDest++ = *pText++;
+		}
+		*pDest = 0;
+		if ( *pText == '\r' )  pText ++;  // saute '\r'
+		if ( *pText == '\n' )  pText ++;  // saute '\n'
+
+		pDest = text;
+		if ( text[0] != 0 && text[1] == '|' )  // commence par "n|" ?
+		{
+			if ( part != -1 && part != text[0]-'0' )  continue;
+			pDest += 2;  // saute "n|"
+		}
+		else
+		{
+			if ( part != -1 )  continue;
+		}
+
+		if ( pente == 0 )
+		{
+			DrawText(pPixmap, pos, pDest, font);
+		}
+		else
+		{
+			DrawTextPente(pPixmap, pos, pDest, pente, font);
+		}
+
+		if ( pDest[0] == 0 )  // ligne vide ?
+		{
+			pos.y += itl/2;  // descend de 1/2 ligne
+		}
+		else
+		{
+			pos.y += itl;  // passe � la ligne suivante
+		}
+	}
+}
+
+// Affiche un texte centr� pouvant �ventuellement
+// contenir plusieurs lignes s�par�es par des '\n'.
+
+void DrawTextCenter(CPixmap *pPixmap, POINT pos, char *pText, int font)
+{
+	char		text[100];
+	char*		pDest;
+	int			itl;
+	POINT		start;
+
+	if ( font == FONTLITTLE )  itl = DIMLITTLEY;
+	else                       itl = DIMTEXTY;
+
+	while ( *pText != 0 )
+	{
+		pDest = text;
+		while ( *pText != 0 && *pText != '\r' && *pText != '\n' )
+		{
+			*pDest++ = *pText++;
+		}
+		*pDest = 0;
+		if ( *pText == '\r' )  pText ++;  // saute '\r'
+		if ( *pText == '\n' )  pText ++;  // saute '\n'
+
+		pDest = text;
+		start.x = pos.x - GetTextWidth(pDest)/2;
+		start.y = pos.y;
+		DrawText(pPixmap, start, pDest, font);
+
+		if ( pDest[0] == 0 )  // ligne vide ?
+		{
+			pos.y += itl/2;  // descend de 1/2 ligne
+		}
+		else
+		{
+			pos.y += itl;  // passe � la ligne suivante
+		}
+	}
+}
+
+// Retourne la hauteur d'un texte.
+
+int GetTextHeight(char *pText, int font, int part)
+{
+	char		text[100];
+	char*		pDest;
+	int			itl;
+	int			h=0;
+
+	if ( font == FONTLITTLE )  itl = DIMLITTLEY;
+	else                       itl = DIMTEXTY;
+
+	while ( *pText != 0 )
+	{
+		pDest = text;
+		while ( *pText != 0 && *pText != '\r' && *pText != '\n' )
+		{
+			*pDest++ = *pText++;
+		}
+		*pDest = 0;
+		if ( *pText == '\r' )  pText ++;  // saute '\r'
+		if ( *pText == '\n' )  pText ++;  // saute '\n'
+
+		pDest = text;
+		if ( text[0] != 0 && text[1] == '|' )  // commence par "n|" ?
+		{
+			if ( part != -1 && part != text[0]-'0' )  continue;
+			pDest += 2;  // saute "n|"
+		}
+		else
+		{
+			if ( part != -1 )  continue;
+		}
+
+		if ( pDest[0] == 0 )  // ligne vide ?
+		{
+			h += itl/2;  // descend de 1/2 ligne
+		}
+		else
+		{
+			h += itl;  // passe � la ligne suivante
+		}
+	}
+
+	return h;
+}
+
+// Retourne la longueur d'un texte.
+
+int GetTextWidth(char *pText, int font)
+{
+	int		width = 0;
+
+	while ( *pText != 0 )
+	{
+		width += GetCharWidth(*pText++, font);
+	}
+
+	return width;
+}
+
+
+// Retourne la longueur d'un grand chiffre.
+
+void GetBignumInfo(int num, int &start, int &lg)
+{
+	static int table[11] =
+	{
+		0,53,87,133,164,217,253,297,340,382,426
+	};
+
+	start = table[num];
+	lg    = table[num+1]-table[num];
+}
+
+// Affiche un grand nombre.
+
+void DrawBignum(CPixmap *pPixmap, POINT pos, int num)
+{
+	char	string[10];
+	int		i = 0;
+	int		start, lg;
+	RECT	rect;
+
+	sprintf(string, "%d", num);
+
+	rect.top    = 0;
+	rect.bottom = 52;
+	while ( string[i] != 0 )
+	{
+		GetBignumInfo(string[i]-'0', start, lg);
+
+		rect.left  = start;
+		rect.right = start+lg;
+		pPixmap->DrawPart(-1, CHBIGNUM, pos, rect);
+		pos.x += lg+4;
+
+		i ++;
+	}
+}
+
+// Retourne la longueur d'un grand nombre.
+
+int GetBignumWidth(int num)
+{
+	char	string[10];
+	int		i = 0;
+	int		start, lg;
+	int		width = -4;
+
+	sprintf(string, "%d", num);
+
+	while ( string[i] != 0 )
+	{
+		GetBignumInfo(string[i]-'0', start, lg);
+		width += lg+4;
+		i ++;
+	}
+
+	return width;
+}
+
diff --git a/text.h b/text.h
new file mode 100644
index 0000000..1f3cf60
--- /dev/null
+++ b/text.h
@@ -0,0 +1,35 @@
+// Text.h
+
+#pragma once
+
+#define FONTWHITE  0
+#define FONTRED    1
+#define FONTSLIM   2
+#define FONTLITTLE 10
+
+extern
+void DrawText(CPixmap *pPixmap, POINT pos, char *pText, int font=0);
+
+extern
+void DrawTextPente(CPixmap *pPixmap, POINT pos, char *pText,
+                   int pente, int font=0);
+
+extern
+void DrawTextRect(CPixmap *pPixmap, POINT pos, char *pText,
+                  int pente, int font=0, int part=-1);
+
+extern
+void DrawTextCenter(CPixmap *pPixmap, POINT pos, char *pText, int font=0);
+
+extern
+int GetTextHeight(char *pText, int font=0, int part=-1);
+
+extern
+int GetTextWidth(char *pText, int font=0);
+
+extern
+void DrawBignum(CPixmap *pPixmap, POINT pos, int num);
+
+extern
+int GetBignumWidth(int num);
+
diff --git a/wave.cpp b/wave.cpp
new file mode 100644
index 0000000..2f0f035
--- /dev/null
+++ b/wave.cpp
@@ -0,0 +1,270 @@
+
+/*****************************************************************
+ *
+ *  Copyright (c) 1996 Microsoft Corporation
+ *
+ *  File:       wave.cpp
+ *  Content:    Routines for getting waves from resources
+ *  Author:     Dave Edson; modified by Peter Donnelly
+ *
+ ******************************************************************/
+
+#include <windows.h>
+#include "wave.h"
+
+typedef struct tagWAVEFILE
+  {
+  DWORD           cbSize;                // Size of file
+  LPWAVEFORMATEX  pwfxInfo;              // Wave Header
+  LPBYTE          pbData;                // Wave Bits
+  }
+WAVEFILE, *LPWAVEFILE;
+
+
+// Function Prototypes  
+BOOL wave_ParseWaveMemory(void *pvRes, 
+                          WAVEFORMATEX **ppWaveHeader, 
+                          BYTE **ppbWaveData,
+                          DWORD *pcbWaveSize);
+
+
+/////////////////////////////////////////////////////////////////
+//
+// WAVE_LoadResource: Gets a wave file into the memory pointed 
+//                    to by pWaveFile from a resource.
+//
+/////////////////////////////////////////////////////////////////
+
+LPVOID WAVE_LoadResource
+  (int           ID,         // ID of resource
+   HMODULE       hModule,    // hInst of app with WAVE
+   LPWAVEFILE    pWaveFile)  // Points to the struct to fill
+{
+    HRSRC   hResInfo;
+    HGLOBAL hResData;
+    void    *pvRes;
+    DWORD   dwSize;
+    LPVOID  lpMemory;
+
+    // Find the resource and load into memory
+    if (((hResInfo = FindResource(hModule, MAKEINTRESOURCE(ID), "WAVE")) != NULL) &&
+        ((hResData = LoadResource(hModule, hResInfo)) != NULL) &&
+        ((pvRes = LockResource(hResData)) != NULL))
+        {
+        // If we found it, copy the bits from the resource into
+        // our own chunk of memory
+        dwSize = SizeofResource(hModule, hResInfo);
+        lpMemory = malloc (dwSize);
+        memcpy (lpMemory, pvRes, dwSize);
+        UnlockResource(hResData);
+        FreeResource(hResData);
+
+        // Parse it out
+        if (wave_ParseWaveMemory(lpMemory, 
+                                 &(pWaveFile->pwfxInfo), 
+                                 &(pWaveFile->pbData), 
+                                 &(pWaveFile->cbSize)))
+          {
+          return lpMemory;  // OK
+          }
+        }
+
+    return NULL;
+}
+
+//////////////////////////////////////////////////////////////////
+//
+// wave_ParseWaveMemory
+//   Parses a chunk of memory into the header and samples.
+//   This is done by looking for the "fmt " and "data"
+//   fields in the memory.
+//
+//////////////////////////////////////////////////////////////////
+
+BOOL wave_ParseWaveMemory
+
+  (LPVOID          lpChunkOfMemory, // Points to raw ram
+   LPWAVEFORMATEX  *lplpWaveHeader, // Points to pointer to header
+   LPBYTE          *lplpWaveSamples,// Points to pointer to samples
+   LPDWORD         lpcbWaveSize)    // Points to size
+{
+    LPDWORD pdw;
+    LPDWORD pdwEnd;
+    DWORD   dwRiff;
+    DWORD   dwType;
+    DWORD   dwLength;
+
+    // Set defaults to NULL or zero
+    if (lplpWaveHeader)
+        *lplpWaveHeader = NULL;
+
+    if (lplpWaveSamples)
+        *lplpWaveSamples = NULL;
+
+    if (lpcbWaveSize)
+        *lpcbWaveSize = 0;
+
+    // Set up DWORD pointers to the start of the chunk
+    // of memory.
+    pdw = (DWORD *)lpChunkOfMemory;
+
+    // Get the type and length of the chunk of memory
+    dwRiff = *pdw++;
+    dwLength = *pdw++;
+    dwType = *pdw++;
+
+    // Using the mmioFOURCC macro (part of Windows SDK), ensure
+    // that this is a RIFF WAVE chunk of memory
+    if (dwRiff != mmioFOURCC('R', 'I', 'F', 'F'))
+      return FALSE;      // not even RIFF
+
+    if (dwType != mmioFOURCC('W', 'A', 'V', 'E'))
+      return FALSE;      // not a WAV
+
+    // Find the pointer to the end of the chunk of memory
+    pdwEnd = (DWORD *)((BYTE *)pdw + dwLength-4);
+
+    // Run through the bytes looking for the tags
+    while (pdw < pdwEnd)
+      {
+      dwType   = *pdw++;
+      dwLength = *pdw++;
+
+      switch (dwType)
+        {
+        // Found the format part
+        case mmioFOURCC('f', 'm', 't', ' '):
+
+          if (lplpWaveHeader && !*lplpWaveHeader)
+            {
+            if (dwLength < sizeof(WAVEFORMAT))
+              return FALSE; // something's wrong! Not a WAV
+
+            // Set the lplpWaveHeader to point to this part of
+            // the memory chunk
+            *lplpWaveHeader = (LPWAVEFORMATEX)pdw;
+
+            // Check to see if the other two items have been
+            // filled out yet (the bits and the size of the
+            // bits). If so, then this chunk of memory has
+            // been parsed out and we can exit
+            if ((!lplpWaveSamples || *lplpWaveSamples) &&
+                (!lpcbWaveSize || *lpcbWaveSize))
+              {
+              return TRUE;
+              }
+            }
+          break;
+
+        // Found the samples
+        case mmioFOURCC('d', 'a', 't', 'a'):
+
+          if ((lplpWaveSamples && !*lplpWaveSamples) ||
+              (lpcbWaveSize && !*lpcbWaveSize))
+            {
+            // Point the samples pointer to this part of the
+            // chunk of memory.
+            if (lplpWaveSamples) *lplpWaveSamples = (LPBYTE)pdw;
+
+            // Set the size of the wave
+            if (lpcbWaveSize)    *lpcbWaveSize = dwLength;
+
+            // Make sure we have our header pointer set up.
+            // If we do, we can exit
+            if (!lplpWaveHeader || *lplpWaveHeader)
+              return TRUE;
+            }
+          break;
+
+        } // End case
+
+      // Move the pointer through the chunk of memory
+      pdw = (DWORD *)((BYTE *)pdw + ((dwLength+1)&~1));
+      }
+
+  // Failed! If we made it here, we did not get all the pieces
+  // of the wave
+  return FALSE;
+} // wave_ParseWaveMemory
+
+
+//////////////////////////////////////////////////////////////////
+//
+// LoadWave
+//   Gets the sound data and loads it into a DirectSound
+//   secondary buffer.
+//                          
+//
+//////////////////////////////////////////////////////////////////
+
+void LoadWave(HINSTANCE hinst, int ResourceID,
+			  LPDIRECTSOUND lpds,
+              LPDIRECTSOUNDBUFFER &lpDSB)
+  {
+// These variables are used in Steps 1 and 2
+  LPVOID              lpWaveData;
+  WAVEFILE            WaveFile;
+  DSBUFFERDESC        dsbd;
+  
+  // These variables are used in step 3, further down below
+  LPVOID            pbData         = NULL;
+  LPVOID            pbData2        = NULL;
+  DWORD             dwLength;
+  DWORD             dwLength2;
+
+
+  lpWaveData = WAVE_LoadResource (ResourceID, hinst, &WaveFile );
+
+  // Step 1: Set up the direct sound buffer. 
+  memset(&dsbd, 0, sizeof(DSBUFFERDESC));
+
+  dsbd.dwSize                 = sizeof(DSBUFFERDESC);
+  // We want a buffer that lives on the sound card's memory 
+  // (DSBCAPS_STATIC) and can have the pan, volume, and 
+  // frequency adjusted (DSBCAPS_CTRLDEFAULT)
+  dsbd.dwFlags                = DSBCAPS_CTRLFREQUENCY | DSBCAPS_CTRLPAN | DSBCAPS_CTRLVOLUME | DSBCAPS_STATIC ;
+
+  // Set up the size and format
+  dsbd.dwBufferBytes          = WaveFile.cbSize; 
+  dsbd.lpwfxFormat            = WaveFile.pwfxInfo;  // Must be a PCM format!
+
+  // Step 2: Create the buffer
+  if (DS_OK != lpds->CreateSoundBuffer(&dsbd, &lpDSB, NULL))
+    {
+    OutputDebugString("Failed to create sound buffer\n");
+    return;
+    }
+// Once this code succeeds, lpDSB will point to a DirectSoundBuffer. 
+// At this point, you can copy blocks of sound data into the buffer, 
+// using the Lock and Unlock interfaces on the DirectSoundBuffer:
+
+  // Lock down the DirectSound buffer
+  if (DS_OK == lpDSB->Lock
+            (0,               // Offset into buffer to start writing
+             WaveFile.cbSize, // Size of wave file to copy in
+             &pbData,         // Points to first block of sound data
+             &dwLength,       // Length of first block of data
+             &pbData2,        // Points to second block of sound data
+             &dwLength2,      // Length of second block of data
+             0L))             // Flags
+    {
+    // Copy first chunk
+    memcpy(pbData, WaveFile.pbData, dwLength);
+
+    // Copy second chunk
+    if (dwLength2) 
+      memcpy(pbData2, WaveFile.pbData+dwLength , dwLength2);
+
+    // Free up the memory allocated in the WAVE_LoadFile function, since we
+    // have copied it to the buffer
+    free (lpWaveData);
+
+    // Unlock the buffer
+    if (DS_OK != lpDSB->Unlock(pbData, dwLength, pbData2, dwLength2))
+      OutputDebugString("Unlock failed");
+    }
+  else
+    {
+    OutputDebugString("Lock failed");
+    }
+  } // LoadWave
diff --git a/wave.h b/wave.h
new file mode 100644
index 0000000..1384aa9
--- /dev/null
+++ b/wave.h
@@ -0,0 +1,14 @@
+/***********************************************
+ * Sound related stuff, I dunno
+************************************************/
+
+
+
+
+
+
+#include <dsound.h>
+
+void LoadWave(HINSTANCE hinst, int ResourceID,
+              LPDIRECTSOUND lpds,
+              LPDIRECTSOUNDBUFFER &lpDSB);
\ No newline at end of file