Tutoriel : Une map pour le moteur Source avec Hammer 4

Choix du SDK

Source SDK et Authoring Tools

Valve met à notre disposition un SDK, qui est un ensemble d'outils qui vont nous permettre de créer des maps pour les jeux utilisant le moteur Source. Au début, seul le Source SDK existait. Mais depuis la sortie de Left 4 Dead premier du nom, Valve a décidé de publier des versions ciblées du SDK. Ces versions s'appellent généralement Authoring Tools. Voici les jeux disponibles dans un Authoring Tools :

Donc, pour récapituler, si vous ne mappez ni pour Left 4 Dead ni pour Portal 2, téléchargez le Source SDK. Pour Left 4 Dead et Portal 2, téléchargez leur Authoring Tools respectif, et si vous mappez pour Alien Swarm, téléchargez le Alien Swarm - SDK.

Installation

Pour installer le SDK, commencez par ouvrir Steam. Dans la fenêtre principale de Steam, allez sous l'onglet Bibliothèque (Library), puis sélectionnez la catégorie Outils (Tools). Double-cliquez sur Source SDK ou un des Authoring Tools, pour lancer le téléchargement, comme s'il s'agissait d'un jeu.

->Téléchargement->

Une fois que c'est fini, toujours dans la catégorie Outils, lancez le SDK, comme si vous lanciez votre jeu préféré.

Le contenu

Les différents SDK, suivant la version choisie

Que vous utilisiez le Source SDK ou un des Authoring Tools, trois logiciels sont présents :

• Hammer : C'est le logiciel que nous allons utiliser pour mapper. Son vrai nom est Valve Hammer Editor (ou Valve Hammer World Editor) ;

• Model Viewer : C'est un petit logiciel qui permet de visualiser les models. Les models sont des "objets" très détaillés que l'on place dans les maps, comme des armoires, des voitures, des tanks, des pylônes électriques, des portes à poignée... Ce logiciel n'est plus vraiment utile. Il l'était au temps où Hammer ne disposait pas de son propre système de visualisation de models (au tout début du Source SDK) ;

• Face Poser : C'est un logiciel dont nous ne parlerons pas car il ne nous sert pas à mapper. C'est une application qui vous permet de définir les animations faciales et les mouvements des personnages dans le cadre de la création d'un mod.

La version du Source Engine, si vous utilisez le Source SDK

