j´ai pas la possibilité quand je tire par ex ds la techdemo 2 de voir les planches se briser quand je tire avec le revolver mais avec la grenade les impacts sont là que faire pour avoir les impact avec le revolver?

oh mes pauvres enfants plaignez vous

Le pirate est au chommage ou plutot en tole donc a moinq ue son disciple prenne la releve, il nyaura pas de beta cette annee.

J´ai trouvé le fichier texte pour modifier la langue des menus. Pour ce que ca interesse, aller dans anon-hl2/hl2/ressources/gameui_english.txt

faites une copie de sauvegarde impérativement, ensuite ils suffit de remplacer les termes en anglais de gauche quand il y a un & devant un terme, laisse le

ex :

Create & --> Créer un &

Voilà j´espère que ca vous plaira car le menu en français ca fait bizarre !

Mais deja proposé, un patch va sortir dans les jours a venir

http://img16.imageshack.us/my.php?loc=img16&image=hl2fr.JPG
la preuve

moi ca donne pareil mais dans le 2nd fichier texte du dossier ressources valve-english.txt ou c un nom comme ça, on peut modifier les noms de mouvement attribuer au touche sur le clavier, et avec moi, ca marche pas, c´ets normal ?

oui, s´ est normal, ce fichier vient de hl1, tu peut le lire dans les commentaires en haut du fichier, il est possible que hl2 ne lise pas le fichier car il n´ en a pas besoin

Sinon, tu a le fichier GameMenu, tu pourra creer de nouveau menu dans le jeu, il faut y assigner une commande console et l´ assigner aussi dans gameui_english
Simpa pour les codes, echap, je clique sur 2 ou 3 bouton et c parti, god, impulse 101...

quelle commande ? ??
Tu ne la crée pas la commande, tu utilise les commandes de hl2

Si tu veut creer tes commande, il te faut le code source de hl2 et modifier " GameUI.dll"

Mais pour sa il faut un bon niveau de programmation C++, que je n´ ai pas

non, tu assicie un element du menu a une commande de la console

Pour associer une touche a une commande console, s´ est hyper simple, ouvre " config.cfg",
tu y trouvera par exemple:
bind " SPACE" " +jump"
ou la touche espace correspond a la commande sauter dans la console

Mais tu peut faire:
bind " b" " impulse 101"

Et tu fais le plein d´ arme a chaque fois que tu fais b

Pour creer des menus, il suffis que la commande console permetant d´ accéder ace menu existe, si il existe, il te suffis d´ editer GameMenu.res, de donner le nom du menu, donner la source dans la console
Par exemple, la commande du menu new game est:
" OpenNewGameDialog"

Mais je le repete, avec le code source, ils suffis de rajouter des commande, recompiler, et le tour est joué, tu peut y mettre ce que tu veut, tant que tu est doué en C++

Ont l´ as dis ensemble

2 ans

Ce que tu a dans le fichier n´ a rien a voir avec la C++, tu veut voir une partie du code source du fichier en question histoire de voir si tu est capable de le modifier ?

héhé, attend 5 minutes que je le retrouve

Voici une bien maigre partie du fichier HL2.exe par exemple:

/ / launcher.cpp : Defines the entry point for the application.
/ /

1. include < windows.h>
2. include < stdio.h>
3. include " vstdlib/icommandline.h"
4. include " engine_launcher_api.h"
5. include " iengine.h"
6. include " tier0/vcrmode.h"
7. include " IFileSystem.h"
8. include " interface.h"
9. include " tier0/dbg.h"
10. include " iregistry.h"
11. include " appframework/iappsystem.h"
12. include < vgui/VGUI.h>
13. include < vgui/ISurface.h>
14. include " tier0/platform.h"
15. include " tier0/memalloc.h"
16. include " filesystem.h"
17. include < direct.h>

//------------------------------------------------
-----------------------------
/ / Modules...

//------------------------------------------------
-----------------------------
static CSysModule *s_hMatSystemModule;
static CSysModule *s_hVguiMatSurfaceModule;
static CSysModule *s_hEngineModule;
static CSysModule *s_hVGuiModule;

static CreateInterfaceFn s_MaterialSystemFactory;
static CreateInterfaceFn s_VGuiMatSurfaceFactory;
static CreateInterfaceFn s_EngineFactory;
static CreateInterfaceFn s_VGuiFactory;

static char g_szBasedir[ MAX_PATH ];
static char g_szGamedir[ MAX_PATH ];

//------------------------------------------------
-----------------------------
/ / Spew function!

