Category Archives: Scripts

[Ace] – MGC Tilemap Ace (Réécriture de la classe Tilemap)

Posted on by

Exemple avec une opacité de 100 pour la tilemap ; le panorama est alors partiellement visible par transparence


Ce script est une réécriture de la classe cachée Tilemap de RMVX Ace.

  • Ne gère pas le flash_data
  • Ne gère pas le décalage des motifs d’autotiles des tiles du tileset A2 avec l’indicateur “counter”
  • Gère le reste, et même d’autres propriétés/méthodes empruntées à la classe Sprite :
    • opacity
    • blend_type
    • color
    • tone
    • wave_amp
    • wave_length
    • wave_speed
    • wave_phase
    • zoom
    • flash
  • Ajout d’une méthode to_zoom(new_zoom, duration) pour un zoom progressif

Nécessite :

  • le fichier MGC_Map_Ace_1_5.dll à la racine du projet
  • les 3 fichiers graphiques suivants, déposés dans Pictures/ :
    • autotiles_data.png
    • autotiles_data_small.png
    • autotiles_data_xsmall.png

Configuration :

  • NEW_TILEMAP_FOR_ALL_MAPS : alimenté à true ou false
    • true : la nouvelle tilemap sera utilisée pour toutes les cartes
    • false : la nouvelle tilemap ne sera utilisée que pour les cartes dont l’id est dans NEW_TILEMAP_MAPS_IDS
  • NEW_TILEMAP_MAPS_IDS : utilisé si NEW_TILEMAP_FOR_ALL_MAPS est à false. Contient la liste des id des cartes pour lesquelles la nouvelle tilemap doit être utilisée

Télécharger la démo contenant le script (V.1.4)
 

[XP/VX/Ace] – MGC ISO Engine

Posted on by

Gestion avancée de l’isométrie 2D dans RPG Maker


Ce système, développé pour RMXP puis porté sur RMVX et RMVX Ace, est un moteur gérant l’isométrie de manière bien plus poussée qu’avec le script 2D ISO. Il s’agit toujours d’un rendu 2D utilisant des tiles (carreaux), mais cette fois le moteur de jeu gère trois dimensions. Les positions des objets sont donc déterminées par trois composantes : x, y et h (z gère déjà la priorité d’affichage des sprites).
La carte est découpée en “blocs”, qui sont des demi-cubes de dimensions 32px × 32px × 16px représentés en vue isométriques.

Ce système est composé d’un éditeur de cartes et du moteur en lui-même.
L’éditeur est un project RPG Maker à placer dans le répertoire de votre projet de jeu, qui contiendra le moteur. Cet éditeur permet de créer des cartes en vue isométrique et de les exporter directement dans le projet parent.
Le moteur, quant à lui, est composé d’un script et d’une DLL capables de charger et afficher des cartes en vue isométrique, et gérer les déplacements des personnages.
Contrairement à la grande majorité de mes scripts utilisant une DLL, celle-là ne sert qu’à accélérer le chargement des cartes et n’est pas appelée à chaque rafraîchissement de l’écran. Les performances en jeu ne dépendent que du moteur de RPG Maker.

Les données à stocker pour chaque carte en vue isométrique sont bien plus importantes que celles d’une carte classique de RPG Maker. Il faut conserver les données de tous les blocs de la carte, c’est-à-dire un nombre total de largeur × profondeur × hauteur blocs, et pour chacun de ces blocs les données sont :

  • sa forme ;
  • son orientation ;
  • les trois textures utilisées (dessus, gauche et droite), sachant que pour chaque texture il faut stocker :
    • l’identifiant du tileset utilisé pour la première couche ;
    • le numéro du tile dans son tileset pour la première couche ;
    • l’identifiant du tileset utilisé pour le masque ;
    • le numéro du tile dans son tileset pour le masque ;
    • l’identifiant du tileset utilisé pour la deuxième couche ;
    • le numéro du tile dans son tileset pour la deuxième couche ;
  • ses passabilités.

Il faut également conserver les données des éléments de décor :

  • coordonnées ;
  • opacité ;
  • indicateur de miroir horizontal ;
  • mode de remplissage.

Tout cela implique des temps de chargement des cartes en vue isométrique assez importants. En effet durant le chargement de la carte tous les blocs sont dessinés par avance pour un affichage plus rapide en cours de jeu. C’est pourquoi la largeur et la hauteur de la carte sont limitées à 50 carreaux.