Le Source Engine est le moteur graphique créé pour Half-Life². Au fil du temps, ce moteur Source a été mis à jour pour suivre les évolutions de la technologie (ajout de HDR, du support multi-cœur, d'effets en tous genres...). Trois versions majeures du Source Engine sont disponibles, et correspondent à leur année de sortie :

• Source Engine 2006 : c'est la première version, celle qui correspond à Half-Life² Deathmatch ;

• Source Engine 2007 : plus de jeux ;

• Source Engine 2009 : c'est la version qui correspond à Half-Life² ainsi que ses épisodes One et Two. Pour Portal, c'est ici aussi ;

• Source Engine MP : c'est la version pour les jeux multijoueurs, c'est-à-dire Counter-Strike: Source, Day Of Defeat: Source et Team Fortress².

Dans le panneau du SDK, choisissez la version de Source à utiliser (Engine Version), en fonction du jeu pour lequel vous allez mapper.

Une fois la version du moteur choisie, sélectionnez le mod pour lequel vous allez mapper (Current Game). Seuls les mods officiels y sont répertoriés.

Lancez Hammer !

Configuration du Source SDK

Pas besoin de configurer le SDK. C'est très pratique, mais le SDK n'est franchement pas le logiciel le plus stable qu'il m'ait été donné de voir. Il est possible que la configuration par défaut soit de temps en temps effacée ou que des bugs apparaissent.

Il se peut aussi que Hammer, et plus généralement le SDK, ne se soit pas configuré par défaut.

Une solution à tous les maux

En cas de problème quelconque, cliquez, dans le panneau d'accueil du SDK, sur Reset Game Configuration, ce qui régénérera une configuration. La fonction Refresh SDK Content peut aussi se révéler salvatrice : elle permet de réactualiser tous les fichiers du SDK, pour en obtenir leur dernière version.

Il se peut aussi qu'à son lancement, Hammer vous dise qu'il n'y a pas de configuration disponible. Pas de panique. Fermez Hammer, le SDK, et lancez le jeu pour lequel vous voulez mapper. Ça actualisera les configurations, et Hammer devrait se lancer sans problème.

Ajouter un mod : Garry's Mod

Par défaut, le Source SDK est configuré pour être utilisé avec la plupart des jeux officiels. Mais, me direz-vous, il en manque un : Garry's Mod. Je vais donc vous expliquer ici comment ajouter manuellement un jeu pour lequel mapper. Je vais utiliser l'exemple du Garry's Mod.

A propos de Garry's Mod

Garry's Mod est un mod assez particulier dans le sens où il est capable d'afficher le contenu d'autres mods comme Counter-Strike: Source, Day of Defeat: Source, Half-life² Episode Two... La configuration sera donc différente en fonction du contenu que vous allez utiliser, et il va falloir préciser quels contenus utiliser.

Choix de la version du moteur Source

La première étape est le choix de la version du moteur Source. Deux versions majeures existent : le Source Engine 2006 et le 2009. Le 2006 est le moteur Source de base, tandis que celui de 2009 est celui qui correspond à la sortie de l'Orange Box (avec Portal, Team Fortress² et surtout Half-Life² Episode Two). Si vous possédez des jeux utilisant le Source Engine 2009, vous mapperez avec cette version. Si ce n'est pas le cas, vous mapperez avec la version 2006.

Choisissez donc, dans le panneau du Source SDK, le moteur que vous allez utiliser. Moi je prends le 2009. mettez ce que vous voulez pour Current Game, ça n'a pas d'importance.

Lancez Hammer, puis allez dans Tools > Options et dans le premier onglet, cliquez sur Edit. Dans la boîte de dialogue qui s'ouvre, cliquez sur le bouton Add. Saisissez Garry's Mod dans le champ Name :

Cliquez sur OK. Voici maintenant ce que vous devriez avoir dans la boîte d'édition des configurations :

Cliquez sur Close, pour fermer la boîte. Dans la liste déroulante de la fenêtre d'Options, sélectionnez Garry's Mod :

Ajout des FGD

Ensuite, il faut ajouter tous les fichiers .fgd dont nous aurons besoin. Les fichiers FGD sont des fichiers texte, contenant des informations sur les entités. On verra ça en détail plus tard, dans la partie II de ce cours.

Dans le cas de Garry's Mod, pas besoin de télécharger de fichier FGD, on va juste ajouter les fichiers FGD des jeux avec lesquels Garry's Mod est compatible. Un fichier Garrysmod.fgd est présent. Ajoutez donc ces fichiers dans la zone Game data files :

• HalfLife2.fgd (ou celui d'HL² Episode 2)

• base.fgd

• cstrike.fgd

• dod.fgd

• hl2mp.fgd

• portal.fgd

• tf.fgd

• garrysmod.fgd (se trouve dans le dossier $SteamUserDir\garrysmod\garrysmod (collez cette adresse dans l’explorateur Windows pour y accéder directement))

Textures et entités

Définissez les valeurs de Default Point Entity class et Default SolidEntity class avec respectivement info_player_start et func_detail.

Pour Cordon Texture, mettez tools/toolsskybox.

Sélection des répertoires

Voici les 3 répertoires à utiliser :

• Game Executable Directory :$SteamUserDir\garrysmod

• Game Directory :$SteamUserDir\garrysmod\garrysmod

• Hammer VMF Directory : $SteamUserDir\garrysmod\garrysmod\maps\vmf

Voici ce que vous devriez avoir :

Une fois que ceci est fait, validez par le bouton OK, et validez la boite de dialogue :

Fermez Hammer.

Programmes de compilation

Rouvrez Hammer et retournez dans les Options (vérifiez que c'est toujours le mode de jeu Garry's Mod qui est sélectionné). Allez dans l'onglet Build Programs et définissez les chemins comme ceci :

• Game Executable :$SteamUserDir\garrysmod\hl2.exe

• BSP :$SteamUserDir\sourcesdk\bin\orangebox\bin\vbsp.exe

• VIS :$SteamUserDir\sourcesdk\bin\orangebox\bin\vvis.exe

• RAD :$SteamUserDir\sourcesdk\bin\orangebox\bin\vrad.exe

• Place compiled maps...$SteamUserDir\garrysmod\garrysmod\maps

Avant toute chose

Une map est un environnement de jeu en 3 dimensions. Cela veut donc dire que le programme que nous allons utiliser, Hammer, est un programme de 3D dont le fonctionnement est similaire à des logiciels de modélisation 3D comme Blender, Maya, 3DSMax... C'est important de le dire, car ce genre de logiciel demande plus de temps d'apprentissage qu'un traitement de texte ou un programme de retouche d'images.

Les étapes de création

Dans un premier temps, nous allons créer un fichier .vmf avec Hammer. Hammer ne travaille d'ailleurs que avec ce format donc vous n'avez pas vraiment le choix. Pour que la map soit jouable, il faudra la compiler, c'est-à-dire convertir le fichier .vmf en un fichier .bsp que le jeu (Half-Life², Left 4 Dead, Counter-Strike...) sera capable de charger. Nous utiliserons aussi Hammer pour compiler.

Quand on crée une map, il est bon de tester fréquemment le résultat, c'est-à-dire de compiler et de tester la map dans le jeu. Tester fréquemment sa map permet de corriger les erreurs rapidement pour éviter de les accumuler. Pour des raisons pratiques, la compilation des maps ne sera abordée que dans la quatrième partie de ce tutoriel. Néanmoins je vous conseille de la lire dès que l'envie vous prend de tester votre début de map (une envie qui viendra assez vite ^^ ).

Chercher de l'aide

Le Source SDK est en anglais, et il n'existe pas de version française, ce qui vous laisse un avant-goût du monde du mapping : quasi tout est en anglais. Il existe bien des sites en français, mais ce n'est jamais vraiment complet. Le meilleur endroit pour vous documenter et chercher des réponses est le Wiki mis en place par Valve. Je vous conseille vivement de vous y référer en cas de problème.

Voilà, ceci étant dit, on peut commencer !

L'environnement de travail

L'environnement de travail est l'espace dans lequel vous allez mapper : c'est Hammer. Vous avez donc lancé Hammer. Allez dans le menu Files puis cliquez sur New, ou faites tout simplement Ctrl+N.

Un nouveau document s'ouvre, vierge :

Voir la vue sous Windows XP

Pour commencer, nous allons un peu analyser les différents composants de l'interface. J'ai numéroté un certain nombre de zones colorées en rouge. L'utilité de ces zones est reprise ci-dessous.

• (1)La barre d'outils horizontale : c'est une barre d'outils classique comme on peut en trouver dans la majorité des programmes de bureautique. Elle a pour fonction de mettre à votre disposition toutes sortes de fonctions faciles d'accès.
  (2)La barre d'outils verticale : cette barre affiche un ensemble d'outils qui nous permettront de mapper. Ils sont indispensables ! Nous y reviendrons plus tard.

• (3)Les 4 vues : vue 3D (camera), vue du dessus (top), vue de face (front) et vue de côté (side). Ces 3 dernières vues constituent les vues 2D.

• (4)Le panneau des textures : c'est grâce à lui que nous allons pouvoir sélectionner une texture pour un bloc. Ce panneau ne nous sera pas d'une grande utilité, car nous passerons plutôt par un autre panneau (le panneau d'application de textures, que nous ne voyons pas sur l'image).

• (5)Le panneau VISGroup : c'est un panneau qui permet de créer des « Groupes de Visibilité ». Ça signifie que vous pouvez rassembler plusieurs objets dans un même groupe, et les masquer, pour ainsi alléger les différentes vues. Nous reviendrons sur ce panneau ultérieurement.

• (6)Le panneau de création : ce panneau va nous permettre de sélectionner un type d'entité, de blocs à créer. C'est un peu abstrait. Nous en parlerons dans la prochaine sous-partie.

Les vues 2D

Pour vous expliquer un peu mieux les vues 2D, voici quelques images (elles viennent du tuto de M@teo21 sur le mapping Half-Life 1). M@téo a donc créé un camion et voici les vues 2D :

Le camion vu de dessus (top).

Le camion vu de face (front).

Le camion vu de côté (side).

La vue 3D

La vue 3D est la représentation en 3 dimensions de votre map, c'est-à-dire de vos vues 2D. Elle permet de vous rendre compte de ce que ça donne. La vue 3D possède plusieurs modes d'affichage. Pour y accéder, cliquez sur Camera, en haut à gauche de la fenêtre 3D. Il y a 6 modes d'affichage, mais seulement 3 nous seront utiles : Wireframe, Flat et Textured.

• Wireframe n'affiche que les arêtes des blocs de votre map.

• Flat affiche votre map, mais sans les textures. Les blocs sont colorés. Ca peut être utile pour repérer des blocs qui dépassent, ou qui posent problème.

• Textured affiche tout simplement votre map comment elle sera dans le jeu, mais sans les jeux de lumière. C'est cet affichage-là que nous utiliserons tout le temps.

Wireframe

Flat

Textured

Les constituants d'une map

On n'y trouve pas énormément de choses différentes en fait. On y trouve principalement des blocs, des entités et des displacements. Les entités peuvent servir à insérer d'autres constituants comme des models, des decals et des overlays. Les entités sont de deux types : bloc ou point.

• des blocs ;

• des displacements ;

• des des entités :

  • des models ;

  • des decals et des overlays ;

  • de la lumière, des interactions, des personnages...

Voici une image d ela vue 3D de Hammer, avec différents constituants :

Explications

Les blocs

Une pièce est constituée des blocs : le sol, les murs, le plafond, le chambranle de la porte, et même la vitre. Les blocs (on dit brush en anglais) sont les constituants les plus simples et sont à utiliser pour créer l'architecture de la map. Ils servent à faite le squelette de la map. Les blocs peuvent être convertis en entités point pour leur ajouter des fonctionnalités, comme par exemple créer une plate-forme élévatrice, une vitre cassable, ou un hélice en rotation.

On applique des tetxures sur les faces de blocs

Les models

Dans l'image ci-dessus, on peut apercevoir un radiateur, un moniteur et un néon. Ces trois éléments-là sont des models, c'est-à-dire des éléments en 3D créés à partir d'un logiciel de modélisation comme Blender, XSI ou 3DsMax. Les models sont évidemment plus complexes à créer que des blocs puisqu'ils nécessitent l'utilisation d'un logiciel de modélisation. Les models peuvent être animés (les personnages, comme Alyx, un Terro ou le Soldier de TeamFortress² sont aussi des models). Les models sont partout ! Heureusement, les différents mods possèdent un large éventail de models que vous pourrez utiliser au sein de vos maps.

Voici un screenshot du mod Black Mesa:Source ou l'on peut apercevoir de nombreux models : le shotgun, la rambarde, les néons, les consoles, le boîtier électrique ainsi que le chargeur HEV et le dispenser de soins :

Les models sont aussi des personnages. Voici le rendu d'un Marine dans Black Mesa: Source d'abord non texturé, puis texturé :

Les displacements

Les displacements englobent une technique de création de relief. C'est grâce à eux que vous allez pouvoir créer des décors plus ou moins naturels, comme des montagnes, des rochers arrondis, des trous, des dunes... ou comme dans l'image plus haut, un tas de gravats.

Voici la map pl_upward de Team Fortress². Toute la colline est faite avec des displacements :

Les decals et les overlays

Les decals sont des entités point qui permettent d'apposer une texture sur une autre. On peut les utiliser pour mettre une tâche de sang, des impacts de balles, des panneaux, de la végétation (avec une texture de végétation) sur un mur. Les overlays reposent sur le même principe à la différence près qu'on peu les étirer.

Dans Left 4 Dead, on peut apercevoir de nombreuses affiches placardées un peu partout. Ce sont des decals :

Les entités

Les entités sont des éléments qui possèdent une fonction. Il existe 2 types d'entités : les entités bloc et les entités point. Chaque entité possède un nom et des spécificités différentes. Par exemple, l'entité point prop_static permet d'insérer un model, alors que l'entité point light_spot insère le faisceaux lumineux d'un spot (c'est le "spot" verdâtres dans l'image donné plus haut).

Les entités bloc sont des blocs qui possèdent certaines fonctions. Comme énoncé plus haut, il peut s'agir de plates-formes élévatrices, de vitres cassables... Mais ces entités blocs peuvent aussi être invisibles pour le joueur. C'est le cas d'une zone d'achat dans Counter-Strike par exemple.

Tous ces points seront abordés plus en détail par la suite.

Création d'un bloc

Commencez par créer une nouvelle map, avec Ctrl + N ou via le menu File > New.

Voici les trois outils principaux dont nous allons nous servir :

• 

  Cet outil est tout simplement l'outil de sélection. C'est lui qui va nous permettre de sélectionner les différents constituants, dont les blocs ;

• 

  Celui-ci, c'est l'outil qui va nous permettre de nous déplacer dans la fenêtre 3D. Son fonctionnement est assez simple : pour avancer ou reculer dans la zone 3D, il suffit d'utiliser la molette de la souris. Laissez le clic gauche enfoncé pour orienter la caméra, et utilisez le clic droit pour effectuer des déplacements latéraux ;

• 

  Ça, c'est l'outil de création. C'est lui qui va nous permettre de tracer le contour (en 2D) d'un bloc.

Choix de la texture

Avant de créer un quelconque bloc, il convient de définir la texture dont il sera habillé. Pour cela, dans le panneau des Textures, cliquez sur Browse (Navigation en anglais, qui peut se traduire par Recherche). Une fenêtre s'ouvre alors vous présentant toute une liste de textures.

Heureusement, il existe un système de filtres. Le champ Filtrer va nous permettre de filtrer les textures en fonction d'un ou plusieurs mots-clés. Entrez-y wall par exemple (wall veut dire mur). L'explorateur va alors rechercher toutes les textures de mur. Toutes les textures portent un nom, et dans ce nom figure son type (wall, concrete, metal, wood, floor, nature, citadel...).

Une face en nodraw est une face qui n'est pas affichée et donc qui n'est pas calculée par le moteur Source une fois dans le jeu. Il ne sert donc à rien de lui faire calculer des faces que le joueur ne verra jamais. C'est la raison pour laquelle il est conseillé de créer les blocs avec la texture nodraw et d'ensuite appliquer une texture sur les faces qui seront visibles par le joueur.

Pour sélectionner la texture nodraw, utilisez le filtre. Une fois trouvée, double-cliquez dessus pour la sélectionner et fermer la fenêtre :

Le bloc

Cliquez sur l'outil de création. Placez-vous dans la vue 2D du dessus (top). Cliquez et laissez enfoncé tout en tirant, comme si vous faisiez une sélection dans un logiciel de dessin. Relâchez le bouton.

Votre bloc n'est pas encore créé, ce n'est que son contour qui est fait. Utilisez les poignées de redimensionnement pour modifier sa taille. Modifiez sa taille dans les 2 autres vues 2D. Quand c'est fait, cliquez droit au centre de l'objet, et cliquez sur Create object.

Il se peut aussi que rien n'apparaisse dans la fenêtre 3D. Si c'est le cas, avec l'outil de sélection, cliquez sur le bloc nouvellement créé puis allez dans le menu View et cliquez sur Center 3D Views on Selection. Ce problème peut aussi survenir lors du chargement d'une map (la vue 3D n'affichera rien). Dans ce cas, procédez de la même façon.

C'est que la vue 3D n'est pas en Textured. Cliquez sur le petit bouton Camera en haut à gauche de la vue 3D, et sélectionnez Textured.

Quelques astuces

• Entraînez-vous à jouer dans la fenêtre 3D : avancez, reculez, tournez... pour vous familiariser ;) Vous pouvez avancer avec les touches W, S, A et D).

• Vous pouvez aussi cliquer sur le bouton droit et le bouton gauche en même temps tout en avançant ou en reculant la souris. C'est pratique pour se rapprocher !

• Un petit truc bien pratique, dans les vues 2D, est d'enfoncer la touche ESPACE en cliquant. Vous avez ainsi la possibilité de déplacer votre grille.

• Pensez aussi à la combinaison Ctrl + E, qui permet de centrer les trois vues 2D sur l'objet sélectionné.

• Le combinaison Ctrl + A permet de remettre la taille des quatre vues par défaut.

Formes géométriques

Vous venez de créer un bloc. Par défaut, ce bloc à la forme d'un parallélépipède rectangle. Mais vous pouvez créer une autre forme, comme un cylindre ou encore une pyramide.

Pour cela, rendez-vous dans le panneau latéral de création, ici :

La liste Objects vous propose la liste des formes géométriques que vous pouvez créer. Suivant la forme choisie, un champ Faces apparaît juste en-dessous. Ce champ vous permet de paramétrer le nombre de faces de votre figure.

• Arch : permet de créer une arche. Les options de création d'une arche sont plus complexes, mais vous saurez vous y retrouver assez facilement ;

• Block : c'est un bête bloc, la forme géométrique par défaut ;

• Cylinder : pour créer un cylindre ;

• Sphere : permet de créer une sphère ;

• Spike : ça sert à créer des pyramides ;

• Torus : c'est un tore, une sorte de beignet creux ^^ ;

• Wedge : c'est un triangle en 3D (pas vraiment un triangle donc). On peut appeler ça une cale.

En effet, et c'est pour une simple raison. Vous vous en sortirez plus facilement avec les blocs simples. Aller faire des sphères et des beignets géants avec des blocs n'est pas vivement recommandé pour des raisons de performances d'affichage. Pour faire des formes arrondies, il vaut mieux utiliser des displacements (que nous verrons par la suite).

Oui, mais pour faire un triangle, je préfère couper un bloc carré en deux. C'est plus simple je trouve (nous verrons comment faire un peu plus loin).

Grille et zoom

La grille

Les vues 2D sont pourvues d’une grille. Celle-ci sert à vous aider à positionner vos blocs et plus tard vos models et vos entités. Par défaut, à l’ouverture de Hammer, la grille est à 64. Vous pouvez voir cette information dans le bas de la fenêtre. C’est l’option intitulée On grid : *nombre*.

Quand la grille est en 64, ça signifie que l’espace entre 2 lignes de la grille vaut 64 unités. Pour vous donner un petit ordre de grandeur, le mur d’un étage d’une maison vaut généralement 128 unités de haut et plus ou moins 16 de large.

Généralement, nous ne travaillerons pas souvent en grille 64. Pour modifier l’unité de la grille, il y a 2 petits boutons dans la barre d’outils horizontale, un + et un - pour augmenter ou diminuer l’unité de la grille :

Le zoom

Toujours dans les vues 2D, vous avez la possibilité de zoomer. Pour zoomer, rien de plus simple : utilisez la molette de votre souris.

Opérations génériques

Voyons maintenant quelques fonctions utiles pour modifier ce bloc.

Déplacer

Rien de plus simple. Pour déplacer un bloc, cliquez dessus avec l'outil de sélection. Votre curseur devient une croix de déplacement qui va vous permettre de déplacer le bloc.

Redimensionnement

Ça, vous savez comment on fait. Il suffit de prendre l'outil de sélection et de cliquer sur le bloc, aussi bien dans la vue 3D que les vues 2D. Les poignées de redimensionnement apparaissent, et vous n'avez plus qu'à modifier votre bloc.

Rotation

Si vous cliquez une deuxième fois sur un bloc déjà sélectionné, les poignées de redimensionnement disparaissent pour laisser place à des poignées de rotation.

Les 15 degrés

Hammer propose soit une rotation totalement libre, soit une sorte de rotation assistée. Dans la rotation libre, vous faites tourner votre bloc comme bon vous semble. Dans la rotation assistée, vous ne faites tourner votre bloc que par tranche de 15 degrés. Je vous conseille fortement de travailler en 15°.

L'étirement

Pour passer en mode d'étirement, cliquez une troisième fois sur votre bloc. De nouvelles poignées apparaissent. Elles vont vous permettre d'étirer (ou d'incliner) votre bloc.

Sélection multiple

Vous pouvez sélectionner plusieurs objets en appuyant sur la touche Ctrl en même temps que vous cliquez sur les blocs.

Vous pouvez également tracer votre sélection. Pour cela, faites comme si vous créiez un bloc : tracez un rectangle avec l'outil de sélection. Utilisez les vues 2D pour lui faire englober tout ce que vous voulez sélectionner.

Une fois que tout est bien en place, tapez Enter sur votre clavier.

Supprimer

Cliquez sur l'objet que vous souhaitez supprimer, et tapez sur Delete, rien de plus simple ^^

Création homologue

C'est un système de création de bloc assez pratique. Par exemple, vous avez un bloc d'une certaine hauteur, et vous souhaitez créer un autre bloc ayant la même hauteur que celui-là, mais pas la même largeur.

Commencez par cliquer, avec l'outil de sélection, sur le bloc de départ. Hammer, sans rien vous dire, va en quelque sorte retenir les dimensions de ce dernier. Prenez l'outil de création, et dessinez votre bloc dans la vue du dessus (top). Comme par miracle, Hammer assignera au bloc la même hauteur que le bloc précédemment sélectionné. Il n'a évidemment pas la même largeur puisque vous venez de la tracer manuellement dans la vue du dessus (logique ça ^^ )

La duplication

Pour dupliquer, il y a le fameux Copier-coller. Mais je dois dire que ce n'est pas pratique.

Hammer vous propose la duplication par déplacement. Pour cela, sélectionnez, dans une des vues 2D, un bloc. Appuyez sur la touche Majuscule et sur une touche directionnelle (attention, n'appuyez qu'une seule fois). Votre bloc est maintenant dupliqué, et déplacé d'une largeur de grille.

Application

Pour ce faire, reprenons notre bon vieux bloc carré. Cliquez sur l'outil d'application de textures :

. Une belle nouvelle fenêtre s'ouvre alors avec tout un tas d'options barbares. Cette fenêtre, tant que maintenant, n'a aucune utilité. Remarquez que votre curseur de souris a changé d'aspect :

. Avec ce nouveau curseur, vous allez cliquer sur une face de votre cube :

La face sur laquelle vous avez cliqué devient alors plus foncée : elle est sélectionnée, et les paramètres de cette face s'affichent dans la fenêtre.

Dans la fenêtre, cliquez simplement sur Browse pour rechercher une nouvelle texture à appliquer sur la ou les faces sélectionnées. Une fois la nouvelle texture trouvée et sélectionnée, cliquez sur le bouton Apply.

Options disponibles

Texture scale : c'est l'échelle de la texture. Une valeur de 1 signifie que la texture n'est pas étirée. A 0.25, la texture est étirée négativement, elle est donc plus petite que la normale. Sous le moteur Source, on laissera généralement une scale de 0.25. On passe parfois à 0.5 ou 1 dans le cas de décors lointains.

Texture shift : c'est le décalage de la texture par rapport à sa position d'origine, sur les axes X et Y. Cette option sert à aligner la texture très précisément.

Boutons Justify : ce sont des petites fonctions d'alignement de la texture, qui peuvent remplir automatiquement Texture shift. Cette zone est composée des fonctions suivantes :

• L (left - aligner à gauche)

• R (right - aligner à droite)

• Fit (adapter l'étirement de la texture aux dimensions de la face)

• T (top - aligner en haut)

• B (bottom - aligner en bas)

• C (center - centrer la texture)

World et Face : ce sont deux options un peu spéciales. Généralement, les 2 options sont cochées dans le cas d'une face horizontale ou verticale. Si la face est oblique (un triangle par exemple), une seule sera cochée. Vérifiez bien que 2 faces aient la même option de cochée si les textures refusent de s'aligner. L'option face est en fait une sorte d'effet miroir de la texture, elle est inversée.

Bien sur, Rotation est l'angle d'inclinaison de la texture :)

Entraînez-vous à faire des blocs et à leur appliquer des textures, à les aligner...

Textures spéciales

Je ne sais pas si vous l'avez remarqué, mais il y a des textures bizarres, quand vous tapez tools dans l'explorateur de textures.

Les textures tools sont des textures qui possèdent une fonction. Quand elles sont appliquées sur un bloc, ce bloc n'est plus considéré comme un simple bloc, il possède une fonction.

Vous remarquerez aussi que la texture nodraw que je vous fais utiliser est une texture spéciale. En effet, dans le jeu, une face de bloc avec cette texture ne sera tout simplement pas affichée, et donc pas calculée par le moteur Source. C'est en fait une technique pour alléger les calculs du moteur. Nous mettons du nodraw SUR TOUTES LES FACES QUE LE JOUEUR NE VOIT PAS. Cette technique est une technique dite d'optimisation. Il y en a plein d'autres, mais celle-ci est la plus élémentaire, et c'est pourquoi il est bon que vous l'adoptiez dès le début :) C'est juste pour vous simplifier la vie que je vous ai dit de créer des blocs directement avec la texture nodraw. Vous n'avez plus qu'à mettre une belle texture sur les faces visibles pour le joueur.

Je vais vous parler ici de quelques autres textures spéciales qui peuvent être utiles. En règle générale, seul nodraw n'a pas besoin d'être appliquée sur toutes les faces d'un bloc. C'est la seule, avec hint et skip.

	C'est juste une texture noire. Elle n'est pas affectée par la lumière. C'est utile pour faire le fond d'un couloir qui s'enfonce dans les ténèbres ^^
	Cette texture bloque les balles (et le joueur aussi)
	Cette texture bloque la lumière
	Le bloc est invisible, mais il est aussi physique, le joueur et les objets peuvent butter contre. Très pratique pour empêcher l'accès à une zone quelconque.
	Le bloc est invisible, mais il est physique, le joueur peut butter contre. Un bloc avec cette texture peut être utilisé comme entité bloc.
	Un bloc avec cette texture est une échelle invisible. Ca ne marche que dans Counter-Strike Source (faire une échelle est plus complexe dans les autres mods).
	Bah, je vous en ai déjà parlé ^^
	Même utilisation que clip, mais ici, c'est seulement pour les joueurs
	C'est une texture que l'on met sur les blocs qui nous serviront à créer des déclencheurs. Par exemple, si le joueur passe dedans, alors, tout explose (je suis sadique, moi ? :D )

Le ciel et ses textures

Pour mettre du ciel dans une map, on utilise la texture toolsskybox. Un bloc de ciel doit être complètement recouvert de cette texture.

Environnement hermétique

Retenez bien ceci : votre map doit toujours être fermée ! Ça signifie que durant le jeu, le joueur ne doit pas pouvoir apercevoir le noir, le vide. Bien sur, dans une map qui se passe complètement à l'intérieur d'un bâtiment, c'est assez facile de fermer la map.

Dans une map qui se déroule à l'extérieur, on va fermer la map avec des blocs de ciel, c'est-à-dire des blocs avec la texture skybox. Regardez cette image, c'est la map de_cbble fournie avec le SDK :

Comme vous le voyez, le mappeur a fermé la map avec des blocs de ciel :)

Dans le jeu, cette texture sera remplacée par une texture de ciel spéciale.

Donc, votre map doit toujours être fermée. Si vous laissez un trou, même d'une seule unité, la compilation de votre map plantera : on dit alors qu'on a un leak.

La texture de ciel

Dans l'explorateur de textures, recherchez toutes les textures appelées skybox. Les textures de ciel s'appellent toujours comme ceci : skybox/nomface.

Une texture de ciel est en fait un jeu de 6 textures : 4 côtés, le bas, et le dessus. Face est tout simplement une indication de 2 lettres, qui permet de définir sur quelle face sera appliquée la texture. Par exemple, pour le ciel de cs_assault, la texture se nomme skybox/assault (on enlève juste les 2 lettres finales). Donc, finalement, le nom de la texture est simplement assault.

Définir la texture

Pour appliquer la texture de cs_assault sur votre map, c'est très simple. Allez dans le menu Map, puis dans Map properties. Cliquez sur SkyBox Texture Name, et entrez le nom de la texture, c'est-à-dire assault.

Mauvaise technique

Parfois il n'est pas facile de repérer l'endroit où se trouve le leak, et le mappeur fait ce que l'on appelait, sous Half-Life1, une Skybox, c'est-à-dire qu'il englobait la map dans un bloc de ciel vide. C'est évidemment un technique à proscrire, y compris pour Half-Life 1 (mais ça on s'en fout ici ^^ ). C'est très mauvais, car le compilateur de visibilité (vvis) et de luminosité (vrad) va croire que votre map n'est pas finie, et va calculer des endroits que le joueur ne devrait pas voir, ce qui fait énormément de travail inutile.

Les textures de dev

Si vous joué à Day Of Defeat, Team Fortress³ ou Counter-Strike, vous avez certainement déjà croisé des maps dites "orange", caractérisées par des textures orange. Outre le fait que ce soit laid, ne nous êtes-vous jamais demandé pourquoi le jeu incluait des textures orange ?

Eh bien ces textures sont en fait des textures de développement, dites "textures de dev". Certaines textures de dev présentent des indications qui aident le mappeur à s'y retrouver dans les dimensions. C'est ce que nous allons voir maintenant.

Les textures de base

Il y a deux textures de bases principales, qui sont souvent utilisées dans les maps orange :

• dev_blendmeasure : texture carrée grise, à utiliser pour le sol

• dev_measuregeneric01 : texture orange de base, à utiliser pour les murs et certains revêtements ne demandant pas de mesures précises

Les murs

128, le standard

Sous la quasi-totalité des jeux Source, un mur d'un étage fait 128 unités de haut. La texture dev_measurewall01a est une texture carrée de 128*128 que vous pouvez utiliser pour texturer vos murs. Le truc pratique c'est que les vrais textures de mur font aussi 128*128 comme grandeur (parfois le double), autrement dit ça vous donne une bonne idée du rendu de votre mur.

Les caisses

D'autres textures peuvent servir de mesure, notamment les textures dev de caisses . Voici les 4 principales :

• 64*64 : dev_measurecrate01 : un demi-mur, ou une très grosse caisse

• 48*48 : dev_measurecrate03 : un muret assez haut. Le joueur peut sauter dessus en s'accroupissant

• 32*32 : dev_measurecrate02 : un petit muret. Le joueur peut sauter dessus sans s'accroupir

Une porte

dev_measuredoor01 représente une porte. Vous pouvez donc l'utiliser pour créer un bloc aux dimensions d'une porte standard. Vous devez aussi penser à découper le chambranle, comme indiqué avec les mesures précises sur la texture.

Un escalier

Voilà aussi un sujet assez déroutant pour les débutants : la taille des marches ! Qu'à cela ne tienne, il existe la texture dev_measurestairs01a qui vous aidera à vous représenter l'escalier et à découper le bloc sans problèmes.

Il existe d'autres textures comme la texture de rampe ou de rambarde ainsi qu'une texture d'échelle. Elles sont moins utiles, et je vous laisse les découvrir par vous-même.

Les dimensions

Le wiki de Valve donne des informations concernant les dimensions dans Half-Life². Ces dimensions sont globalement les mêmes dans les différents mods. Je vous propose ici de voir quelques dimensions intéressantes, qui vous aideront à vous familiariser avec les grandeurs.

Système métrique

Hammer travaille en unités, et il est possible de savoir combien de mètres font une unité. Ce n'est pas super important, mais ça peut quand même vous être utile. Voici donc une table avec les données :

Les joueurs

Faire un conduit, un petit passage... c'est bien, mais encore faut-il savoir la taille des joueurs !

Obstacle au sol

Les joueurs peuvent franchir automatiquement (sans qu'il ne doive sauter) une hauteur de 18 unités, et ce que le joueur soit debout ou accroupi.

Passer sous

Debout, un joueur peut passer, sans s'abaisser sous une hauteur de 73 unités. Accroupi, il ne peut passer sous une hauteur de 37 unités.

Passer entre

Côté largeur, un joueur peut passer entre deux blocs éloignés de minimum 33 unités. Ainsi, un conduit d'aération doit au minimum faire 33 unités de large et 37 unités de haut.

Pente

A partir d'une inclinaison de 45 degrés, il n'est plus possible aux joueurs de grimper dessus.

Utiliser des objets

• Un joueur prend automatiquement un objet si le centre de cet objet se trouve à 25 unités de lui ;

• Un joueur peut "Utiliser" un objet, un bouton, une porte... à partir de 82 unités.

Les maps du SDK

Le Source SDK n'embarque pas de documentation (il faut aller sur le Wiki de Valve pour ça) mais embarque en revanche toute une série de maps d'exemple, portant le préfixe sdk_. Ces maps d'exemple se trouvent dans le dossier sourcesdk_content\hl2\mapsrc (à partir de votre dossier de profil Steam).

Les maps techniques

Ce sont des maps qui expliquent (enfin, "expliquent" est un bien grand mot ^^ ) certaines techniques comme la manipulation des cubemaps, la création d'une grue avec un électro-aimant... c'est souvent assez complexe pour votre niveau actuel. Ces maps ne sont pas souvent belles (souvent texturées en orange), puisque leur but est d'expliquer, pas de passer un concours de beauté ^^ .

Les maps du jeu

Ici c'est déjà plus intéressant ! Il s'agit de maps tirées d'Half-Life² (et une de Half_life² Deathmatch). Ce sont donc des maps complètes que vous pouvez ouvrir avec Hammer pour regarder comment c'est fait. Je vous le dit tout de suite, ce sera compliqué de vous y retrouver au début ^^ . Voici la liste des maps que vous pouvez ouvrir, et je vous conseille de commencer par sdk_dm_lockdown qui est une map HL²DM, et donc un peu plus simple que les maps HL² (car pas de gestion des changements de niveau, de ciel en 3D...).

sdk_dm_lockdown.vmf ouverte dans Hammer

• sdk_dm_lockdown.vmf : c'est la map HL²DM, et elle se trouve dans le dossier sourcesdk_content\hl2mp\mapsrc

• sdk_background.vmf : elle est petite et plutôt vide, et est destinée à être chargée en arrière-plan du menu d'HL²

• sdk_d1_town_03.vmf

• sdk_d1_trainstation_01.vmf

• sdk_d1_trainstation_02.vmf

• sdk_d1_trainstation_03.vmf

• sdk_d1_trainstation_04.vmf

• sdk_d1_trainstation_05.vmf

• sdk_d2_coast_12.vmf

• sdk_d3_c17_13.vmf

• sdk_d3_citadel_01.vmf

Clipping Tool

Le Clipping Tool est un outil de découpe. Il permet de couper des parties de bloc afin d'obtenir un bloc avec une forme plus complexe. C'est un outil extrêmement pratique. Nous allons donc voir comment nous en servir.

Commencez par créer un bloc. Une fois que c'est fait, sélectionnez votre bloc et prenez l'outil de clipping :

.

Maintenant, dans la vue 2D de coté (side) (ou une autre, comme vous voulez ^^ ), cliquez au milieu d'une arête, et maintenez le clic enfoncé. Déplacez votre souris vers l'arête perpendiculaire à la première. Une sorte de sélection blanche suit votre déplacement. Relâchez le clic une fois que vous êtes arrivé sur l'autre arête.

La zone « sélectionnée » en blanc sera la partie du bloc que vous allez conserver. Si vous préférez conserver l'autre partie, recliquez sur l'outil clipping pour inverser la sélection.

Quand tout est OK, faites Enter, sur votre clavier.

Votre bloc est maintenant clippé.

La troisième position

Je vous ai dit que si vous recliquiez sur l'outil de clipping, la sélection était inversée. Si vous recliquez une troisième fois dessus, tout se sélectionne et les 2 parties du bloc sont conservées, mais deviennent deux parties indépendantes :

Déplacement de la ligne de coupe

Avant de valider par Enter, vous pouvez modifier comme bon vous semble la position de la ligne de coupe. Il suffit pour cela de cliquer sur une des extrémités de la ligne et de la déplacer ;)

Un petit exercice

Il est important que vous vous familiarisiez avec l'outil clipping. Pour cela, je vais juste vous demander de reproduire la forme suivante (elle est évidemment faite de plusieurs blocs clippés (coupés) :

Moi, j'ai fait un bloc que j'ai coupé en 4 petits blocs. J'ai coupé ceux-ci par la suite. Vous pouviez très bien créer directement les 4 blocs et les couper après ;)

Carve et Hollow

Le Carve

L'outil Carve, qu'on appelle souvent "carving" est à proscrire. Si j'en parle ici, c'est pour vous dire qu'il existe mais qu'il est mauvais de l'utiliser. L'outil Carve permet de trouer un bloc à l'aide d'un autre bloc. Voici les étapes :

Dans un premier temps, on a deux blocs : le bloc carvé est le gros vert, et le carvant est le bloc turquoise :

Ensuite, le but du jeu est de percer un trou dans le bloc carvé. Pour cela, on déplace le bloc carvant à l'intérieur du bloc carvé :

Dans une des vues 2D, on clic droit sur le bloc carvant et on clic sur Carve. Il ne reste plus qu'à retirer ou supprimer le bloc carvant. Si on sélectionne le bloc carvé on se rend compte qu'il a été découpé et que la partie qui était occupée par le bloc carvant n'existe plus :

Avec deux cubes, la structure obtenue n'est pas encore trop mauvaise. Mais si vous tentez l'expérience avec des cylindres, ça peut virer au cauchemars. Pour plus d'informations, voyez ce tutoriel d'optimisation, paragraphe Carve.

Le Hollow

Tout comme l'outil Carve, le Hollow n'est généralement pas conseillé. Il peut être utilisé pour aller plus vite, mais attention aux erreurs !

L'outil Hollow sert tout simplement à évider un bloc. Pour l'utiliser, sélectionnez un bloc (un gros bloc, qui fait tout le volume de votre pièce. Ensuite, cliquez droit sur le bloc dans une des vues 2D, et sélectionnez Make Hollow (ou Ctrl + H) :

Hammer vous demande l'épaisseur des murs ; Hammer va évider le bloc pour ne garder que 6 petits blocs qui feront office de murs, plafond et sol. C'est l'épaisseur de ces murs qu'il vous demande. 32 ou 16 sont de bonnes valeurs pour l'épaisseur d'un mur.

Vous pouvez spécifier une valeur négative. Dans ce cas, les 6 nouveaux blocs seront crées à l'extérieur du gros bloc (le volume déterminé par le gros bloc est alors le volume réel de la pièce). Voici 3 petits screens (en vue Top) pour illustrer ça :

Comme je l'ai dit, évitez le Hollow, et privilégiez la méthode suivante avec le Clipping Tool.

http://hl.logout.fr/?p=optimisation#II_2_B_b

Évider correctement un bloc avec le Clipping Tool

C'est ma technique préférée : créer un gros bloc - exactement comme pour l'outil Hollow - puis le découper comme je le veux avec le Clipping Tool. Pour ce fait, vous devez savoir utiliser le Clipping Tool de façon rapide, de manière à ce que cette méthode se révèle plus rapide que la création manuelle de 6 bloc séparés.

C'est un peu difficile de donner des screens pour illustrer, donc je vais juste vous expliquer la méthode de coupe que j'utilise.

1. passer le Clipping Tool en mode 3 (pour conserver les deux parties)

2. dans une des vues 2D de face ou de côté, couper horizontalement le bloc deux fois de suite (le sol et le plafond)

3. toujours dans une des vues 2D de face ou de côté, sélectionner le bloc du milieu, et couper deux fois pour obtenir deux murs

4. ensuite, passer en vue 2D Top, sélectionner le bloc du milieu et couper deux fois

5. pour terminer, supprimer le bloc du milieu qui ne sert plus à rien

Et théoriquement, vous devriez obtenir une belle pièce qu'il ne reste plus qu'à texturer :) .

Vertex Tool

Le Vertex Tool est un outil qui va nous permettre de créer des formes encore plus complexes qu'avec le Clipping Tool. Le Vertex Tool va nous permettre de déplacer les sommets et les arêtes d'un bloc.

Allez, on va commencer à jouer avec le Vertex Tool.

Créez un bloc et sélectionnez-le. Cliquez sur l'outil vertex :

Voyez, les sommets de votre bloc sont représentés par des carrés blancs et les milieux des arêtes par des carrés jaunes.

Dans une vue 2D, cliquez sur un sommet, et déplacez-le pour voir ce que ça donne :) Pour valider la modification, il suffit de cliquer sur l'outil de sélection.

En réalité, dans la vue 2D, vous ne déplacez pas qu'un sommet, mais plusieurs : vous déplacez tous les sommets qui sont dans l'alignement de celui sur lequel vous avez cliqué. Si vous ne souhaitez en déplacer qu'un, il vous suffit de le cliquer dans la vue 3D, et de le déplacer au moyen d'une des vues 2D.

Vous pouvez aussi déplacer un sommet sur un autre. Hammer va alors vous demander si vous voulez rassembler les 2 sommets en un seul :

Cette technique, je l'utilise souvent pour créer des triangles et autres formes moins courantes, comme les trapèzes par exemple.

D'ailleurs, pour vous exercer, vous allez créer un trapèze en 3D :) . C'est assez simple : à partir d'un bloc carré ou rectangulaire, il suffit de rapprocher les sommets du dessus vers le centre. Voici donc l'objet à reproduire (la vue 3D est en Wireframe) :

Et l'image complète :

Dangers du Vertex Tool

Quand vous manipulez des blocs avce le Vertex Tool, et dans une moindre mesure le Clipping Tool, certains "bugs" peuvent apparaître. Ces problèmes empêcheront Hammer de compiler votre map, ce qui peut être assez ennuyeux. Néamoins, ces bugs sont généralement simples à corriger, car Hammer vous les indiquera, notamment avec la commande Alt + P qui affiche les erreurs de la map.

Voyons donc les 3 erreurs qui peuvent apparaître quand on fait joujou avec les vertex !

Brush outside world

Traduction : un bloc est en dehors du monde.

C'est assez rare qu'un bloc se retrouve en dehors de la grille de Hammer, en revanche, il arrive parfois que les sommets d'un bloc ne soient pas alignés sur le grille de Hammer. On le vérifie en mettant la grille en grandeur 1. Ce genre de bug se produit quand vous opérez plusieurs modifications, notamment des redimensionnements sur des blocs complexes.

Voici un exemple :

Brush with coplanar faces

Traduction : un bloc possède des faces coplanaires.

Un bloc possède des faces qui se situent dans le même plan. Cela se produit généralement quand vous déplacez un sommet dans le même plan que deux autres. Par exemple, ce cube dans lequel je vais déplacer le sommet sélectionné (en rouge) ;

Je le déplace pour former un triangle :

>

Dans ce cas, il n'y a pas de "merge" possible

Les faces non-planes

http://www.siteduzero.com/tutoriel-3-8 [...] tml#ss_part_3

Le problème des faces non-planes est courant. Ce problème survient quand on déplace un sommet et qu'on le place dans un autre plan. Le face définie par ce sommet se retrouve alors dans une drôle de posture : elle n'est plus plate. Or, une face non plate, ce n'est pas acceptable ! Voici comment créer une telle surface...

En prenant un cube, il suffit de sélectionner un sommet dans la vue 3D, et de le déplacer via une des vues 2D, comme ceci :

>

On obtient alors une forme géométrique "hybride" qui ne ressemble à rien :

Quand on va compiler la map, le compilateur va se retrouver avec la face du dessus qui se trouve dans deux plans géométriques différents. J'ai coloré l'image pour bien montrer les deux plans de la face supérieure :

Ce problème de face non-plane est fréquent quand on déplace des sommets et il faut y faire attention. Ci-dessus, j'ai mis une texture de caisse, donc on voit clairement qu'il y a un problème. Mais, avec une texture de sol ou de mur, il peut être plus difficile de déceler le problème :

On ne constate pas que la face du dessus n'est pas valide. Si vous faites Alt + P, Hammer vous affichera l'erreur Invalid solid structure. Hammer peut corriger le problème si vous cliquez sur le bouton Fix, mais il y a 90% de chances que Hammer produise une structure inadaptée. Il vous faudra donc supprimer le bloc et le recréer, tout simplement.

La salle

Je vous proposerais bien de faire une maison, mais c'est un peu nul. Mon idée est donc de recréer une des salles de la prison de Nova Prospekt, dans Half-Life², car j'ai particulièrement apprécié ce chapitre. La salle que je vous propose de créer est assez simple, mais sera un bon entraînement.

Le sol

On va commencer par créer le sol. Mettez la grille de Hammer en taille 32, et créez un bloc de 512 unités de large, et 768 de long. Pour l'épaisseur, mettez ce que vous voulez, 64 par exemple. Sur la face supérieure, appliquez-lui la texture concrete/concretefloor013a :

Les murs du rez-de-chaussée

Après le sol, les murs. Un mur "normal" fait 128 unités de haut. Pour leur épaisseur, 24 unités conviendra, mais il vous faudra changer la taille de la grille : mettez-là à 8. Construisez les 4 murs de la salle, en faisant en sorte que leur arrête inférieure "côté sol" soit bien en contact avec ce sol. Appliquez la texture plaster/plasterwall034c sur les faces intérieures des murs :

Astuces

Une fois que vous avez créé un premier mur, dupliquez-le, avec la combinaison Majuscule + Flèche directionnelle, et déplacez-le ensuite à l'endroit voulu, avec la souris ou les flèches directionnelles. Ça vous évite de devoir redessiner un bloc, ce qui est une perte de temps.

N'oubliez pas qu'avec l'outil d'application de textures, vous pouvez sélectionner plusieurs faces en même temps, en maintenant le touche Ctrl enfoncée tout en cliquant sur les faces.

Les murs de l'étage

Une prison a des murs plus hauts qu'une maison, d'autant plus qu'il s'agit d'une grande salle dans laquelle nous ajouterons une passerelle. Sur nos 4 murs, nous allons monter 4 nouveaux murs, toujours de 128 unités de haut. Il faut savoir qu'en mapping, il es rare de faire de très grands blocs. On privilégiera généralement des blocs de petite taille pour pouvoir mieux jouer avec les textures. Les faces intérieures de ces 4 nouveaux murs seront texturées avec plaster/plasterwall034b, ce qui va permette de faire une continuité entre la texture du bas et la texture du haut :

Le plafond

Ici, c'est l'inverse du sol... On utilisera la texture plaster/plasterceiling008a pour la face visible du plafond. Tout comme le sol, une hauteur de 64 me semble bonne, bien qu'en réalité vous pouvez mettre ce que vous voulez :

Colonnes et poutres

En mapping, le plus gros souci est de trouver des idées pour "meubler" les salles. Ici, je vous propose d'ajouter 3 colonnes qui soutiennent une poutre. Le côté droit restera libre, car nous y ajouterons une passerelle par après. Les poutres et colonnes ressembleront donc à des L retournés :

Pour faire ça, il nous faudra 3 blocs : la poutre, la partie inférieure de la colonne et la partie supérieure (pour pouvoir mettre des textures différentes). Pour vous simplifier la vie, créez une première structure, que vous dupliquerez par après.

Les poutres et colonnes sont carrées, avec une largeur et une profondeur de 24 unités. Travaillez en taille de grille 8. Laissez une espace de 128 unités sur la droite, et texturez avez les mêmes textures que les murs. Pour la poutre, utilisez la texture plaster/plasterwall034a :

Pour finaliser la colonne/poutre, on va utiliser le Vertex Tool pour créer un angle à 45 degrés au niveau de l'intersection entre la poutre et la colonne. Cette technique vise simplement à réduire le nombre de faces invisibles (ce qui occasionnera moins de calculs pour l'affichage) :

