Backgrounds/fr

From M.U.G.E.N Wiki

Jump to: navigation, search

This page is in progress of being translated to fr. You can help translating it or go to another language version that follows:



Synthèse

Un décor dans M.U.G.E.N consiste en un ou plusieurs éléments de décors, et zéro ou plus contrôleurs de décor. Tout ceci est combiné aux réglages du décor pour produire l'apparence et la fonctionnalité d'un stage à utiliser dans M.U.G.E.N.

Les réglages du stage contrôlent les paramètres globaux tels que la taille du décord, le mouvement de la caméra, la position de départ des personnages et de la camera par rapport au stage, la couleur des ombres, la réflexion du sol, etc. La plupart des jeux de combat utilisent des valeurs adaptées de ces paramètres de décor sur leurs stages, notamment par rapport à la taille et au mouvement de la camera.

Un élément de décor est un unité de graphique individuelle qui est affichée à l'écran. Toutes les parties visibles d'un décor sont formée d'éléments de décor. Chaque élément de décor a ses réglages propres pour les données de sprites, la transparence, l'emplacement, le "tiling", la vitesse de défilement par rapport à la caméra et l'animation (si applicable). Les éléments en parallaxe ajoutent un effet de trame lorsque la caméra se déplace. Les éléments de décor peuvent être de n'importe quelle taille, même si en pratique, les décors sont souvent des pièces assemblées de plusieurs éléments de taille moyenne.

Un contrôleur de décor (ou "BG Controller" ou "BGCtrl") va réaliser des manipulations additionnelle sur un élément de décor, comme changer sa position ou sa vitesse, le rendre visible ou invisible, etc. L'utilisation de BGCtrl permet de faire aller et venir un personnage dans le décor, faire voler des débris à travers l'écran, ou créer des changements dans le décor à des instants déterminés (comme entrer dans une grotte quand les personnages se battent sur un bateau). En général, les BGCtrl peuvent vous permettre de créer des effets plus avancés pour un stage, ou optimiser certaines animations pour réduire la consommation de mémoire, même si beaucoup de stages fonctionneront très bien sans aucun contrôleur.

Quand vous créez un stage, vous devez vous assurer que la partie visible à l'écran est toujours complètement "couverte" par des éléments de décor. Laisser des trous dans le décor créera des effets "miroirs" sur ces endroits. Activer le paramètre debugbg remplira tous les trous d'une teinte brillante de magenta, ce qui devrait vous aider à les trouver et à les corriger.

Au-delà de l'utilisation évidente dans les stages, les objets de décor sont utilisés dans M.U.G.E.N pour les décors de tous les écrans système tels que l'écran titre et l'écran de sélection des personnage, ou encore, ou encore pour être utiliser dans les storyboards. Ces types de décor sont appelés "décors système" et "décors de storyboard" respectivement. Les objets de décor utilisés dans les stages sont appelés "décors de stage". En dehors de l'utilisation qui en est fait, il n'y a pratiquement pas de différence entre les différents types de décors. Ce document couvre le paramétrage des stages ainsi que le format des objets de décor.

Description des paramètres de stage

Les réglages du stage définissent la relation du décor avec le stage. Les paramètres de stage doivent être dans le même fichier que le décor. Il y a plusieurs groupes qui composent les réglages. Ce sont :