L’ajout de la gestion d’une dimension supplémentaire a un impact majeur sur le code : alors que le script 2D ISO était très simple et compatible avec la plupart des autres systèmes, ce script redéfinit les déplacements des personnages et leurs interactions. De ce fait ce script aura très peu de chance d’être compatible avec un autre système, à moins que celui-ci ait spécifiquement été développé pour se greffer sur ce moteur.

Téléchargement :
Télécharger la démo contenant l’ensemble des composants pour RMXP (V.1.3)
Télécharger la démo contenant l’ensemble des composants pour RMVX (V.1.3)
Télécharger la démo contenant l’ensemble des composants pour RMVX Ace (V.1.3)

Utilisation du moteur :

  • Vous pouvez déclarer un évènement comme insensible à la gravité en ajoutant le commentaire Floating dans sa page. Dans ce cas, grâce à la commande Script… de Move route, vous pouvez utilisez les commandes de déplacement incr_h et decr_h pour respectivement faire monter et faire descendre d’un bloc l’évènement.
  • L’altitude initiale d’un évènement peut être définie en ajoutant le commentaire Altitude X dans sa page, où X est un entier représentant la valeur de l’altitude en blocs.
  • Les sprites des évènements sont positionnés par défaut au centre du carreau sur lequel ils se trouvent, comme s’ils étaient des parois verticales. Pour simuler l’effet d’un évènement “couché”, ajoutez le commentaire Ground dans sa page
  • le commentaire Shadow ajoute une ombre recouvrant la surface d’un carreau sous l’évènement. Ceci est particulièrement utile pour les plates-formes mobiles afin de mieux les situer dans l’espace.
  • Les personnages ne peut pas se déplacer s’il y a un obstacle devant eux. Cependant, si l’obstacle n’excède pas 1 bloc en hauteur, et s’il n’y a pas un autre évènement posé au-dessus du personnage, la touche [A] permet au joueur de sauter pour atterrir sur le dessus de l’obstacle. Pour un PNJ, vous pouvez ajouter le commentaire Jumper afin qu’il effectue des sauts dans ce cas. S’il y a un autre évènement posé au-dessus du personnage, la commande de saut le pose à terre.

Utilisation de l’éditeur

Ajout de l’éditeur dans un projet RPG Maker :

Le dossier MGC_ISO_Editor doit être placé à la racine du projet RPG Maker parent qui contient le script MGC ISO Engine.

Vous pourrez ensuite le supprimer une fois votre jeu terminé, avant de le publier.

Les ressources graphiques :