Pour finir, sélectionnez vos 3 blocs, faites Ctrl + G pour les grouper. Dupliquez-les 2 fois pour obtenir 3 structures, et répartissez-les sur l'espace de votre salle : un au milieu (repérez-vous avec la petite croix au centre du bloc du "sol") et deux de part et d'autre. Vous devriez obtenir ceci :

La passerelle

On va maintenant mettre en place une passerelle assez simple. Commencez par tracer un bloc de 8 unités de haut, dont le dessus du bloc se trouve à la même hauteur que le dessus du mur du rez-de-chaussée, comme ceci :

Réduisez la taille de la grille, et prenez l'outil Clipping Tool. Avec ce dernier, on va couper la passerelle aux intersections avec les colonnes. Pour chaque colonne, coupez deux fois, à gauche et à droite :

Vue Top

Vous obtenez donc 3 gros blocs, et 3 autres plus petits, de la largeur des colonnes. Maintenant, agrandissez les 3 plus grands blocs pour les faire venir de part et d'autre des colonnes, comme ceci. Dès que c'est fait, placez une autre passerelle au fond de la pièce, et commencez à texturer les faces visibles, ce qui devrait vous donner plus ou moins ça :

L'escalier

Bon, on a une plate-forme en hauteur, mais il manque quelque chose pour y accéder. Nous aborderons les échelles par la suite, car elles ne sont pas toujours simples à mette en place et requièrent le maniement des entités, ce qui n'a pas encore été abordé. On va donc faire un escalier.

Une marche d'escalier fait généralement 8 unités de haut, sur 24 unités de profondeur. Quand à la largeur, c'est comme vous voulez, 128 pour un double, et 64 pour un simple escalier. Ici, les marches feront 128 unités de large pour coller avec la largeur de la passerelle.

Commencez par créer une première marche, celle du dessus. Comme je l'ai dit, 8 unités de haut, 24 de profondeur et 128 de largeur. Avec le Vertex Tool, transformez la marche en un triangle. Le côté incliné sera la "face" arrière de l'escalier :

Dès que c'est fait, texturez les faces avant et supérieure de la marche, avec la texture concrete/concretestair005a. Mais ici, il va falloir chipoter avec les réglages de la texture pour l'aligner correctement :

Activez le Texture Lock et dupliquez et la marche (avec Majuscule + Flèche directionnelle) et déplacez la copie. Répétez ça jusqu'à obtenir un escalier jusqu'au sol :

Désactivez le Texture Lock. Sélectionnez les faces arrières des marches, et appliquez leur une texture de plafond. Pensez à aligner les textures (mettez 0 à X et Y dans les cases Texture shift du panneau de propriété des textures.

Il ne nous reste plus qu'à placer un bloc pour fermer l'escalier du côté gauche. Faites un bloc de 4 unités de large que vous placez du côté gauche de l'escalier. Avec le Vertex Tool, modifiez le bloc pour qu'il épouse la forme de l'escalier :

Texturez le bloc avec la même texture que celle des marche, pour obtenir ceci :

En ce qui concerne les face gauches et droite du bloc, il vous faudra modifier l'angle (j'ai mis 35°) de la texture.

La balustrade

On va ajouter une balustrade pour ne pas tomber de la passerelle, ce serait gênant. Pour faire une balustrade, c'est très simple : créer un bloc et lui appliquer une texture de balustrade ! Il y en a plusieurs, que vous trouverez avec le mot clé rail. Moi, je vais utiliser metal/metalrail013c.

Créez un bloc de 32 unités de haut, sur 2 unités de large. Placez ce bloc entre l'escalier et la première colonne. Dès que c'est fait, appliquez la textures de rambarde sur les faces avant et arrière. Comme vous pouvez le constater, cette texture est spéciale : ce qui apparaît en noir est en réalité transparent !

Du côté de l'escalier, créez une montant, que vous allez texturer pour "fermer" la rambarde, comme ceci :

Vous avez compris le truc ? Bien, finissez la passerelle en ajoutant une rambarde entre chaque colonne :

Portes et fenêtres

Histoire d'encore un peu pratique, on va ajouter une petite pièce avec une porte et une fenêtre. C'est l'occasion de réutiliser le Clipping Tool pour faire des découpes au sein des blocs.

Dans le coin opposé à l'escalier, créez une pièce, faite de deux parois de 8 unités d'épaisseur. Pour faire plus joli, j'ai décidé de faire un coin oblique. Pour réaliser un coin oblique, créez un bloc normal et modifiez-le avec le Vertex Tool. Je texture avec plaster/plasterwall034d :

La porte

Dans la face avant, on va creuser un trou pour la porte. Prenez le Clipping Tool, mettez-le en mode 3 (pour conserver tout ce qui est coupé) et coupez deux fois dans le sans de la hauteur :

Dès que c'est fait redimensionnez le bloc central, qui sera le haut de la porte :

La fenêtre

C'est le même principe, sauf que le bloc du milieu sera coupé en deux horizontalement, pour obtenir le bas et le haut. Faites une fenêtre sur l'autre côté :

Les encadrements

Notre porte est un peu moche, de même que la fenêtre. Ce qu'il manque, c'est un encadrement. Créez-en un, avec une texture comme metal/metalwall062a. Faites ça proprement : pensez à raccorder les bords avec le Vertex Tool pour obtenir ceci :

Faites de même pour la porte.

Quand c'est fait, terminez la petite pièce en y plaçant un toit :

Vous pouvez télécharger la map utilisée pour réaliser ce chapitre.

Petites explications

Ahhhha, bonne question :)