(tous les paramètres sont requis à moins d'être spécifiquement marqués comme "optionnel")

Groupe Info

name = nom_du_stage
Ce paramètre définit le nom à afficher dans la liste de sélection des stages.

Groupe Camera

startx = pos_x
Règle la coordonnée x de la position de départ de la caméra. Devrait être réglé à 0.
starty = pos_y
Règle la coordonnée y de la position de départ de la caméra. Devrait être réglé à 0.
boundleft = min_x
C'est la valeur minimum de la coordonnée x que la caméra peut atteindre. Elle doit être négative. Ajustez cette valeur pour limiter jusqu'où peut aller la caméra vers la gauche.
boundright = max_x
C'est la valeur maximum de la coordonnée x que la caméra peut atteindre. Elle doit être positive. Ajustez cette valeur pour limiter jusqu'où peut aller la caméra vers la droite.
boundhigh = min_y
C'est la valeur minimum de la coordonnée y que la caméra peut atteindre. Elle doit être négative. Ajustez cette valeur pour limiter jusqu'où peut aller la caméra vers le haut.
boundlow = max_y
C'est la valeur maximum de la coordonnée y que la caméra peut atteindre. Elle doit toujours être à 0.
verticalfollow = proximité
Cette valeur affecte le mouvement vertical de la caméra pour suivre le joueur le plus haut. Elle doit être réglée entre 0 et 1. Une valeur de 0 signifie que la caméra ne montera pas du tout. Une valeur plus grande forcera la caméra à suivre le joueur le plus haut. Une valeur de 1 fera que la camera suivra le joueur aussi près que possible.
floortension = v_dist
C'est la distance verticale minimum qu'il doit y avoir entre le joueur le plus haut et le sol (donnée en valeur positive), avant que la caméra ne commence à monter pour le suivre.
tension = h_dist
C'est la distance horizontale minimum qui peut séparer un joueur d'un bord latéral de l'écran avant que la caméra ne le suive. Les valeurs valides vont de 0 à 160.

Groupe PlayerInfo

p1startx = x_start
Règle la position x de départ du Joueur 1.
p1starty = y_start
Règle la position y de départ du Joueur 1.
p2startx = x_start
Règle la position x de départ du Joueur 2.
p2starty = y_start
Règle la position y de départ du Joueur 2.
p1facing = facing_flag
Contrôle vers quel côté le Joueur 1 est tourné au départ. Mettez 1 pour qu'il regarde vers la droite, ou -1 pour qu'il regarde vers la gauche.
p2facing = facing_flag
Contrôle vers quel côté le Joueur 2 est tourné au départ. Mettez 1 pour qu'il regarde vers la droite, ou -1 pour qu'il regarde vers la gauche.
leftbound = x_min
Règle la position x minimum autorisée pour tous les joueurs.
rightbound = x_max
Règle la position x maximum autorisée pour tous les joueurs.

Groupe Bound

screenleft = min_dist_gauche
Distance minimum autorisée entre les joueurs et le bord gauche de l'écran. Doit être positive.
screenright = min_dist_droite
Distance minimum autorisée entre les joueurs et le bord droit de l'écran. Doit être positive.

Groupe StageInfo

zoffset = v_dist
v_dist est la distance verticale entre le bord haut de l'écran et le niveau du sol, donnée en pixels. Le paramètre zoffset est mal nommé, mais il est resté inchangé pour des raisons de compatibilité.
zoffsetlink = elem_ID
Si ce paramètre est indiqué, il lie la valeur du zoffset à la position y d'un élément de décor avec le numéro ID spécifié. Par exemple, vous pouvez lier la valeur à un élément "factice" (dummy -- voir Autres types d'éléments de décor) avec un paramètre sin.y pour faire monter et descendre les personnages de façon sinusoïdale.
autoturn = turn_flag
Laissez ce paramètre à 1 pour que les personnages se tournent automatiquement pour se faire face. Mettre ce paramètre à une autre valeur causera un comportement non désiré.
resetBG = reset_flag
Si mis à 1, les éléments de décor seront réinitialisés entre les rounds. Si mis à 0, les décors continueront sur leur lancée.
localcoord = width, height
Dimensions de la résolution du stage. 320, 240 par défaut si omis.
xscale = xscale
Facteur de mise à l'échelle horizontal pour les offsets, les vitesses, les sprites et les animations.
yscale = yscale
Facteur de mise à l'échelle vertical pour les offsets, les vitesses, les sprites et les animations.

Groupe Shadow

