Quake III Arena
Tutorial 01 : Premier Mod

..:: DescriptioN ::..

Nous allons voir toutes les étapes pour créer un mod pour Quake III Arena. Vous aurez besoin du code source 1.32 (ou sur eMule) de Quake III. Ce code source inclut également le code source de Team Arena. Vous aurez également besoin d'un logiciel pour modifier ce code. DevCpp fera l'affaire. Les compilateurs sont déjà inclus avec les sources.

Installez (de préférence) les sources dans le répertoire par défaut : c:\quake3\source. Retirez la Lecture Seule sur les fichiers installés. N'hésitez pas à faire une copie des fichiers originaux pour ne pas avoir à réinstaller le code source à chaque erreur ou nouvelle tentative.

Avant de compiler les sources, il faut modifier les fichiers BAT suivants :
C:\quake3\source\code\cgame\cgame.bat
C:\quake3\source\code\game\game.bat
C:\quake3\source\code\q3_ui\q3_ui.bat
En rajoutant cette ligne en début de fichier, pour que les compilateurs situés dans ce répertoire fonctionnent :
set PATH=%PATH%;C:\Quake3\source\bin

Vous pouvez maintenant compiler les sources, en cliquant sur les 3 fichiers BAT mentionnés ci-dessus.

Vous obtenez des fichiers QVM et MAP dans le répertoire C:\quake3\baseq3\vm. Seuls les QVM sont importants. Pour qu'ils soient pris en compte dans le jeu, vous devez zipper le répertoire C:\quake3\baseq3\vm en vm.zip. Renommez-le ensuite en VM.pk3 et placez-le dans le répertoire baseq3 de votre jeu Quake III Arena.

Attention : lorsque vous ouvrez le ZIP ou le PK3 avec Winzip, il faut obligatoire que la colonne chemin contienne la valeur "vm\" (pour chaque fichier QVM). Si cette colonne est vide, votre fichier PK3 ne sera pas pris en compte. Notez également que pour que votre PK3 soit lu en premier, il faut qu'il soit le dernier dans l'ordre alphabétique.


..:: Première modificatioN ::..

Nous allons modifier le zoom. Dans la version original, on peut spécifier une touche de zoom.
Si on appuie, on zoom jusqu'au max (cg_zoomFov) ou moins.
Si on relache, on dézoome automatique jusqu'au champ de vision normal (cg_fov).
Il faut maintenir la touche zoom pour zoomer.
On ne peut pas choisir de zoomer moins que prévu.

Le code suivant effectue les modifications suivantes :
Si on appuie une première fois, on zoom jusqu'au max (ou moins).
Si on relache avant, on stoppe le zoom et on conserve le niveau de zoom.
Si on rappuie une seconde fois en mode zoom, on dézoome jusqu'au FOV normal.
Il faut donc relacher la touche zoom pour conserver notre niveau zoom.
On a l'avantage de choisir un niveau de zoom inférieur (idéal selon la situation).

Effectuez les modifications suivantes dans les fichiers cgame/CG_LOCAL.H et cgame/CG_VIEW.C, aux endroits indiqués. Pour cela, vous pouvez ouvrir les fichiers avec Notepad, vous pouvez ouvrir le projet cgame.dsp avec Microsoft Visual C++ ou vous pouvez l'importer à partir de DevCpp (Fichier/Import).Ne compiler le code avec votre compilateur. Pour compiler, effectuez les opérations décrites auparavant.

Un numéro de ligne approximative est affiché. Rechercher plutôt la séquence de mots "gris clairs" dans le fichier puis remplacez-la par la séquence de mots "gris foncés".


CG_LOCAL.H (ligne 33) 


#define ZOOM_TIME 150


#define ZOOM_TIME           1000    // durée (em ms) du zoom   (plus lente que d'habitude)
#define ZOOM_TIME_OUT       300     // durée (en ms) du dézoom (plus rapide que le +zoom)