Les displacements servent à donner du relief à une ou plusieurs faces d'un bloc. On utilisera les displacements pour créer des collines, des trous d'obus, des paysages vallonnés, des falaises, des tas de gravats et autres éléments qui demandent du relief.

Pour vous illustrer la chose, voici 2 images de maps où l'on voit des displacements.

1. La première image est un screenshot tiré du solo d'Half-Life² (c'est juste avant d'arriver là où il y a la grue, où vous devrez soulever le buggy avec). Sur l'image, les rochers faisant office de falaises ainsi que le sol sont displacés ; on leur a appliqué des displacements. Je sais, l'image n'est pas belle, c'est en rapport avec ma FX5500 :D

2. La deuxième image est un screenshot de la map dm_avalon pour Half-Life²DM, réalisée par 3D-Mike, un ex-mappeur de chez Valve. Dans cette map, la quasi-totalité du décor est faite de displacements, ce qui donne un effet assez réaliste. Si vous ne connaissez pas cette map, voici sa page officielle : http://www.3d-mike.com/game/dm_avalon.htm.

Paint Geometry

Préparation

Réaliser des displacements est en théorie très simple. Mais en pratique, ça l'est moins. Displacer un simple sol pour donner un peu de relief comme dans le premier screen est relativement simple. Par contre, les displacements de la map dm_avalon sont beaucoup plus compliqués à réaliser.

Créez un bloc, avec comme toujours la texture nodraw. Sur la face supérieure, appliquez une texture d'herbe (moi j'ai choisi nature/blenddirtgrass001a).

Bien. Reprenez l'outil d'application de texture et sélectionnez la face texturée. Dans la fenêtre de l'outil, il y a un onglet intitulé Displacement, cliquez dessus.

Pour le moment, nous ne savons encore rien faire. Cliquez sur Create pour créer un displacement. Une petite boîte de dialogue vous demande quelle est la « puissance » de displacement souhaitée. Vous avez le choix entre 2, 3 et 4. Laissez 3.

Comme par enchantement, toutes les faces non-sélectionnées de votre bloc disparaissent (dans la vue 3D). Seule la face sélectionnée subsiste ; elle est displacée. Votre face est « découpée » en triangles. Le principe du displacement est de modifier la position (verticale dans ce cas ci) des sommets des triangles, ce qui donnera un relief à notre face.

Création du relief

Vous êtes toujours sous l'onglet Displacement et votre face est toujours sélectionnée ? Bon, cliquez sur Paint Geometry. C'est cet outil qui va nous permettre d'élever et d'abaisser les sommets des triangles. Passez votre curseur sur votre face et vous verrez que votre curseur a encore changé de forme :)

La nouvelle fenêtre nous offre 2 options principales : Distance et Radius. Distance est tout simplement le nombre d'unités dont sera élevé ou abaissé un sommet. Radius est le diamètre de la grosse boule verte. Plus son diamètre est important, plus l'élévation ou la diminution sera large. Enfin, ce n'est pas facile à expliquer tellement c'est simple ^^ Faites 3 ou 4 tests en ayant modifié ces options :)

Pour élever ou abaisser un sommet, il suffit, dans la vue 3D de placer le curseur au-dessus du sommet et de cliquer soit droit, soit gauche.

Le cas des displacements verticaux

Vous pouvez bien entendu, comme dans le cas des falaises, displacer des faces verticales. La technique est un peu spéciale, car vous n'allez plus augmenter au diminuer la hauteur des sommets, mais bien avancer ou reculer les sommets. Pour cela, vous allez devoir modifier l'axe sur lequel vous travaillez (X, Y ou Z).

Pour spécifier l'axe sur lequel vous travaillez, c'est la liste déroulante Axis du panneau Paint Geometry. Par défaut, vous travaillez en Face Normal, ce qui équivaut en fait à l'axe des Z (Z-Axis). Les axes verticaux sont donc soit X soit Y, tout dépend de la position de votre face. Modifiez simplement l'axe de travail et testez pour voir lequel est le bon ;)

Vertical et horizontal

Continuons dans l'optique des falaises :) Si la falaise n'était constituée que d'une face verticale, ça ne rendrait pas bien. Donc, les faces verticales et horizontales sont displacées de manière à former une courbure plus jolie.

Pour réaliser ce genre d'effet, il suffit de sélectionner la face du dessus ainsi que la face verticale et de créer un displacement.

Ensuite, il n'y a plus qu'à travailler les faces :)

Pour plus de facilité, vous pouvez sélectionner les 2 faces en même temps et donc passer de l'une à l'autre sans aucun problème ;)

Paint et Invert Alpha

Paint Alpha

Ahhhh, le Paint Alpha, que voilà quelque chose de très pratique :)

Bon, comment vous expliquer ce que c’est… Voici plutôt 2 images : la première sans alpha et la deuxième avec.

Grace à l’alpha, on va en quelque sorte apposer une autre texture sur la première. Mais attention, on ne fait pas cela avec n’importe quelle texture. On fait cela avec toutes les textures qui contiennent blend dans leur nom. D’ailleurs, ces textures sont représentées avec les 2 types de couleurs dans l’explorateur de textures.

Ce fameux alpha permet de créer des sentiers (un peu comme dans la deuxième image), et de donner plus de réalisme aux décors et aux displacements.

Pour peindre l’alpha, il vous suffit de cliquer sur le bouton Paint Alpha de l’onglet Displacement. Le Paint Alpha s’utilise un peu de la même façon que le Paint Geometry.

Pour augmenter (ajouter) de l’alpha, cliquez avec le bouton gauche. Pour diminuer, cliquez avec le bouton droit.

Invert Alpha

C’est un outil qui permet tout simplement d’intervertir les 2 couches. Dans mon premier exemple, le sable deviendrait de l’herbe, et l’herbe du sable. Like this :

Noise et Sew

Noise, le générateur de terrain

L'outil Noise et un petit outil qui permet de générer du relief. Pour cela, il suffit de rentrer la valeur minimale d'élévation ainsi que la valeur maximale, et le tour est joué :)

La valeur minimale peut être un nombre négatif, ou un nombre positif.

Sew, l'égaliseur de terrain

L'outil Sew vous permet d'égaliser 2 (ou plus) displacements ensemble. Mais pour cela, il faut certaines conditions. Les displacements doivent être du même Power, se toucher et leur zone commune ne peut être qu'égale, 2 fois plus grande ou 2 fois plus petite.

->

Subdivide

L'outil Subdivide est un outil très spécial, et c'est assez compliqué de vous expliquer concrètement à quoi il sert. Pour être simple, je vais vous dire qu'il sert à arrondir. Et pour vous le prouver, voici un exemple.

Faites un bloc, et créez-y des displacements sur la face supérieure et sur un côté. Sélectionnez ces 2 faces, et cliquez sur le bouton Subdivide puis admirez !

->

En fait l'arête toute droite séparant les 2 faces a été incurvée et donne un arrondi parfait.

Je vais maintenant vous montrer 3 petites astuces.

Le 1er exemple, mais en mieux

Le problème de l'exemple ci-dessus, c'est qu'il reste des « coins ». Pour qu'il n'y en ait pas, c'est très simple.

1. Créez 3 blocs identiques placés en ligne l'un à côté de l'autre

2. Sélectionnez toutes les faces supérieures ainsi que les faces de côté (que vous comptez displacer)

3. Créez un displacement

4. Subdividez

5. Supprimez les 2 blocs à l'extrémité, ne gardez que le bloc central

->->->

La sphère

Alors là, rien de plus simple :

1. Créez un bloc

2. Sélectionnez ce bloc avec l'outil de sélection

3. Créez un displacement. Toutes les faces du bloc seront alors displacées

4. Subdividez, et admirez votre sphère

Le cylindre

C'est un peu comme pour « le 1er exemple mais en mieux ». Nous allons ici créer un cylindre, pour faire une colonne par exemple.

1. Créez 3 blocs identiques les uns au-dessus des autres

2. Sélectionnez tous les blocs, et créez un displacement

3. Vous allez maintenant supprimer les displacements de TOUTES les faces supérieures et inférieures des cubes. Pour cela, sélectionnez la face, et dans l'onglet Displacement, cliquez sur Destroy

4. Sélectionnez les 3 blocs, et subdividez-les

5. Supprimez le bloc du dessus ainsi que celui du dessous. Il vous reste donc le bloc central qui fera office de colonne

->

Techniques avancées

Je vais laisser là main à Tydax, qui va vous expliquer un peu plus en détail comment faire de bons displacements. Je vous ai expliqué la base, il va vous expliquer comment ne pas foirer vos emplacements !

Accéder au chapitre sur les displacements avancés

Les décals

L'outil décal est symbolisé par un bloc de couleur brique avec une cible dessus. C'est cet outil qui va nous permettre d'appliquer un décal.

Un décal est une texture généralement de petite taille, possédant des zones transparentes, que l'on appose sur une texture. C'est comme si vous colliez une décalcomanie sur votre peau. Ici, on colle une texture sur une autre.

Apposer un décal

Plaquer un décal est assez simple. Commencez par choisir une texture de décal (bah oui, logique ^^ ). Cliquez sur Browse pour choisir la texture. Les décals officiels peuvent être listés très facilement en tapant decal (ou decals) dans le champ Filter :

Parcourez les textures proposées histoire de voir un peu tout ce qui est proposé.

C'est vrai, mais il faut que vous pensiez à une chose : quand le décal sera appliqué, son arrière-plan sera transparent.

On va faire un petit exemple pour que vous compreniez mieux. Tapez dans le champ Filter : decals/decal_posters006a, et double-cliquez sur la texture trouvée.

Maintenant, prenez l'outil décal. Le pointeur de votre souris change alors de forme et ressemble à une sorte d'étoile difforme ^^ . Il ne vous reste plus qu'à cliquer au centre du bloc sur lequel vous voulez apposer ce décal :

->

Et voilà, votre décal est appliqué :) . Et remarquez, l'arrière-plan est transparent ;) .

Déplacer et supprimer un décal

Bien évidemment vous pouvez supprimer ou déplacer votre décal. Pour ce faire, prenez l'outil de sélection, et zoomez au centre du décal dans la vue 3D. Au centre du décal se trouve une petite croix en 3 dimensions. Cliquez dessus pour sélectionner le décal. Ensuite, si vous voulez le supprimer, utilisez la touche Delete de votre clavier.

->

Pour le déplacer, utilisez les touches directionnelles dans les vues 2D. Mais attention, n'enfoncez pas le décal dans le mur, ou ne le faites pas sortir. Déplacez-le seulement de gauche à droite et de haut en bas (ou vice-versa ^^ ).

Les overlays

Les overlays ressemblent aux décals mais ceux-ci ont quelque chose en plus ! Avec les décals, vous appliquez une texture qui ne se répète pas. Grâce aux overlays vous pouvez faire répéter cette texture ce qui peut-être avantageux dans certains cas. Les overlays peuvent aussi êtres apposés sur les displacements, chose impossible avec les décals.

Apposer un overlay

Il n'y a rien de difficile : ça se fait exactement comme pour un décal, sauf que vous pouvez prendre la texture que vous voulez, ça ne doit pas nécessairement être une texture decal. Cela dit, vous pouvez rechercher les décals en mettant overlay dans Filter, mais la liste n'est pas bien grande. L'outil pour appliquer un overlay se trouve juste en dessous de l'outil décal.

Modifier un overlay

Une fois appliqué, l'overlay ressemble au décal : il mesure la même taille que sa texture. Mais, dans les vues 2D apparaissent des poignées de redimensionnement qui vous permettent de modifier la largeur et la hauteur de l'overlay. En fonction de ces modifications, la texture se répète :

->->->

Entités-point & entités-bloc

J'ai déjà vaguement parlé des entités, mais je n'ai pas été très bavard. Voici pour moi l'occasion de me racheter :) .

On distingue tout d'abord 2 types d'entités :

• Les entités-point

• Les entités-bloc

Entités-point

Les entités-point, comme leur nom l'indique, sont un point de l'espace. Ce point de l'espace possède une fonction bien précise. Par exemple, l'entité appelée light est une « ampoule ». C'est de ce point là que démarrera une source lumineuse.

Les entités-point sont très nombreuses. On y trouve par exemple :

• Le point de départ d'un joueur

• Une arme posée par terre

• Une source sonore (du son est diffusé à partir de cette entité)

• Un personnage

• Les models

• ...

Pour insérer une entité, c'est très simple : cliquez sur l'outil

. Allez maintenant dans la liste déroulante Objects du petit panneau Objects, et sélectionnez light dans ladite liste.

Il ne vous reste plus qu'à la créer, comme un bloc. Vous cliquez dans une des vues 2D et vous cliquez droit puis validez Create object.

Dans votre vue 3D, vous avez maintenant une jolie petite ampoule.

Entités-bloc

Les entités-bloc sont comme les entités-point, mais elles possèdent un volume. C'est un bloc qui est devenu une entité. Ce type d'entité sert par exemple à définir un espace, une zone dans laquelle il se passera quelque chose. C'est le cas des zones d'achat de CS. Toute la zone est un bloc dans lequel les joueurs peuvent acheter, s'ils s'y trouvent. Une porte peut être une entité-bloc. Elle aura alors des paramètres qui feront que si le joueur se trouve tout près, elle s'ouvrira.

Pour créer une entité-bloc, rien de plus simple : créez un bloc et sélectionnez-le. Dans le panneau vu précédemment, cliquez sur ToEntity. Pour supprimer le caractère d'entité d'un bloc, il suffit de cliquer sur ToWorld.

Une fenêtre s'ouvre alors, et la liste déroulante Class vous permet de définir l'entité créée. Je vous parlais des zones d'achat de CS. Dans ce cas, c'est func_buyzone.

Généralement, les entités-bloc dans lesquelles le joueur peut rentrer (entités-bloc invisibles) sont texturées avec la texture tools/toolstrigger.

Paramètres principaux

Ce qui fait l'entité c'est avant tout ses paramètres. Sélectionnez une entité dans votre fenêtre 3D et faites Alt+Enter (ou clic droit > Proprieties dans une des vues 2D). Une fenêtre comme cela s'ouvre :

ou

Il y a 5 onglets principaux :

• Class info

• Outputs

• Inputs

• Flags

• VisGroup

Class et Flags

Class

L'onglet Class Info est très important. C'est sous celui-ci que se trouvent les paramètres (ou les attributs) généraux de l'entité sélectionnée. Tous ces paramètres sont dans la zone Keyvalues.

Vous avez la possibilité de modifier tous ces attributs. Pour cela, cliquez sur l'un d'eux. La valeur de l'attribut est alors affichée dans la zone de droite, juste au dessus de la zone Help.

Par exemple, cliquez sur Brightness (qui veut dire Luminosité en français). La valeur de cet attribut est alors affichée dans le champ de saisie à droite, et un bouton appelé Pick Color (Choisir la Couleur) est apparu. Vous pouvez cliquer dessus, et vous pourrez alors choisir la couleur qu'aura votre lumière ;) . Il en va plus ou moins de la même façon pour tous les autres attributs.

Le petit radar ainsi que la zone de saisie Angles permettent de définir l'orientation de l'entité. Cette fonction n'est pas active dans le cas d'une entité de classe light. Par contre, vous pouvez passer la classe (champ Class) en light_spot, et dans ce cas, vous aurez la possibilité de définir l'orientation.

Bien sûr, nous reviendrons sur les paramètres de chaque entité dans les parties suivantes. Ici, c'est juste pour vous montrer comment ça fonctionne.

Flags

Passez sous l'onglet Flags. Sous cet onglet sont présent d'autres paramètres, mais ce sont seulement des paramètres booléens (coché ou non). Dans le cas de notre light, il n'y a qu'un paramètre : Initialy Dark. Si ce flag est coché, la lampe sera éteinte, jusqu'à ce qu'on l'allume (ce que nous verrons plus tard).

Outputs et Inputs

Les outputs et les inputs servent en quelque sorte à faire communiquer plusieurs entités entre elles. C’est ce qui va nous servir à créer des boutons qui allument une lampe, qui provoquent un bombardement, et plein d’autres choses marrantes ^^ .

Au début, ça me paraissait très obscur, je ne pigeais pas bien comment les utiliser. Je ne comprenais pas ce que venaient faire les inputs, et c’est pour cela que je ne vous parlerai pas beaucoup ce ces inputs (du moins au début), car seul les outputs suffisent pour vous expliquer comment ça marche.

Un output est une sorte de commande qui va servir à appeler une autre entité. Par exemple, si un joueur passe dans une certaine zone, il y a un tremblement de terre. Dans ce cas, quand le joueur sera dans la zone, l’entité-bloc (la zone donc) va appeler l’entité qui se chargera de créer un tremblement de terre. C’est ce qu’on appelle l’output.

Je vais vous montrer de quoi se compose un output.

Allez sous l’onglet Outputs.

La grande zone blanche montre tous les outputs créés. Vous n’en avez aucun, bien évidemment. Pour créer un nouvel output, il faut cliquer sur Add.

Les champs de saisie auparavant grisés vont s’activer. Il va falloir les remplir.

• My output named : c’est le nom de l’output. C’est en fait un événement qui déclenchera l’output. Suivant l’entité sur laquelle vous créez un output, la liste que Hammer vous propose est différente. Si vous connaissez, c’est quelque chose de semblable aux événements Javascript (onclick, onmouseover…)).

• Targets entities named : c’est le nom de l’entité qui sera appelée par l’output. Le nom d’une entité se définit dans son paramètre Name.

• Via this input : c’est ce qui se passera au niveau de l’entité qui sera appelée. Par exemple, une lumière (light) peut soit s’allumer soit s’éteindre.

• With a parameter override of : c'est un paramètre additionnel. On laissera généralement ce champ vide (sur <none>). Nous l'utiliserons lors de la création d'outputs plus complexes.

• After a delay in seconds of : c’est le temps avant que l’output ne soit déclenché. Si le champ vaut 0 (0.00), alors l’output est déclenché instantanément.

Ca, c’est de la théorie. Vous comprendrez mieux comment utiliser ces fameux outputs dans les mini-tutos suivants.

Voici un exemple d’output :

OnStartTouch, (dès que l'entité-bloc est touchée), elle appelle l’entité dont le nom est boumfaitlabombe, et lui dit qu’elle doit exploser (Explode) après 3 secondes.

Par la suite, dès que nous allons rencontrer une nouvelle entité, je vous donnerai, dans un tableau, son nom, son type et un résumé de son utilité. Le nom sera un lien vers le Wiki officiel de Valve, où vous pourrez trouver des informations plus complètes sur l’entité en question. Ces informations seront en anglais, mais ont comme principale utilité de lister tous les outputs et tous les inputs de l’entité, car je ne le ferai pas à chaque fois (bien trop long ou inutile).

Aventure solo

info_player_start est le point de départ d'un joueur dans une map pour Half-Life² (une map solo).

Dans la vue 3D, cette entité est représentée par Gordon Freman lui-même, tout modélisé en vert, excepté ses lunettes et sa barbichette ^^ .

Cette figuration représente la taille réelle d'un personnage dans le jeu, vous pouvez l'utiliser comme repère pour créer vos maps.

Cette entité ne possède pas d'attribut spécifique, si ce n'est son orientation, mais ça, vous pouvez le définir directement via les vues 2D, comme un simple bloc.

Le cas de HL²DM

Deathmatch normal

Dans les maps multijoueurs, il y a plusieurs points de réapparition (de respawn). On utilise l'entité info_player_deathmatch.

Il est important de toujours placer un info_player_start, même dans les maps multijoueurs. En effet, cette entité symbolisera le point de départ de la caméra en mode Spectateur.

J'y viens ;)

Rebels VS Combines

En fait, dans une map Deathmatch normal, tout le monde respawn (réapparaît) dans n'importe quel info_player_deathmatch. Vous savez qu'on peut jouer en mode Team (Rebels contre Combines). Dans la plupart des maps, ce sont des info_player_deathmatch qui sont utilisés : combines comme rebels utilisent les même points de respawn, comme dans les maps dm_resistance, dm_avalon, enfin, quasi toutes).

