Les Ateliers de 3D Gamestudio Créez votre premier simulateur de vol

Transcription

Les ateliers de 3D Gamestudio
créez votre premier simulateur de vol
© Conitec Mai 2001 1
Les Ateliers de
3D Gamestudio
Créez votre premier
simulateur de vol
par Doug POSTON Août 2000
Les dernières nouvelles, les démonstrations, les mises à jour et les outils, aussi bien que le Magazine des Utilisateurs, le
Forum des Utilisateurs et le concours annuel sont disponibles à la page principale GameStudio
http://www.3dgamestudio.com/
Avant propos à propos de la traduction française de ce manuel
La traduction est un art difficile. D'autant plus qu'il m'a fallu apprendre le moteur au fur et à mesure de la traduction.
Malgré tous mes efforts il est clair que tout n'est pas parfait. Je vous invite donc lorsque vous avez le moindre doute, un
problème de compréhension voire un mauvais fonctionnement par rapport à ce que vous avez lu, à consulter le manuel
en Anglais ou en Allemand, tous deux étant téléchargeables sur le site de Conitec et à me faire part de vos remarques.
Et je réclame par avance votre indulgence.
Je vous souhaite le plus grand plaisir à lire ces lignes et à mettre en pratique ce que vous apprendrez.
Alain Brégeon
mailto:[email protected]
Avant propos de la part de l’auteur
Cher Lecteur,
J'ai produit cet atelier pour vous aider à répondre à la question "Comment faire un simulateur de
vol avec 3DGameStudio ?". Je vais en profiter pour vous montrer quelques nouvelles particularités
qui sont apparues la mise à jour 4.19.
Cet atelier, comme l'Atelier d'Aventure avant cela, vise surtout les utilisateurs qui ont un peu
d'expérience de 3DGameStudio. Je suppose que vous avez travaillé les différents tutoriaux et
savez comment employer les outils (WED, MED et WDL) .
Ce texte complète la documentation qui va avec 3DGameStudio, et ne la remplace pas. Si quelque
chose dans cet atelier est peu clair lisez s'il vous plait les manuels qui sont fournis avec
3DGameStudio. Je fais par avance des excuses pour des formulations que vous trouveriez peu
claires, un code défectueux, des erreurs, ou des omissions.
J'espère que vous trouvez les ateliers informatifs et agréables.
- Doug.
Obtenez la dernière version
Avant de commencer, assurez-vous d'avoir la dernière version de 3DGameStudio (4.19 ou au
dessus) puisque nous allons nous servir de plusieurs des nouvelles particularités qui ont été
ajoutées. Aussi vous aurez besoin du dernier constructeur de monde, parce que pour un
simulateur de vol nous utiliserons un monde extrêmement énorme.
Préparez votre workspace
Créez un dossier appelé "Flight Sim Workshop" dans votre dossier GSTUDIO. C'est le répertoire
ou vous stockerez tous les éléments du jeu.
La première chose que nous allons ajouter à notre dossier est le modèle de jeu et le sous dossier
image. Si vous ne les avez pas déjà, allez à la page de téléchargement de Conitec (http: //
www.conitec.net/a4update.htm) et récupérez le niveau de FlightSim. Décompressez le contenu
dans votre dossier. Votre dossier doit maintenant contenir au moins les fichiers:
compass.pcx
mount16.pcx
sky1.pcx
nsk y1.pcx
aircraft.mdl
jet.wav
repertoire Flight Sim Workshop
Créons le niveau
Notre niveau va être simple. Une grande surface de terre, plate avec un ciel.
Ouvrez WED et choisissez "File-> New"
Ouvrez le manager de texture ("Texture-> Texture Manager"). Sélectionnez ' add WAD", naviguez
dans votre dossier " Flight Sim Workshop " et ajoutez le standard.wad. Fermez le manager de
texture.
WED : Manager de texture
Choisissez "Add Primitive - > Cube (large)".
Agrandissez le cube, en le créant extrêmement long, large, et mince autour de 40000x40000x50
quants de taille (près de la taille Maxi de niveau qui est de 50,000 quants). La façon la plus simple
de faire cela est d'augmenter 'la Profondeur de Vue ' de vos vues 'arrière' et 'de côté' (en
employant la touche +) jusqu'à la taille souhaitée, centrez la boîte et retaillez là dans la vue
supérieure jusqu'à ce qu'elle disparaisse tout juste dans les vues de côté et arrière. Alors revenez
en arrière lentement jusqu'à ce qu'elle réapparaisse.
Cela va être votre sol. Parce qu'il est si énorme, nous ne pouvons pas appliquer une texture
ombrée pour cela. Les textures ombrées découpent automatiquement la surface en petits carrés
pour l'éclairage dynamique et allouent de la mémoire vidéo pour la carte d'ombres. Et donneront
des temps de construction très longs, et demanderont des tailles de fichier de niveau et des
exigences de mémoire vidéo. Donc nous emploierons une texture plate ici.
Cliquez directement sur la texture 'tilegrass' dans la barre de texture, choisissez "setting", cochez
ensuite ' flat' et mettez l'échelle à 0.5. Nous la réduisons un peu parce que pour l'augmentation de
notre monde plus loin, nous allons aussi employer des modèles réduits pour cela. Ceci étant fait,
un monde de 40,000 x 40,000 quants nous apparaîtra comme plusieurs km².
Appliquez maintenant la texture plate, réduite à notre plan sol et déplacez là ensuite juste au
centre.
WED : Notre Plan de sol
Ajoutez un autre cube et augmentez-le proportionnellement afin qu'il entoure juste notre plan de
sol. L'idéal serait que notre sol s'étende légèrement à l'extérieur de cette boîte, mais assurez-vous
de laisser assez de place au-dessus du sol. Evidez ce bloc (Alt+H) et donnez-lui une texture
"skyblue". C'est notre boîte de ciel
WED : Notre boîte ciel
Avec la boîte de ciel sélectionnée, employez la commande duplicate (Ctl+D) pour faire un double
de cette boîte et réduisez là afin qu'elle tienne à l'intérieur de la boîte de ciel. La boîte doit toujours
laisser beaucoup d'espace au-dessus du sol, dépasser en dessous du sol et croisez le sol à
chacune de ses extrémités.
WED : À l'intérieur de la boîte de limitation
Cochez le drapeau 'Flat' de la texture 'défaut' et l'appliquer au bloc. Ouvrez alors la fenêtre de
Propriétés du bloc. Cochez le drapeau "Invisible" et assurez-vous qu'aucune autre option ne soit
cochée. Elle agira comme notre boite de limitation, assurant que le joueur ne pourra pas voler à
l'extérieur de notre monde. Nous pouvons ajouter plus tard des montagnes à la frontière du
monde, mais pour le moment la boîte de limitation fera l'affaire.
WED : Rendez la Boîte Invisible
Sauvegardez le niveau dans votre dossier Flight Sim Workshop (appelez-le "FlyWork"), compilez
(avec Level Map de coché) et exécutez le niveau.
Vous devriez voir une pelouse d'herbe agréable qui s'allonge sur des kilomètres.
Notre monde
C'est la carte minimale pour un simulateur de vol; juste un espace pour nous faire commencer.
Plus tard vous trouverez du temps pour ajouter d'autres structures à cette carte (des maisons, des
montagnes, etc.) pour rendre les choses plus intéressantes.
Ajout de l'Avion
Maintenant nous allons ajouter notre modèle d'avion. Pour notre simulateur de vol nous ferons
avec le modèle d'hélicoptère (bien que nous emploierons toujours la physique d'avion pour le
contrôler).
Select "Object-> Load Entity" et utilisez les fenêtres de navigation de fichier pour trouver le modèle
"aircraft.mdl". Le modèle doit apparaître dans votre monde. Placez-le près du centre de votre sol
pour qu'il repose sur la surface.
Aircraft.mdl ajouté
Sauvegardez, recompilez et exécutez le niveau. Regardez notre modèle d'avion. Assurez-vous
qu'il est sur ou presque sur le sol. Ajustez le placement du modèle jusqu'à ce que vous soyez
satisfaits.
Notre Avion.
Création de votre script
Créer un scénario pour votre niveau. Ouvrez votre fenêtre de Propriétés de Carte ("File->
MapProperties ") et appuyez sur bouton "new". Le bouton à côté du Scénario doit changer de
"ndef" à "flywork.wdl".
Nouveau Scénario dans Carte Properties
Ouvrez votre dossier de niveau sélectionnez et ouvrez (double-clic) le fichier "flywork.wdl". Si
Windows demande quelle application employer pour ouvrir le fichier, choisissez "bloc-notes" (ou
n'importe quel éditeur de texte simple).
Vous devez remarquer que le jeu typique, "modèle" a été créé pour vous. C'est suffisant pour la
plupart des projets mais nous voulons faire quelque chose de plus avancé cette fois. Allons-y et
sélectionnez tout (dans le bloc-notes de Microsoft employez "Edit-> select All") et cliquez sur la
touche "suppr". Maintenant nous allons tout recommencer à zéro.
Ajout d'un chemin
Commençons en définissant les chemins que notre programme va employer. Les chemins sont
employés pour dire au moteur où il peut placer les fichiers employés dans notre projet (des
images, des sons, d'autres scénarios, etc.). Le dossier ou nous sommes ("Flight Sim Workshop")
est déjà inclus, aussi, dans notre cas, nous devons seulement ajouter le répertoire "template" et le
répertoire "image".
Tapez la ligne suivante :
PATH ".. \\ template"; // Chemin du sous répertoire templates de WDL
Notez que tous les chemins sont relatifs à notre dossier de niveau. La ligne ci-dessus dit ceci,
"remonte d'un niveau (" ..") et redescend dans le dossier template (" \\ template")".
Maintenant nous voulons inclure notre dossier "images" de la même façon. Ajoutez cette ligne:
PATH " images"; // le Chemin de notre répertoire images
Comme le dossier "images" est dans le même dossier que notre niveau tout ce que nous devons
faire est de lui dire : ""regarde dans le dossier appelé IMAGES dans ce répertoire".
Note : l'ordre dans lequel ces deux lignes apparaissent est déterminant pour savoir quel dossier
est vérifié d'abord. Car si vous employez plus d'un fichier avec le même nom, votre niveau emploie
seulement le premier fichier trouvé. Par exemple, si vous avez voulu changer la flèche du curseur
("ARROW.PCX") afin qu'elle soit blanche au lieu de rouge, vous pourriez créer votre nouvelle
flèche blanche et la sauver comme "ARROW.PCX" dans votre dossier de niveau. Maintenant votre
niveau emploiera votre nouveau curseur et non le curseur par défaut dans le répertoire template.
Mais, si vous mettez ce curseur dans IMAGES, vous emploierez le curseur de template (puisque
vous avez dit à votre niveau de regarder là d'abord). Vous pouvez changer l'ordre ou vous
regardez en changeant l'ordre les lignes apparaissant dans PATH. Par exemple, changez les deux
lignes que vous avez entrées comme suit :
PATH " images"; // Chemin de notre répertoire images
PATH ".. \\ template"; // Chemin du sous répertoire templates de WDL
Maintenant le moteur regardera d'abord dans votre dossier de niveau, puis dans votre
dossier"images" et finalement dans le dossier template.
Ajoutez les "include"
Après que nous ayons créé nos chemins nous devons ajouter nos fichiers "include". Tapez sous
PATHs:
// Include files
INCLUDE <movement.wdl>;
INCLUDE <messages.wdl>;
INCLUDE <particle.wdl>;
INCLUDE <doors.wdl>;
INCLUDE <actors.wdl>;
INCLUDE <weapons.wdl>;
INCLUDE <war.wdl>;
INCLUDE <menu.wdl>;
La commande "INCLUDE" dit à A4 de remplacer cette ligne avec le contenu du fichier entre "< >".
C'est comme ci nous étions allés chercher le fichier en question, avions copié tout son code, et
l'avions collé dans le scénario.
C'est un outil puissant parce qu'il nous permet de réutiliser le code d'autres projets et permet de
faire des mises à jour dans les fichiers inclus sans devoir récrire votre code. Par exemple, la mise
à jour 4.19 inclut du code pour permettre au joueur de nager dans l'eau. Ainsi n'importe quel projet
qui inclut "movement.wd" peut employer ce nouveau code pour la nage.
Comme pour les chemins, l'ordre des lignes INCLUDE est important. Puisque quelques scénarios
utilisent des valeurs qui sont déclarées dans d'autres scénarios. Par exemple : "actors.wdl"
emploie la variable, "force" qui est déclarée dans movement.wdl". Si nous mettons "actors.wdl"
avant "movement.wdl" nous obtiendrions des erreurs.
C'est bien d'INCLURE des scénarios même si vous n'employez aucune de leurs particularités
dans votre code. La plupart des fichiers dans template sont interdépendants l'un sur l'autre aussi si
vous faites des projets pour utiliser l'un d'entre eux, vous devez les INCLURE tous pour être sûrs.
L'exception à cette règle est le scénario "Venture.wdl", qui n'est employé par aucun des autres
scénarios, mais emploie chacun d'eux.
Les valeurs de départ du moteur
Maintenant nous allons mettre quelques valeurs importantes qui aideront à décider comment le
simulateur sera montré. Ces valeurs déterminent la résolution, la profondeur des couleurs, le taux
de rafraîchissement et l'éclairage. Ajoutez les lignes suivantes au-dessous des lignes "INCLUDE":
// Valeurs de départ du moteur
IFDEF LORES;
var video_mode = 4; // 320x240
IFELSE;
var video_mode = 6; // 640x480
ENDIF;
var video_depth = 16; // D3D, 16 bit resolution
var fps_max = 40; // 40 fps max
var floor_range = 200; // empêchent des changements de brillance soudains sur l'avion
Si vous avez écrit des scénarios WDL avec les versions précédentes de 3D GameStudio, la
première chose que vous voyez est que nous utilisons "var" au lieu de "SKILL". Nous faisons cela
parce que "var" est un peu plus court et c'est aussi compatible avec Javascript. Ce qui signifie que
la vieille formule de "SKILL VIDEO_MODE {VAL 6;} " a été remplacée par un style javascript plus
élégant, "var video_mode = 6;"
"fps_max" et "floor_range" sont des nouveautés de la version 4.19. Vous pouvez tout savoir sur
elles dans le manuel WDL. Brièvement, "fps_max" limite le taux de rafraîchissement pour qu'il
n'excède pas la valeur. En mettant "fps_max" à 40 nous nous limitons à 40 rafraîchissements par
seconde (même si le système sur lequel nous exécutons ce programme peut montrer plus).
"floor_range"" a été créé avec des simulateurs de vol en mémoire. Il limite le rayon dans lequel la
lumière de l'entité dépend de la brillance et les ombres de la surface au sol ci-dessous. Ce qui
signifie que si notre avion vole haut sur une ville et il passe sur une ombre, son éclairage n'est pas
changé. Notez que "video_mode" et "video_depth" sont en lecture seule, ce qui signifie qu'ils ne
peuvent plus être mis directement une fois que le programme s'exécute. Ils peuvent seulement
être changés en appelant l'instruction "SWITCH_VIDEO"..
La Fonction Principale "Main"
Dans n'importe quel projet vous avez besoin de la fonction "Main" (principale). C'est la première
fonction à être appelée lorsque le programme démarre. Dans la plupart des cas la fonction
principale est très simple, la notre ne fera pas exception. Entrez s'il vous plaît les lignes suivantes
(sous votre dernière ligne) :
// Desc: notre fonction MAIN appelée au démarrage du jeu
function main()
{
IFNDEF NOTEX; // invalide d3d_texreserved avec -d notex sur carte 3D faible
D3D_TEXRESERVED = min(12000,D3D_TEXMEMORY/2);
ENDIF;
// cartes du ciel du jeu avant chargement du niveau pour priorité
init_environment(); // crée notre environnement(ciel, nuages, etc.)
LOAD_LEVEL <flywork.WMB>;
load_status(); // restore les variables globales
}
Nous allons explorer chacune de ces lignes.
Fonctions contre ACTIONS
Vous avez remarqué que nous sommes passés de "ACTION main {..}" à "Function main () {..}".
Les fonctions sont des nouveautés de la 4.19. Elles se comportent presque identiquement aux
ACTIONS sauf qu'elles n'apparaissent pas dans la liste déroulante des actions attachables à une
entité. Ainsi, si vous avez créé une fonction qui va être directement attachée à une entité (par
exemple my_player) faite une ACTION, sinon, faites une fonction.
D3D_TEXRESERVED (et la fonction min(x, y))
La première chose que nous faisons dans "main" est d'essayer de réserver une portion de
mémoire sur la carte vidéo de l'utilisateur pour pré charger nos textures. Cela réduit le retard du au
premier chargement qui peut arriver lorsqu'une nouvelle texture est vue pour la première fois en
jouant.
J'ai dit, "essaye" parce que toutes les cartes vidéo ne nous permettront pas de réserver la
mémoire. Pour manipuler cette carte nous avons mis le code à l'intérieur d'un bloc "IFNDEF
NOTEX;... ENDIF". Si l'utilisateur ne peut pas employer D3D_TEXRESERVED (c'est-à-dire qu'il a
une carte pas terrible) il doit mettre le drapeau ",-d" à "-d notex" avant le lancement de ce
programme donc A4 saura qu'il faut sauter ce bloc de code.
Nous ne voulons pas employer toute notre mémoire vidéo pour des textures pré chargées, si nous
faisons cela, A4 n'aura plus la possibilité de charger d'autres textures pendant que le niveau
s'exécute (cela causera l'arrêt du programme avec un message d'erreur). A4 réserve
automatiquement 2Mo de mémoire pour les textures, mais, pour être sûr, nous ne devons alors
pas allouer plus de la moitié de la mémoire vidéo valide. La quantité de mémoire disponible varie
d'un système à un autre, mais vous pouvez toujours connaître le total de mémoire disponible en
vérifiant la valeur dans D3D_TEXMEMORY.
Ainsi nous réservons 12Mo de mémoire vidéo sur des systèmes avec 24Mo ou plus de mémoire
vidéo ou la moitié de la mémoire disponible sur des cartes avec moins de 24Mo auquel cas nous
prendrions la moitié de la mémoire vidéo et la comparerions à 12Mo, en prenant la plus petite
valeur.
Nous pourrions le faire comme ceci:
If ((D3D_TEXMEMORY/2) < 12000)
{
D3D_TEXRESERVED = D3D_TEXMEMORY/2;
}
ELSE
{
D3D_TEXRESERVED = 12000;
}
Nous pouvons le faire également en employant une seule ligne en utilisant la fonction "min(x,y)"
qui compare deux valeurs et retourne la plus petite des deux :
D3D_TEXRESERVED = min(12000,D3D_TEXMEMORY/2);
init_environment () (le nouvel appel de fonction)
Notre premier appel de fonction montre la nouvelle façon pour appeler des fonctions. L'ancienne
façon "CALL init_environment;" a été remplacée par la nouvelle "init_environment();". Ces deux
méthodes travaillent de la même façon, mais la nouvelle nous permet d'employer nos propres
fonctions et actions de la même façon que nous emploierions des fonctions prédéterminées
(comme, "min" et "max").
Il ne vous reste plus qu'à saisir la fonction "init_environment" (au-dessous de la fonction
principale) :
// notre environnement bitmaps
BMAP my_sky = <sky1.pcx>,0,0,128,128;
BMAP my_clouds = <sky1.pcx>,128,0,128,128;
BMAP my_mountains = <mount16.pcx>;
// Desc : créez le ciel, les nuage et la scène
function init_environment()
{
sky_map = my_sky;
cloud_map = my_clouds;
scene_map = my_mountains;
scene_field = 180;
scene_angle.tilt = -10;
SKY_SPEED.X = 0;
SKY_SPEED.Y = .025;
CLOUD_SPEED.X = 3;
CLOUD_SPEED.Y = 4.5;
SKY_SCALE = 1.0;
SKY_CURVE = 1;
}
Les trois premières lignes définissent nos trois images bitmap définissant le ciel. Les deux
premières images bitmaps ("my_sky" et" my_clouds") chargent la moitié gauche et la moitié droite
de notre image de ciel ("sky1.pcx") tandis que "my_mountains" charge notre image bitmap de la
montagne. Ces images bitmaps sont alors chargées dans les trois bitmaps qui composent notre
ciel ("sky_map, cloud_map, et, scene_map") .
Vous trouverez plus d'information sur ces images bitmaps et autres valeurs utilisées dans le
manuel WDL (Chapitre 7 : Variables du Moteur).
Sauvegardez votre travail et exécutez le niveau. Vous devez remarquer notre rendu de ciel avec
des nuages qui bougent au-dessus et une chaîne de montagnes au loin. Vous remarquerez aussi
que comme vous vous déplacez au bord de notre monde vous pouvez voir devant vous, le fond de
ces montagnes. Vous pouvez fixer cela à un certain degré en faisant "scene_map" plus grand et
en le déplaçant vers le bas (en ajustant la valeur de "scene_angle.tilt"). Vous pouvez aussi cacher
le bord de la carte en ajoutant des constructions, des arbres ou des montagnes le long des bords.
Création de notre Avion
Ce qui fait de notre projet un simulateur de vol et non pas un jeu de courses automobiles, un
simulateur de tank, ou quelqu'autre type de jeu est le modèle de vol d'avion. Nous allons explorer
comment créer une ACTION simple d'avion pour attacher à notre modèle d'avion pour l'aider à
quitter la terre.
Le modèle de vol de base
Quelques simulateurs de vol à l'écart des autres(en plus du graphisme et du choix des avions pour
voler) sont comme les vrais modèles. Quelques modèles de vol sont très complexes; ils peuvent
employer des données de vol réel et exécuter des calculs mathématiques complexes pour calculer
exactement ce qui arriverait quand vous augmentez votre angle de volet de 3 degrés.
D'autres simulateurs de vol ont une approche différente; ils établissent quelques règles simples qui
produisent des résultats qui se rapprochent de la physique d'un avion. En plus d'être plus facile à
écrire, ces simulateurs de vol "simples" peuvent aussi être beaucoup plus amusant
(particulièrement si vous ne voulez pas rester assis à lire un manuel avant de pouvoir voler) .
Notre atelier va aller au plus simple. Le modèle de vol présenté ici couvre les quatre forces de
base agissant sur l'avion (la montée, la poussée, la gravité et la traîne), crée quelques règles et
limites et calcule comment l'avion se comportera.
Création des variables
Commençons par mettre les valeurs employées par notre modèle d'avion. Entrez ces lignes à la
fin de notre fichier scénario :
// DEFINE et valeurs pour l'avion
DEFINE _MODE_PLANE,16;
DEFINE _RPM,SKILL31; // vitesse du moteur.
// airplane values
var stallspeed = 8; // l'avion cale au dessous de cette vitesse
var climbrate = 1.5; // taux de montée maximal
var climbfactor = 0.1; // profil d'aile
var height_max = 750; // hauteur maximale
var speed_max = 25; // vitesse de l'air max
var max_rpm = 7; // vitesse du moteur max
// sound vales
var enghandle = 0;
SOUND engsound = <jet.wav>; // engine sound
// animation string
string anim_fly_str = "fly";
define _FLYSCALE 0.3; // scaling down the aircraft
Le premier DEFINE donne une valeur à l'un des deux MOVEMODE que nous contrôlerons dans
notre modèle de vol (le second étant _MODE_DRIVING qui est défini dans "movement.wdl"). Le
deuxième DEFINE nous dit d'employer SKILL31 comme la valeur RPM du modèle (vitesse de
rotation du moteur).
Les valeurs d'avion sont les valeurs constantes qui seront employées pour calculer comment des
forces différentes affecteront l'avion (et les limites auxquelles ces forces peuvent agir). Nous
prendrons ces valeurs comme elles se présentent dans le code. Quand vous avez achevé cet
atelier n'hésitez pas à ajuster ces valeurs et voir comment elles changent le comportement de
l'avion.
Les valeurs suivantes manipulent le son produit par le moteur ("enghandle" et "engsound") le nom
des encadrements d'animation de l'hélice de notre modèle d'avion ("anim_fly_str") et l'échelle de
notre avion pour faire que le monde apparaisse plus grand.
Codage de l'Action
Puisque cette fonction est attachée au modèle d'avion à l'intérieur du niveau nous en ferons une
ACTION. C'est une grande action qui est éclatée en plusieurs sections. Pour éviter toute
confusion, j'ai inclus l'intégralité séparément dans ces archives.
Initialisation des valeurs de l'avion
La première chose consiste à initialiser notre entité:
// Desc : notre action avion
ACTION player_aircraft
{
// Init values
if (MY.client == 0) { player = MY; } // créée sur le serveur?
MY._TYPE = _TYPE_PLAYER;
MY.ENABLE_SCAN = on; // pour que les ennemis puissant me détecter !
IF(MY._FORCE == 0) { MY._FORCE = 1.5; }
IF(MY._MOVEMODE == 0) { MY._MOVEMODE = _MODE_PLANE; }
//réduit le modele de l'avion afin que notre monde nous paraisse plus grand
MY.scale_x *= _FLYSCALE;
MY.scale_y *= _FLYSCALE;
MY.scale_z *= _FLYSCALE;
drop_shadow(); // _movemode doit être mis à 1 avant
Jusqu'ici c'est semblable à l'action "player_move" dans "movement.wdl". Nous vérifions pour voir si
nous sommes sur un serveur, définissons notre type comme joueur, rendons notre entité sensible
aux événements de recherche, donnons une valeur à force (si non déjà mis dans le modèle luimême) et mettons "MOVEMODE" comme étant un avion.
Après que toutes les valeurs soient mises nous appelons "drop_shadow" pour que notre avion
produise une ombre sur la terre.
La boucle WHILE de l'avion
Maintenant nous commençons à entrer au cœur de notre action:
// tant que nous sommes dans un MOVEMODE valide c'est à dire ou je vole ou je roule
WHILE(MY._MOVEMODE == _MODE_PLANE
|| MY._MOVEMODE == _MODE_DRIVING)
{
_player_force(); // met les valeurs force et aforce de l'entrée du joueur
scan_floor(); // met floor_normal, my_height, et floor_speed
Nous resterons dans cette boucle jusqu'à ce que l'entité ne vole plus comme un avion ou roule sur
le sol (dans notre cas, nous devons toujours être dans un de ces deux modes) .
La première chose que nous recueillons est l'entrée du joueur et l'environnement. Avec un appel
simple à "_player_force" nous réunissons toute l'information de mouvement du clavier de
l'utilisateur, la souris et l'entrée de levier de commande et stockons les résultats dans les variables
"force" et "aforce". "Scan_floor" nous dit à quelle distance de la surface la plus proche nous
sommes (ainsi que la vitesse et l'inclinaison de cette surface).
Moteur (la Poussée)
Ensuite nous calculons la vitesse du moteur:
// Calcule le régime du moteur (accélère le moteur avec [Home], [Fin])
// MY._RPM = rpm / 1000
MY._RPM += 0.0025*force.Z*TIME;
// limite _RPM entre 0 et 7000 rpm maxi
MY._RPM = max(0,min(max_rpm,MY._RPM));
Le régime du moteur est mis par l'utilisateur en appuyant sur les touches "Home" et "Fin", on est
censé simuler le joueur ajustant l'accélérateur de l'avion. " _player_force "convertit la touche
pressée " Home/Fin " en une valeur "force.Z" positive/négative". En multipliant la valeur "force. Z "
par le temps qui a passé depuis le dernier affichage (TIME) et une valeur constante (censée
représenter la vitesse à laquelle nous changeons notre régime du moteur) nous pouvons calculer
le changement de vitesse (RPM) du moteur.
Nous limitons la vitesse du moteur pour qu'elle n'excède pas "max_rpm" et que la valeur soit
toujours positive (au-dessus du zéro). Nous pourrions faire cela en employant un couple de
déclarations "If", mais il est plus rapide d'employer la fonction min/max. La déclaration "max
(0,min(max_rpm, MY.RPM))" ce lit comme suit : "prenez la valeur minimale (la plus petite) de
max_rpm et MY.RPM, prenez maintenant la valeur maximale (la plus grande) entre cette valeur et
zéro".
Le son du moteur
Maintenant occupons-nous du son du moteur. Nous voulons que le son de moteur joue
continuellement en fond sonore chaque fois que le moteur fonctionne. Ce serait également
agréable de changer le son en fonction de la façon dont le moteur tourne.
// démarrer, arrêter ou accorder le son du moteur
if(MY == player)
{
// si le moteur est en marche...
if(MY._RPM > 0)
{
if(enghandle == 0) // aucun son n'est joué
{
// démarre le son du moteur en marche
PLAY_LOOP engsound,25;
enghandle = RESULT;
}
// ajuste le son en fonction de speed_ahead
temp = (MY._RPM + MY._SPEED_X * 0.2) * 60;
TUNE_SOUND enghandle,25,temp;
}
else // le moteur est arrêté...
{
if(enghandle != 0) // le son est joué
{
// arête le son du moteur
STOP_SOUND enghandle;
enghandle = 0;
}
}
} // END if(MY == player)
La première chose à contrôler et de s'assurer que cette action est appelée par le joueur ( si nous
avions attaché cette action à une autre entité, nous ne voudrions pas que cela effectue notre son).
Ensuite nous vérifions si le moteur tourne (My._RPM > 0). Si le moteur fonctionne nous vérifions
alors si le son du moteur joue déjà en vérifiant pour voir si une valeur est stockée dans
"enghandle". Si nous ne jouons pas actuellement le son de moteur, la valeur dans "enghandle"
sera à zéro.
Pour commencer le son de moteur et le jouer constamment à l'arrière-plan vous pouvez employer
l'instruction PLAY_LOOP. Ce sera la boucle du son à l'arrière-plan jusqu'à ce que nous appelions
l'instruction STOP_SOUND. PLAY_LOOP renvoie une valeur dans le champ RESULT. Cette
valeur est l'indicateur de l'état du son. Il est important que nous sauvions cet indicateur d'état
parce que c'est la seule façon que nous avons pour changer ou arrêter le son une fois qu'il
commence à jouer. Donc nous sauverons cet indicateur d'état du son dans la variable
"enghandle".
La chose suivante que nous faisons tandis que le moteur fonctionne est d'ajuster la fréquence du
son du moteur pour refléter la vitesse à laquelle le moteur tourne. Nous faisons cela en employant
la formule (My._RPM + My._SPEED_X * 0.2) * 60 pour calculer le pourcentage de la fréquence
normale pour utiliser dans la lecture du son. Une fréquence plus haute le fait sembler être comme
le moteur tournant plus rapidement, une fréquence inférieure le fait sembler être plus lentement.
Calcul de l'ascension
Ensuite nous allons calculer comment la vitesse actuelle et l'angle de l'avion effectuent l'ascension
de notre avion.
// Calculent la force d'ascension, dépendant de la vitesse, de l'angle d'inclinaison et de l'angle du roulis
force.z = (climbfactor*MY._SPEED_X) * (0.05 * (90 + ang (MY.tilt) - (0.5*abs (ang (MY.roll)))));
Dans ce calcul, nous calculons l'ascension (force.z) en combinant trois facteurs.
L'ascension d'un avion vient de l'air se déplaçant rapidement sur ses ailes. Plus l'avion se déplace
vite plus l'air d'ascension est créé. La force de cette "ascension de base" est calculée par
("climbfactor*MY._SPEED_X") où "MY._ SPEED_X" est la vitesse avant de l'avion et "climbfactor"
est une valeur constante qui représente la forme de l'aile et sa capacité de produire l'ascension
(C'est " l'effet airfoil ").
La valeur d'ascension est alors modifiée par l'inclinaison et le roulis de l'avion (connu en aviation
comme étant l'angle d'attaque. Si le nez de l'avion pointe vers le haut, l'avion est plus probable
pour s'élever. L'indication du nez de l'avion en bas le fait tomber à la terre. Le roulement de l'avion
d'un côté vers l'autre réduit la quantité d'ascension qui peut être créé par les ailes. La combinaison
de ces deux angles est calculée en prenant 1/20 de l'inclinaison et en soustrayant la moitié de la
valeur absolue du roulis. Ces valeurs sont loin des données physiques réelles, mais ils produisent
des résultats raisonnables dans la plupart des situations.
Les avions doivent maintenir une certaine vitesse pour rester en l'air. Quand un avion tombe audessous de cette vitesse il entre dans ce que les pilotes appellent "une cale". Quand l'avion est
calé ces ailes ne produisent plus aucune ascension. Nous pouvons simuler cela en ajoutant cette
règle simple :
// si notre vitesse est inférieure à la vitesse de "calage"
if(MY._SPEED_X < stallspeed)
{
// stall (no lift)
force.z = 0;
}
La force que l'ascension essaye de surmonter est la gravité. La chose suivante que nous faisons
est de réduire l'effet d'ascension par la force de gravité:
// l'avion est affecté par la force de gravité
force.z -= gravity;
Pour nous assurer que nous ne montons pas soudainement en flèche dans l'air nous allons limiter
la quantité dont nous pouvons nous élever à notre maximum "climbrate" :
// limite la force d'ascension
force.z = min(force.z,climbrate);
mouvement sur le terrain
Les avions passent beaucoup de leur temps sur le terrain. Nous employons les étapes suivantes
pour gérer le mouvement tandis que nous ne sommes pas en l'air.
La première chose que nous devons évaluer c'est si nous sommes sur le terrain (my_height < 5).
Auquel cas nous mettons notre " _MOVEMODE" à "_MODE_DRIVING" :
// si nous conduisons sur le terrain,
IF(my_height < 5)
{
MY._MOVEMODE = _MODE_DRIVING;
Ensuite nous calculons la force avant (force.x) en prenant la moitié du régime du moteur moins 1
(en utilisant la valeur max pour nous assurer que nous n'allons jamais en arrière) :
// la force avant dépend de la vitesse du moteur
force. X = max (0,0.5 * (MY._RPM - 1));
Puisque la direction sur le terrain est gérée par le manche (ou les touches de curseur
gauche/droite) et les pédales nous vérifions pour voir si le joueur emploie le manche pour diriger.
Si c'est le cas, la valeur aforce.pan sera déjà mise, sinon nous employons une force venant des
pédales (que nous stockons dans force.Y) :
// dirige avec le manche et les pédales [<] [>]
if (aforce.pan == 0)
{
aforce.pan = force.Y;
}
Pour maintenir l'avion sur le terrain, nous ajustons l'angle du roulis en mettant la force de roulis
(aforce.roll) égale à une fraction de l'angle de roulis actuel de l'avion (ang(MY.roll)) :
// si l'angle de roulis n'était pas zéro
// applique une force de roulis pour mettre l'angle arrière
aforce.roll =-0.2*ang (MY.roll);
maintenant nous employons les valeurs de la force angulaire (aforce) pour mettre la vitesse
angulaire de l'avion:
// Maintenant accélère la vitesse angulaire et met les angles
friction = min(1, TIME*ang_fric);
MY._ASPEED_PAN + = (TIME* 0.3 * aforce.pan)
- (friction * My._ ASPEED_PAN);
My._ASPEED_ROLL + = (TIME * aforce.roll)
- (friction * My._ASPEED_ROLL);
et ensuite nous employons la vitesse angulaire des temps d'avion une fraction de la vitesse avant
(My._SPEED_X) pour calculer le gîte, l'inclinaison et le roulis de l'avion lorsqu'il roule sur le sol:
MY.pan += TIME * MY._ASPEED_PAN * MY._SPEED_X * 0.025;
MY.roll+= TIME * MY._ASPEED_ROLL;
MY.tilt = 0;
Nous employons le même type de calculs pour calculer la vitesse avant de l'avion:
friction = min(1,TIME*gnd_fric*0.3);
// accelerate the entity relative speed by the force
MY._SPEED_X += TIME*force.X - friction*MY._SPEED_X;
dist.X = TIME * MY._SPEED_X;
dist.Y = 0;
dist.Z = 0;
Maintenant nous employons n'importe quelle force d'ascension (force.z) issue des calculs
d'ascension précédents pour soulever l'avion du sol:
MY._SPEED_Z += TIME*force.z - friction*MY._SPEED_Z;
absdist.X = 0;
absdist.Y = 0;
absdist.Z = TIME*MY._SPEED_Z;
Maintenant si nous avons réduit l'avion pour gagner une taille relative plus grande du monde, nous
devons mettre à l'échelle la vitesse par la même valeur. Un avion de taille jouet se déplace plus
lentement qu'un avion réel
// si le modèle d'avion est mis à l'échelle, nous avons besoin de mettre sa vitesse à l'échelle également
dist.x *= _FLYSCALE;
dist.y *= _FLYSCALE;
dist.z *= _FLYSCALE;
absdist.x *= _FLYSCALE;
absdist.y *= _FLYSCALE;
absdist.z *= _FLYSCALE;
La distance verticale absolue de l'avion est ajustée (absdist. Z) par l'ascension (qui lorsque nous
sommes sur le sol n'est jamais inférieure à zéro) plus la distance qui tient l'avion au-dessus de la
surface de la terre. C'est une vraie distance qui ne doit pas être réduite!
// Ajoutent la vitesse donnée par l'élasticité de la terre
absdist. Z = max(0, absdist. Z) - min(0, max (my_height,-10));
La dernière chose que nous avons à faire est d'ajouter n'importe quelle vitesse horizontale
obtenue d'une plate-forme se déplaçant (cela pourrait être utile si votre avion se reposait à l'arrière
d'un porte-avions) :
// si l'avion est sur une plate-forme se déplaçant ajoute la vitesse de la plate-forme
absdist. X + = my_floorspeed. X;
absdist. Y + = my_floorspeed. Y;
}
Mouvement en l'air
C'est le type de mouvement dans un simulateur de vol par lequel nous sommes le plus intéressé.
C'est là où nous contrôlons l'avion en l'air.
La première chose à faire est de mettre "_MOVEMODE" à " _MODE_PLANE" :
ELSE // aéroportée
{
MY._MOVEMODE = _MODE_PLANE;
Puis nous utilisons les valeurs de "force" et "aforce" validées dans " _player_force" pour calculer
les forces de l'inclinaison, du roulis et du gîte sur l'avion. Pour simuler la tendance naturelle de
l'avion à se centrer lui-même lorsque aucune entrée n'est donnée (c'est-à-dire le levier de
commande est centré), nous prenons une fraction de l'angle courant (le gîte, l'inclinaison ou le
roulis) et le soustrayons de chacune des forces angulaires:
// l'inclinaison est faite par les touches haut/bas,
// et oscille en arrière une fois relâchée
aforce.tilt = (-0.1*force.X) - (0.01*ang(MY.tilt));
// le roulement est fait par les touches gauche/droite,
// et oscille en arrière une fois relâchée
aforce.roll = (-0.1*aforce.pan) - (0.02*ang(MY.roll));
// la force du gite depend du gouvernail pédale
// et de l'angle du roulis
aforce.pan = (0.01*force.Y) - (0.03*ang(MY.roll));
La vitesse avant (la poussée) est directement rapprochée du régime du moteur. Cette valeur est
ensuite modifiée par l'angle d'inclinaison (réduisant la vitesse si nous nous inclinons vers le haut,
prenant de la vitesse si nous nous inclinons vers le bas) et, dans une mesure moindre, par la
valeur absolue du roulis:
// la force avant depend de la vitesse du moteur
// et de l'angle d'inclinaison et de roulis
force.X = (0.5*MY._RPM) // vitesse du moteur
-(0.01*ang(MY.tilt))// moins vitesse due à l'inclinaison
-(0.005*abs(ang(MY.roll)));// moins la vitesse due au roulis
Maintenant nous employons les forces angulaires que nous avons calculées ci-dessus pour
changer la vitesse angulaire de l'avion:
// Maintenant accélère la vitesse angulaire et change les angles
friction = min(1,TIME*ang_fric);
MY._ASPEED_PAN += (TIME*aforce.pan)
-(friction*MY._ASPEED_PAN);
MY._ASPEED_TILT += (TIME*aforce.tilt)
-friction*MY._ASPEED_TILT);
MY._ASPEED_ROLL += (TIME*aforce.roll)
-(friction*MY._ASPEED_ROLL);
Ces vitesses angulaires sont alors employées pour changer les angles de l'avion:
MY.pan += TIME * MY._ASPEED_PAN;
MY.roll += TIME * MY._ASPEED_ROLL;
MY.tilt += TIME * MY._ASPEED_TILT;
Pour empêcher notre avion de voler trop haut ou trop vite nous réduisons les valeurs de
l'ascension (la force. Z) et les valeurs de la poussée (force. X) par une fraction de la hauteur et la
vitesse actuelle moins leur valeur max:
// limite artificielle
// pour empêcher d'aller au delà de notre monde
force.Z -= max(0, 0.01*(my_height - height_max));
// pour empêcher un sur régime
force.X -= max(0, 0.1*(MY._SPEED_X - speed_max));
Maintenant nous employons la poussée (la force. X) pour calculer la vitesse avant de l'avion. Nous
utilisons cette valeur pour calculer la distance relative que parcourt l'avion pendant un cycle
d'affichage:
// accélère la vitesse relative de l'avion par la force
friction = min(1,TIME*gnd_fric*0.2);
MY._SPEED_X += (TIME*force.X) - (friction*MY._SPEED_X);
dist.X = TIME * MY._SPEED_X;
dist.Y = 0;
dist.Z = 0; // la force d'ascension contrôle seulement la vitesse absolue
Nous faisons la même chose avec la force d'ascension (force.Z). La seule différence par rapport
au mouvement avant calculé ci-dessus, est que cette ascension agit toujours en face de la traction
de la gravitation de la terre (Z absolu). Finalement nous réduisons les vitesses résultantes de
nouveau:
// ajpute les forces d'ascension et de gravité
MY._SPEED_Z += (TIME*force.z) - (friction*MY._SPEED_Z);
absdist.X = 0;
absdist.Y = 0;
absdist.Z = TIME * MY._SPEED_Z;
//si nous avons réduit notre modèle d'avion nous devons réduire notre vitesse également.
dist.x *= _FLYSCALE;
dist.y *= _FLYSCALE;
dist.z *= _FLYSCALE;
absdist.x *= _FLYSCALE;
absdist.y *= _FLYSCALE;
absdist.z *= _FLYSCALE;
} // END 'airborne'
Terminons l'action "player_aircraft"
Maintenant que nous avons calculé les distances relatives et absolues, l'avion va se déplacer pour
cette frame (que ce soit sur le sol ou en l'air) nous pouvons déplacer l'avion sur cette distance,
mettre à jour son animation (" aircraft_anim "), déplacer la vue de caméra (" move_view ") et
libérer le contrôle à d'autres fonctions pour une frame (" wait(1) ") :
// Maintenant déplace ME par les distances relative et absolue
YOU = NULL; // l'entité YOU est considérée comme passable MOVE
MOVE ME,dist,absdist;
aircraft_anim(); // anime l'avion
// Si je suis le seul joueur, dessine la camera et les armes par rapport à ME
if (client_moving == 0) { move_view(); }
// On attend un tick et on recommence
wait(1);
}
}
La fonction "aircraft_anim"
Maintenant tout que nous devons faire est de définir la fonction "aircraft_anim". "aircraft_anim" fait
tourner le propulseur de l'avion par le RPM courant du moteur. Nous faisons cela en incrémentant
la valeur de l'avion " _ANIMDIST" en multipliant son " _RPM" par le temps nécessaire à l'animation
de cette frame. Cette valeur est alors "enveloppée" pour donner une valeur entre 0 et 100 (par
l'utilisation d'une boucle While) puis cette valeur est employée pour choisir l'encadrement
d'animation approprié utilisant "SET_CYCLE". La fonction est la suivante :
function aircraft_anim()
{
MY._ANIMDIST += MY._RPM * TIME;
// 'enveloppe' l'animation TIME à une valeur entre 0 et 100 pourcent
while(MY._ANIMDIST > 100) { MY._ANIMDIST -= 100; }
// choisit la frame en fonction du pourcentage
SET_CYCLE MY,anim_fly_str,MY._ANIMDIST;
}
Attacher l'Action
Sauvegardez votre fichier de scénario et retournez dans WED. Trouvez votre modèle d'avion et
assurez-vous qu'il est sélectionné. Employez sa fenêtre de propriétés pour changer son action à
"player_aircraft". Sauvegardez le niveau et compilez le (puisque le seul changement que nous
avons fait était à une entité de carte vous pouvez économiser du temps en choisissant "Update
Entities".
Sélectionnez "Run Level ..."à partir du menu "fichier" et amusez-vous à voler avec votre tout
premier simulateur de vol.
Le niveau fini en exécution
Conclusion
Nous avons appris beaucoup de choses avec cette classe de travaux dirigés. Nous avons écrit un
fichier de scénario à partir de rien, appris certaines des nouvelles commandes et syntaxe de la
version 4.19 et avons créé un modèle de vol simple qui est sympa pour voler.
Cet atelier couvre seulement l'essentiel d'un simulateur de vol. Parmi les choses que vous pouvez
améliorer nous trouvons :
•
•
•
amélioration du modèle de vol (en ajoutant plus de réalisme),
modification du terrain WED (en ajoutant des choses comme des montagnes, des arbres,
etc.),
utilisation de panneaux pour créer une cabine avec jauge, boussole, et cetera.
La deuxième partie de cet atelier couvrira le combat aérien.

Les Ateliers de 3D Gamestudio Créez votre premier simulateur de vol

Transcription

Documents pareils

Transcription Gad Elmaleh “L`autre, c`est moi” - Echo-Fle?

PACK 2 PPL - Centre de formation aéronautique du castellet

L`EHPAD sous les sunlights des tropiques

3 Le Maroc et l`avion

F-117 NightHawk

La 22e édition du Superball de l`Artois a bien vécu

VISITE DE la CHAINE de MONTAGE de l`AIRBUS A380 à

Optimisation d`avions en papier