Cinq types d’ensemble de textures sont utilisés par l’éditeur pour l’affichage des cartes en vue isométrique. A moins que le contraire ne soit explicitement spécifié, tous les ensembles de textures doivent avoir une largeur de 128px.

  • Tilesets : nommés TilesetXX, où XX est un identifiant sur deux chiffres compris entre 00 et 99, ces ensembles contiennent les tiles utilisés pour le sol, ou plus précisément le dessus des blocs. Il se trouvent dans le répertoire \Graphics\MGC_ISO_Tilesets. Les tiles que ces ensembles contiennent sont des rectangles (64px × 32 px) qui doivent être positionnés de cette manière :

    A chaque tile est attribué un numéro dépendant de sa position dans l’ensemble. Ce numéro permet de créer des tiles animés ou de définir des motifs plus larges en ajoutant des sous-fichiers graphiques nommés TilesetXX_YYY, où YYY est le numéro du tile sur trois chiffres.

    • grands motifs : ils sont un ensemble de tiles isométriques basiques, qui forment un carré en vue normale (dimensions du sous-fichier : largeur = 2 × hauteur, avec comme hauteur un multiple de 32px). Les grands motifs sont utilisés pour éviter une trop grande répétition des tiles.Exemple :
      En utilisant le tileset suivant nommé Tileset03 :

      S’il n’y a pas de fichier Tileset03_001 dans le même répertoire, alors quand la première texture est appliqué sur l’ensemble du terrain de la carte, le résultat obtenu est le suivant :

      S’il existe le fichier Tileset03_001 dans le répertoire :

      Le résultat est différent : c’est le grand motif qui est répété à la place du tile présent dans le tileset.

    • tiles animés : il faut utiliser un format d’animation en plusieurs motifs, qui doivent se présenter de la façon suivante dans le sous-fichier :

      Il est possible d’animer des grands motifs (largeur du fichier = n × 2 × hauteur).

    Concrètement, pour chaque tile d’un tileset qui doit être dessiné, s’il existe un sous-fichier, c’est ce dernier qui est utilisé.

  • Wallsets de côté gauche : nommés Wallset_LeftXX, ils contiennent les sprites utilisés pour dessiner les parois gauches des blocs. Ils sont déposés dans le répertoire \Graphics\MGC_ISO_Wallsets. Les tiles sont contenus dans des carrés de 32px de côté, et sont disposés comme suit :

    Comme pour les tilesets, des motifs plus grands peuvent être définis, qui doivent être le regroupement de n tiles en largeur, et 2 × tiles en hauteur.

    Exemple :
    Un fichier de 4 tiles en largeur, et donc 8 tiles en hauteur :

    Il n’est pas possible d’animer les tiles de paroi.

  • Wallsets de côté droit : nommés Wallset_RightXX et également placés dans le répertoire \Graphics\MGC_ISO_Wallsets, ils contiennent les sprites utilisés pour dessiner les parois droites des blocs. Ils sont similaires à ceux utilisés pour le côtés gauche, avec juste un effet “miroir”.
  • Masksets : nommés MasksetXX, ils sont placés dans le répertoire \Graphics\MGC_ISO_Masksets. Les masques contenus dans ces ensembles sont utilisés pour combiner deux tiles de sol en un, principalement pour créer des transitions plus douces entre deux terrains différents. Les masques sont également utilisés pour créer des autotiles. Ils se présentent sous la forme de tiles de sol en noir et blanc.
    • Masques simples : aux pixels noirs correspondent les pixels du tile utilisés pour la première couche, tandis qu’aux blancs correspondent ceux du tile de la deuxième couche. Les masques simples fonctionnent de la même manière que les tiles de sol, ce qui veut dire que des sous-fichiers peuvent être utilisés pour obtenir des masques d’un plus grand motif, ou des masques animés.
    • Masques autotiles : ils sont définis à l’aide d’un sous-fichier nommé MasksetXX_YYY_Auto. A l’instar des masques simples, les pixels noirs et blancs correspondent respectivement à la première et à la deuxième couche de sol. Le sous-fichier a un format spécial :

      Il est possible d’obtenir des autotiles animés en concaténant les motifs dans le sous-fichier.

      Lorsqu’un tile est créé via la combinaison de deux couches en se basant sur un masque, alors si plusieurs éléments le composant sont animés (première couche / masque / deuxième couche), le nombre de motifs de l’animation est le plus petit trouvé.

  • Scenerysets : nommés ScenerysetXX_Z, où Z est soit l, soit s, ils sont placés dans le répertoire \Graphics\MGC_ISO_Scenerysets. Ils sont utilisés pour dessiner des éléments de décor.
    Les sprites ont une hauteur de 80px (Z = l) ou 48px (Z = s).

    Des éléments de décor animés peuvent être créés via des sous-fichiers nommés ScenerysetXX_Z_YYY.

Editeur :

Les cartes créées grâce à l’éditeur n’apparaissent dans le projet parent qu’à partir du moment où elles sont exportées. L’éditeur a son propre système de sauvegarde des cartes. Cela signifie que vous pouvez déplacer le dossier de l’éditeur d’un projet à un autre, tout en conservant les cartes enregistrées dans l’éditeur.

>>Menu principal

  • New map (Nouvelle carte) : création d’une nouvelle carte en vue isométrique. Aucun fichier ne sera conservé tant que la carte n’aura pas été sauvegardée.
  • Load map (Charger une carte) : charge une carte sauvegardée dans l’éditeur.
  • Import map (Importer une carte) : permet d’importer des cartes en vue isométriques présentes dans le projet parent. Les cartes ainsi importées ne seront pas modifiées dans le projet parent à moins qu’elles ne soient exportées de nouveau en précisant l’écrasement des données de la carte.
  • Export map (Exporter une carte) : exporte des cartes en vue isométriques vers le projet parent.
  • Delete map (Supprimer une carte) : supprime des cartes sauvegardées dans l’éditeur.
  • Iso Converter (Convertisseur Iso) : outil permettant de convertir des ressources en vue isométrique.