Mais le cas de dm_runoff est spécifique. Dans le camp rebel, il n'y a que des info_player_rebel, et dans le camp combine, que des info_player_combine. Ainsi, chaque team respawn dans son camp respectif.

Ben alors, tous les points de respawn sont utilisés pour faire réapparaître les joueurs. Vous pouvez également placer des info_player_deathmatch. Ceux-ci ne seront utilisés que si le serveur est en mode Deathmatch simple (pas du Team).

Les cas de CS:S et DOD:S

Counter Strike Source

Les deux entités sont info_player_counterterrorist et info_player_terrorist. Je pense que les 2 types d'entités peuvent se passer de commentaires, c'est assez logique il me semble ;) .

Day Of Defeat Source

De même que pour Counter-Strike, les 2 entités n'on pas besoin d'êtres expliquées. info_player_allies, c'est pour l'armée US, et les info_player_axis, pour la Wehrmacht.

Les models statiques

Pour placer un model dans votre map, rien de plus simple, il suffit de placer une entité prop_static.

L’apparence du model va se définir dans les propriétés de l’entité, et plus particulièrement dans la propriété World Model. Cliquez dessus, puis cliquez sur Browser pour ouvrir l’explorateur de models.

Dans la fenêtre d’explorateur, vous avez une liste dans laquelle les models sont classés. Cliquez sur un des items de cette liste. Le contenu de cette catégorie s’affiche alors dans la zone juste en dessous. Vous y voyez le nom du mod pour lequel chaque model est disponible ainsi que le nom du model. Si vous cliquez dessus, vous pouvez voir le model en 3D dans le cadre de droite.

Pour l’exercice, nous allons insérer le model de l’APC des combines (leur 4x4). Pour cela, saisissez apc dans Filter. Dès que le model est trouvé, cliquez sur OK. Validez ensuite vos propriétés et ajustez le placement du model au moyen des vues 2D :

Propriétés usuelles

• Skin : certains models peuvent avoir plusieurs skins, c'est-à-dire plusieurs apparences. Par exemple, suivant le skin choisi pour un arbre, celui-ci peut soit être nu, soit être touffu, ou entre les deux, comme en automne. Pour savoir si votre model possède des skins, avec l’explorateur de models, sélectionnez votre model, et cliquez sur l’onglet Skins. Le skin par défaut s’appelle skin0. Pour spécifier un skin, il vous suffit d’indiquer le numéro du skin de votre model dans la propriété Skin du prop_static.

• Collisions : cette propriété peut prendre 3 valeurs :

  • Not Solid : le model est alors traversable par le joueur, il ne butte pas contre. C’est très utile pour de petits models comme des cannettes, des seaux, des débris… En effet, c’est râlant de devoir sauter au dessus d’une cannette pour ne pas butter contre ^^ .

  • Solid :c’est le contraire de Not Solid

  • Use Bounding Box : c’est une combinaison de Not Solid et Solid. Certaines parties du model sont traversables, d’autres non. Pour savoir quelles parties seront solides, dans l’explorateur de models, il suffit de cocher la case Collision Model. Des lignes rouges apparaîtront sur le model, dans la vue 3D de l'explorateur, pour indiquer le squelette imperméable du model.

Les models physiques

On entend par model physique, un model qui réagit aux lois de la physique. Ce sont les objets comme les caisses, les blocs, et autres petites choses pouvant être utilisées avec le Gravity Gun.

La mise en place d'un prop_physics se déroule comme un prop_static. Il y a juste quelques propriétés qui diffèrent.

• Damage filter : Nom de l'entité filter_damage_type qui définira le type de dommages occasionnés si le model est brisé.

• Explosion damage : Dégâts causés par l'explosion.

• Explosion radius : Grandeur du rayon du cercle dans lequel agit l'explosion.

• Performance mode : Type de débris générés une fois le model cassé

  • Normal : il y en a un peu.

  • No Gibs : il n'y en a pas.

  • Full Gibs on All Platforms : il y en a beaucoup.

• Preasure delay : Temps en secondes avant que le model ne se casse à cause d'une pression exercée (quelque chose fait pression sur le model, un joueur par exemple).

• Mass Scale : permet de multiplier la masse de l'object. Ca permet de le rendre plus lourd.

Les prop_physics sont utilisés dans les maps solo. Généralement, dans une map multijoueurs, on préférera utiliser des prop_physics_multiplayer. Ce sont exactement les deux mêmes entités excepté que le prop_physics_multiplayer demande moins de ressources, ce qui est plutôt bénéfique en multijoueurs.

Les models respawnables

Quand vous cassez une caisse ou une table dans une partie d'HL²DM, elle réapparaît après un certain temps.

Tout se paramètre de la même façon qu'un prop_physics. Pour modifier le laps de temps entre chaque réapparition, modifiez simplement la propriété Respawn Time. Le temps est par défaut de 60 secondes.

Visibilité d'un model

Pour alléger les calculs du moteur d'affichage, il est possible de masquer un model à partir d'une certaine distance. C'est extrêmement pratique et ça permet vraiment de soulager le moteur.

La distance de visibilité se paramètre avec les deux propriétés Start Fade Dist/Pixels et End Fade Dist/Pixels.

• Start Fade Dist/Pixels : c'est la distance à partir de laquelle le model commence à disparaître.

• End Fade Dist/Pixels : c'est la distance à partir de laquelle le mode a complètement disparu.

Ce n'est pas facile de juger la distance comme ça, au pif. Vous voyez, il y a une icône de caméra (

). Cliquez dessus, et Hammer va calculer la distance entre le model et la caméra 3D.

Mais ce n'est pas suffisant ! Il y a moyen de régler le Fade autrement. Cliquez sur le bouton Toggle Helpers (

). Maintenant, dans les vues 2D (votre model est toujours sélectionné), sont présents deux cercles. Ce sont en fait les deux cercles qui délimitent la distance de visibilité (le Start Fade et le End Fade). Vous pouvez les agrandir ou les rétrécir avec les poignées de redimensionnement.

Une lampe simple

Comme je vous l'ai déjà dit je ne sais plus où, light représente une source lumineuse. Ce n'est donc pas une lampe "en dur" que le joueur peut voir ! Il ne verra que la lumière. C'est pourquoi il faut généralement placer l'objet qui générera la source lumineuse, sinon le joueur va croire que la lumière sort du néant, ce qui n'est pas très réaliste ^^ .

Voici comment placer une entité light :

Comme vous pouvez le voir, la light n'est pas collée au model de tube néon (le model est models/props_wasteland/prison_flourescentlight002b.mdl), et ce pour une bonne raison : light envoie de la lumière dans toutes les directions, et si elle était trop proche du néon, et donc des murs, il y aurait un jeu de lumière particulièrement affreux qui se reflèterait contre ces derniers. Il convient donc de toujours distancer une light des murs.

A créer de l'ambiance, à ajouter de la lumière où il n'y en a pas assez par exemple. Enfin, ce n'est pas facile à expliquer, alors regardez :

Tout au fond, il y a une lampe qui éclairera le coin et la moitié de la pièce. Le toit est percé d'une espèce de coupole laissant entrer le soleil. J'ai placé une light en plein milieu de la pièce. C'est cette light qui va ajouter un peu de luminosité. Evidemment, ça ne doit pas être une light comme un spot de 1000 Watts ^^ . C'est une légère lumière qui ajoute un petit plus à l'ambiance lumineuse de la pièce.

Voici quelques propriétés :

• Brightness : c'est la couleur de la lumière. Très important comme propriété. Les 3 premiers nombres sont les codes de couleur RVB. Vous les définissez en cliquant sur Pick Color. Le quatrième nombre est important et on l'oublie souvent : c'est l'intensité de la lumière. Plus le nombre est élevé, plus la lumière est lumineuse. 150 ou 200 sont de bonnes valeurs. On peut même descendre plus bas de manière à créer de plus beaux jeux d'ambiance.

• Appearance : vous permet de donner un effet spécial à votre lumière. Aidez-vous de la liste ci-dessous pour choisir l'effet qui vous plaît :

  • Normal : c'est l'apparence que l'on utilise la plupart du temps. La lumière reste allumée.

  • Fluorescent Flicker : utilisé pour obtenir une lumière cassée, généralement un néon. Celle-ci clignote aléatoirement.

  • Slow, strong pulse : la lumière s'éteint et se rallume progressivement.

  • Slow pulse, noblack : c'est pareil, mais la lumière ne s'éteint pas aussi longtemps.

  • Gentle pulse : la lumière clignote mais reste allumée.

  • Flicker A : clignote assez rapidement.

  • Flicker B : la lumière s'éteint brusquement, et se rallume progressivement.

  • Candle A : cet effet est utile lorsque la lumière provient d'une bougie. Elle s'éteint et se rallume de temps en temps, comme si le vent agissait sur la bougie.

  • Candle B : idem, mais dans un autre style.

  • Candle C : idem, c'est un autre effet, histoire de varier...

  • Fast strob : effet stroboscope garanti. La lumière clignote très rapidement. J'espère que vous n'êtes pas épileptiques !

  • Slow strob : pareil, mais ça clignote moins rapidement. Heureusement pour nos yeux ! Ce style permet de mettre une réelle ambiance dans votre map car la lumière ne s'allume que par intermittence.

Il n'y a qu'un seul et unique flag pour light : Initialy Dark. Cochez-le si vous souhaitez que la lampe ne soit pas allumée par défaut. Dans ce cas, il faudra prévoir un bouton pour l'allumer. Nous y reviendrons ;) .

Les spots

Comme je vous l'ai laissé entendre dans la sous-partie ci-dessus, nous allons utiliser les light_spot pour générer une source lumineuse qui, au contraire de light, aura une direction. Pour résumer, c'est un spot ^^ .

Ici, le spot peut être placé sans problème près du model de néon. Le trait rouge symbolise la direction de la lumière.

Pour orienter un light_spot, faites-le tourner dans les vues 2D, tout simplement.

Les propriétés sont les mêmes que pour light, excepté quelques unes :

• Inner : c'est la grandeur de l'angle à la sortie du spot, en degrés.

• Outer : c'est la grandeur de l'angle que fait la lumière après la sortie du spot.

Il faut voir la lumière générée par light_spot comme un cône. Le sommet du cône est l'origine de light_spot. L'élargissement de cet angle est Inner. La base du cône, c'est Outer.

Un light_spot possède le même flag qu'une light.

Les faisceaux lumineux

point_spotlight va nous servir à ajouter un effet supplémentaire à nos spots. C'est une entité qui permet de créer un faisceau lumineux. On n'utilise pas ça avec chaque light_spot ! Généralement, on utilise un point_spotlight avec un light_spot qui a pour vocation d'éclairer fort et loin, comme les phares des combines :

Un point_spotlight se place exactement comme un light_spot. Il convient de le placer juste à côté du light_spot et de l'orienter de la même façon.

N'oubliez pas de configurer ces 3 propriétés :

• Color : la couleur du faisceau.

• Spotlight Lenght : c'est la longueur du faisceau. Une valeur de 150 peut convenir.

• Spotlight Width : la largeur du faisceau. Ici, une largeur de 50 est conseillée.

Ah oui, une dernière chose. Vous devez cocher les 2 flags, et en particulier le premier ;) .

Le soleil

light_environment

Très important dans une map : l'ensoleillement. Celui-ci se définit avec l'entité-point light_environment.

Cette entité possède 3 propriétés très importantes : Pitch Yaw Roll, Brightness et Ambiant.
Vous connaissez les 2 premières, mais pas la troisième. Ambiant est tout simplement la couleur des ombres qui seront générées par l'ensoleillement.

Comme ce n'est pas facile, il existe des listings des paramètres à attribuer à un light_environment en fonction du sky.

Voici donc un listing : Les skys d'HL² - Par la torture facile

env_sun

env_sun est la représentation visuelle du soleil. Ce n'est pas obligatoire de la placer, mais ça peut être un plus, notamment pour les maps qui se déroulent à l'aube ou au couché du soleil.

Avec un env_sun

Sans env_sun

(Les screens viennent de la map factice de la tortue facile. J'avais la flemme d'en recréer une moi-même ^^ ).

Cette entité prend les mêmes paramètres que le light_environment ;) .

Les câbles

Après les lampes, pourquoi ne pas voir les câbles ? Ben oui, ce sont eux qui vont servir à acheminer l'électricité, et ainsi donner plus de réalisme.

Faire des câbles est quelque chose de relativement simple. Un câble est caractérisé par une entité de départ, (le move_rope) et des points d'attache (des keyframe_rope).

Donc, un simple câble aura un début (move_rope) et une fin, qui sera son seul point d'attache, en plus que le move_rope.

Allez, placez dans votre map le move_rope. Remplissez sa propriété Next Keyframe en mettant cable_1. Ensuite, créez un keyframe_rope, que vous nommerez cable_1.

La propriété Next Keyframe indique le point d'attache suivant du câble. Vous pouvez mettre autant de keyframe_rope que vous le voulez. Il vous suffit de tous les nommer et de remplir correctement leur propriété Next Keyframe.

Comme propriétés, nous avons ceci :

• Slack : c'est la tension (la courbure) du câble. N'ayez pas peur de mettre une valeur importante comme 100 voir 150.

• Type : c'est le type de câble. On laisse généralement Rope. Si on met sur Rigid, les effets du Slack sont annulés (ben oui, le câble est rigide et non courbé ^^ ).

• Subdivision : c'est le nombre de câbles. Vous pouvez mettre une valeur allant de 1 à 8. Si vous mettez 5, il y aura 5 câbles qui partiront du point A pour arriver au point B. Plus il y a de câbles, plus le moteur graphique doit calculer. C'est pourquoi il n'est pas bon de mettre plus de 3 câbles ;) .

• Width : comme vous l'aurez deviné, c'est la grosseur du câble. Une valeur de 1 ou de 2 est raisonnable. Les valeurs décimales sont aussi acceptées, comme 0.5 ;) .

• Collide with world : si vous voulez que le câble se cogne contre les autres éléments.

• Start dangling : si le câble semble séparé de son point d'accroche (pas super utile comme truc).

• Breakable : si le câble peut être cassé.

Voilà, c'est tout pour les câbles :) .

Les étincelles

env_spark vous permet de créer des étincelles. C'est assez pratique pour mettre de l'ambiance, comme dans une salle à moitié inondée et pleine d'appareils électriques.

Pour mettre des étincelles, placez un env_spark où vous souhaitez en avoir. Ensuite, paramétrez l'entité :

• Max Delay : le temps maximum entre deux étincelles.

• Magnitude : c'est l'intensité des étincelles. Vous avez le choix entre Petite, Moyenne et Grande (en anglais ^^ ).

• Spark Trail Length : c'est le longueur de la traînée des étincelles.

Il y a aussi quelques flags :

• Start On : très important ça.

• Glow : mettre un effet de lueur.

• Silent : pas de bruit.

• Directional : pour orienter les étincelles suivant un angle (le Pitch Yaw Roll).

Un petit laser fixe

Comme nous sommes dans l'électricité, je vais vous parler des lasers. Mettre quelques rayons lasers peut ajouter un peu d'ambiance dans votre map.

Pour mettre en place un laser, il nous faut trois entités : deux info_target et un env_beam. Les info_target sont des entités qui n'ont pas d'utilité précise, si ce n'est de représenter un point. Les paramètres du laser se définiront avec l'env_beam.

Bon, placez un premier info_target où vous désirez que votre laser commence. Vous nommerez cette entité laser_1a. Ensuite, vous placez le deuxième info_target où vous voulez que votre laser finisse. Appelez cette dernière laser_1b.

Voilà, les points de départ et d'arrivée de votre laser sont placés. Il ne reste plus qu'à les « attacher » entre eux. C'est ce que nous allons faire avec l'env_beam.

Placez votre env_beam où vous voulez, ça n'a pas d'importance. Ouvrez ses propriétés, et dans Start Entity, mettez laser_1a. Dans End Entity, mettez laser_1b. Voilà, votre laser est presque fini :) .

Voici mon exemple (j'ai placé des models pour faire les « générateurs » du laser, pour ne pas qu'il sorte du mur comme par magie ^^ ) :

Il reste d'autres propriétés. Et certaines sont importantes :

• Beam color : c'est la couleur du laser. Moi, comme mes points de départ et d'arrivée sont rouges, je mets mon laser en rouge.

• Life : ça c'est la durée pendant laquelle votre laser va rester activé avant de s'éteindre puis de se rallumer. Moi je mets 0, pour que le laser soit permanent.

• Width of Beam : c'est l'épaisseur du laser.

• Amount of noise : plus la valeur que vous allez entrer ici est grande, plus votre laser va s'agiter, un peu comme un éclair.

• Damage / Second : les points de vie qui seront retirés par seconde si le joueur passe dans ce laser.

N'oubliez pas de cocher le flag Start On, sinon votre laser ne sera pas déclenché par défaut. Il y a d'autres flags intéressants comme Start/EndSparks qui définissent si vous voulez des étincelles au début/à la fin de votre laser.

La lampe qui balance

Eh ben je vais vous expliquer comment en faire une :) .

Parce qu'on n'avait pas encore étudié les câbles :D .

Cette petite partie va donc faire intervenir un peu tout ce qu'on a déjà vu, comme les câbles, les models physiques et les lampes.

Pour commencer, au plafond, créez une entité move_rope. Paramétrez-la comme suit :

Citation : Entité

Next KayFrame : fil_1
Width : 1
Position Interpolator : Linear

Maintenant, placez une entité keyframe_rope, à la hauteur où vous désirez que votre lampe soit, avec ces propriétés :

Citation : Entité

Name : fil_1
Parent : lampe_1
Width : 1

Donc, souvenez-vous, ceci est le câble (le fil) de la lampe.

Maintenant, créez un prop_physics. Ce sera notre lampe. Vous devez la placer juste sous le keyframe_rope. Paramétrez-le comme suit :

Citation : Entité

Name : lampe_1
World Model : models/props_c17/lamp_standard_off01.mdl

Remarquez, la propriété Parent du keyframe_rope contient le nom du prop_physics. Cela veut dire que ce keyframe_rope, ou plutôt le bout du fil est parenté (« attaché ») au prop_physics. Ca aura pour effet de faire balancer le bout du fil en même temps que la lampe si le joueur tire dessus.