//------------------------------------------------
-----------------------------
SpewRetval_t LauncherDefaultSpewFunc( SpewType_t spewType, char const *pMsg )
{
OutputDebugString( pMsg ) ;
switch( spewType )
{
case SPEW_MESSAGE:
case SPEW_WARNING:
case SPEW_LOG:
OutputDebugString( pMsg ) ;
return SPEW_CONTINUE;

case SPEW_ASSERT:
case SPEW_ERROR:
default:
::MessageBox( NULL, pMsg, " Error!", MB_OK ) ;
return SPEW_DEBUGGER;
}
}

//------------------------------------------------
-----------------------------
/ / Implementation of VCRHelpers.

//------------------------------------------------
-----------------------------
class CVCRHelpers : public IVCRHelpers
{
public:
virtual void ErrorMessage( const char *pMsg )
{
NOVCR(
::MessageBox( NULL, pMsg, " VCR Error", MB_OK )
);
}

virtual void* GetMainWindow()
{
//return game->GetMainWindow();
return NULL;
}
};

static CVCRHelpers g_VCRHelpers;

//------------------------------------------------
-----------------------------
/ / Purpose:
/ / Output : char

//------------------------------------------------
-----------------------------
char *GetGameDirectory( void )
{
return g_szGamedir;
}

//------------------------------------------------
-----------------------------
/ / Purpose:
/ / Output : char

//------------------------------------------------
-----------------------------
char *GetBaseDirectory( void )
{
return g_szBasedir;
}

//------------------------------------------------
-----------------------------
/ / Gets the executable name

//------------------------------------------------
-----------------------------
static bool GetExecutableName( char *out )
{
if ( ! ::GetModuleFileName( ( HINSTANCE ) GetModuleHandle( NULL ) , out, MAX_PATH ) )
{
return false;
}
return true;
}

//------------------------------------------------
-----------------------------
/ / Purpose: Return the directory where this . exe is running from
/ / Output : char

//------------------------------------------------
-----------------------------
static const char *UTIL_GetExecutableDir( )
{
static char exedir[ MAX_PATH ];

exedir[ 0 ] = 0;
if ( ! GetExecutableName( exedir ) )
return NULL;

char *pSlash;
char *pSlash2;
pSlash = strrchr( exedir,´\\´ ) ;
pSlash2 = strrchr( exedir,´/´ ) ;
if ( pSlash2 > pSlash )
{
pSlash = pSlash2;
}
if ( pSlash)
{
*pSlash = 0;
}

// Return the bin directory as the executable dir if it´s not in there
// because that´s really where we´re running from...
char *p = Q_stristr( exedir, " bin" ) ;
if ( ! p )
{
strcat( exedir, " \\bin" ) ;
}

return exedir;
}

//------------------------------------------------
-----------------------------
/ / An aggregate class factory encompassing all factories in all loaded DLLs

//------------------------------------------------
-----------------------------
void* LauncherFactory(const char *pName, int *pReturnCode)
{
void *pRetVal = NULL;

// FIXME: Really, we should just load the DLLs in order
// and search in the order loaded. This is sort of a half-measure hack
// to get to where we need to go

// First ask ourselves
pRetVal = Sys_GetFactoryThis()( pName, pReturnCode ) ;
if ( pRetVal)
return pRetVal;

// First ask the file system...
pRetVal = GetFileSystemFactory()( pName, pReturnCode ) ;
if ( pRetVal)
return pRetVal;

// Next the material system...
pRetVal = s_MaterialSystemFactory( pName, pReturnCode ) ;
if ( pRetVal)
return pRetVal;

// Next the mat surface
pRetVal = s_VGuiMatSurfaceFactory( pName, pReturnCode ) ;
if ( pRetVal)
return pRetVal;

// Next the engine
pRetVal = s_EngineFactory( pName, pReturnCode ) ;
if ( pRetVal)
return pRetVal;

// Next vgui2
pRetVal = s_VGuiFactory( pName, pReturnCode ) ;
if ( pRetVal)
return pRetVal;

return NULL;
}

//------------------------------------------------
-----------------------------
/ / Loads, unloads major systems

