Objectifs constructibles
Un article de Wiki-Mapping.
Voici la traduction d'une partie du manuel Level Designers Reference.
Sommaire |
[modifier] Généralités
Le but du système de construction était d'introduire des éléments de jeu de type RTS. Il a été crée afin d'être aussi flexible que possible, en supportant plusieurs étapes de construction, celles-ci pouvant être faites de models ou de brushes.
La capacité de construire est particulière à la classe d'ingénieur. L'ingénieur est capable de construire des objets tels que des ponts, des tours de surveillance et des positions défensives à des endroits prédéfinis. Les endroits où ces constructions sont possibles devraient être repérés par le model habituel de caisses, afin que tout le monde puisse les reconnaître.
Chaque construction est caractérisée par une classe, qui détermine la quantité d'énergie nécessaire à chaque étape de la construction. La vitesse à laquelle une construction peut se faire augmente avec le nombre d'ingénieurs.
Lorsqu'une construction est en cours, une représentation de l'objet transparente apparaît. Celle-ci devient solide une fois l'objet construit. Si un joueur est dans la zone de construction, il lui est indiqué qu'il faut quitter les lieux avant que celle-ci ne s'achève. Dans le cas contraire, il sera tué instantanément avec lorsque la construction prendra fin.
Une construction qui n'aura pas été achevée ou touchée par un ingénieur disparaîtra au bout de 30 secondes. Les constructions en plusieurs étapes reviendront à la dernière étape achevée.
Une fois la construction achevée, l'équipe ennemie peut l'endommager. La classe de cette construction détermine la façon dont il faut agir pour la détruire. L'équipe qui a réalisé la construction ne peut la détruire.
[modifier] Les classes de construction
La majorité des propriétés des constructions sont déterminées par le script, seuls quelques éléments "de base" sont présents dans la map. Cela peut poser problème au novice n'ayant que peu de connaissances en scripting, mais les cartes existantes offrent une quantité d'exemples sur lesquels il est possible de se baser.
Le système de constructions contient 6 variables permettant de modifier le fonctionnement des constructions. Ces variables sont réparties en 3 sous-ensembles, ce qui permet une certaine constance d'une map à l'autre. Les différences principales entre chaque construction sont la quantité de stamina nécessaire à l'ingénieur et le type d'explosifs à utiliser pour la destruction.
On a attribué aux plus importantes constructions les quantité de stamina les plus importantes, afin d'encourager les ingénieurs à travailler ensemble. La valeur définie ici devrait normalement refléter l'importance par rapport aux autres objectifs de la map. La seule exception concerne les véhicules qui ont une barre de vie importante car ils peuvent être détruits par tous les types d'explosifs.
Tous les objets constructibles doivent avoir une classe déterminée lors du chargement de la map. Les autres paramètres peuvent êtres changés une fois que la classe est choisie. Voici les valeurs possibles :
| Classe | stamina | XP (contruc) | XP Dest. | Vie | Armes | Durée (msec) | Icone |
|---|---|---|---|---|---|---|---|
| 1 | 0.5 | 5 | 5 | 350 | * | 2500 | Grenade |
| 2 | 1 | 7.5 | 7.5 | N/A | 2* | 5000 | Satchel Charge |
| 3 | 1.5 | 10 | 10 | N/A | 3* | 2500 | Dynamite |
Armes :
- 1* = Tous les explosifs (Dynamite, Satchel, Grenades, Panzerfaust, Mortier, Air Strike, etc.)
- 2* = Dynamite, Satchel
- 3* = Dynamite
Il est à noter que la clef constructible_health n'est à appliquer qu'aux constructions de classe 1, par ce que les autres classes ne sont sensibles qu'aux dynamites ou aux satchels.
Voici les commandes correspondant aux colonnes du tableau ci-dessus :
- constructible_chargebarreq
- constructible_constructxpbonus
- constructible_destructxpbonus
- constructible_health
- constructible_weaponclass
- constructible_duration
Il est à noter que la clef constructible_health n'est à appliquer qu'aux constructions de classe 1, par ce que les autres classes ne sont sensibles qu'aux dynamites ou aux satchels.
Par exemple, si un tank reçoit beaucoup de dommages et peut être endommagé par tous les explosifs, les réglages suivants sont à utiliser :
example_tank
{
spawn {
constructible_class 1
constructible_health 1200
}
}
[modifier] Nouvelles entités
Tous les objectifs constructibles contiennent un noyau d'entités qui sont utilisées à chaque fois, et ce quel que soit la configuration. Chacune de ces constructions doit contenir au moins une entité func_constructible et une entité trigger_objective_info reliées.
Si l'entité trigger_objective_info n'est pas reliée à une autre entité, elle existera toujours dans la map, produira l'affichage du message "you are near..." et sera réactive aux explosifs.
L'usage de la commande setstate permet d'activer ou de désactiver l'entité trigger_objective_info pour différents modes de jeu. Une fois que l'entité a été désactivée, toutes les icônes en relation visibles sur la command map disparaissent.
Note : Il est bon de conserver l'entité trigger_objective_info à l'extérieur de l'entité func_constructible afin que les ingénieurs qui construisent ne soient pas tués lorsqu'ils achèvent la construction.
Les objectifs n'étant pas la propriétés d'une équipe en particulier contiennent deux func_constructible car les deux équipes ne peuvent posséder la même construction. L'entité trigger_objective_info est alors reliée aux deux func_constructible a la fois.
[modifier] func_constructible
L'entité func_constructible est l'entité principale. Elle détermine quelle équipe peut construire ou détruire une construction donnée. L'entité func_constructible est faite de brushs, et doit contenir un brush avec la texture origin - sinon, il peut y avoir des problèmes lorsqu'il s'agit de poser une dynamite.
Lorsqu'une équipe doit déposer des explosifs à proximité d'une construction, c'est l'entité func_constructible qui détermine où ceux-ci doivent être posés. Note : Il faut prendre garde à ne pas mettre deux func_constructible trop proches l'un de l'autre à cause de la grande zone d'influence de certains explosifs.
L'entité func_constructible a les clefs suivantes :
- targetname: Le nom utilisé pour faire référence à cette entité.
- scriptname: Le nom de la routine associée dans le script.
- track: Identifie la construction.
- wait, score, health: Ne sont plus utilisées (remplacées par des lignes de script).
- constages: Liste des entités func_brushmodel représentant les étapes de construction.
- desstages: Liste des entités func_brushmodel représentant les étapes de destruction.
La clef track fonctionne comme l'identifiant d'un groupe. Tours les entités avec la même valeur seront construites en même temps. C'est cette valeur qui est utilisée afin de prévenir les joueurs se situant dans la zone de construction. Si l'entité est mis en transparence via le script, aucun message ne s'affichera chez les joueurs.
L'entité func_constructible à les options suivantes :
- start_built: Construit par défaut.
- invulnerable: Ne peut être détruit par des explosifs.
- axis_constructible: Peut être construit par les Axis.
- allied_constructible: Peut être construit par les Alliés.
Si l'entité func_constructible n'est pas assignée à une équipe lorsque la map est chargée, alors le chargement va échouer. Si les deux équipes sont sélectionnées, alors ce sera l'équipe des Axis qui sera choisie.
Note : Il faut savoir que certains explosifs ont un rayons d'effet très grand, et par conséquent peuvent être placés à une certaine distance du func_constructible tout en détruisant l'objectif.
[modifier] trigger_objective_info (TOI)
Cette entité est utilisée afin de représenter d'autres enttiés (func_constructible, func_explosive, misc_commandmap_marker ) sur la command map. L'état de la construction détermine quelles icônes sont visibles sur la command map.
L'entité trigger_objective_info est faite de brushes et doit contenir un brush avec la texture origin, sinon, elle apparaîtra au mauvais endroit sur la command map. Lorsqu'un joueur se situe dans l'entité trigger_objective_info, l'objectif peut être construit, ce qui se traduit par l'apparition de l'icône avec les pinces et d'un message à l'écran.
Les maps sont limitées à un maximum de 18 entités trigger_objective_info. Cela comprend en général les command posts, les stands de soins/munitions, les endroits avec des indications à l'écran, et tous les objectifs constructibles. Certains objectifs constructibles peuvent n'exister que dans certains modes de jeu.
Note : La map Fueldump est à la limite pour ce nombre d'entités.
L'entité trigger_objective_info possède les clés suivantes :
- targetname: Le nom utilisé dans le script pour faire référence à cette entité.
- scriptname: La routine associée dans le script.
- shortname: Le nom affiché sur la command map.
- objflags: Sert pour les icônes qui ont un effet de battement sur la command map.
- track: Text servant à afficher dans you are near....
- customimage: Remplace l'icône par défaut pour les deux équipes.
- customalliedimage: Remplace l'icône par défaut uniquement pour les alliés.
- customaxisimage: Remplace l'icône par défaut uniquement pour les axis.
- infoAxis/infoAllied: N'est plus utilisé.
- score: Remplacé par des lignes de script.
L'entité trigger_objective_info peut avoir les options suivantes :
- axis_objective: Ne fonctionne qu'avec les entités 'func_explosive'.
- allied_objective: Ne fonctionne qu'avec les entités 'func_explosive'.
- tank: Affiche l'icône "tank" sur la command map.
- is_objective: Affiche une icône par défaut sur la command map.
- is_healthammocabinet: Affiche l'image des râteliers de soins/munitions sur la command map.
- is_commandpost: Affiche l'icône d'un command post sur la command map.
[modifier] Constructions pour une seule équipe
Le drapeau et les caisses marquent l'endroit où les ingénieurs peuvent construire l'objectif. Chaque équipe possède son propre skin pour le drapeau et les caisses afin que celles-ci soient facilement reconnaissables par tous les joueurs.
- Caisses de construction & skins : ( misc_gamemodel )
models/mapobjects/cmarker/cmarker_crates.md3
models/mapobjects/cmarker/axis_crates.skin
models/mapobjects/cmarker/allied_crates.skin- Drapeau & skins : ( misc_gamemodel )
models/mapobjects/cmarker/cmarker_flag.md3
models/mapobjects/cmarker/axis_cflag.skin
models/mapobjects/cmarker/allied_cflag.skinValeurs supplémentaires pour le drapeau :modelscale: 0.4frame: 0.4 (Vitesse d'animation)
spawnflags: 2 (Animation en cours dès le début)
Le drapeau et les caisses sont des entités misc_gamemodel avec des clés targetname et scriptname afin que le script puisse y faire référence.
Il faut créer un ensemble de brushs avec la formes des caisses et l'une des textures clip. Ensuite, il faut créer un brush avec la texture origin, sélectionner tous les brushs avec la texture clip et en faire une entité func_static. Puis sélectionner l'entité func_static et lui donner des valeurs de targetname et de scriptname nécessaires à son appel depuis le script.
L'objet à construire est fait de brushs et est situé à une distance raisonnables des caisses. Il faut créer un brush avec la texture origin, sélectionner l'objet à construire et en faire une entité func_constructible.
Note : Si vous voulez un objet constructible à partir d'un model, il faut utiliser des brushes avec une texture clip à la place. Il est important que l'entité func_constructible contienne des brushs, car les explosifs doivent toucher quelque chose de cette nature.
Sélectionner l'entité func_constructible et donner des valeurs de targetname et de scriptname afin que le script puisse y faire référence et que l'entité trigger_objective_info ai la construction pour cible. Définir alors les spawnflags afin d'attribuer la construction à une équipe. (Seule une équipe doit être sélectionnée.)
Enfin, créer un brush trigger_objective_info autour des caisses de construction et cibler l'entité func_constructible. Il fait laisser assez de place afin que les ingénieurs puissent bouger autour des caisses tout en construisant. Définir alors toutes les clefs et options nécessaires pour l'entité trigger_objective_info.
[modifier] Scripting
Tous les objets constructibles nécessitent un script pour fonctionner. Cela peut aller du simple copier/coller de script existant à la création d'un nouveau script en entier.
[modifier] Les bases du scripting
Le fichier contenant le script est situé dans le dossier /maps/ et possède l'extension .script. Le nom du fichier doit être le même que celui du fichier de la map. (Ex : 'oasis.bsp', 'oasis.script')
Le fichier contenant le script est constitué de routine déterminant les propriétés et le comportement des entités dans le jeu. Chaque entité à la possibilité de se voir attribuer une routine. Afin qu'une entité puisse avoir une routine à elle dans le fichier .script, elle doit avoir des clefs targetname et scriptname.
Par exemple: targetname : alliedmgnest et scriptname : alliedmgnest.
Il est recommandé que les valeurs de targetname et scriptname soient les mêmes afin que le script soit plus facile à débugger. (Techniquement, toutes les entités ne nécessitent pas une valeur de targetname et de scriptname, mais il est recommandé d'attribuer ces clefs)
Chaque routine est composée de fonctions qui sont déclenchées par les évènements du jeu. Par exemple : la fonction spawn est appelée lorsque l'entité spawn au chargement de la map.
Certaines fonctions existent pour toutes les entités, quelque soit leur type. Ces fonctions sont : spawn, trigger, pain et death. Quelques entités ont d'autres fonctions qui sont spécifiques à leur rôle dans la map.
Le script peut exécuter plusieurs routines à la fois, mais chaque routine ne peut exécuter qu'une seule fonction à la fois. Par exemple, si une fonction utilise une commande wait, cela va stopper toutes les autres fonctions de cette même routine. A cause de cette limitation, plusieurs entités peuvent être nécessaires si l'on veut exécuter plusieurs tâches en même temps.
Chaque routine peut utiliser jusqu'à 8 variables locales. Ces variables locales ne peuvent être appelées depuis l'extérieur de la routine. Le système de script supporte jusqu'à 10 variables globales qui peuvent être utilisées dans toute routine / fonction su script.
Les variables peuvent être utilisées pour stocker des valeurs permettant de déterminer l'état de certains objets ou l'avancement des objectifs. Par exemple, dans la map Radar, une variable est utilisée pour compter le nombre de pièces volées.
[modifier] Les scripts relatifs aux constructions
L'entité func_constructible a 5 fonctions de base définies ci-dessous :
- spawn : cette fonction est lancée dès le chargement de la map. Toutes les fonctions spawn devraient commencer par l'instruction wait avant de commander d'autres actions, parce que toutes les entités ne sont pas forcément déja chargées à ce moment.\\
Tous les objets constructibles doivent définir leur classe dans cette fonction. Cela détermine la quantité de stamina nécessaire à la construction. (Cf. Tableau ci-dessus)\\ Les objets servant à la construction (caisses...) devraient être visibles initialement (setstate default), et la construction en elle même devrait être invisible.
- buildstart: Cette fonction est appelée lorsque la construction début. Les différents objets de la construction deviennent alors visibles (texture semi-transparente). Cela montre aux joueurs que la construction à lieu.
- built: Cette fonction est appelée lorsque la construction est terminée. Tous les objets servant à la construction deviennent invisibles et la construction en elle même devient visible.
- decayed: Si personne n'a aidé à la construction pendant 30 secondes (valeur par défaut), alors cette fonction est appelée. Si cette fonction n'est pas définie, alors la construction va rester sous sa forme semi-transparente.
- death: Cette fonction est appelée lorsque la construction est détruite. Tous les objets servant à la construction deviennent visibles alors que la construction en elle même devient invisible.
Si la construction implique une MG, alors elle doit être réparée par le script à ce moment. Si la MG est endommagée durant la destruction de l'objet, alors elle sera construite sous sa forme endommagée.
La commande sur laquelle repose le système de constrution est setstate. Cette commande permet de changer une entité d'un état à l'autre : default / invisible / underconstruction. Combiné avec les fonctions ci-dessus, le système de construction n'est pas difficile à mettre en place.
[modifier] Construction pour les deux équipes :
Une construction neutre n'est pas différente d'une simple construction à l'exception près qu'il y en a une pour chaque équipe, toutes deux liées à la même entité trigger_objective_info. L'entité func_constructible ne peut être associée qu'à une seule équipe, par conséquent, une construction neutre nécessite deux entités func_contructible (deux constructions).
Il est recommandé que les constructions soient différentes pour les deux équipes afin que les joueurs puissent voir à distance qui a construit l'objet. L'entité trigger_objective_info détermine quelle entité func_constructible est construite et quelle routine du script est active.
[modifier] Constructions en plusieurs étapes :
Le système de constructions peut contenir jusqu'à 3 étapes pour une même construction (stage1, stage2, final) et deux étapes différentes pour la destruction. En fonction de ce qui arrive à l'entité func_constructible l'un ou l'autres des états est actifs (Cf. diagramme ci-dessous) :
http://gnoun.info/mapping/images/construction_3.jpg
La meilleure façon de réaliser une construction à plusieurs étapes est de créer l'objet final en premier et de faire comme si c'était une construction à une étape. Il suffit ensuite d'ajouter les étapes intermédiaires.
Les constructions à plusieurs étapes utilisent deux autres clefs de l'entité func_constructible.
- constages: Liste d'entités func_brushmodel pour la construction.
- desstages: Liste d'entités func_brushmodel pour la destruction.
Chaque étape de construction/destruction supplémentaire nécessite une nouvelle entité func_brushmodel avec une clé targetname. C'est la valeur de la clé targetname qui apparaît dans les listes constages & desstages.
Par exemple, si les étapes 1 et 2 correspondent à des clés targetname "constage1" et "constage2", alors, la clé constages de l'entité func_constructible aura la valeur "constage1;constage2;"
Note : Dans les listes constages et desstages, les étapes doivent être séparées par des points virgules, et ne pas avoir d'espaces. Ces clés ne sont pas utiles s'il n'y a qu'une unique étape de construction.
Où que soit l'entité func_constructible dans la map, toutes les étapes de construction/deconstruction apparaîtront. Cela ne pose aucun problème de créer des étapes autre part dans la map ou au même endroit, toutes les étapes apparaîtront au même endroit.
La dernière étape d'une construction en plusieurs étapes est toujours identifiés par le mot clé final dans le script. Si la construction ne prend que deux étapes, alors on n'utilisera que stage1 et final.
Exemple de construction en plusieurs étapes :
//============================================
// Test de construction en plusieurs étapes
//============================================
constructfinal
{
spawn
{
wait 200
constructible_class 1
setstate constage1 invisible
setstate constage2 invisible
setstate constructfinal invisible
setstate desstage1 invisible
setstate desstage2 invisible
setstate construct_stage1 default
setstate construct_stage2 default
setstate construct_stage3 default
}
//============================================
// Stage 1
//============================================
buildstart stage1
{
wm_announce "Stage 1 started ..."
}
built stage1
{
setstate construct_stage1 invisible
wm_announce "Stage 1 BUILT!"
}
decayed stage1
{
setstate construct_stage1 default
wm_announce "Stage 1 DECAYED!"
}
death
{
setstate construct_stage1 default
wm_announce "Stage 1 DEATH!"
}
Note : La routine constructfinal correspond à l'entité func_constructible. Les valeurs constage1, constage2, desstage1 et desstage2 sont les clés targetname des entités func_brushmodel.
Les valeurs construct_stage1, construct_stage2 et construct_stage3 font référence aux objets de construction. (Les caisses et les brushs avec la texture clip.)
//============================================
// Stage 2
//============================================
buildstart stage2
{
wm_announce "Stage 2 started ..."
}
built stage2
{
setstate construct_stage2 invisible
wm_announce "Stage 2 BUILT!"
}
decayed stage2
{
setstate construct_stage2 default
wm_announce "Stage 2 DECAYED!"
}
destroyed stage2
{
setstate construct_stage2 default
wm_announce "Stage 2 DESTROYED!"
}
//============================================
// Stage 3
//============================================
buildstart final
{
wm_announce "Stage 3 started ..."
}
built final
{
setstate construct_stage3 invisible
wm_announce "Stage 3 BUILT!"
}
decayed final
{
setstate construct_stage3 default
wm_announce "Stage 3 DECAYED!"
}
destroyed final
{
setstate construct_stage3 default
wm_announce "Stage 3 DESTROYED!"
}
}
Note : Chaque étape a quatre fonctions qui se lancent en fonction de l'état de l'entité func_constructible. Certaines de ces fonctions ne servent à rien dans le cas présenté ici, mais sont inclues afin d'être modifiées comme vous le souhaitez.