CG_LOCAL.H (ligne 506) 


// zoom key
qboolean	zoomed;
int		zoomTime;
float		zoomSensitivity;


// Variables pour le Zoom
qboolean	zoomed;                 // est-ce qu'on appuie sur la touche +zoom
int		zoomTime;               // Temps pendant lequel on appuie sur +zoom
float		zoomSensitivity;        // Sensibilité
qboolean	zooming;                // Sommes-nous en train de zoomer
int		setZoomFov;             // Valeur du fov avant le zoom

CG_VIEW.C (ligne 425) 


void CG_ZoomDown_f( void ) { 
	if ( cg.zoomed ) {
		return;
	}
	cg.zoomed = qtrue;
	cg.zoomTime = cg.time;
}


void CG_ZoomDown_f( void )
{
    // Si on appuie pour la première fois (+zoom)
    if ( !cg.zoomed && !cg.zooming )
    {
        cg.zoomed = qtrue;      // on est en mode zoom (fov actuel < cg_fov)
        cg.zooming = qtrue;     // le fov est modifié (fov actuel < fov précédent)
        cg.zoomTime = cg.time;  // on récupère le temps actuel
    }
    // si on rappuie encore une fois, on dézoom
    else if ( cg.zoomed && !cg.zooming )
    {
        cg.zoomed = qfalse;     // mode zoom off
        cg.zooming = qtrue;     // le fov est modifié (fov actuel < fov précédent)
        cg.zoomTime = cg.time;  // on récupère le temps actuel
    }
}

CG_VIEW.C (ligne 433) 


void CG_ZoomUp_f( void ) { 
	if ( !cg.zoomed ) {
		return;
	}
	cg.zoomed = qfalse;
	cg.zoomTime = cg.time;
}


void CG_ZoomUp_f ( void )
{
        cg.zooming = qfalse;        // le fov n'est plus modifié (mais stabilisé)
        cg.zoomTime = 0;            // on arrête la modification du zoom
}

CG_VIEW.C (ligne 487) ==> CG_CalcFov( ) 


		if ( cg.zoomed ) {
			f = ( cg.time - cg.zoomTime ) / (float)ZOOM_TIME;
			if ( f > 1.0 ) {
				fov_x = zoomFov;
			} else {
				fov_x = fov_x + f * ( zoomFov - fov_x );
			}
		} else {
			f = ( cg.time - cg.zoomTime ) / (float)ZOOM_TIME;
			if ( f > 1.0 ) {
				fov_x = fov_x;
			} else {
				fov_x = zoomFov + f * ( fov_x - zoomFov );
			}
		}
	}


        // ici : fov_x contient la valeur de la variable cg_fov
        // ici : zoomFov contient la valeur de la variable cg_zoomFov
        // si on zoom
        if ( cg.zoomed )
        {
            if ( cg.zooming )
            {
                f = ( cg.time - cg.zoomTime ) / (float)ZOOM_TIME;
                if ( ( f >= 0.0 ) && ( f <= 1.0 ) )
                {
                    fov_x = fov_x + f * ( zoomFov - fov_x );
                    cg.setZoomFov = fov_x;
                }
                // si on arrive au terme du zoom
                else if ( f > 1.0 )
                {
                    fov_x = zoomFov;        // on fixe le zoomFov
                    cg.setZoomFov = fov_x;  // on sauvegarde la valeur du zoomFov
                }
            }
            else
                fov_x = cg.setZoomFov;
        }
        
        // si on dézoom
        else
        {
            // on met à jour le fov si nécessaire
            f = ( cg.time - cg.zoomTime ) / (float)ZOOM_TIME_OUT;
            if ( ( f >= 0 ) && ( f <= 1.0 ) )
                fov_x = cg.setZoomFov + f * ( fov_x - cg.setZoomFov );
        }

BeLZeL - [http] belzel.free.fr
belzel [at] free [dot] fr
visiteurs