//------------------------------------------------
-----------------------------
static bool LoadAppSystems( )
{
// Start up the file system
FileSystem_LoadFileSystemModule();
if ( !FileSystem_Init( ) )
return false;

// Load up the material system
s_hMatSystemModule = FileSystem_LoadModule("materialsystem.dll");
if ( !s_hMatSystemModule)
{
Error( " Unable to load materialsystem.dll" ) ;
return false;
}

s_MaterialSystemFactory = Sys_GetFactory(s_hMatSystemModule);
if ( !s_MaterialSystemFactory)
{
Error( " Unable to get materialsystem factory" ) ;
return false;
}

// Load up the engine
s_hEngineModule = FileSystem_LoadModule( " engine.dll" ) ;
if ( ! s_hEngineModule )
{
Error( " Unable to load engine.dll" ) ;
return false;
}

s_EngineFactory = Sys_GetFactory( s_hEngineModule ) ;
if ( ! s_EngineFactory )
{
Error( " Unable to get engine factory" ) ;
return false;
}

// Load up vgui2
s_hVGuiModule = FileSystem_LoadModule( " vgui2.dll" ) ;
if ( ! s_hVGuiModule )
{
Error( " Unable to load vgui2.dll" ) ;
return false;
}

s_VGuiFactory = Sys_GetFactory( s_hVGuiModule ) ;
if ( ! s_VGuiFactory )
{
Error( " Unable to get vgui2 factory" ) ;
return false;
}

// Load up the mat system surface
s_hVguiMatSurfaceModule = FileSystem_LoadModule("vguimatsurface.dll");
if ( !s_hVguiMatSurfaceModule)
{
Error( " Unable to load vguimatsurface.dll" ) ;
return false;
}

s_VGuiMatSurfaceFactory = Sys_GetFactory(s_hVguiMatSurfaceModule);
if ( !s_VGuiMatSurfaceFactory)
{
Error( " Unable to get vguimatsurface factory" ) ;
return false;
}

return true;
}

static void UnloadAppSystems()
{
if ( s_hVguiMatSurfaceModule)
{

FileSystem_UnloadModule(s_hVguiMatSurfaceModule)
;
s_VGuiMatSurfaceFactory = NULL;
s_hVguiMatSurfaceModule = 0;
}

if ( s_hVGuiModule )
{
FileSystem_UnloadModule( s_hVGuiModule ) ;
s_VGuiFactory = NULL;
s_hVGuiModule = 0;
}

if ( s_hEngineModule )
{
FileSystem_UnloadModule( s_hEngineModule ) ;
s_EngineFactory = NULL;
s_hEngineModule = 0;
}

if ( s_hMatSystemModule)
{
FileSystem_UnloadModule(s_hMatSystemModule);

s_MaterialSystemFactory = NULL;
s_hMatSystemModule = 0;
}

FileSystem_UnloadFileSystemModule();
}

//------------------------------------------------
-----------------------------
/ / System connection...

//------------------------------------------------
-----------------------------
static bool InitAppSystems( void* hInstance )
{
vgui::ISurface *matsurf = static_cast<vgui::ISurface *>( s_VGuiMatSurfaceFactory( VGUI_SURFACE_INTERFACE_VERSION, NULL ) ) ;
if ( matsurf )
{
matsurf->Connect( LauncherFactory ) ;
}
else
{
Error( " Unable to get vguimatsurface IAppSystem * interface" ) ;
}

return true;
}

static void ShutdownAppSystems()
{
// Shut down the file system
FileSystem_Shutdown();
}

1. define HARDWARE_ENGINE " engine.dll"

/ / This is a big chunk of uninitialized memory that we reserve for loading blobs into.
/ / For more information, see LoadBlob.cpp in the engine
/ /char g_rgchBlob[0x03800000];

//------------------------------------------------
-----------------------------
/ / Purpose: Return the directory where this . exe is running from
/ / Output : char

//------------------------------------------------
-----------------------------
void UTIL_GetBaseAndGameDir( char *basedir, char *gamedir )
{
int j;
char *pBuffer = NULL;

basedir[ 0 ] = 0;
gamedir[ 0 ] = 0;

if ( GetExecutableName( basedir ) )
{
_splitpath
(
basedir, / / Input
NULL, / / drive
NULL, / / dir
gamedir, / / filename
NULL / / extension
);

pBuffer = strrchr( basedir,´\\´ ) ;
if ( *pBuffer )
{
*(pBuffer+1) = ´\0´;
}

j = strlen( basedir ) ;
if ( j > 0)
{
if ( ( basedir[ j-1 ] == ´\\´ ) ||
( basedir[ j-1 ] == ´/´ ) )
{
basedir[ j-1 ] = 0;
}
}
}

char const *pOverrideDir = CommandLine()->CheckParm( " -basedir" ) ;
if ( pOverrideDir )
{
strcpy( basedir, pOverrideDir ) ;
}
}

//------------------------------------------------
-----------------------------
/ / Purpose: The real entry point for the application
/ / Input : hInstance -
/ / hPrevInstance -
/ / lpCmdLine -
/ / nCmdShow -
/ / Output : int APIENTRY

