Créez votre premier simulateur de volabregeon.free.fr/french/simulateur de vol.pdf · en Anglais ou en Allemand, tous deux étant téléchargeables sur le site de Conitec et à me

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.

http://www.3dgamestudio.com/

mailto:[email protected]


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 lui-mê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 au-dessous 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.

Documents

Créez votre premier simulateur de volabregeon.free.fr/french/simulateur de vol.pdf · en Anglais ou en Allemand, tous deux étant téléchargeables sur le site de Conitec et à me