Voici ce que vous devriez avoir :

Bon, continuons. Placez un phys_ballsocket sur le move_rope. phys_ballsocket que vous paramétrez comme ceci :

Citation : Entité

Entity 1 : lampe_1

Cette entité bizarre marque l'origine du système de balancement. La première entité liée à cette dernière est le prop_physics (lampe_1). En réalité, et pour faire bref, le phys_ballsocket va s'occuper de gérer le balancement.

Nous avons presque fini. Il ne reste plus qu'à placer la lumière. Placez un point_spotlight juste sous la lampe :

Citation : Entité

Parent : lampe_1
Color : 238 232 221
Pitch Yaw Roll : 90 0 0
Spotlight Length : 256
Spotlight Width : 60

Citation : Flags à cocher

Start On
No Dynamic Light

Vous voyez, le point_spotlight est parenté avec lampe_1. Si la lampe bouge, le faisceau bougera aussi :) .

Juste sous le point_spotlight, créez un light_spot avec ces paramètres :

Citation : Entité

Picth Yaw Roll : 90 0 0
Brightness : 238 232 221 200
Inner : 0
Outer : 50
Pitch : -90

Non. C'est tout à fait possible de le faire, mais alors il faut utiliser un light_dynamic en lieu et place du light_spot. Mais le light_dynamic a un très gros problème : il demande beaucoup de ressources et de calculs et en particulier pour les petites configurations.

Vous pourrez tester dans le jeu, on ne remarque pas trop que la source lumineuse est fixe, car le point_spotlight donne l'impression que la lumière suit vraiment la lampe.

Le trigger_once

Dans ce premier exemple, le joueur passera dans une zone, et la lumière s'allumera. La zone dans laquelle le joueur passera sera ce que l'on appelle, en mapping, un trigger. Trigger veut dire déclencheur en anglais.

Un trigger_once est une zone de déclenchement. Elle a comme particularité de ne pouvoir appeler qu'une seule fois une ou plusieurs entités.

Dans mon exemple, j'ai placé le trigger_once entre les 2 grilles, et le light_spot se trouve au dessus des barils explosifs. Le light_spot a son flag Initialy Dark coché. La lumière sera donc éteinte au démarrage de la map.

La première fois que le joueur passera dans le trigger_once, le spot s'allumera. Si le joueur repasse par après, il ne se passera rien.

Donnez un nom à votre light_spot. Je l'ai appelé super_lampe (la propriété Name). Maintenant, nous allons créer votre premier output :) .

Allez dans l'onglet Outputs, des paramètres du trigger_once. Cliquez sur Add, et rentrez ces valeurs :

Ca veut dire : quand le joueur touchera le trigger_once (OnStartTouch), il appellera l'entité nommée super_lampe en lui disant de s'allumer (TurnOn).

Ah oui, en parlant de flags, les triggers ont ceux-ci :

• Clients : si coché, le joueur peut déclencher le trigger. Il est coché par défaut.

• NPCs : si coché, tous les NPC peuvent le déclencher. Les NPC sont les monstres, les combines, enfin, tout ce qui « vit ».

• Pushables : si coché, un objet peut être poussé dans le trigger pour le déclencher.

• Physics Objects : un objet physique peut déclencher le trigger (par exemple, tirer un radiateur avec le Gravity Gun dans le trigger le déclenchera).

• Only players ally NPCs : tous les joueurs et les NPC alliés (les gentils comme les vortigaults par exemple) déclencheront le trigger.

• Only clients in vehicles : seulement le joueur s'il est dans un véhicule, comme le buggy de Freeman.

• Only clients not in vehicles : seulement le joueur s'il n'est pas dans un véhicule.

• Everythings : tout peut le déclencher.

• Physics debris : les débris physiques peuvent le déclencher. Par exemple, s'il y a une caisse et que vous la cassez, les débris de cette caisse peuvent déclencher le trigger.

Le trigger_multiple

Le trigger_multiple s'utilise comme un trigger_once. La seule différence est que le trigger_multiple peut être déclenché plusieurs fois.

Mais attention, dans ce cas, nous n'allons plus utiliser TurnOn pour le Via this input. En effet, si la lumière vient d'être allumée et que le joueur repasse dans le trigger, la lumière ne s'éteindra pas (normal, puisqu'on va demander à super_lampe de s'allumer).

Il suffit de mettre Toggle à la place de TurnOn. Ca veut dire qui si la lumière était allumée, elle s'éteint, et si elle était éteinte, elle s'allume.

Le trigger_multiple possède une propriété utile : Delay before reset. C'est le temps, en secondes, avant que l'on puisse réutiliser le trigger_multiple. Par exemple, si on met "4", et qu'on traverse le trigger une première fois, il ne se passera rien pendant 4 secondes si on retraverse la zone.

Le logic_auto

Vous vous attendiez à voir encore un trigger_machin ? Eh ben non, ici, c'est d'un logic_auto dont on va parler. Mais on ne va pas en parler beaucoup.

Logic_auto est une entité qui se déclenche au chargement de la map. Grâce à celle-ci, nous allons pouvoir appeler, toujours via des outputs, des entités lors du chargement de la map.

Je n'ai pas d?exemple à vous montrer (il n'y en a aucun qui me vient à l'esprit en fait) sur l'utilisation de ceci. Ah si, je peux vous dire que ça sert à initialiser certaines entités comme les monstres (les NPC), qui par défaut ne sont pas actifs dans une map.

Le compteur

Ben, oui, c'est possible. Pour cela, nous allons utiliser un trigger_multiple et un math_counter. Cette dernière entité permettra de compter le nombre de passages.

Commencez par faire votre trigger_multiple. Ensuite, créez un math_counter et réglez-lui ses propriétés comme ceci :

Citation : math_counter

Name : compteur
Initial Value : 0
Minimim Legal Value : 0
Maximum Legal Value : 2

Je pense que les 4 propriétés se passent de commentaire. Comme vous le voyez, le math_counter peut déclencher à 2 moments : quand une valeur minimale est atteinte, et quand une valeur maximale est atteinte. Dans mon cas, je n'ai besoin que d'une des deux, j'ai choisi de passer par la valeur maximale.

Maintenant, un petit output :

Voilà. Donc, quand le math_counter arrivera à sa valeur maximale (OnHitMax), il appellera super_lampe en lui disant de s'allumer (Toggle). Si vous aviez choisi de passer par la valeur minimale, vous auriez utilisé OnHitMin comme output.

Comme output de votre trigger_multipe, mettez :

Donc, quand on touche le trigger (OnTrigger (j'aurais pu mettre OnStartTouch, mais si je mets OnTrigger, il faut que le joueur soit bien dedans pour déclencher, c'est mieux)), il appellera compteur en lui disant d'ajouter (Add) 1 à sa valeur.

Effectivement. En fait, il faut remettre la valeur initiale du compteur à 0, après 5 passages. Pour cela, le math_counter va s'auto-appeler (on va lui faire un output à lui-même).

Prenez votre math_counter, et créez cet output :

Ce qui veut dire : "Quand il arrivera à sa valeur maximale, il appellera compteur (c'est à dire lui-même) en lui disant de redéfinir sa valeur initiale (SetValue) en la mettant à zéro (With a parameter override of)".

Voilà, je pense qu'avec ce premier mini-tuto portant sur les déclencheurs et les outputs vous avez compris ce que c’est. Vous avez aussi compris ce que sont les inputs. Ce sont donc les méthodes qui permettent d'agir sur l'entité cible (allumer la lampe, compter…).

Le bouton

C'est le bouton le plus basique. Pour en faire un, créez votre bouton, avec soit des blocs, soit avec un model. Moi j'ai choisi de le faire avec un model (models/props_lab/freightelevatorbutton.mdl).

Si vous avez créé votre bouton avec un ou plusieurs blocs, sélectionnez-le(s) et convertissez-le(s) en func_button. Ce sera le bouton :) .

Pour le model, c'est différent. Créez un bloc avec la texture toolsinvisible, à l'endroit où se trouve le bouton. C'est ce bloc que vous allez convertir en func_button. Cochez son flag Don't move.

L'output de ce bouton est d'une simplicité, que je me demande même si je dois vous le donner ^^ . Vous allez le faire, ça vous fera un peu d'exercice.

Quand on appuie sur le bouton, celui-ci doit appeler la lampe et lui disant de s'allumer si elle était éteinte, ou de s'éteindre si elle était allumée.

Voilà, vous venez de créer un fabuleux bouton :) .

La VALVe

Pour faire une valve (une vanne), vous avez deux possibilités : soit vous créez une vanne en bloc que vous transformerez en func_door_rotating, soit vous mettez un model de vanne que vous parentez à un func_door_rotating avec la texture invisible.

Je vais partir sur le deuxième choix car je n'ai pas envie de créer une valve en blocs ;) .

Voilà, dans l'image suivante, j'ai créé un func_door_rotating, avec la texture toolsinvisible. Cette entité est un cylindre et est un peu plus grande que le model de la valve (models/props_pipes/valvewheel001.mdl). Je précise que la valve est un prop_dynamic, puisqu'elle tournera en même temps que l'entité func_.

Voici maintenant les propriétés utiles du func_door_rotating :

• Speed : vitesse de rotation

• Delay Before Reset : temps avant que la roue ne revienne à sa position initiale après avoir été tournée. Mettez -1 si vous ne voulez pas que la vanne revienne à sa position d'origine

• Distance : le nombre de degrés qu'il faudra tourner avant que la vanne ne soit complètement ouverte

Quelques flags :

• X/Y Axis : c'est l'axe de rotation

• Passable : pour ne pas que le joueur se bloque dedans ^^

• Toggle : si la vanne est fermée, on l'ouvre, et inversement

• Use Opens : il faut appuyer sur la touche Utiliser pour tourner

Quelques outputs intéressants :

• OnFullyOpen : quand c'est complètement ouvert

• OnFullyClosed : quand c'est complètement fermé

• OnOpen : quand on ouvre la vanne

• OnClose : quand on la ferme

Relais d'appels

Quand on a beaucoup d'outputs, il peut être intéressant de tous les centraliser au même endroit (la même entité). Pour cela, on va utiliser une entité neutre, appelée logic_relay.

C'est une entité qui n'a pas de fonction spécifique. Elle sert juste à établir une relation entre une entité et une autre.

Regardez ce schéma : un trigger appelle le logic_relay, qui à son tour va appeler une entité env_spark (l'entité pour faire des étincelles, souvenez-vous ^^ ) :

Oui, on sait, et dans le cas de ce schéma, il vaut mieux :D . Maintenant, imaginez, vous avez plusieurs triggers dans votre map. Tous ces triggers appellent 3 entités (une env_spark, une light et une autre non-définie (obsolete)). Cela veut donc dire que vous devez, pour tous vos triggers, créer les outputs vers chaque entité appelée. C'est contraignant ! Dans ce cas-ci, un logic_relay peut s'avérer pratique :

Vous voyez, c'est le logic_relay qui va se charger d'appeler les entités ciblées. Ainsi, vous n'aurez qu'à faire UN simple output vers le logic_relay, pour chaque trigger :) .

Pour appeler un logic_relay, utilisez sont input Trigger, comme ceci :

Pour appeler une entité à partir du logic_relay, utilisez l'output OnTrigger :

Filtres d'activation

Dans les propriétés des entités de type trigger, vous en avez peut-être repéré une qui s'appelle Filter Name.

Filter Name fait référence à un type d'entités bien spécifique les : filter_activator_ .

Il y a 3 entités de bases présentes dans cette classe d'entités (suivant le mod pour lequel vous mappez, d'autres entités de ce type peuvent être présentes, comme filter_activator_tfteam si vous mappez pour Team Fortress²) :

• filter_activator_class

• filter_activator_name

• filter_activator_team

Ces entités permettent de créer des filtres pour autoriser, par exemple, l'équipe blue à déclencher un trigger.

C'est un peu difficile à comprendre, je vais prendre un exemple concret.

J'ai un trigger_multiple qui ne doit être déclenché que par un joueur de l'équipe rouge. Pour ce faire, je lie le trigger à un filter_activator_team. Je configure cette dernière pour qu'elle retourne vrai si c'est un joueur de l'équipe rouge qui se trouve dans le trigger. Si c'est un joueur bleu, le filtre retournera faux, et le trigger ne sera pas déclenché.

C'est pratique non ?

Propriétés :

• Name : le nom de l'entité

• Filter mode : mode de filtrage

  • Allow entities that match criteria : valeur par défaut, comme dans mon exemple ci-dessus

  • Disallow entities that match criteria : c'est le contraire. Pour reprendre mon exemple, si c'est un bleu qui se trouve dans la zone, le trigger sera déclanché.

• Filter * : c'est le paramètre de filtrage. Le nom de cette propriété diffère suivant l'entité.

Filter_activator_class

Cette entité filtre en fonction du nom de classe. Par exemple, si vous faites une map solo pour Half-Life², vous pouvez n'autoriser que certaines entités (classe = nom d'entité). Les citoyens sont des entités npc_citizen. Si vous mettez npc_citizen dans la propriété Filter Classname, il n'y aura que les citoyens qui valideront le filtre (il renverra "vrai").

Filter_activator_name

C'est le même principe que filter_activator_class, sauf que vous filtrez les entités en fonction de leur propriété Name (qui est différent du nom de l'entité !).

Filter_activator_team

Ça c'est comme dans mon exemple, cette entité sert à filtrer en fonction de l'équipe. Suivant les mods, le contenu de la propriété Filter Team peut différer (soit 0 ou 1, soit red soit blue).

Un escalier sadique

Pour illustrer l'utilisation des func_physbox, j'ai décidé de les mettre en scène dans un escalier.

Un func_physbox est un bloc, qui réagit aux lois de la physique. Il peut tomber, être attrapé avec le Gravity Gun... C'est un peu l'équivalent du prop_physics, mais pour un bloc.

En fait, je vais créer un escalier dont les marches centrales tomberont quand vous marcherez dessus.

Commencez par créer un escalier. Dans mon exemple, je vais prendre un escalier simple, composé de deux montants et de marches.

Mettez vos marches et vos montants en func_detail. Laissez juste quelques marches, au centre de l'escalier, en blocs.

Voici le moment d'apprendre les func_details :) . Ces derniers, inexistants sous Half-Life 1 sont indispensables sous le moteur Source. Retenez bien ceci : tout ce qui n'est pas un bloc de structure doit être en func_detail. J'entends par bloc de structure des blocs importants comme les murs, les plafonds, le sol. C'est l'architecture basique de la map. Tout le reste doit être en func_detail, comme les poutres, les colonnes, les rebords... donc tout ce qui est un détail et qui ressort d'un mur.

C'est pour une meilleure optimisation de votre map. Plus votre map est optimisée, moins votre carte graphique souffrira. Les func_details servent à soulager le moteur d'affichage.

Bon, de retour à notre escalier :) . Convertissez en func_physbox, une à une, les marches que vous avez laissées en bloc.

Dès que c'est fait, sélectionnez les toutes, et faites Alt + ENTER pour éditer leurs propriétés.

• Name : donnez un nom, par exemple escalier_sadique.

• Material Type : mettez Metal. C'est pour indiquer que ces marches réagiront comme du métal (ça fera donc un bruit de métal en tombant)

Ben en fait c'est tout ^^ . Ah non, cochez le flag Start Asleep. Grâce à ce flag, les func_physbox vont rester en l'air et non tomber au chargement de la map.

Les autres propriétés ne sont pas utiles et je pense que vous pouvez déjà les comprendre à peu près toutes tout seul :) .

Maintenant, il va falloir déclencher la chute des marches quand je joueur passera dessus. Pour ça, rien de plus simple : un trigger_once.

Celui-ci comprendra cet output :

EnableMotion veut dire qu'on va autoriser les func_physbox à bouger. C'est comme si le flag Start Asleep se décochait, ce qui fait que les marches tomberont :) .

Et voilà, votre escalier est prêt ;) .

Les échelles

Sous le moteur Source, pour faire une échelle, il faut un début et une fin :) .

Comme je le disais, il faut deux points pour définir une échelle. Ces deux points vont être créés avec une entité func_useableladder. Malgré la particule func_ dans le nom de l'entité, c'est une entité-point !

Alors, pour faire une échelle, commencez par la créer en blocs ou avec un model (recherchez ladder dans l'explorateur de models). Dès que c'est fait, créez l'entité func_useableladder à la base de l'échelle. Ce sera le début de votre échelle.

Au centre de cette entité, dans les vues 2D, il y a un petit cercle. Cliquez dessus et maintenez le clic enfoncé en déplaçant le bloc vers le haut. Cette deuxième partie de l'entité sera la fin de votre l'échelle. Essayez de positionner cette deuxième partie dans l'axe de la première partie (sauf si vous avez fait une échelle oblique ^^ ).

Pour finir la structure de votre échelle, donnez lui un nom. Ca nous permttra d'utiliser les dismounts...

Les dismounts

Les dismounts sont des points de sorties de l'échelle. Ce sont des endroits ou le joueur peut poser les pieds de façon à sortir de l'échelle en toute sécurité. Il faut placer des dismounts au début et à la fin de l'échelle (bah oui, si le joueur descend au lieu de monter ^^ ).

L'entité pour placer un dismount est info_ladder_dismount. Placez-les comme ceci :

Maintenant, vous n'avez plus qu'à renseigner la propriété Laddername avec le nom de votre échelle, de façon à lier les dismounts à l'échelle ;) .

Les échelles de CS:S

Sous Counter-Strike Source, pour faire une échelle, c'est tout simple (même trop simple ^^ ). Il suffit de créer un bloc en lui appliquant la texture toolsinvisibleladder. Le bloc se place devant l'échelle, où le joueur passera, comme ceci :

Ici, pas de dismounts ni rien. Juste un bloc texturé :) . CS c'est le mapping pour les feignants :D .

L'entité de brush

L?entité func_brush est une nouvelle entité apparue avec le moteur Source. Elle a pour fonction de remplacer les entités func_illusionary, func_wall et func_wall_toggle, ces dernières datant de HL1, mais toujours présents sous Source.

Le func_brush possède tout un tas de propriétés, mais je ne vais vous en citer que deux, qui je pense, sont les principales :) .

• Start Disabled :

  • Yes : le bloc ne sera pas visible par défaut

  • No : le bloc sera visible par défaut

• Solidity : spécifie la solidité du bloc

  • Never Solid : le bloc ne sera jamais solide

  • Always Solid : le bloc sera toujours solide, et ce, même si il est masqué (via le Start Disabled)

  • Toggle : si le bloc est affiché, il est solide. S?il est masqué, il n?est pas solide. C?est la position sur laquelle je place généralement cette propriété.

Grâce à cette entité, vous pourrez, par exemple, créer un champ de force (un bête bloc avec une texture de champ de force comme effects/com_shield003a) entre deux plates-formes qui sera affiché si le joueur appuie sur un bouton.

Pour afficher ou masquer le func_brush via les outputs, vous devrez utiliser les inputs Disable et Enable. Dans le cas de mon champ de force, mon output serait (Start Disabled est renseigné avec Yes) :