//------------------------------------------------
-----------------------------
extern " C" __declspec(dllexport) int LauncherMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow )
{
// Register myself as the primary thread.
//Plat_RegisterPrimaryThread();

// Hook the debug output stuff.
SpewOutputFunc( LauncherDefaultSpewFunc ) ;

// Quickly check the hardware key, essentially a warning shot.
if( ! Plat_VerifyHardwareKeyPrompt() )
{
return -1;
}

// Start VCR mode?
const char *filename;
CommandLine()->CreateCmdLine( g_pVCR->Hook_GetCommandLine() ) ;
if( CommandLine()->CheckParm( " -vcrrecord", & ) )
{
if ( ! g_pVCR->Start( filename, true, &_VCRHelpers ) )
{
Error( " -vcrrecord: can´t open ´%s´ for writing.\n", filename ) ;
return -1;
}
}
else if( CommandLine()->CheckParm( " -vcrplayback", & ) )
{
if ( ! g_pVCR->Start( filename, false, &_VCRHelpers ) )
{
Error( " -vcrplayback: can´t open ´%s´ for reading.\n", filename ) ;
return -1;
}
}

// initialize winsock
WSAData wsaData;
int nReturnCode = ::WSAStartup( MAKEWORD(2,0), & ) ;

registry->Init();

CommandLine()->CreateCmdLine( g_pVCR->Hook_GetCommandLine() ) ;

UTIL_GetBaseAndGameDir( GetBaseDirectory(), GetGameDirectory() ) ;

// Set default game directory
if ( ! CommandLine()->CheckParm( " -defaultgamedir" ) )
{
CommandLine()->AppendParm( " -defaultgamedir", GetGameDirectory() ) ;
}

bool memdump = CommandLine()->CheckParm( " -leakcheck" ) ? true : false;

_chdir( GetBaseDirectory() ) ;

bool restart = true;
while ( restart )
{
// Set engine string ( from registry or command line override),
// remove -gl, -d3d, etc. from command line and write current value
// into registry
restart = false;

if ( LoadAppSystems() )
{
// NOTE: This is sort of a hack required because we´re running hl2/hl2.exe
// instead of running directly from the bin directory
g_pFileSystem->RemoveSearchPath( NULL, " EXECUTABLE_PATH" ) ;
g_pFileSystem->AddSearchPath( UTIL_GetExecutableDir(), " EXECUTABLE_PATH" ) ;

if ( InitAppSystems( ( void *)hInstance ) )
{

1. if 1 / / #ifdef LAUNCHER_LOADS_ENGINE_AS_DLL

// running in debug mode, load engine via normal interface
IEngineAPI *engineAPI = ( IEngineAPI * ) LauncherFactory( VENGINE_LAUNCHER_API_VERSION, NULL ) ;
if ( engineAPI )
{
restart = engineAPI->Run( ( void * ) hInstance, GetBaseDirectory(), LauncherFactory ) ;
}

1. else

// blob unload information
BlobFootprint_t g_blobfootprintClient;

// running securely, load blob´d engine
IEngineAPI *engineAPI = NULL;

NLoadBlobFile(enginedll, &_blobfootprintClient, &, FALSE);

if ( engineAPI)
{
// Unmount and remount the filesystem as the engine will mount it on its own.
restart = engineAPI->Run( ( void * ) hInstance, UTIL_GetBaseDir(), ( char *)CommandLine()->GetCmdLine(), Sys_GetFactoryThis() ) ;
}

// free the blob
FreeBlob(&_blobfootprintClient);

1. endif // LAUNCHER_LOADS_ENGINE_AS_DLL

ShutdownAppSystems();
}

UnloadAppSystems();
}

// Remove any overrides in case settings changed
CommandLine()->RemoveParm( " -sw" ) ;
CommandLine()->RemoveParm( " -startwindowed" ) ;
CommandLine()->RemoveParm( " -windowed" ) ;
CommandLine()->RemoveParm( " -window" ) ;
CommandLine()->RemoveParm( " -full" ) ;
CommandLine()->RemoveParm( " -fullscreen" ) ;
};

registry->Shutdown();

// shutdown winsock
::WSACleanup();

if ( memdump )
{
g_pMemAlloc->DumpStats();
}

return 0;
}

j´ ai de bonne bases en VB6, un language un peut moins complexe, mais j´ arrive a comprendre comment fonctionne le programme HL2.exe, s´ est tres instructif d´avoir ce code

Pas tant que sa, sa se fais petit a petit, il y en a qui testent le jeu sous toutes les coutures, pour pouvoir encore le paufiner, l´ améliorer afin qu´ il sois au maximum souple pour les modeurs, qui font vivre le jeu ( que serais hl2 sans CS, dod, TFC...)

tous les programmes, non, sa depend, il n´ y a rien de plus compliqué a réaliser qu´ un jeu 3D, surtout pour un jeu comme hl2, quand ce sont des ptits programme, aucun problemes, mais la c du gros, c le fruit d´ un gros travail d´ equipe

Regarde moi, je developpe des application, je n´atteind jamais un tel niveau, c trop compliqué pour moi

et puis, meme pour DDraw, j´ ai du mal
( DDraw et la partie de DX8 qui gere l´ affichage en 2D)