>> Nouvelle carte :

  • Type : Seulement deux types sont disponibles pour le moment : une vue isométrique classique, et une vue hybride affichant des tiles isométriques dans une carte rectangulaire à l’écran.

    Les cartes de second type utilisent en bordure des tiles qui ne sont pas considérés comme à l’intérieur de la carte : ils ne sont pas passables, et les actions d’édition sont limitées (élever / abaisser / appliquer une texture / ajouter un élément de décor).

  • Dimensions : la largeur et la profondeur de la carte sont limitées à 50 blocs, principalement pour limiter les temps de chargement. L’altitude maximale est de 24 blocs et la hauteur de la carte n’est pas fixée à sa création. Elle est déterminée à chaque sauvegarde grâce au bloc le plus haut placé.
  • “Void” (Vide) : cette option ajoute à la carte une altitude supplémentaire souterraine (à -8 blocs)., qui n’est pas passable par défaut, principalement utilisée pour afficher des fossés ou du vide.

>> Charger une carte :

Sélectionnez la carte sauvegardée que vous désirez charger, puis accepter pour démarrer l’édition de la carte.

>> Importer une carte :

Sélectionnez la carte en vue isométrique présente dans le projet parent et que vous désirez charger, puis accepter pour démarrer l’édition de la carte. Le nom de la carte est conservé.

>> Exporter une carte :

Sélectionnez la carte sauvegardée que vous souhaitez exporter vers le projet parent et accepter pour commencer le processus d’export.
Dans le cas où il existe déjà une carte en vue isométrique de même nom dans le projet parent, il vous sera demandé si vous désirez l’écrasez ou créer une nouvelle carte.
Tous les ensembles de tiles utilisés pour la carte seront copiés dans le répertoire des ressources graphiques du projet parent.

Attention : le projet parent doit être fermé pendant l’export de cartes.
Dans l’éditeur du projet parent, vous pourrez visualiser l’altitude maximale de chaque colonne de blocs grâce à un jeu de couleurs. Pour cela, il faut utiliser :

  • RMXP : identifiant de tileset = 51
  • RMVX : le tileE
  • RMVXA : le tileE pour l’identifiant de tileset = 5

>> Supprimer une carte :

Sélectionnez la carte sauvegardée que vous souhaitez effacer et accepter pour supprimer physiquement les fichiers associés. Cette carte n’apparaîtra plus dans l’éditeur.

>> Convertisseur isométrique :

Deux répertoires input et output se trouvent dans le dossier Iso Converter. Déposez vos ressources graphiques à convertir dans le dossier input. Les ressources en vue isométriques obtenues seront placées dans le dossier output.

Edition d’une carte :

  1. Fenêtre d’information de l’éditeur : contient le nom de la carte, les coordonnées du curseur et un bloc présentant les textures sélectionnées.
  2. Fenêtre de textures : permet la sélection des textures à appliquer.
  3. Menu : pour sélectionner le mode de l’éditeur ou encore sauvegarder la carte.
  4. Fenêtre d’informations additionnelles : certaines informations peuvent apparaître ici en fonction du mode de l’éditeur.

>> Commandes :

  • [A] : appel la fenêtre de textures.
  • [B] : appel le menu.
  • [C] : applique l’action qui correspond au mode courant. Laissez le bouton [C] appuyé tout en vous déplaçant afin de lancer l’action sur chaque bloc sur la trajectoire.
  • [Bas/Gauche/Droite/Haut] : déplace le curseur dans le plan horizontal.
  • [L/R] : change l’altitude du curseur.

Des commandes supplémentaires peuvent être activées pour les touches [X], [Y] et [Z], en fonction du mode courant. Ces commandes seront précisées dans la fenêtre d’informations additionnelles.

Vous pouvez utiliser les touches de raccourci [F5], [F6], [F7] et [F8] pour naviguer rapidement entre les modes, sans passer par le menu.

Si vous pressez la touche [F9], le mode de visualisation de la carte va basculer en mode “coupe” (suivant l’axe X ou Y).

>> Fenêtre de textures :

Appelée via le bouton [A], cette fenêtre permet de sélectionner les textures qui seront appliquées.

  • [A/B] : fermer la fenêtre.
  • [C] : sélectionner la texture à la position du curseur.
  • [L/R] : parcourir les ensembles de textures pour le type courant.
  • [X/Y] : parcourir les différents types d’ensemble de textures : sol, paroi gauche, paroi droite et -si l’indicateur de masque est activé- seconde couche et masque.