C?était tout simplement un bloc non-solide. Il est donc remplacé par la propriété Solidity du func_brush.

Le func_wall est l?ancêtre du func_detail. Quant au func_wall_toggle, c?est un bloc que l?on peut masquer et afficher, comme le func_brush. Cela dit, le func_wall_toggle a la possibilité d?être commandé via l?input Toggle, que le func_brush ne possède par (il n?a que Disable et Enable). Rappelez-vous le tuto sur les lampes, avec l?input Toggle. Ici, c?est pareil : si le mur était masqué, il s?affiche et vice-versa. Ca peut être utile dans certains cas, mais c?est plutôt rare ;) .

Les blocs cassables

Quoi de plus amusant dans une map que de pouvoir tout casser ? Rien me direz-vous, et vous avez raison ^^ . C?est pour cela que je vais vous montrer comment faire un bloc cassable.

L?entité est func_breakable (breakable veut dire cassable en anglais). Voici les propriétés utiles de cette entité de barbare :

• Explosion Damage : c?est la puissance de l?explosion si l?entité est cassée. Si vous laissez 0, il n?y aura pas d?explosion

• Explosion Radius : c?est le rayon dans lequel l?explosion se fera ressentir

• Performance Mode : c?est utilisé pour définir le nombre de débris que génèrera le cassage

  • Normal : la quantité de debris est normale

  • No Gibs : il n?y a aucuns debris. Le calcul pour le moteur d?affichage est donc plus simple

  • Full Gibs on All Platforms : il y a beaucoup de débris, et donc beaucoup de calculs d?affichage

• Strength : c?est le nombre de points de vie que possède l?entité. Plus le nombre est élevé, plus le bloc est résistant. Si vous mettez 0, l?entité ne sera pas cassable avec des armes (il faudra la casser avec les outputs par exemple)

• Material Type : très important, c?est le type de matériau dont est faite l?entité. Si vous avez fait une caisse en bois, choisissez Wood

• Spawn On break : c?est ce qui apparaîtra une fois le bloc cassé

• Explode Magnitude : c?est l?intensité de l?explosion

Et voici les flags disponibles :

• Only Break On Trigger : pour seulement casser via un trigger (output)

• Break On Touch : pour casser dès qu?on le touche

• Break On Pressure : pour casser si une pression est exercée sur l?entité (si vous marchez dessus par exemple)

• Break immediately on Physics : pour casser le bloc dès qu?il est pris

• Don?t take physics damage : pour ne pas qu?il provoque de dommages s?il heurte le joueur

Les vitres

Faire une vitre est quelque chose de très simple. En effet, il vous suffit de mettre une texture de vitre (glass, pour le filtre de l?explorateur de textures) sur la face visible. Toutes les autres faces doivent impérativement être recouvertes de nodraw, y compris la face inverse de celle texturée (l?autre côté quoi ^^ ) ! C?est tout :) .

Non. Votre vitre ne sera pas cassable. Pour la rendre cassable, convertissez-la en func_breakable, et n?oubliez pas de mettre la propriété Material Type en position Glass ;) .

Mais si vous cassez cette vitre, elle va se casser d?un coup, comme du temps d'Half-Life1. Pour donner une effet réaliste (la vitre se casse par morceaux), nous allons utiliser un func_breakable_surf.

J'ai pris le screen juste au moment ou un rebel me lançait une grenade. La déflagration fait péter les vitres, ça donne un bel effet ^^ .

Les propriétés ce cette dernière sont les même que pour un func_breakable. Strenght a juste changé de nom est et devenu Health. Il y a deux propriétés qui sont apparues :

• Fragility : c?est la fragilité de la vitre une fois qu?elle est cassée. Si vous tirez dans la vitre, elle va se morceler. C?est la fragilité des ces morcellements que définit cette propriété

• Surface Type : c?est le type de surface. Laissez Glass.

Il reste une chose pour améliorer notre vitre (cassable ou pas) : la réflexion. C?est ce que je vais vous expliquer maintenant :) .

Les cubemaps

L?env_cubemap est une entité assez abstraite. Pour faire simple, elle sert à créer des reflets.

Vous devez placer cette entité au centre de toutes vos pièces. Une fois votre map compilée et lancée, vous devez tapez buildcubemap dans la console.

Le jeu va alors créer toute une série d?images, qui sont les reflets de l?environnement. Ces images sont appelées des cubemaps. Les images sont prises de l?endroit où se trouve l?env_cubemap.

Les cubemaps ne sont pas visibles partout. En effet, seule certaines textures sont réfléchissantes (quelques textures de métal, les textures d?eau et de vitres).

Si vous faites une vitre, vous devez placer un env_cubemap (en plus de celui qui est déjà dans la pièce) près de celle-ci, et faire pointer cet env_cubemap vers la vitre.

Pour cela, nous allons nous servir de sa propriété Brush faces. Cliquez sur Pick et, dans la vue 3D, allez cliquer sur la vitre (la face qui est face à l?env_cubemap). Vous pouvez aussi picker (faire pointer l'env_cubemap vers une ou plusieurs faces) plusieurs faces en maintenant la touche Ctrl enfoncée.

Porte translative

Dans un premier temps, nous allons voir comment créer une porte translative.

C'est une porte qui coulisse :) . La porte coulissante est la plus simple à réaliser. Bon, commençons la création !

Créez le bloc qui fera office de porte et transformez-le en func_door. C'est tout. Il ne reste plus qu'à paramétrer l'entité.

• Speed : c'est la vitesse de déplacement de la porte. Une valeur de 100 est tout à fait correcte.

• Start Sound : son qui sera joué à l'ouverture de la porte.

• Stop Sound : son qui sera joué à la fermeture de la porte.

• Delay Before Reset : temps avant que la porte ne revienne à sa position initiale. Si vous mettez -1, la porte ne reviendra pas, elle restera ouverte.

• Lip : c'est le nombre d'unités dont la porte dépassera une fois ouverte. Par défaut, le déplacement de la porte est égal à sa largeur (ou profondeur/hauteur suivant l'orientation). Si la porte fait 100 unités de largeur, elle se déplacera de 100 unités. Maintenant, si vous mettez un lip de 10, elle se déplacera de 90 unités.

• Health : c'est la vie de la porte. Laissez 0 si vous ne voulez pas qu?on ouvre la porte en tirant dessus. Si vous le souhaitez, spécifiez la vie de la porte.

• Locked Sound : son joué si la porte est verrouillée et que le jouer tente de l'ouvrir.

• Loop Moving Sound : Mettez Yes si vous voulez que le Start Sound soir joué en boucle jusqu'à ce que la porte ait fini de s'ouvrir.

• Move Direction : très important, c'est la direction d'ouverture de la porte. Vous devez vous référer à la vue du dessus (Top) pour orienter le radar. Vous pouvez aussi choisir Up ou Down si vous voulez que la porte monte ou descende.

Voilà pour les principales propriétés. Voici maintenant les flags.

• Starts open : la porte sera ouverte par défaut

• Non-solid to Player : la porte ne sera pas solide pour le joueur (sans intérêt)

• Passable : on peut passer au travers (sans intérêt)

• Toggle : assez pratique. La porte reste chaque fois dans sa dernière position jusqu'à ce qu'on l'actionne

• Use Opens : il faut appuyer sur Utiliser pour ouvrir la porte

• NPCs Can't : le NPC (joueurs et monstres contrôlés par l'ordinateur) ne peuvent pas se servir de la porte

• Touch Opens : toucher la porte pour l'ouvrir

• Starts locked : la porte sera verrouillée par défaut

• Door Silent : la porte ne fera pas de bruit

Porte rotative

Voyons maintenant comment créer une porte traditionnelle, avec des blocs. Nous verrons par après comment faire une porte avec un model (cette porte là aura une clenche).

La porte rotative fonctionne exactement comme la porte translative. Il va juste falloir spécifier l?axe de rotation et l?angle d?ouverture.

Allez, convertissez votre bloc de porte en func_door_rotating. Ensuite, activez l?option Toggle Helpers (

). Vous devriez voir apparaître une grosse boule mauve au centre de votre porte :

Cette boule est le centre de l?axe de rotation vertical de la porte.

Dans la vue 2D du dessus, déplacez la boule (elle est au centre du bloc et votre curseur se transforme en croix) et mettez-là sur un coté de la porte :

Ainsi, votre porte s?ouvrira comme une porte normale (si vous aviez laissé le boule au centre, la porte aurait tourné sur elle-même).

Toutes les propriétés sont les mêmes que pour une func_door sauf la propriété Move Direction qui est remplacée par la propriété Distance. C?est tout simplement l?angle d?ouverture de la porte, en degrés. 90 est une valeur appréciable, puisque c?est l?angle droit.

Voici juste quelques flags en plus :

• Reverse Dir : la porte s'ouvrira en sens inverse

• One-way : on ne peut ouvrir la porte que dans un sens

• X axis : par défaut, la porte s'ouvre selon l'axe des Z (vue Top). Mais vous pouvez la faire tourner selon l'axe des X si ça vous chante (c'est très rare quand même)

• Y axis : idem, mais pour l'axe des Y

Porte model

Une porte avec des clenches ça vous dit ?

Dans ce cas, nous allons utiliser un model de porte ! Ce ne sera pas un func_door_rotating, mais un prop_door_rotating.

Cette porte model se configure comme un model, et comme un func_door_rotating. Il y a juste quelques propriétés qui diffèrent de l?entité func_ :

• Rotation Distance : c?est l?angle d?ouverture de la porte

• Fully Open Sound : son joué quand la porte est complètement ouverte

• Fully Close Sound : son joué quand la porte est complètement fermée

• Moving Sound : son joué durant l?ouverture/fermeture de la porte

• Open Direction : c?est le sens d?ouverture ;

  • Open Both Directions : on ouvrira la porte dans les deux sens

  • Open Forward Only : la porte s?ouvre seulement en avant

  • Open Backward Only : la porte s?ouvre seulement en arrière

Il y a un flag important : Use closes. Cochez-le pour que les clenches soient affichées ;)

Porte et vanne

Ici, il s'agit de créer une porte de garage qui s'ouvre en même temps que le joueur tourne une vanne. A la fin d'Half-Life² EpisodeOne, Gordon ouvre une porte de cette manière pour faire passer Alyx. Il se fait alors canarder par un strider.

Nous avons vu comment réaliser une vanne, dans le chapitre sur les déclencheurs (La VALVe). Nous allons donc en créer une de la même façons (un model parenté à un momentary_rot_button avec une texture invisible).

momentary_rot_button se comporte de la même façon que func_door_rotation, mais il possède quelque chose en plus : il revient à sa position initiale quand on le lâche (quand on lâche la vanne donc).

Vous appellerez ce momentary_rot_button, door_vanne.
Ensuite, il faut créer la porte de garage. Faites votre bloc, et transformez-le en func_movelinear. Vous l'appellerez door_garage. La configuration est simple, si ce n'est quelques paramètres :

• Move Direction : c'est la direction dans laquelle le bloc bougera. Ici, la porte va monter, donc sélectionnez Up dans la petite liste déroulante.

• Start Position : c'est le position de départ. Si votre porte est fermée, mettez 0.

• Move Distance : c'est la distance, en unités de Hammer, sur laquelle l'entité va pouvoir bouger. Ca correspond généralement à la hauteur de votre bloc (moins quelques unités).

Revenons à notre momentary_rot_button. Il y a quelques propriétés à modifier :

• Speed : vitesse de rotation en degrés par secondes

• Distance : c'est le nombre de degrés maximum dont l'entité tournera

• Auto-return Speed : c'est la vitesse de rotation quand la vanne est lâchée et qu'elle revient à sa position initiale

• Start position : position de départ. Mettez 0.

• Start Direction : direction dans laquelle tournera la vanne. Laissez Forward (en avant).

Vous pouvez aussi cocher certains flags comme Not Solid, Use Activate et l'axe de rotation (moi c'est Y Axis).

Passons maintenant aux outputs appliqués sur door_vanne :) .

Le premier output dit que quand la vanne est complètement fermée, elle s'appele elle même pour se bloquer. Ainsi, elle ne retournera pas à sa position d'origine si elle est complètement fermée.

C'est tordu ça ^^ . L'état initial est Open, et l'état final est Close. Donc quand la vanne est tournée, elle est fermée (close).

Le deuxième output appelle la porte door_garage à chaque fois que le position de la vanne change (quand vous tournez quoi ^^ ). Et à chaque fois on va modifier, avec SetPosition, la position de la porte sur son axe, en fonction de l'ouverture de la vanne. Donc, plus on tourne, plus la porte s'ouvre :) .

Eau de base

Sous Source, créer de l'eau est très simple. En effet, tout comme les vitres, il suffit de faire un bloc recouvert de nodraw et d'appliquer une texture d'eau sur sa face supérieure.

Pensez aussi à mettre un env_cubemap et à picker la face texturée de votre bloc d'eau. L'env_cubemap est nécessaire pour les cartes graphiques ne supportant pas DirectX9, et donc ne disposant pas du calcul des reflets en temps réel. Les reflets seront donc calculés à l'avance via cet env_cubemap ;) . Avec ma FX5500, je bénis ce système :D .

Si vous mettez de l'eau, vous devez placer une entité water_lod_control qui va vous permettre de configurer la qualité du rendu de l'eau. Cette entité est souvent ignorée des mappeurs, et des maps de trois blocs avec un piscine fait parfois plus ramer la carte graphique que le chapitre en bordure d'eau du solo d'Half-Life² (chez moi en tous cas).

Cette entité possède deux propriétés :

• Start Transition to Cheap Water : c'est le nombre d'unités à partir duquel le rendu de l'eau deviendra moins beau. Une valeur de 500 est conseillée.

• End Transition to Cheap Water : c'est le nombre d'unités à partir duquel le rendu de l'eau sera définitivement moins beau. Une valeur de 1000 voir 800 est indiquée.

Donc, plus vous vous éloignerez moins beau sera le rendu de l'eau et les calculs effectués par votre carte graphique seront moindres. Cela se remarque fort avec les petites cartes graphique, genre FX5500. Pour les cartes graphiques plus puissantes, la transition belle/moche eau est quasiment imperceptible, puisque ces cartes sont capables de toujours afficher un bon rendu.

L'eau qui monte

De l'eau qui ne bouge pas, c'est nul ! Imaginez, le joueur est dans une salle. Tout à coup, l'eau monte. C'est déjà plus amusant :) .

Pour faire bouger de l'eau, il suffit de convertir le bloc d'eau en func_water_analog et de le paramétrer. Il suffira de l'appeler via un de ses inputs.

Vous devez penser à mettre le func_water_analog dans sa position d'origine. Je veux dire par là que vous devez le déplacer (l'enfoncer dans le sol), et nom le raccourcir. Voici maintenant comment le paramétrer :

• Move Direction : très important, c'est le sens dans lequel bougera votre eau

• Speed : c'est la vitesse de déplacement

• Move Distance : distance, en unités, dont le bloc sera déplacé

• Sound played when the water brush starts moving : son joué dès que le mouvement commence

• Sound played when the water brush stops moving : son joué dès que le mouvement s?arrête

• Wave Height : hauteur des vagues, en unités

Pour déplacer l'entité, vous devez l'appeler avec son input Open. Pour la faire revenir à son emplacement d'origine, il faut utiliser l'input Close.

Hydroglisseur

Comme on parle de l'eau, pourquoi ne pas parler de l'hydroglisseur ?

L'airboat (nom anglais de l'hydroglisseur) se place avec l'entité prop_vehicle_airboat. Cette entité se paramètre de la même façon qu'un prop_. Il y a juste une ou deux options différentes.

• Start locked : mettez Yes si vous voulez que l'airboat ne soit pas utilisable par défaut. Il vous faudra alors l'activer via l'input Unlock (ou Lock si vous voulez le rendre non-utilisable)

• Has Gun : mettez Yes si vous voulez que l'hydroglisseur soit équipé du gauss (le canon à impulsion)

Son d'ambiance

Ajouter des sons dans sa map est quelque chose d'assez important. Ca permet de créer une bonne ambiance, et de rajouter tous ces petits plus qui font que la map est agréable :)

La pose d?un son se fait avec l?entité-point ambient_generic. C?est très simple, et rapide. Voici les paramètres utiles disponibles :

Propriétés

• Name : nom de l?entité

• Sound Name : nom du son joué. Utilisez le browser de sons pour trouver le son idéal. N?oubliez pas d?utiliser le filtre de recherche, c?est très pratique

• Volume : volume du son. Le maximum est 10.

• Dynamic Presets : Préréglages. Vous avez plusieurs options disponibles, pour ajouter de l'effet à votre son

• Start Volume : volume de départ

• Max Audible Distance : distance maximum dans laquelle le son sera entendu par le joueur.

Flags

• Play everywhere : le son sera joué partout. La propriété Max Audible Distance est alors inutile

• Start Silent : le son ne sera pas joué par défaut, il faudra le déclencher

• Is NOT Looped : le son ne sera pas joué en boucle

Vous vous souvenez comment voir dans les vues 2D et 3D la visibilité d'un model ? (le bouton

de la barre d'outils). Eh bien, avec ce bouton, vous pouvez aussi voir la portée du son (la Max Audible Distance).

Les soundscapes

Principe

Réaliser un téléporteur simple est quelque chose de très facile. La zone de téléportation se défini avec l?entité-bloc trigger_teleport. Voici les 2 propriétés utiles disponibles pour cette entité :

• Start Disabled : mettez No si vous ne voulez pas que le téléporteur soit désactivé par défaut

• Remote Destination : le nom de l?entité qui fait office de destination

Pour créer la destination, on utilise l?entité info_teleport_destination. Cette entité n?a pas de propriétés spécifiques, excepté qu?elle peut être parentée.

Attendez ! Nous allons faire un téléporteur DeLuxe? , avec un model animé et tout. Un peu de patience ^^ .

Mise en place

Nous allons utiliser un model de téléporteur. Allez le chercher, c?est models/props_combine/combine_teleportplatform.mdl. Insérez-le au moyen d?un prop_dynamic.

Ne changez pas les propriétés, celles par défaut sont bonnes. Spécifiez simplement un nom, via la propriété Name. Mettez model_tele_combine.

Avec un trigger_multiple, tout simplement. Je vous ai dit que le trigger_teleport comprenait la propriété Start Disabled. Nous allons la mettre sur Yes. Une fois le joueur dans le trigger_multiple, celui-ci va activer le trigger_teleport qui téléportera le joueur :)

Voici l'image. En dessous se trouve le trigger_teleport. Le long bloc vertical est donc le trigger_multiple.

Voilà les paramètres des deux triggers :

Trigger_teleport :

• Name : trigger_tele_combine

• Start Disabled : Yes

• Remote Destination : teleport_destination

Trigger_multiple :

• Delay Before Reset : 10

Nous nous occuperons des outputs après. Il faut faire en sorte que quand un joueur se trouve dans le trgigger_multiple, un autre joueur ne puisse pas rentrer. Bah oui, chacun son tour, on fait un téléporteur professionnel, on ne rentre pas comme des bourrins à 20 en même temps !

