Une map pour le moteur Source avec Hammer 4

Dans cette troisième partie apparentée aux déclencheurs, je vais continuer à vous parler des entités de type logic_, que j'appelle des opérateurs, car ils servent à réaliser des opérations comme comparer deux valeurs, appeler une entité aléatoirement...

Je vous ai déjà parlé précédemment des logic_relay (relais d'appels) et de logic_auto (déclenchement automatique au démarrage de la map). Je vais donc vous en expliquer d'autres, globalement moins utiles, mais néanmoins indispensables .

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 .

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