Les ensembles d’éléments de décor ne sont disponibles que si le mode d’édition du décor est sélectionné.

>> Menu :

>>>> Mode d’édition du relief (Heights) :

Vous permet de sculpter la carte.

  • Add block (Ajouter un bloc) : ajoute ou remplace un bloc aux coordonnées du curseur, en appliquant les textures courantes. Appuyez sur [X] pour modifier la forme du bloc, et [Y] ou [Z] pour changer son orientation.
  • Delete block (Supprimer un bloc) : supprime le bloc aux coordonnées du curseur.
  • Elevate ground (Elever le terrain) : élève le terrain à la position du curseur via l’ajout d’un nouveau bloc reprenant les textures du bloc immédiatement en dessous. Dans ce mode le curseur ne bouge pas librement en altitude. Les touches [R] et [L] permettent cependant de parcourir les altitudes disponibles.
    Si le curseur est positionné sur un bloc de “vide”, cette commande permet de le remplir.
  • Lower ground (Abaisser le terrain) : abaisse le terrain à la position du curseur via la suppression d’un bloc. Si le “vide” est autorisé pour la carte, alors cette commande permet de creuser des fossés.

>>>> Mode d’édition des textures :

Pour appliquer des textures aux blocs disposés dans la carte.

  • Set (Appliquer) : applique la texture sélectionnée sur la partie d’un bloc (dessus, gauche, droite). Le curseur ne bouge pas librement en altitude pour l’application de textures de sol. Les touches [R] et [L] permettent cependant de parcourir les altitudes disponibles.
  • Fill (Remplir) : applique la texture de sol sélectionnée sur tous les blocs consécutifs à la même altitude partageant actuellement la même texture.
  • Fill (level) (Remplir par niveau) : applique la texture de sol sélectionnée sur tous les blocs consécutifs à la même altitude, qu’ils partagent actuellement la même texture ou non.

>>>> Mode d’édition des passabilités :

Pour modifier les passabilités des tiles de la carte. Les passabilités sont automatiquement calculées à l’ajout de blocs ou leur suppression, et donc ce mode sert principalement à spécifier les passabilités des éléments de décor.

  • Set passability (Définir la passabilité) : applique un tile de passabilité aux coordonnées du curseur, qui va spécifier la possibilité de passage dans les quatre directions.
    • [X] : permet de visualiser la carte texturée. Aucune action ne peut être effectuée dans ce mode. Pressez à nouveau [X] pour revenir au mode normal.
    • [Y] : change l’orientation du tile de passabilité.
    • [Z] : change la nature du tile de passabilité.
  • Remove passability (Supprimer la passabilité) : supprime le tile de passabilité aux coordonnées du curseur. La position devient passable.
  • Reinitialize (Réinitialiser) : réinitialiser toutes les passabilités de la cartes en prenant les valeurs par défaut.

>>>> Mode d’édition des éléments de décor (Scenery) :

  • Add (Ajouter) : ajoute l’élément de décor sélectionné aux coordonnées du curseur. La sélection d’un élément de décor s’effectue via la fenêtre de textures.
    • [X] : change l’opacité de l’élément de décor.
    • [Y] : change le mode de transparence de l’élément de décor.
    • [Z] : active ou désactive la symétrie horizontale.
  • Delete (Supprimer) : supprime tous les éléments de décor aux coordonnées du curseur.
  • Delete all (Tout supprimer) : supprime tous les éléments de décor de la carte.

>>>> Mode de placement des évènements (Events) :

Vous permet de placer plus précisément des évènements créés auparavant dans le projet parent, après l’import de la carte.

  • Move (Déplacer) : un premier appui sur le bouton [C] sélectionne l’évènement aux coordonnées du curseur. Vous pouvez ensuite déplacer ce évènement et valider sa nouvelle position avec un nouvel appui sur le bouton [C]. Tant qu’aucun évènement n’est sélectionné, les touches directionnelles vous permettent de passer d’un évènement à l’autre.

>>>> Mode de masque :

  • Enable/Disable (Activer/Désactiver) : active ou désactive l’utilisation des masques pour le dessin des blocs.

>>>> Système :