Pour ça, je vais créer un func_wall_toggle, habillé de toolsinvisible. Mettez-lui wall_tele_combine comme nom, et cochez son flag Starts Invisible.

Pour ajouter du réalise (un téléporteur réaliste ?), on va ajouter deux ambient_generic. Un pour la fermeture du téléporteur, et un autre pour la "mise à feu" du téléporteur.

Voici les paramètres :

Son 1

• Name : son_tele_open_combine

• Sound Name : ambient/levels/citadel/pod_open1.wav

• Max Audible Distance : 1000

Son 2

• Name : son_tele_start_combine

• Sound Name : ambient/levels/citadel/portal_open1_adpcm.wav

• Max Audible Distance : 1000

Pour les deux, cochez les flags Start Silent et Is NOT Looped.

Les connexions

Voici tous les outpits du trigger_multiple :

Le petit gars arrive. Il entre dans le trigger_multiple. Ce trigger va alors tout commander. Il commence par dire à model_tele_combine de redéfinir son animation (SetAnimation). Son animation va devenir close. Dans la même seconde, son_tele_open_combine est joué, et wall_tele_combine est activé (Toggle).

A ce stade, les autres joueurs ne peuvent pas rentrer dans le téléporteur. Le joueur en est prisonnier. Après 3 secondes, son_tele_start_combine est joué, et deux secondes plus tard, le téléporteur (trigger_tele_combine) est activé. Le joueur est alors téléporté.

Deux secondes plus tard, le trigger_teleport est re-désactivé, et prêt à être réutilisé. Et pour finir, le téléporteur (model_tele_combine) se réouvre (SetAnimation > open), son_tele_open_combine est une nouvelle fois joué (pour accompagner l?ouverture du téléporteur). Et enfin, wall_tele_combine est togglé, et redevient inactif. Toute la machinerie est prête à fonctionner de nouveau :)

Et voilà, votre téléporteur est fini :) . Prochaine étape : réaliser le même téléporteur que celui du docteur Kleiner, mais ça, je vous laisse faire, je suis fatigué :D .

Opérateurs de condition

Logic_case

Un logic_case est en quelque sorte l'équivalent d'un switch en programmation. Si vous ne connaissez pas, un switch est une condition qui teste toute une série de valeurs. Par exemple, un switch en Javascript ressemble à ceci :

switch(valeur) {
        case "1":
                // Si valeur vaut 1 alors...
        break;
        case "thunderseb":
                // Si valeur est égale à thunderseb alors...
        break;
        case "25":
                // Si valeur vaut 25 alors...
        break;
        default:
                / Si valeur n'est égale à aucun des choix précédents...
        break;
}

On teste successivement ce que vaut "valeur", et si on trouve, pas exemple que "valeur" vaut 3, on exécute quelque chose.
Eh bien avec le logic_case (remarquez le mot "case", qu'on trouve aussi dans le switch ^^ ), on va aussi tester une valeur et voir si elle correspond à des entrées définies.

En programmation (comme dans mon exemple), on peut mettre beaucoup de conditions de test (il n'y en a que 3 dans l'exemple). Mais dans le logic_case, on ne peut en mettre que 16, ce qui est déjà beaucoup ^^ .

Première utilisation : le switch classic

Lors du test du logic_case, si une des "case" (par "case", comprenez chaque propriété CaseXX) correspond à la valeur, l'output correspondant est déclenché. Par exemple, si la "case" 2 est vérifiée, l'output déclenché est OnCase2. Si aucune "case" ne correspond, on peut déclencher l'output OnDefault s'il est spécifié. Cela veut donc dire que vous devez spécifier claque output possible !

Remarquez que vous ne devez pas tout remplir, seulement ce dont vous avez besoin

Pour déclencher le logic_case et débuter le test, il faut utiliser son input InValue (valeur entrante en anglais) en fournissant en paramètre la valeur à tester :

La valeur envoyée est donc "thunderseb", ce qui correspond à la deuxième "case" (voir mon image ci-dessus). Cela veut donc dire que c'est l'output OnCase2 qui sera déclenché.

Honnêtement, je n'ai pas d'exemple simple et utile de cette utilisation. Cependant, il existe une deuxième utilisation du logic_case qui se révèle beaucoup plus intéressante !

Deuxième utilisation : le switch aléatoire

Une autre utilisation du logic_case consiste à ne pas renseigner les propriétés CaseXX mais seulement les différents outputs OnCaseXX.

Il n'y a pas de test. Nous n'allons plus utiliser l'input InValue pour déclencher le logic_case, nous allons utiliser l'input PickRandom, qui signifie Choisir aléatoirement . Cela veut donc dire que parmi les différents outputs définis du logic_case, un de ces outputs va être choisi et déclenché.

Et ici, j'ai un exemple concret à vous donner ! (hou que je suis content ^^ ). Imaginez, vous débutez devant 4 portes, et une seule de ces portes est ouverte. Mais la porte qui s'ouvre n'est pas toujours la même. Le but est donc de choisir, au début de la map, quelle porte sera ouverte. Ainsi le joueur aura une petite "surprise" à chaque commencement.

Pour mettre cette idée en oeuvre, il suffit de mettre un logic_auto (souvenez-vous, je vous en ai déjà parlé) qui appelle le logic_case, lequel choisira entre 4 outputs différents (1 pour chaque porte). Voici ce que ça peut donner :

Logic_branch

Le logic_branch est une entité qui vérifie si une valeur est booléenne. Si vous faites de la programmation, le mot "booléen" vous dit certainement quelque chose. Si ce n'est pas le cas, je vais vous l'expliquer brièvement :) .

Une valeur booléenne (boolean en anglais) est une valeur qui peut être soit vraie soit fausse c'est à dire true ou false en anglais ou encore 1 ou 0 en électronique ou en logique.

Les valeurs à utiliser avec un logic_branch sont 0 (pour false) et 1 (pour true).

Donc le logic_branch analyse une valeur pour savoir si elle est vraie ou fausse, et en fonction du résultat du test déclanche ou output :

• OnTrue : si la valeur est vraie (si c'est 1);

• OnFalse : si la valeur est fausse (si c'est 0).

L'entité est simple à mettre en oeuvre mais, je le concède, un peu tordue à comprendre ^^ . Je vais vous expliquer son fonctionnement par le biais d'un exemple :) .

Vous souvenez-vous du func_brush ? Pour rappel, c'est un bloc que l'ont peut afficher ou masquer. Il est censé remplacer son homologue func_wall_toggle qui permet là même chose. Mais le func_wall_toggle a quelque chose en plus, il peut être masqué s'il était affiché, et affiché s'il était masqué (d'où son nom "toggle").

En fait, grâce au logic_branch, je vais reproduire le comportement "toggle" du func_wall_toggle avec un func_brush. !

Ce qu'il faut, c'est changer la valeur du logic_branch et l'état du func_brush à chaque fois que le test est effectué. Pour cela, posons que quand le func_brush est affiché la valeur du logic_branch est 1, et s'il est masqué, la valeur est 0.

Commençons par définir les deux outputs du logic_branch qui changent l'état du func_brush. Comme le mur est affiché par défaut, mettez la valeur 1 dans la propriété Value du logic_branch.

Grâce à ça, dès que le test est effectué, si il vaut true ça veut dire que le mu est affiché, donc on souhaite le masquer. C'est le contraire s'il vaut false. Évidemment ça ne marche qu'une fois, puisque nous n'avons pas changé la valeur. C'est pour cela que nous allons ajouter deux autres outputs, qui appellent le logic_branch (que j'ai nommé branch) (l'entité s'auto-appelle ^^ ) :

Et voilà, votre func_brush est devenu un func_wall_toggle ^^ . Bien sûr si vous mettez un bouton pour faire apparaître/disparaître le mur, vous devez appeler le logic_branch, et non le func_brush en utilisant l'input Test, comme ceci :

Opérateur de comparaison

Les deux entités dont je vais vous parler maintenant permet de comparer deux valeurs numériques. Je ne vais pas trop m'attarder sur cette entité, car la probabilité que vous l'utilisiez est vraiment très faible (ou plutôt, c'est une excuse parce que je n'ai pas trouvé d'exemple de leur utilisation ^^ ).

Le logic_compare permet de comparer une valeur à une autre et de déclencher 4 outputs :

• OnEqualTo : si les deux valeurs sont égales

• OnGreaterThan : si la valeur à comparer est plus grande que la valeur de référence

• OnLessThan : si la valeur à comparer est plus petite que la valeur de référence

• OnNotEqual : si les deux valeurs sont différentes (un mix de OnGreaterThan et de OnLessThan quoi ^^ ).

La valeur de référence (ou la valeur de comparaison) se défini dans la propriété Compare Value. La propriété Initial Value est la valeur à comparer, c'est à dire celle qui sera opposée à la Compare Value (valeur de comparaison).

Bien évidemment il y a des inputs pour modifier ces deux valeurs (attention à ne pas les mélanger ^^ ) :

• SetValue : pour re-définir la valeur à comparer (la propriété Initial Value donc)

• SetCompareValue : pour re-définir la valeur de comparaison (la propriété Compare Value)

Il y a aussi deux manière de déclencher la comparaison :

• Compare : le nom parle de lui-même ^^

• SetValueCompare : ça a le même effet que l'input SetValue, mais après avoir re-défini la valeur, le processus de comparaison est enclenché

Opérateur temporel

Le logic_timer est une entité assez intéressante. Elle permet de déclencher des outputs à intervalles de temps réguliers ou irréguliers (aléatoire).

Pour vous expliquer son utilisation, je vais l'utiliser pour jouer un son d'ambiance bien sympa comme... le cris d'un Fast Zombie dans la nuit noir et brumeuse de Ravenholm :D .

Le principe est vraiment très simple. Un logic_timer va appeler un ambient_generic après un laps de temps aléatoire.

Commencez par placer votre ambient_generic et utilisez le son NPC_FastZombie.AlertFar. Pensez aussi à cocher le flag Play everywhere. Pour mon exemple je vais nommer cette entité "crifastzombie" (je sais, c'est original ^^ ).

Maintenant, au tour du logic_timer. Comme vous devriez déjà l'avoir remarqué, il n'y a pas énormément de propriétés. Comme nous allons jouer le son à intervalles irréguliers, mettez Yes pour la propriété Use Random Time. Il s'agit ensuite de définir les propriété Minimum et Maximum Random Time. Une valeur comprise, en secondes, entre ces deux valeurs sera utilisée comme temps aléatoire.

Maintenant ajoutons un petit output pour jouer le son :

J'utilise l'output OnTimer qui est exécuté quand le temps (aléatoire ou non) est atteint. Il existe aussi deux autres outputs, OnTimerHight et OnTimerLow qui sont déclenchés respectivement quand le temps le plus haut est atteint et quand le temps le plus bas est atteint. Ça n'a bien sûr pas d'intérêt ici.

Voilà, c'est prêt :) . Une longue complainte de zombie viendra égayer votre map ^^ .

Pour terminer, quelques inputs qui peuvent être utiles :

• RefireTime : pour re-définir la propriété Refire interval

• FireTimer : déclenche immédiatement le timer. Ça appelle en fait son output OnTimer, sans tenir compte de l'intervalle de temps (à utiliser si vous êtes pressé ^^ )

• LowerRandomBound : pour re-définir le temps minimum

• UpperRandomBound : pour re-définir le temps maximum

Préparation de la map

Il faut dans un premier temps nous occuper de la partie mapping :) .

Créez une ruelle étroite, et ensuite, placez les models. Je vous ai listé ici les models nécessaires :

Essayez de vous arranger pour obtenir quelque chose comme ceci (remarquez que j'ai mis quelques décals, histoire de décorer un brin) :

Préparation des entités

On va maintenant mettre en place les entités, mais sans s'occuper des outputs, juste le placement et le paramétrage.

Les func_rot_button

Pour faire tourner le bouton rouge et la vanne de gaz, on va utiliser des func_rot_button. Vous savez comment ça marche, donc ça ira vite ^^ .

Créez, avec la texture invisible, vos deux boutons rotatifs. Voici les paramètres que je vous suggère :

Bouton rouge

• Name : firetrap_boutonrouge

• Speed : 200

• Sounds : Squeaky

• Delay Before Reset : 1

• Distance : 90

Cochez les flags Not Solid, Y Axis (ou un autre, ça dépend d'orientation de votre bouton) et Use Activates.

Vanne de gaz

• Name : firetrap_vannedegaz

• Speed : 200

• Sounds : Squeaky

• Delay Before Reset : 3

• Distance : 360 (un tour complet, pour que ce soit bien ouvert ^^ )

Cochez les flags Not Solid, Toggle (pour pouvoir fermer et ouvrir) et Use Activates.

Les étincelles

Souvenez-vous des étincelles, l'entité env_spark. Il va falloir placer un env_spark à l'extrémité de chaque bec Bunsen, avec les mêmes paramètres, à savoir :

• Name : firetrap_spark

• Magniture : Medium

• Spark Trail Length : Long

Les env_steam

env_steam est une nouvelle entité. Elle permet de créer un jet de vapeur. Nous allons l'utiliser pour représenter les jets de gaz qui sortent des bec Bunsen :) . On mettra donc une de ces entités à chaque sortie de bec Bunsen.

L'env_steam est représenté sous la forme d'un cône. Le sommet symbolise le point de départ du gaz, et la base indique dans quel sens le jet est projeté, ce qui est plutôt pratique pour bien positionner l'entité. Comme c'est une nouvelle entité, je vais vous lister ses propriétés, les expliquer, et donner les valeurs adéquates dans le cas de notre jet de gaz incolore :) .

• Name : firetrap_vapeur

• Initial State : état initial de l'entité. Mettez Off

• Particule Type : : type de particule qui est projeté :

• • Normal : un gros jet gras ^^

  • Heat Wave : un effet vague de chaleur, comme sur les autoroutes quand il fait chaud.Choisissez cette option, ça donnera un bel effet flou

• Spread Speed : vitesse de dissociation des particules. Il faut comprendre que c'est la vitesse à laquelle les particules s'éloignent les unes des autres. En mettant une valeur de 15, le jet reste relativement compact

• Speed : vitesse de sortie du jet de gaz. Mettez 200

• Particule start size : taille des particules au début du jet. Mettez 10

• Particule end size : taille des particules à la fin du jet. Mettez 20

• Emisson rate : fréquence d'émission des particules. Une valeur de 25 est acceptable

• Color : couleur du jet. Prenez une teinte orangée ( 239 194 61 ), mais si ça n'a pas beaucoup d'importance, puisqu'on va rendre le jet transparent ^^

• Length of steam jet : longueur du jet. Une longueur de 80 convient largement

• Translucency : transparence. Laissez 255

• How fast does the particles spin : (pour Episode One) vitesse de rotation des particules. Laissez 8

Les départs de feu

Il existe une entité pour créer une flamme, nous la verrons juste après, et il existe aussi une entité pour créer un effet d'embrasement. Cette entité se nomme env_firesource. Placez également une de ces entités à la sortie de chaque bec Bunsen (près des env_spark, ce qui est logique).

• Name : firetrap_firesource

• Radius : 60

Le brasier

Nous voici enfin aux flammes ^^ . L'entité utilisée pour en créer une est env_fire (remarquez que le nom des entités correspondent souvent à leur fonction ^^ ).

• Name : firetrap_fires

• Start Disabled : Yes

• Duration : temps que brûle la flamme. Mettez ce que vous voulez, car on cochera le flag Infinite Duration ^^

• Sire : taille de la flamme. Voyez ma remarque plus bas...

• Attack : vitesse à laquelle la flamme grandit pour aboutir à sa taille maximale (Size). Ca doit être rapide, c'est du gaz. Mettez 0.05

• Type : type de flamme. Laissez bien Naturel, on n'a pas besoin d'un effet plasma

• Ignition point : position du point d'ignition. Mettez 1, la flamme est au sol ^^ .

• Damage Scale : mettez 10 pour multiplier par 10 les dommages causés par la flamme

Cochez aussi le flag Smokeless, pour ne pas créer trop de fumée. On fait un simple brasier, pas un incinérateur ^^ .

Pensez à mettre un Size décroissant sur les env_fire. Près des becs Bunsen, mettez une Size de 110, et descendez jusqu'à 80 pour les flammes les plus éloignées de ce bec. Ça donne un effet de réel, car il y a plus de gaz près des becs, donc de plus grandes flammes ;) .

Les ambient_generic

On va ajouter plusieurs sons, au moyen d'ambient_generic. Il n'y a pas de réglages particulier, hormis le nom de l'entité, le son à jouer et quelques flags. Je vous ai fait un tableau pour présenter ça proprement :

Pour finir...

On va aussi ajouter un petite light qu'on allumera en même temps que les flammes, pour appuyer l'éclairage de ces flammes :)

• Name : firetrap_light

• Brightness : 254 174 10 500

Et cochez le flag Initialy Dark.

Voici une image de ce que j'obtiens. Vous devriez avoir sensiblement la même chose :

Ce que j'obtiens. Remarquez que les env_steam, les env_firesource et les env_spark sont au même endroit sur chaque bec

Mise en place des outputs

Attaquons-ous maintenant au codage des outputs ; ce n'est pas difficile, mais ça demande de la logique :) .

Histoire de nous simplifier la tâche, nous allons créer deux logic_relay : un pour démarrer l'embrasement, et un autre pour y mettre fin. Nommez respectivement ces deux entités firetrap_relay_start et firetrap_relay_end. Laissez la propriété Start Disabled sur Yes.

On y reviendra plus tard. On va commencer par les outputs de la vanne de gaz.

La vanne de gaz

J'utilise l'output OnIn, qui a pour effet d'être déclenché dès qu'on pose les mains sur la vanne (dès qu'on presse E ^^ ). Comme ça, dès qu'on commence à tourner, ça se déclenche. Donc, dès qu'on pose les mains, on actionne/arrête les jets de vapeur (firetrap_vapeur), ainsi que leur bruit (firetrap_vapeur_son). J'active aussi le logic_relay de départ de feu (firetrap_relay_start). Mais attention, il est activé, pas déclenché !

On le déclenchera quand on tournera le bouton rouge. Ce stratagème nous empêche de déclencher le logic_relay sans avoir ouvert le gaz avant (puisque dans ce cas, le logic_relay n'aurait pas été activé).

Maintenant, on va ajouter les outputs quand on lâche la vanne (on vient de de la refermer) :

Donc là, rien de bien compliqué. On annule tout ce qui a été fait avec OnIn. On fait appel au relais firetrap_relay_end, qu'on déclenche (il sera activé par le relais de démarrage du feu).

Le bouton rouge

Ici, il n'y a que 3 outputs très simples :

Très simple. On joue le son du bouton, on actionne les étincelles une fois (SparkOnce) et on déclenche le logic_relay qui va à son tour déclencher le brasier :) .

Le relais de départ

On va enfin s'occuper du firetrap_relay_start. On va activer les env_firesources, les env_fire. On active aussi firetrap_relay_end, et on désactivé le firetrap_relay_start (il s'auto-désactive ^^ ). On en profite aussi pour allumer la light, 0.5 secondes après :) .

Le relais de fin