intensity = darkness_val ;(optional)
Ceci contrôle la luminosité de l'ombre. Les valeurs valides vont de 0 (le plus clair) à 256 (le plus sombre). 128 par défaut si omis.
color = r,v,b ;(optional)
Ce paramètre affecte la couleur de l'ombre. r,v,b sont les composantes de couleur (entre 0 et 255) des ombres des joueurs. Plus le nombre est élevé, moins la couleur correspondante sera présente dans l'ombre. Plus les nombres sont faibles, plus les ombres seront claires. 0,0,0 par défaut si omis.
yscale = scale_y ;(optional)
C'est le facteur de mise à l'échelle vertical de l'ombre. Utilisez un plus grand scale_y pour rendre l'ombre plus longue. Vous pouvez utiliser un scale_y négatif pour que l'ombre tombe de l'autre côté des joueurs. 0.4 par défaut si omis.
fade.range = haut_y, bas_y ;(optional)
Ce paramètre vous permet de régler l'intervalle dans lequel l'ombre est visible. On s'en sert pour créer des effet de dégradé sur l'ombre lorsque le joueur s'éloigne du sol. La première valeur est le niveau haut et la seconde, le niveau du milieu. Les deux représentent des coordonnées y du joueur. L'ombre est invisible si le joueur est au-dessus du niveau haut, et complètement visible s'il est sous le niveau du milieu. L'ombre est dégradée entre ces deux niveaux. Si omis, par défaut, il n'y a pas d'effet (l'ombre est toujours complètement visible). Notez que les coordonnées y sont négatives, et que haut_y doit être inférieur à bas_y.

Groupe Reflection

reflect = reflect_flag ;(optional)
Réglez reflect à 1 pour activer la réflexion d'ombre, 0 pour les désactiver. La réflexion d'ombres crée un effet de "sol ciré". 0 par défaut si omis.

Groupe Music

bgmusic = bgm_filename ;(optional)
bgm_filename est le nom du fichier de musique à jouer dans le stage. Les fichiers de musique sont normalement mis dans le dossier sound/. Laisser bgm_filename vide fera qu'aucune musique ne sera jouée. Si le fichier musique n'existe pas, aucun fichier ne sera joué. Pour jouer un CD audio, mettez le numéro de la piste suivi de ".da". Utiliser 0 comme numéro de piste jouera une piste choisie au hasard. Par exemple, pour jouer la piste 3 d'un CD audio, utilisez bgmusic = 3.da. Si omis, par défaut, il n'y a pas de musique.
bgvolume = volume_offset ;(optional)
Ce paramètre ajuste le volume des musiques jouées. Utilisez 0 pour normal, une valeur négative pour baisser le volume, et une valeur positive pour l'augmenter (uniquement pour les mp3, mods et CDA). Les valeurs valides vont de -255 à 255. 0 par défaut si omis.

Description des éléments de décor

Pour définir les éléments de décor de votre stage, vous devez d'abord créer un groupe BGDef à la fin de votre fichier DEF. Le format est le suivant:

[BGDef]
spr = stages/mon_stage.sff
debugbg = 1

Vous devez remplacer stages/mon_stage.sff par le chemin du fichier SFF contenant les données de sprites de votre stage. Pour éviter tout ralentissement de jeu, rappelez-vous de régler debugbg = 1 quand votre stage est finalisé.

Une fois la définition BGDef créée, tout ce qui se trouve après dans le fichier DEF est considéré comme appartenant à la section BGDef. Dans la section BGDef vous pouvez spécifier un élément de décor ou plus. Les éléments de décor sont dessinés dans l'ordre dans lequel ils apparaissent dans le fichier DEF (avec les derniers éléments affichés par dessus les précédents), donc les éléments les plus en arrière-plan doivent être définis en premier.

Eléments de décor statiques

Le format pour décrire un élément de décor statique est le suivant.

[BG nom_de_mon_élément]
type = normal
spriteno = 0,0
id = 0
layerno = 0
start = 0,0
delta = .5, .5
trans = none
mask = 0
tile = 0,0
tilespacing = 0,0
window = 0,0,319,239
windowdelta = 0,0

Plusieurs paramètres peuvent être omis. Nous allons examiner cet exemple ligne par ligne.

[BG nom_de_mon_élément]  ; (requis)
Seul [BG] est requis pour l'instant. nom_de_mon_élément peut être tout ce que vous voulez. En général, ça aide de donner à chaque élément un nom distinct et descriptif, puisque "nom_de_mon_élément" sera utilisé dans les messages d'erreur.
type = normal  ; (requis)
Ceci indique que cet élément de décor est un sprite statique, sans animation ni parallaxe.
spriteno = 0,0  ; (requis)
Ceci indique quel sprite du SFF doit être affiché pour cet élément de décor.
id = 0  ; (optionnel)
Attribue un numéro ID auquel se référera l'élement de décor. Ceci est utiliser pour permettre aux contrôleurs de décor de spécifier quels éléments ils contrôlent. Plusieurs éléments de décor peuvent partager le même numéro ID au besoin.
layerno = 0  ; (optionnel)
Si layerno = 0, alors l'élément de décor est dessiné derrière les personnages. Si layerno = 1, alors cet élément est dessiné devant les personnages. Pour chaque "layer" ("couche" en anglais), les éléments de décor sont dessinés du fond vers vers l'avant, dans l'ordre dans lequel ils apparaissent dans le fichier DEF. layerno a une valeur de 0 par défaut si omis
start = 0,0  ; (optionnel)
Spécifie la position de départ de l'élément de décor par rapport au milieu haut de l'écran (les valeurs y positives vont vers le bas). L'axe de l'élément de décor (celui indiqué pour le sprite spécifié dans le SFF) est placé à cette position de départ. Si omis, start vaut 0,0 par défaut.
delta = .5,.5 ; (optionnel)
Indique de combien de pixels l'élément de décor doit être déplacé pour chaque pixel de déplacement de la caméra dans les directions horizontale et verticale, respectivement. Mettre delta=1,1 fera que l'élément de décor se déplacera à la même vitesse que la caméra. C'est le bon réglage pour des choses telles que le sol sous les pieds des personnages. Pour des éléments plus éloignés, utilisez des valeurs de delta plus petites pour créer une illusion de profondeur. De même, les éléments à l'avant-plan (layerno = 1) se voient généralement attribués des deltas plus grand que 1. Il est possible de donner une valeur négative au delta, mais ceci peut avoir un effet non désiré. delta vaut 1,1 par défaut si omis.
trans = none ; (optionnel)
Indique si l'élément de décor doit être transparent ou non. Les modes de transparence sont none, add, add1, sub. Ceci indique pas de transparence (valeur par défaut), addition de couleur (effet projecteur), 50% d'addition de couleur, et soustraction de couleur (effet d'ombre).
mask = 0  ; (optionnel)
Si mask est mis à 1, la couleur 0 du sprite ne sera pas affichée. Ceci est utilisé pour dessiner des objets qui ne sont pas de forme rectangulaire. Pour des raisons de vitesse, mask devrait être réglé à 0 quand il n'est pas utile. mask a une valeur de 0 par défaut.
tile = 0,0 ; (optionnel)
Cette ligne indique si l'élément de décor doit être répété ("tiled", tile = tuile en anglais) dans les directions horizontale et/ou verticale, respectivement. Une valeur de 0 indique aucun "tiling", une valeur de 1, un tiling infini, et toute valeur supérieure à 1 causera la répétition de l'élément le nombre de fois indiqué. Si cette ligne est omise, aucun "tiling" ne sera réalisé.
tilespacing = 0,0 ; (optionnel)
Si le "tiling" est activé, cette ligne indique l'espace à laisser entre chaque instance du "tiling" dans les directions horizontale et verticale, respectivement. Il n'y a aucun effet si le tiling n'est pas activé. tilespacing vaut 0,0 par défaut.
window = 0,0,319,239  ; (optionnel)
Spécifie la fenêtre avec quatre coordonnées x1, y1, x2 et y2 respectivement. Considérant le coin haut gauche de l'écran comme étant (0,0), ces coordonnées sont utilisées pour créer une boîte rectangulaire avec (x1,y1) et (x2,y2) en angles opposés. A chaque instant, seule la partie de l'élément de décor qui correspond à cette boîte (la "fenêtre") sera affichée. Dans cet exemple, la fenêtre spécifiée est (0,0) - (319,239), soit l'intégralité de l'écran. Si vous n'avez pas besoin d'effet de fenêtre, omettez complètement cette ligne.
windowdelta = 0,0  ; (optionnel)
Indique le delta de la fenêtre de l'élément de décor. Il fonctionne de façon similaire au paramètre delta pour l'élément de décor lui-même. Dans certains cas particuliers, des effets intéressants peuvent être créés en utilisant différentes valeurs pour delta et windowdelta (en combinaison avec window). Par défaut, windowdelta vaut 0,0 (pas de mouvement).

Eléments de décor animés

Le format pour décrire un élément de décor animé est presque exactement le même que pour un élément de décor normal. Il n'y a que trois différences notables, qui sont expliquées ci-dessous.

[BG mon_élément_animé]
type = anim
actionno = 55

(tous les autres paramètres autres que spriteno sont les mêmes que pour un élément de décor statique).

D'abord, pour les éléments à animer, un type anim doit être spécifié. Ensuite un "numéro d'action" (actionno) doit être défini. Ceci remplace le paramètre spriteno qui serait utilisé pour un élément de décor normal. La valeur de actionno doit correspondre à une animation définie dans le fichier DEF. Dans cet exemple, puisque actionno vaut 55, l'action 55 doit être définie de façon similaire à ceci

[Begin Action 55]
0,0,0,0,5
0,1,0,0,5

Le format est le même que pour la définition d'animations dans le fichier AIR, donc les détails seront omis ici. La définition de Action sera placée n'importe où sous le groupe [BGDef]. Les méthodes typiques sont soit de définir l'action juste après l'élément auquel elle appartient, soit de réunir toutes les animations du stage ensemble au début ou à la fin du groupe [BGDef].

Notez que chaque sprite utilisé dans l'animation a son axe propre (défini dans le fichier SFF). Quand l'animation est jouée, l'axe de chaque sprite sera aligné de façon à correspondre à l'axe de l'élément de décor lui-même.

L'effet du paramètre tilespacing est différent pour les éléments de type anim, comparés aux éléments de type normal. Pour un élément normal, la valeur x de ce paramètre indique la distance horizontale entre le bord droit du premier "tile" et le bord gauche du second "tile". Dans le cas d'un élément anim, la valeur x indique la distance horizontale entre le bord gauche du premier "tile" et le bord gauche du second "tile". Ceci fonctionne de la même manière pour la valeur y. La raison de cette différence est que la taille d'une anim n'est pas nécessairement constante. Le tilespacing a une valeur par défaut de 1,1 pour les éléments de type anim.

La dernière différence entre les éléments normaux et animés est que les éléments animés ont toujours mask = 1.

Eléments de décor en parallaxe

Pour voir un exemple d'élément de décor en parallaxe, regardez le sol dans le stage de KFM. Les éléments de décor en parallaxe, comme leur nom l'indique, donne l'illusion d'un parallaxe (phénomène où les objects proches donnent l'impression de bouger plus vite que les objets éloignés quand la caméra bouge). Les éléments de décor en parallaxe doivent être consitués d'un unique sprite (ils ne peuvent pas être animés). Ils ne peuvent pas non plus être transparents.

Le format est le suivant:

[BG mon_élément_parallaxe]
type = parallax
spriteno = 10, 0
xscale = 1,1.75
yscalestart = 100
yscaledelta = 1.2

(tous les autres paramètres sont les mêmes que pour les élément statiques, sauf que trans est désactivé).

Les premier et second paramètres xscale règlent le delta horizontal des bords haut et bas de l'élément de décor, respectivement (les deltas pour le reste de l'élément sont linéairement interpolé entre ces deux valeurs). Par exemple, si nous spécifions delta = .78, .75, alors le haut du sprite bougera à .78 * 1 = .78 pixels à chaque mouvement d'un pixel de la caméra, et le bas bougera à .75 * 1.75 = 1.3125 pixels à chaque mouvement d'un pixel de la caméra. Le xscale est responsable de la création de l'effet de parallaxe dans la direction horizontale.

yscalestart est le pourcentage auquel ajuster le sprite verticalement quand la caméra est au niveau du sol. 100 par défaut.

yscaledelta est la valeur à ajouter au facteur de mise à l'échelle à chaque fois que la caméra monte d'un pixel. Dans l'exemple ci-dessus, quand la caméra monte d'un pixel, le facteur de mise à l'échelle devient 101.2%, et si elle monte d'un autre pixel, le facteur sera de 102.4%, etc.

Paramètres avancés

Ces paramètres peuvent être ajoutés à n'importe quel élément de décor si nécessaire.

id = id_number
Attribue un numéro ID pour l'élément de décor. De multiples éléments peuvent partager le même numéro ID. L'intérêt du numéro ID est de permettre aux contrôleurs de décor ("BG Controllers") d'indiquer à quels éléments ils s'appliquent. 0 par défaut si omis.
positionlink = link_flag
Mettez positionlink à 1 pour verrouiller la position de cet élément à la position de l'élément qui le précède immédiatement dans le fichier DEF. S'il est mis à 1, les valeurs du paramètre start pour l'élément courant sont traités comme des décalages à partir de la position de l'élément précédent. Le paramètre delta n'aura pas d'effet dans ce cas. C'est utile pour qu'un grand groupe d'éléments bougent à l'unisson ; si vous changez les valeurs du start et du deltat du premier élément dans la chaine du positionlink, les effets seront visibles à travers tous les éléments de la chaîne. positionlink a une valeur par défaut de 0 si omis.
velocity = vel_x, vel_y
Indique les vitesses initiales x et y de l'élément de décor (valeur par défaut : 0). Cette fonctionnalité est également englobée par le contrôleur de décor VelSet.
sin.x = amplitude, durée, phase
Spécifie un mouvement sinusoïdal pour l'élément dans la direction x. Le premier paramètre est l'amplitude, le second est la durée du mouvement en ticks, et le troisième désigne la phase initiale du mouvement sinusoïdal (0 par défaut, c'est-à-dire que l'élément débutera au milieu exact de son intervalle sinusoïdal). Ce paramètres est naturellement remplacé par le contrôleur de décod SinX.
sin.y = amplitude, durée, phase
Fonctionne de la même façon que le paramètre sin.x, mais dans la direction y.

Autres types d'éléments de décor

Outre les types de décor normal, anim et parallax, il existe également un type dummy. Comme son nom l'indique (dummy = chose factice en anglais), un décor de type dummy n'a pas de graphisme associé. La position d'un élément dummy est affectée comme pour n'importe quel autre type d'élément. Actuellement, le seul usage d'un élément de type dummy est de servir de point d'ancrage pour l'effet du paramètre zoffsetlink dans le groupe StageInfo.

Background controllers

Background controllers operate on an internal timer that starts at 0 when the round starts, and increases by 1 for every game tick. When the timer reaches the controller's start time, then the controller becomes active. When the timer reaches the controller's end time, then the controller deactivates. If a positive looptime is specified for the controller, then the controller's internal timer will reset to 0 when the looptime is reached.

Background controllers must be grouped under a parent BGCtrlDef. You can use multiple BGCtrlDefs to separate the controllers into several groups. Each block of BGCtrlDef and background controllers may be placed anywhere within the [BGDef] section of the DEF file. The general format for these blocks is as follows.

[BGCtrlDef my_controller_name]
looptime = GLOBAL_LOOPTIME
ctrlID = DEFAULTID_1, DEFAULTID_2, ...

[BGCtrl my_controller_1]
type = CONTROLLER_TYPE
time = START_TIME, END_TIME, LOOPTIME
ctrlID = ID_1, ID_2, ...
(controller-specific parameters here)

[BGCtrl my_controller_2]
(etc.)

GLOBAL_LOOPTIME specifies the number of ticks after which the BGCtrlDef should reset its internal timer, as well as the internal timers of all BGCtrls it contains. To disable the looptime, set it to -1 or omit the parameter.

DEFAULTID_1, DEFAULTID_2, etc., specify the IDs of background elements to be affected by any BGCtrl that doesn't specify its own list of ctrlIDs. You can list up to 10 ID numbers for this parameter. If the line is omitted, then the default will be to affect all éléments de décor.

START_TIME, END_TIME, and LOOPTIME are the times at which the background controller should start acting, stop acting, and reset its internal timer, respectively. If LOOPTIME is omitted or set to -1, then the background controller will not reset its own timer. (Its timer can still be reset by its parent BGCtrlDef if a GLOBAL_LOOPTIME is specified.) The background controller will be continuously active between START_TIME and END_TIME. START_TIME is required, but if END_TIME is omitted then it will default to the same value as START_TIME (so the controller will be active for 1 tick only).

ID_1, ID_2, etc., specify the IDs of éléments de décor for this controller to act on. This list, if specified, overrides the default list specified in the BGCtrlDef. The maximum number of IDs specifiable is 10.

Below is the list of BGCtrl types and their associated parameters.

  • null

    As the name implies, this controller does nothing. It is useful mainly for debugging, when you want to quickly disable a controller without commenting the whole thing out. Simply change the type to null and comment out the old type. This controller has no additional parameters.

  • Visible

    value = visible_flag

    Sets the visibility status of the elements.

    While active, this controller sets the affected éléments de décor to be invisible (0) or visible (1). Time will still pass for invisible elements (meaning, in the case of animated elements, that the animation will continue to progress even though it can't be seen).

  • Enabled

    value = enabled_flag

    Sets the enabled status of the elements.

    This controller either disables (0) or enables (1) the affected background elements. When an element is disabled, it is invisible and time does not pass for it (so, in the case of animated elements, any animation is paused when it's disabled).

  • VelSet

    x = vel_x

    Sets the x-velocity of the elements.

    y = vel_y

    Sets the y-velocity of the elements.

    This controller will set the x/y velocity of the affected background elements to the specified values. Velocities are measured in pixels per game tick. You can specify either or both of the x and y parameters. If either is omitted, the element's velocity in that direction will not change.

  • VelAdd

    x = vel_incr_x

    Changes the x-velocity of the elements by vel_incr_x.

    y = vel_incr_y

    Changes the y-velocity of the elements by vel_incr_y.

    This controller will add the specified values to the x/y velocity of the affected éléments de décor. You can specify either or both of the x and y parameters. If either is omitted, the element's velocity in that direction will not change.

  • PosSet

    x = pos_x

    Sets the x-position of the elements.

    y = pos_y

    Sets the y-position of the elements.

    This controller will set the x/y coordinate of the affected éléments de décor to the specified values. You can specify either or both of the x and y parameters. If either is omitted, the element's coordinate on that axis will not change.

  • PosAdd

    x = x_displacement

    Displaces the x-coordinate of the elements.

    y = y_displacement

    Displaces the y-coordinate of the elements.

    This controller will displace the x/y coordinate of the affected éléments de décor by the specified values. You can specify either or both of the x and y parameters. If either is omitted, the element's coordinate on that axis will not change.

  • Anim

    value = action_no

    Changes the animation displayed by the affected elements to the specified animation number.

  • SinX

    value = amplitude, period, offset

    Changes the amplitude, period, and phase offset for the affected elements' sinusoidal motions in the x-direction. These values have the same effect as they do for the sin.x élément de décor parameters.

  • SinY

    value = amplitude, period, offset

    Changes the amplitude, period, and phase offset for the affected elements' sinusoidal motions in the y-direction. These values have the same effect as they do for the sin.y élément de décor parameters.

Simple Example

Suppose we want to make a person walk back and forth from (-300,0) to (300,0), right behind the main characters. We'll use background controllers to accomplish this task.

First, define the walking animations. Say that the character's walking sprites are 10,0 through 10,3 and that they face to the right.

; Walk right
[Begin Action 10]
10,0,0,0,6
10,1,0,0,6
10,2,0,0,6
10,3,0,0,6

; Walk left
[Begin Action 11]
10,0,0,0,6,H
10,1,0,0,6,H
10,2,0,0,6,H
10,3,0,0,6,H

Now start the character off at the far left edge of his range.

[BGDef]
(...)

[BG Peregrinator]
type = anim
actionno = 10
id = 10
start = -300, 0
delta = 1,1

Let's give Peregrinator a comfortable ambling speed of 2 pixels per tick. The one-way distance for his walk is 600 pixels, which will take 300 ticks. In total, it'll take him 600 ticks to make the round trip. Using this knowledge, set up the background controllers appropriately: since the entire situation repeats every 600 ticks, we can set the global looptime to 600.

[BGCtrlDef Peregrinator]
; reset the whole deal every 600 ticks.
looptime = 600
ctrlID = 10

; Set velocity of 2 pixels/sec rightward at time 0.
[BGCtrl Walk Right]
type = VelSet
time = 0
x = 2

; Set velocity of 2 pixels/sec leftward at time 300.
[BGCtrl Walk Left]
type = VelSet
time = 300
x = -2

And that's it! You can make the walk look better by having Peregrinator slow down and display a turning animation at each end of his walk. This would entail use of the VelAdd and Anim controllers. If you want Peregrinator to stop and start at regular intervals as he goes from one end to the other, you could create more VelSet and Anim controllers with their own individual looptimes (to get the behavior to repeat at regular intervals).


Personal tools