Permet de sauvegarder la carte, ou de régler quelques paramètres techniques.

  • Parameters (Paramètres) : tous les réglages sauf le langage sont enregistrés avec la carte, et affectent l’affichage dans le projet parent une fois la carte exportée. La langue sélectionnée n’affecte que l’éditeur.
    • Language (Langue) : choix de la langue utilisée pour les libellés présents dans l’éditeur.
    • Automatic borders (Bordures automatiques) : choix du style de bordure automatique des blocs.
    • Automatic shadows (Ombres automatiques) : active ou désactive les ombres automatique des blocs.
    • Patterns offsets (Décalage des motifs) : affecte l’origine des dessins de grands motifs dans la carte.
  • Save the map (Sauvegarder la carte) : sauvegarde la carte dans l’éditeur. Si la carte n’a pas été encore sauvegardée, fonctionne de la même manière que la commande Save as a new map.
  • Save as a new map (Sauvegarder en tant que nouvelle carte) : sauvegarde la carte en tant que nouvelle carte dans l’éditeur. Un nouveau nom technique est donné arbitrairement à la carte. Cela peut être utilisé pour copier des cartes.
  • Save a picture (Sauvegarder une image) : crée un fichier image au format .PNG représentant la carte entière, qui est déposé dans le dossier /Pictures.
    Cela peut aider à créer des cartes pour le script 2D ISO, repris dans le script de combat tactique de GubiD GTBS
  • Back to title (Revenir à l’écran titre) : retour au menu initial. Toutes les modifications non sauvegardées sont perdues

[XP/VX/Ace] – Enregistrer des objets Bitmap en fichiers .PNG

Posted on by

Il existe plusieurs scripts capables d’enregistrer le contenu d’instances de la classe Bitmap en fichier .PNG. Ma version a pour caractéristique d’être probablement une des plus rapides, puisqu’elle fait exclusivement appel à du code C compilé dans une DLL, et fait appel aux fonctions de la librairie libpng.
 
 
Utilisation :
 
Il faut copier le fichier MGC_PNG.dll à la racine de votre projet RPG Maker (XP, VX ou VX Ace).
Télécharger le fichier MGC_PNG.dll
 
Puis insérer un nouveau script au-dessus de main, qui contient le code suivant :

#====================================================================
# Enregistrer les Bitmap en PNG
# v.1.0
# Auteur : MGC
#====================================================================
# ** Bitmap
#--------------------------------------------------------------------
# Ajoute une méthode pour créer un fichier image PNG
# à partir d'une instance de la classe Bitmap.
# Nécessite également la dll "MGC_PNG.dll".
#====================================================================
class Bitmap
  #--------------------------------------------------------------------------
  # * Constantes
  #--------------------------------------------------------------------------
  CREATE_PNG = Win32API.new("MGC_PNG", "createPNG", "ll", "l")
  #--------------------------------------------------------------------------
  # * Méthode d'appel pour créer un fichier PNG
  #     chemin : chemin + nom du fichier à créer
  #--------------------------------------------------------------------------
  def save_as_png(chemin)
    unless chemin[/\//] then chemin = './' << chemin end
    CREATE_PNG.call(self.__id__, chemin.__id__)
  end
end

Appeler alors la méthode save_as_png à partir d'une instance de la classe Bitmap, en passant en paramètre le chemin concaténé avec le nom du fichier à enregistrer.
 
ATTENTION : assurez-vous que le chemin existe bien avant d'enregistrer une image ! Au besoin vous pouvez mettre en place des sécurités en ruby en utilisant des commandes Dir.mkir.
 

[XP] – 2D ISO

Posted on by

Gestion de l’isométrie dans RPG Maker

Rendu à l’écran du script 2D ISO

Ce script, qui date du 16 août 2006, fut la base de la gestion de l’isométrie dans RMXP puis dans RMVX.
Auparavant, des tentatives en isométrie dans RMXP furent menées, mais un problème majeur émergeait systématiquement : la gestion des déplacements et des collisions. En effet RMXP utilise un système de tiles qui sont des carreaux de 32px de largeur. La vue isométrique classique des jeux vidéos utilise une grille triangulaire, qu’il est alors impossible de faire correspondre précisément à la grille carrée de RMXP.

L’idée a été de séparer l’affichage de la gestion des déplacements et des collisions. Tous les personnages conservent leur déplacements sur une carte classique de RMXP, mais ils sont affichés sur une seconde carte en rendu isométrique.
Ce script a été tout d’abord modifié par Siegfried, qui a ajouté un système de hauteurs (décalage de l’affichage vertical en fonction des coordonnées en x et en y des personnages), puis repris par Gubid dans son fameux script de combats tactiques GTBS, et adapté sur par lui-même sur RMVX.

Comment utiliser ce script ?

Vous trouverez dans la démo deux parties : le script 2D ISO de base, et un addon.
L’addon ajoute les fonctions suivantes :

  • déplacements du joueur par huitième de carreau
  • déplacements du joueur dans les huit directions (désactivable)
  • le joueur peut courrir grâce à la touche [Z] (désactivable)
  • le joueur peut sauter grâce à la touche [A] (désactivable)
  • gestion des plates-formes mobiles

Le script 2D ISO doit être placé au-dessus de main et sous tous les autres scripts de base de RMXP.
L’addon, s’il est utilisé, doit être placé immédiatement sous le script 2D ISO de base.

Deux cartes sont nécessaires au fonctionnement du script : une carte gérant les données, et une le rendu isométrique.
Tout d’abord définissez les dimensions de la carte de données, puis créez la grille d’une carte en vue isométrique à partir de ces dimensions. L’origine de la carte (le coin en haut à gauche) se retrouve en haut de la carte en vue isométrique.
Un carreau isométrique est contenu dans un rectangle de 64px par 32px.

Exemple pour une carte de données de 20 carreaux de large pour 16 carreaux en hauteur :

Carte en vue isométrique (20 * 16)

La hauteur en pixels de la carte en vue isométrique doit être un multiple de 32. Par conséquent, si la somme de la hauteur et de la largeur en carreaux de la carte de données est impaire, vous devez augmenter la hauteur de la carte en vue isométrique, la carte devant toujours être calée en haut (il y aura une bande vide d’un hauteur de 16px en bas).

Exemple pour une carte de données de 19 carreaux de large pour 16 carreaux en hauteur :

Carte en vue isométrique (19 * 16)

C’est à vous de dessiner la carte en vue isométrique de la manière que vous voulez et d’en faire un tileset exploitable, en jouant sur les couches et les priorités des carreaux pour obtenir l’affichage souhaité.
Une fois cette carte créée dans RMXP, vous devez lui ajouter la carte de données en tant que carte fille dans l’arborescence.
Cette carte de données est utilisée pour définir les passabilités et autres caractéristiques des carreaux.

Exemple : utilisation du premier tilesetpour définir les endroits impassables (carreau de la tente marron) et les endroits de type “bosquet” (carreau des hautes herbes).

Exemple de carte de données en utilisant le premier tileset

Les évènements doivent être placés sur la carte de données, tandis que le panorama et le brouillard doivent être spécifiés pour le tileset de la carte en vue isométrique.

Configuration de l’addon

Au début du script vous trouverez le passage suivant :

    ###### SWITCHES/VARIABLES CONFIG ######
    $num_switch_run = 1 # switch that enables/disables running
    $num_switch_jump = 2 # switch that enables/disables jumping
    $num_switch_8dirs = 3 # switch that enables/disables 8-dirs movements
    $num_switch_void = 4 # switch triggered when falling
    $num_variable_x_secure = 1 # last x position before falling
    $num_variable_y_secure = 2 # last y position before falling
    $num_terrain_void = 1 # terrain tag number for void
    ###### END CONFIG ######

Ces lignes correspondent respectivement à :

  • numéro d’interrupteur pour activer/désactiver la possibilité de courrir pour le joueur
  • numéro d’interrupteur pour activer/désactiver la possibilité d’effectuer des sauts pour le joueur
  • numéro d’interrupteur pour activer/désactiver les déplacements dans les huit directions
  • numéro de variable stockant la composante horizontale de la dernière position sûre du joueur, avant une chute dans le vide
  • numéro de variable stockant la composante verticale de la dernière position sûre du joueur, avant une chute dans le vide
  • numéro de terrain pour indiquer les carreaux correspondant au vide

Télécharger la démo contenant le script

[XP] – Moving Platforms (Plates-formes mobiles)

Posted on by

Gestion des plates-formes mobiles !

Ce script date du 16/05/2006 (+ petit dépoussiérage le 27/04/2011), et son objectif était de mettre en place un système de plates-formes mobiles inspirés des vieux A-RPG de l’époque Megadrive/SNES.

Qu’apporte ce script ?

  • déplacements du joueur par huitième de carreau
  • déplacements du joueur dans les huit directions (désactivable)
  • le joueur peut courrir grâce à la touche [Z] (désactivable)
  • le joueur peut sauter grâce à la touche [A] (désactivable)
  • gestion des plate-formes mobiles

Configuration :

Au début du script vous trouverez le passage suivant :

    ###### SWITCHES/VARIABLES CONFIG ######
    $num_switch_run = 1 # switch that enables/disables running
    $num_switch_jump = 2 # switch that enables/disables jumping
    $num_switch_8dirs = 3 # switch that enables/disables 8-dirs movements
    $num_switch_void = 4 # switch triggered when falling
    $num_variable_x_secure = 1 # last x position before falling
    $num_variable_y_secure = 2 # last y position before falling
    $num_terrain_void = 1 # terrain tag number for void
    ###### END CONFIG ######

Ces lignes correspondent respectivement à :

  • numéro d’interrupteur pour activer/désactiver la possibilité de courrir pour le joueur
  • numéro d’interrupteur pour activer/désactiver la possibilité d’effectuer des sauts pour le joueur
  • numéro d’interrupteur pour activer/désactiver les déplacements dans les huit directions
  • numéro de variable stockant la composante horizontale de la dernière position sûre du joueur, avant une chute dans le vide
  • numéro de variable stockant la composante verticale de la dernière position sûre du joueur, avant une chute dans le vide
  • numéro de terrain pour indiquer les carreaux correspondant au vide

Tout cela est très rigolo, mais comment créer des plates-formes ?

Une plate-forme mobile est un évènement dont le nom contient [PF]. La case Through doit être cochée. Toutes ses caractéristiques seront spécifiées dons la commande Move route.
Dans la démo vous pourrez trouver de nombreux exemples et vous en inspirer.

Itinéraire : grâce aux commandes Move down, Move left, Move right, Move up et leurs quatre équivalents pour les diagonales, vous définissez l’itinéraire de la plate-forme. Une fois que celle-ci a terminé son parcours, elle retourne à sa position d’origine.

Vitesse : utilisez la commande Script… et écrivez Speed x, où x représente un entier, sachant que 1 est la vitesse la plus lente.

Attente : grâce aux commandes Wait…, vous pouvez précisez un temps d’attente (en frames) de la plate-forme entre deux déplacements.

Activation : par défaut les plates-formes sont toujours activées : elles répètent inlassablement leurs mouvements. Vous pouvez cependant jouer sur le panneau Conditions afin de n’activer une plate-forme que lorque certains interrupteurs ou varibles respectent certaines conditions.
En utilisant les options de déclenchement du panneau Trigger, vous pouvez par exemple ne déclencher une plate-forme que si le joueur marche dessus : il suffit d’activer un interrupteur qui correspond à une condition d’activation du panneau Conditions en ayant choisi Event Touch dans le panneau Trigger.

Modes de déplacement : des modes de déplacements permettent la désactivation automatique des plates-formes afin qu’elles ne soient pas toujours en mouvement.

  • Si vous utilisez la commande Script… et écrivez 1-Move, une plate-forme se désactivera automatiquement à la fin de son déplacement dans une direction donnée.
  • Si vous utilisez la commande Script… et écrivez 1-Journey, une plate-forme se désactivera automatiquement quand elle rencontrera la commande Destination (toujours avec Script…).
  • Si vous utilisez la commande Script… et écrivez Loop, une plate-forme se désactivera automatiquement une fois revenue à son point de départ.

Autres :

  • Si vous utilisez la commande Script… et écrivez Above, le joueur ignorera le contact avec les autres évènements tant qu’il sera sur la plate-forme.
  • Si vous utilisez la commande Script… et écrivez Stand, cela signifie que la plate-forme est immobile. Il ne s’agit pas d’une position sûre et le joueur ne réapparaîtra pas sur la plate-forme s’il tombe dans le vide.
  • En ajoutant [Deco] dans le nom de la plate-forme, la joueur la traversera et tombera. Cette option est utilisée pour créer des parties inférieures de plates-formes.
  • Si vous utilisez la commande Script… et écrivez Fall, la plate-forme tombera une fois arrivée à destination (et ne reviendra donc pas à son point de départ).
  • Si vous utilisez la commande Script… et écrivez Appear, la plate-forme est invisible et immatérielle tant qu’elle n’est pas active.

Télécharger la démo contenant le script