 FunLabyrinthe

FunLabyrinthe

Bienvenue dans FunLabyrinthe, un jeu dans lequel vous évoluerez dans de nombreux labyrinthes de tous genres. Non seulement vous rencontrerez de l'herbe et des murs, mais bien des obstacles vous barreront la route, tandis que des objets vous aideront dans votre quête.

Dans FunLabyrinthe, vous pouvez bien sûr jouer aux labyrinthes fournis avec le jeu. Mais vous pouvez également créer vos propres labyrinthes, grâce à l'éditeur de labyrinthes. Des personnalisations à l'infini sont possibles ! Créez les labyrinthes les plus difficiles et défiez vos amis !

  • FunLabyrinthe
    • Comment jouer
      • Quelques cases classiques
    • Créer ses propres labyrinthes
      • Utilisation de base de FunLabyEdit
        • Créer un nouveau labyrinthe
        • Ajouter une carte
        • Éditer la carte
        • Les 4 composantes d'une case
        • Barques, téléporteurs, et autres composants supplémentaires
        • L'inspecteur d'objets
      • Concepts de FunLabyrinthe
        • Grandes classes de composants
      • Créer des cases simples avec les SimpleSquares
        • Créer le fichier SimpleSquares et l'associer au labyrinthe
        • Créer un bouton ou autre effet
        • Créer un objet simple
        • Créer un obstacle simple
      • Aspects avancés avec le langage FunDelphi
        • Créer un source FunDelphi
        • Première approche : un terrain très simple
        • Événements et instructions
        • Objets et actions
        • Conditions avec if
        • Héritage et sous-classes
        • Plugins pour le joueur
      • Commandes classiques de l'interface
      • Maintenir des labyrinthes de la version 4.x
      • Experts : le nec plus ultra avec Delphi
  • Résultat
Consulter cette rubrique sur internet
À suivre... Comment jouer

Voir aussi

Aller à la page
(C) 2000-2011 Sébastien Doeraene


Comment jouer

Vous êtes ici : FunLabyrinthe

Sommaire

  • Démarrer un labyrinthe
  • Où suis-je ?
  • Se déplacer dans le labyrinthe
  • Messages
  • But du jeu
  • Et après ?

Démarrer un labyrinthe

Avant tout, il est nécessaire de choisir un labyrinthe. Utilisez le menu Fichier|Nouvelle partie, qui vous listera tous les labyrinthes disponibles. Choisissez celui qui vous intéresse. Le labyrinthe démarre !

La façon la plus simple et la plus directe d'apprendre à jouer est de lancer le labyrinthe Didacticiel. D'ailleurs, la première fois que vous lancez FunLabyrinthe, il vous propose tout seul de lancer ce labyrinthe.

Où suis-je ?

Dans la majorité des labyrinthes, vous êtes le pion bleu Exemple de message. Mais il peut arriver que vous changiez de couleur, ou ayez une toute autre apparence. Vous pouvez même devenir invisible !

Se déplacer dans le labyrinthe

En règle générale, on se déplace avec les touches directionnelles dans le labyrinthe (Haut, Bas, Gauche et Droite). Vous pouvez vous déplacer sur l'herbe, mais pas sur les murs.

Il existe beaucoup de cases différentes. Découvrez-lez dans la rubrique Quelques cases classiques.

Messages

Il arrivera régulièrement que des messages vous apparaissent, comme celui-ci :

Exemple de message

Pour afficher la suite du message, ou pour le terminer, appuyez sur la flèche du bas, ou sur Enter.

Certains messages vous demandent de sélectionner une réponse parmi plusieurs choix. Utilisez alors les flèches directionnelles pour choisir votre réponse, puis appuyez sur Enter.

But du jeu

Et le but du jeu, dans tout ça ? Eh bien, il varie d'un labyrinthe à l'autre. Mais comme expliqué dans la descriptions des cases classiques, il y a deux victoires habituelles : sortir du labyrinthe, ou trouver le trésor.

Et après ?

Il existe bien d'autres choses dans FunLabyrinthe. D'autres cases, d'autres modes de fonctionnement. Certains labyrinthes vous suprendront certainement. Mais lorsque des cases spéciales ou des fonctionnement étranges seront présents dans certains labyrinthes, des explications seront souvent données au sein de ceux-ci.

Bonne chance, et bon amusement !

Consulter cette rubrique sur internet
À suivre... Quelques cases classiques

Voir aussi

Aller à la page
(C) 2000-2011 Sébastien Doeraene


Quelques cases classiques

Vous êtes ici : FunLabyrinthe > Comment jouer

Sommaire

  • Terrains
  • Effets
  • Obstacles
  • Outils

De nombreux types de case existent, et les auteurs de labyrinthes peuvent en créer autant qu'ils veulent. Il est donc impossible de lister tous les types de case, mais voici les principales.

Outre l'herbe et les murs, un certain nombre de cases existent de base, et fonctionnent souvent de la même façon quel que soit le labyrinthe. On peut les regrouper en 4 catégories : terrains, effets, outils et obstacles.

Terrains

Les terrains sont partout. Chaque case a au moins son type de terrain. Généralement, les terrains vous empêchent d'aller dessus, à moins d'avoir un objet ou autre artifice donné. Vous connaissez déjà l'herbe et le mur. En voici quelques autres.

Herbe Herbe : vous pouvez en principe toujours aller sur l'herbe.

Mur Mur : vous ne pouvez jamais aller sur les mur.

Eau Eau : à moins d'avoir une bouée, ou tout autre moyen d'aller sur l'eau, vous ne pourrez pas vous déplacer sur l'eau.

Trou Trou : impossible de sauter dans ce trou d'une profondeur inconnue. Mais peut-être parviendrez-vous à passer au-dessus, avec une planche par exemple.

Dehors Dehors : on trouve cette case à l'extérieur de certains labyrinthes. Si vous parvenez à sortir du labyrinthe, vous gagnez.

Effets

Certains cases ont aussi ce qu'on appelle un effet. Les effets réagissent lorsqu'on tombe dessus. Voici quelques exemples :

Flèche nord Flèche nord : elle vous repousse systématiquement vers le nord, et vous ne pouvez rien y faire. Il s'agit donc, en quelque sorte, d'un sens unique. Il existe aussi des flèches dans les autres directions, bien entendu.

Carrefour Carrefour : comme son nom ne l'indique pas, vous ne pouvez pas changer de direction sur un carrefour. Plus exactement, il vous force à continuer dans la direction où vous alliez. Donc, vous le traversez toujours sans pouvoir tourner.

Escalier montant Escalier descendant Escalier : les escaliers vous permettent de monter et de descendre d'un étage.

Ascenseur Ascenseur : il permet de monter et descendre un à plusieurs étages à la fois. Il demande à chaque fois à quel étage on veut se rendre.

Tourniquet direct Tourniquet indirect Tourniquet : le tourniquet est une bête curieuse. Comme la flèche, il vous repousse, mais la direction dépend d'où vous venez. Si vous venez d'en bas, le tourniquet bleu (direct) vous envoie à droite, et le tourniquet orange (indirect) vous envoie à gauche. Il faut en fait regarder le sens de la flèche qui se trouve du côté d'où vous venez. Attention : après l'avoir utilisé, le tourniquet change de couleur, et donc de sens !

Trésor Trésor : le but ultime de beaucoup de labyrinthes. Si vous trouvez le trésor, vous gagnez !

Obstacles

Les obstacles bloquent votre route, ou cachent de nouvelles surprises en-dessous d'eux. Il faut parvenir à s'en débarrasser. Certains obstacles peuvent être détruits avec un objet, d'autres de différentes manières.

Bloc en argent Bloc en argent : il peut être détruit avec une clef d'argent.

Bloc en or Bloc en or : semblable au bloc en argent, mais se détruit avec une clef en or.

Mur Passage secret : en tout point identique au mur, le passage secret se désintègre pourtant rien qu'en poussant dessus. Ne cherchez pas trop les passages secrets dans tous les labyrinthes : généralement, un indice quelconque vous permettra de deviner qu'il y en a.

Outils

Pour vous aider dans votre tâche, vous trouverez plusieurs sortes d'outils dans le labyrinthe. Souvent, lorsque vous trouvez un outil, il disparaît, et vous l'emportez avec vous comme un objet.

Bouée Bouée : elle vous permet, une fois que vous l'avez trouvée, d'aller dans l'eau, autant de fois que vous voulez.

Planche Planche : elle vous permet de franchir certains terrains, comme l'eau ou les trous, pourvu qu'il n'y ait qu'une seule case à franchir.

Clef d'argent Clef d'or Clefs d'argent et d'or : elles ouvrent des blocs (ou autres verrous) de même couleur. Mais attention : chaque clef ne sert qu'une seule fois !

Consulter cette rubrique sur internet
À suivre... Créer ses propres labyrinthes

Voir aussi

Aller à la page
(C) 2000-2011 Sébastien Doeraene


Créer ses propres labyrinthes

Vous êtes ici : FunLabyrinthe

Le grand intérêt de FunLabyrinthe est qu'il vous est possible de créer vos propres labyrinthes. Il est même possible de créer ses propres types de case.

C'est généralement en créant ses propres labyrinthes, et en défiant ses amis de les résoudre, qu'on s'amuse le plus avec FunLabyrinthe.

À cet effet, vous utiliserez l'éditeur de labyrinthe, qui apparaît comme ceci :

Fig. 1 Éditeur de labyrinthes

  • Utilisation de base de FunLabyEdit
    • Créer un nouveau labyrinthe
    • Ajouter une carte
    • Éditer la carte
    • Les 4 composantes d'une case
    • Barques, téléporteurs, et autres composants supplémentaires
    • L'inspecteur d'objets
  • Concepts de FunLabyrinthe
    • Grandes classes de composants
  • Créer des cases simples avec les SimpleSquares
    • Créer le fichier SimpleSquares et l'associer au labyrinthe
    • Créer un bouton ou autre effet
      • Modifier une case d'une carte
      • Activer/désactiver un effet
      • Afficher un message au joueur
      • Déplacer le joueur
      • Changer la couleur du pion du joueur
      • Faire gagner ou perdre le joueur
      • Rendre visible ou invisible le joueur
      • Temporiser
      • Modifier la direction du joueur
      • Continuer le déplacement
    • Créer un objet simple
    • Créer un obstacle simple
  • Aspects avancés avec le langage FunDelphi
    • Créer un source FunDelphi
    • Première approche : un terrain très simple
    • Événements et instructions
    • Objets et actions
    • Conditions avec if
    • Héritage et sous-classes
    • Plugins pour le joueur
  • Commandes classiques de l'interface
  • Maintenir des labyrinthes de la version 4.x
  • Experts : le nec plus ultra avec Delphi
Consulter cette rubrique sur internet
À suivre... Utilisation de base de FunLabyEdit

Voir aussi

Aller à la page
(C) 2000-2011 Sébastien Doeraene


Utilisation de base de FunLabyEdit

Vous êtes ici : FunLabyrinthe > Créer ses propres labyrinthes

L'utilisation de base de FunLabyEdit consiste à créer des labyrinthes, sans créer ses propres types de case. Tant que l'on reste dans cette optique, l'éditeur de labyrinthes est très simple à utiliser, et quasi exclusivement visuel.

Vous pouvez presque consulter les pages de cette rubrique comme un tutoriel, dans l'ordre.

  • Créer un nouveau labyrinthe
  • Ajouter une carte
  • Éditer la carte
  • Les 4 composantes d'une case
  • Barques, téléporteurs, et autres composants supplémentaires
  • L'inspecteur d'objets
Consulter cette rubrique sur internet
À suivre... Créer un nouveau labyrinthe


Créer un nouveau labyrinthe

Vous êtes ici : FunLabyrinthe > Créer ses propres labyrinthes > Utilisation de base de FunLabyEdit

La première étape est de démarrer un nouveau labyrinthe. Pour ce faire, utilisez le menu Fichier|Nouveau, ou cliquez sur l'icône [image] dans la barre de menus. Une boîte de dialogue apparaît, vous permettant d'indiquer le titre, la description, le genre de labyrinthe, la difficulté et l'auteur du labyrinthe (vous).

Créer un nouveau projet

Tâchez de choisir un bon titre pour votre labyrinthe, car il est utilisé comme base pour le nom de fichier dans lequel il sera enregistré. Néanmoins, si vous changez d'avis plus tard, pas de panique. Vous pourrez toujours modifier le titre (et d'autres propriétés) plus tard avec le menu Fichier|Propriétés.

Une fois validé, votre labyrinthe est créé et ouvert dans l'éditeur. D'emblée, le logiciel vous invite à ajouter une carte à votre labyrinthe : la carte principale.

Consulter cette rubrique sur internet
À suivre... Ajouter une carte

Voir aussi

Aller à la page
(C) 2000-2011 Sébastien Doeraene


Ajouter une carte

Vous êtes ici : FunLabyrinthe > Créer ses propres labyrinthes > Utilisation de base de FunLabyEdit

Sommaire

  • Les différents contrôles de la fenêtre
  • _1 - Vue miniature de la carte
  • _2 - Sélection, ajout et suppression d'étage
  • _3 - Agrandir et rétrécir la carte
  • _4 - Zoom
  • _5 - ID de la carte
  • _6 - Taille de zone
  • _7 - Pré-remplissage des zones
  • _8 - Modifier l'extérieur du labyrinthe

Dans FunLabyrinthe, chaque labyrinthe peut être composé de plusieurs cartes (map dans le jargon). La majorité des labyrinthes n'ont qu'une seule carte. Lorsque vous créez un nouveau labyrinthe, l'éditeur crée directement une carte. Pour en ajouter une supplémentaire plus tard, utilisez le menu Cartes|Ajouter.

Lorsque vous ajoutez une carte au labyrinthe, une boîte de dialogue apparaît afin de sélectionner ses dimensions, et de la préremplir avec les terrains de votre choix.

Fig. 2 Boîte de dialogue Ajouter une carte

Cette boîte de dialogue est une des plus complexes de l'éditeur, et vous y êtes confrontés dès le départ. Toutefois, une fois que l'on a appris à s'en servir, elle est vraiment très puissante.

Après avoir configuré votre carte comme vous l'entendez, cliquez sur OK pour créer effectivement la carte. Vous pourrez alors éditer cette carte case par case.

Les différents contrôles de la fenêtre

1 - Vue miniature de la carte

L'image que vous voyez est une représentation miniature de la carte que vous êtes en train de créer. Bien entendu, vous ne pouvez observer qu'un seul étage à la fois, et chaque étage peut être différent.

Si la carte devient trop grande, les barres de défilement vous permettront de voir tout son contenu.

2 - Sélection, ajout et suppression d'étage

Avec les flèches haut et bas (grises) accollées à la boîte d'édition, vous pouvez changer d'étage. Au départ, il n'y a qu'un étage : pas étonnant donc que ne puissiez pas changer la valeur !

Les boutons [image] et [image] vous permettent d'ajouter un étage respectivement tout en haut du labyrinthe et tout en bas. Si vous appuyez 2 fois sur le premier, vous aurez donc 3 étages en tout.

Leurs équivalents rouges [image] et [image] permettent de retirer un étage, respectivement tout en haut et tout en bas.

3 - Agrandir et rétrécir la carte

Les boutons similaires qui se trouvent des quatre côtés de la carte permettent, quant à eux, d'agrandir et de rétrécir la carte en hauteur et en largeur.

Notez que l'agrandissement et le rétrécissement se font toujours par zone. Les zones sont dessinées avec un quadrillage noir. Plus d'infos au point 6 - Taille de zone.

4 - Zoom

Cette track-bar vous permet de modifier le zoom appliqué à la carte. Les zooms possibles vont de 10 % à 100 % par incrément de 10 %. Par défaut, la carte est affichée avec un zoom de 40 %.

5 - ID de la carte

Dans FunLabyrinthe, toute chose - qu'on appelle composant - a un ID (prononcez idé), c'est-à-dire un identificateur. Au sein d'un labyrinthe chaque composant doit avoir son ID propre, différent de celui de tous les autres. Les cartes sont un des nombreux types de composants, et doivent donc avoir un ID.

Ce champ vous permet donc de choisir l'ID de la carte. La règle de style veut que tous les ID de carte se terminent par "Map" (qui veut dire "carte" en anglais). Votre première carte a par défaut l'ID MainMap, ce qui signifie "carte principale". Vous pourrez généralement garder cet ID par défaut, car vous n'aurez que rarement besoin de plusieurs cartes.

6 - Taille de zone

Non seulement le labyrinthe a une taille (son étendue), mais il a aussi une taille de zone. Les zones sont représentées en édition par un quadrillage noir. En mode jeu, leur influence se manifeste sur ce que voit le joueur. Il voit toujours la zone dans laquelle il se trouve, augmentée de une case tout autour.

Par défaut, les zones font 7x7 cases, une taille de zone qui a fait ses preuves au niveau stratégique.

7 - Pré-remplissage des zones

Les numéros 7 et 8 ne sont pas essentiels, mais contribuent au confort de création des labyrinthes.

Ainsi, vous pouvez pré-remplir des zones avec un motif de terrains de votre choix. Commencez par sélectionner les zones sur lesquelles appliquer le remplissage en cliquant dans la zone numéro 1. Vous pouvez sélectionner des zones supplémentaires en maintenant la touche Ctrl enfoncée. La touche Shift vous permettra aussi de sélectionner un ensemble contigü de zones. Les zones sélectionnées sont entourées de jaune.

Il y a trois types de motifs :

  • Terrain : le terrain placé sur toutes les cases des zones sélectionnées, sauf contre-ordre par les indications suivantes ;
  • Quadrillage : terrain placé une case sur deux, dans les sens horizontal et vertical, sauf contre-ordre par la troisième option ;
  • Ceinture : terrain placé sur le pourtour des zones sélectionnées, en suivant la ligne jaune dessinée par la sélection.

    • Une fois vos options choisies, cliquez sur le bouton "Remplir les zones sélectionnées" pour les appliquer. N'oubliez pas que les modifications s'appliquent uniquement à l'étage actuellement visible.

    Il n'est pas facile de décrire l'effet exact que vous obtiendrez. Le mieux étant de tester par vous-mêmes différentes combinaisons.

    8 - Modifier l'extérieur du labyrinthe

    Cette boîte liste vous permet de choisir le terrain qui se trouve à l'extérieur du labyrinthe, à l'égage actuellement visible. À nouveau, vous en comprendrez vite l'effet après l'avoir testé.

    Consulter cette rubrique sur internet
    À suivre... Éditer la carte

    Voir aussi

    Aller à la page
    (C) 2000-2011 Sébastien Doeraene


Éditer la carte

Vous êtes ici : FunLabyrinthe > Créer ses propres labyrinthes > Utilisation de base de FunLabyEdit

L'éditeur de FunLabyrinthe 5.0 peut faire un nombre incalculable de choses, mais le plus important, c'est de pouvoir éditer la ou les carte-s de votre labyrinthe. Lorsque vous avez ouvert un labyrinthe dans l'éditeur, il ressemble à ceci :

Cette fenêtre contient trois zones importantes : la carte au milieu, la palette des composants à gauche, et l'inspecteur d'objets à droite. Seuls les deux premiers nous intéressent pour l'instant.

La palette des composants vous montre tous les composants utiles pendant l'édition de votre labyrinthe. En premier, vous trouvez le joueur, suivi des catégories Terrains, Effets, Outils et Obstacles, qui sont les quatre composantes des cases.

Pour éditer un labyrinthe, il est très important de bien comprendre les quatre composantes des cases.

1

La catégorie suivante contient les "neutres". Ce sont des composantes de case comme les autres mais qui ne font rien. De base, vous trouverez le bouton enfoncé et le téléporteur inactif. Ce sont donc juste des décorations.

En-dessous, vous trouverez d'autres catégories qui seront détaillées ailleurs.

Pour modifier une case de la carte, sélectionnez d'abord le composant que vous voulez y placer. Puis, cliquez sur la carte à l'endroit de votre choix. Vous pouvez placer plusieurs fois le même composant sur la carte sans devoir le resélectionner à chaque fois dans la palette. Lorsque vous placez un composant, tous les composants au-dessus de celui-ci sont effacés avant. Par exemple, si vous placez un effet, l'outil et l'obstacle sont supprimés ; mais si vous placez un obstacle, l'effet et l'outil restent intacts.

Pour placer un outil, vérifiez bien que vous avez sélectionné celui sous la rubrique "Outils", et non celui sous la rubrique "Objets". Ce dernier ne se placera jamais sur le labyrinthe.

1

Pour placer le joueur, sélectionnez-le comme si vous choisissiez n'importe quel type de case. Il est cependant placé au-dessus de toutes les composantes de la case.

C'est aussi simple que ça.

Pour tester votre labyrinthe, appuyez sur F9. N'oubliez pas d'enregistrer régulièrement votre travail.

Consulter cette rubrique sur internet
À suivre... Les 4 composantes d'une case

Voir aussi

Aller à la page
(C) 2000-2011 Sébastien Doeraene


Les 4 composantes d'une case

Vous êtes ici : FunLabyrinthe > Créer ses propres labyrinthes > Utilisation de base de FunLabyEdit

Sommaire

  • Terrain
  • Effet
  • Outil
  • Obstacle

Chaque case de FunLabyrinthe est constituée de 4 composantes. Ces composantes sont, dans l'ordre : le terrain, l'effet, l'outil et l'obstacle. Chacune de ces composantes répond à certains types d'interactions avec le joueur. Cette section détaille le but et le sens de chaque composante.

Toute case a au moins un terrain. Les trois autres composantes, en revanche, sont optionnelles.

Terrain

Le terrain est la composante primaire de la case. Il se dessine en premier, et donc en-dessous des trois autres composantes. Un terrain reste généralement en place, et autorise ou non le joueur à venir dessus.

Ainsi, l'herbe autorise toujours le joueur à venir dessus ; le mur ne l'y autorise jamais ; et l'eau l'y autorise lorsqu'il a une bouée ou une barque.

Le terrain peut répondre à 4 types d'événements :

  • Le joueur tente d'entrer sur la case ;
  • Le joueur tente de sortir de la case ;
  • Le joueur est entré sur la case ;
  • Le joueur est sorti de la case.

    • Effet

    Les effets sont généralement des composants qui agissent lorsque le joueur exécute la case, ce qui survient lorsqu'il est arrivé dessus de manière naturelle (suite à l'appui sur une touche ou depuis une flèche, par exemple). Ils restent généralement en place (ne disparaissent donc pas).

    Les flèches, par exemple, forcent le joueur à continuer son déplacement dans la direction indiquée. Mais elles n'empêchent jamais le joueur de venir dessus, au contraire d'un terrain.

    Chaque effet peut répondre à 3 types d'événements :

  • Le joueur est entré sur la case ;
  • Le joueur est sorti de la case ;
  • Le joueur exécute la case.

    • De ces trois événements, le troisième est de loin le plus important.

    Outil

    Les outils, comme les effets, sont activés lorsque le joueur exécute la case. Cependant, contrairement aux effets, ils disparaissent en général de la carte lorsqu'ils sont activés. Souvent, le joueur reçoit un objet correspondant.

    Par exemple, l'outil bouée disparaît lorsque le joueur tombe dessus. Mais le joueur gagne un objet bouée, et un message le lui signale.

    Un outil peut répondre à un seul type d'événement, à savoir que le joueur exécute la case. S'il y a à la fois un effet et un outil sur une case, le joueur trouve l'outil avant d'exécuter l'effet.

    Obstacle

    Les obstacles, comme les terrains, peuvent empêcher le joueur de venir dessus. Cependant, leur vocation est d'être détruits à un moment ou à un autre, au contraire des terrains qui restent en place. Souvent, il faut que le joueur puisse faire une action donnée.

    Les blocs en argent et or sont l'exemple typique d'un obstacle. Lorsque le joueur a une clef, il peut détruire le bloc et ensuite passer son chemin.

    Les obstacles ne peuvent répondre qu'à un seul type d'événement, celui indiquant que le joueur pousse sur la case.

    Consulter cette rubrique sur internet
    À suivre... Barques, téléporteurs, et autres composants supplémentaires

    Voir aussi

    Aller à la page
    (C) 2000-2011 Sébastien Doeraene


Barques, téléporteurs, et autres composants supplémentaires

Vous êtes ici : FunLabyrinthe > Créer ses propres labyrinthes > Utilisation de base de FunLabyEdit

Sommaire

  • Créer une nouvelle barque
  • Créer un nouveau téléporteur
  • Autres composants supplémentaires

La palette des composants contient certains boutons munis d'une icône [image]. En cliquant dessus, vous créez un nouveau composant dont le type dépend du bouton sur lequel vous avez cliqué.

Créer une nouvelle barque

Si vous cliquez sur l'icône de la barque, par exemple, vous pourrez créer une nouvelle barque. Un nouveau bouton apparaît dans la palette des composants, sous l'onglet Barques. Vous pouvez alors placer cette barque où vous voulez. Notez que la barque est similaire au joueur, dans le sens où vous pouvez la placer à un seul endroit. Si vous la placez à un second endroit, elle disparaîtra du premier endroit.

C'est pour cela qu'il est possible de créer plusieurs barques.

Créer un nouveau téléporteur

Les téléporteurs aussi peuvent être créés avec un créateur de composants. Vous pouvez placer plusieurs fois le même téléporteur à des endroits différents : ceux-ci seront alors "connectés" dans leur circuit de téléportation.

En termes plus simples : lorsqu'un joueur arrive sur un téléporteur, il est envoyé à un autre téléporteur de même type que celui sur lequel il est arrivé. Quand il y a plus de deux téléporteurs de ce type, le sens est déterminé dans le sens "suivant", c'est-à-dire que le téléporteur destination est recherché étage par étage de bas en haut, ligne par ligne de haut en bas, à partir du téléporteur source.

Il est possible de changer ce comportement par défaut avec l'inspecteur d'objets.

Autres composants supplémentaires

Selon les unités utilisées par votre projet de labyrinthe, d'autres créateurs de composants peuvent apparaître. Référez-vous à la documentation de ces unités.

Consulter cette rubrique sur internet
À suivre... L'inspecteur d'objets

Voir aussi

Aller à la page
(C) 2000-2011 Sébastien Doeraene


L'inspecteur d'objets

Vous êtes ici : FunLabyrinthe > Créer ses propres labyrinthes > Utilisation de base de FunLabyEdit

Sommaire

  • Propriétés dépendantes du joueur
  • Propriétés du joueur lui-même

L'inspecteur d'objets est la colonne de droite de l'éditeur de labyrinthes. Grâce à celui-ci, vous pourrez personnaliser et configurer de nombreux aspects de votre labyrinthe.

L'inspecteur d'objets affiche toujours les propriétés du composant sélectionné dans la palette des composants. Par exemple, si vous sélectionnez le passe secret, l'inspecteur ressemblera à ceci :

La colonne de gauche donne les noms des propriétés du passe secret. Celle de droite les valeurs de ces propriétés. Vous pouvez modifier les valeurs en accord avec leur "type" (nombre, texte, etc.). Vous ne pouvez pas modifier l'ID du passage secret : il est juste là à titre indicatif. Par contre, vous pouvez modifier l'ID des composants que vous avez créés en plus, comme les barques et les téléporteurs.

Tous les composants visuels (dont tous les composants de case) ont au minimum les 5 propriétés qu'a le passage secret. Voici leur description :

  • EditVisualTag : texte très court affiché sur le dessin du composant, mais uniquement pendant l'édition (pas pendant le jeu). Très pratique pour numéroter des barques ou des téléporteurs (ce qui est d'ailleurs fait par défaut), ou pour, comme le passage secret, marquer en édition un composant qui est comme invisible dans le jeu.
  • ID : l'ID du composant (modifiable seulement pour les composants créés en plus de ceux par défaut).
  • Name : le nom du composant. C'est une sorte de description très brève du composant. Le nom apparaît dans les petites bulles d'aide par exemple.
  • Painter : le peintre du composant, son image. En cliquant sur le bouton [image], une boîte de dialogue apparaîtra, vous permettant de modifier l'image du composant sélectionné.
  • Tag : un nombre entier quelconque. Il n'a pas de but prédéfini. Si vous programmez des cases spéciales, vous pouvez utiliser cette valeur comme vous l'entendez.

    • D'autres composants ont de nombreuses propriétés différentes.

    Propriétés dépendantes du joueur

    Certains composants ont des propriétés qui dépendent du joueur. Par exemple, si vous sélectionnez un objet (et non un outil) dans la palette, l'inspecteur d'objets montrera le nombre de cet objet que le joueur possède (0 par défaut). Cela vous permet, par exemple, de donner une bouée au joueur dès le début de la partie :

    Notez également les propriétés DisplayInObjectList et DisplayInStatusBar qui, si elles valent False au lieu de True, empêchent l'objet d'apparaître respectivement dans la liste d'objets du joueur et dans la barre de statut de FunLabyrinthe. Ces propriétés existent pour tous les objets.

    Cette séparation des propriétés dépendantes du joueur est une prévision faite pour la version 6.0, qui devrait proposer du multi-joueurs.

    Propriétés du joueur lui-même

    Le joueur est sans doute le composant le plus important, et il a de nombreuses propriétés. En plus de ses propriétés, il a des attributs et des plugins.

    Les propriétés spécifiques au joueur sont les suivantes :

  • Color : couleur du joueur. Actuellement affichée en valeurs hexadécimales. Vous pouvez la modifier en cliquant sur les [image]. Vous pouvez aussi spécifier la valeur Alpha, c'est-à-dire le niveau de transparence. 0 veut dire tout à fait transparent, et 255 veut dire tout à fait opaque.
  • DefaultTemporization : temporisation par défaut. C'est le temps, en millisecondes, que FunLabyrinthe attend entre le moment où le joueur arrive sur une flèche, et où la flèche le repousse.
  • Direction : direction initiale du joueur.
  • DrawMode : spécifie le mode d'affichage du joueur. Avec dmColoredPainter, dessine le peintre coloré selon la couleur Color. Avec dmPainter, dessine le joueur en respectant son peintre Painter. Avec dmDirPainters, choisit l'un des NorthPainter, EastPainter, SouthPainter et WestPainter en fonction de la direction courante du joueur.
  • ViewBorderSize : taille de la bordure de la vue. C'est le nombre de cases que voit le joueur en plus de la zone où il se trouve.

    • Les attributs dépendent des unités utilisées par le labyrinthe. Par défaut, il n'y en a pas. Mais dans cet exemple, l'attribut ViewRestrictionRadius est le rayon du cercle que peut voir le joueur (tout autour il y a du noir). C'est lié au plugin ViewRestrictionPlugin.

    Enfin, en dessous, vous pouvez sélectionnez quels plugins sont attachés au joueur au démarrage du labyrinthe. False indique qu'il n'est pas attaché, True indique qu'il l'est. Ici, le plug-in CatacombesViewRestrictionPlugin est attaché au joueur.

    Consulter cette rubrique sur internet
    À suivre... Concepts de FunLabyrinthe

    Voir aussi

    Aller à la page
    (C) 2000-2011 Sébastien Doeraene


Concepts de FunLabyrinthe

Vous êtes ici : FunLabyrinthe > Créer ses propres labyrinthes

Sommaire

  • Maître et composants
  • Actions
  • Les différentes classes de composants
  • Plugins du joueur
  • Mode du joueur
  • Timers

Afin d'aller plus loin dans la création de labyrinthes, et notamment pour créer ses propres cases et ses propres effets, il est nécessaire de comprendre les concepts essentiels qui régissent FunLabyrinthe.

Maître et composants

FunLabyrinthe est organisé en une série de composants de tous genres. En général, toute "chose" qui a une existence dans FunLabyrinthe est un composant. Le joueur, l'herbe, une carte, un objet, sont autant d'exemples de composants.

Tous les composants d'un labyrinthe sont reliés à un maître. Le maître (master) est l'autorité suprême dans FunLabyrinthe. Il connaît tous ses composants, et tous ses composants le connaissent. Afin de pouvoir reconnaître un composant d'un autre, chaque composant a un ID (prononcez idé), c'est-à-dire un identifiant.

Les ID de composants respectent un format particulier : ils sont constitués uniquement de lettres non accentuées et de chiffres, et doivent commencer par une lettre. Des exemples valides sont "ComponentID", "Ciph3r" ou "CeTiDbizarre". Des exemples invalides sont "Bonjour monsieur", "123" ou "Erroné", respectivement à cause de l'espace, du chiffre au début et de l'accent sur le e.

Certains composants sont "visuels", c'est-à-dire qu'ils peuvent être dessinés à l'écran. Le joueur et les composantes de cases sont des composants visuels. D'autres sont non visuels, comme les plugins attachés aux joueurs (cfr. infra).

Actions

Certaines cases doivent tester si le joueur est capable de faire une chose ou l'autre. Par exemple, l'eau doit tester s'il est capable d'aller sur l'eau. Les blocs doivent tester s'il est capable d'ouvrir une serrure de la couleur appropriée. Ces phénomènes sont connus sous le terme d'actions.

En lui-même, le joueur ne sait pas faire d'actions. Mais les objets qu'il transporte, ou les plugins qui lui sont raccordés, peuvent l'aider à faire des actions. L'objet clef d'or, par exemple, permet au joueur d'effectuer l'action d'ouvrir une serrure en or, s'il a au moins une clef.

Les actions sont représentées par leur nom, qui suit les mêmes règles règles de format que les ID de composants (cfr. supra).

Il existe trois actions standard dans FunLabyrinthe :

  • OpenSilverLock : Ouvrir un verrou en argent (exemple : le bloc en argent)
  • OpenGoldenLock : Ouvrir un verrou en or (exemple : le bloc en or)
  • GoOnWater : Aller sur l'eau

    • En plus de ces trois actions standard, vous pouvez bien entendu créer les vôtres.

    Certaines actions acceptent un paramètre, un nombre entier qui précise leur signification. Mais ceci dépasse le cadre de cette section introductive.

    Les différentes classes de composants

    Il y a beaucoup de types de composants différents. On dit qu'il y a des classes de composants. Les classes ont des noms qui commencent par un T, et qui respectent aussi le même format que les ID de composants. Les composantes de case sont un exemple de classe de composant (TSquareComponent).

    Il y a des sous-classes d'autres classes ; tous les composants qui appartiennent à une sous-classe appartiennent aussi à la classe plus large. Ainsi, la classe des terrains (TField) est-elle une sous-classe de la classe des composantes de case. En effet, tous les terrains sont des composantes de case.

    Selon la classe d'un composant, l'inspecteur d'objets affichera une liste différente de propriétés. C'est ainsi que le joueur n'a pas la même liste de propriétés que le passage secret.

    Voir aussi la rubrique Grandes classes de composants.

    Plugins du joueur

    S'il est possible de créer de nombreuses cases supplémentaires, il n'est pas possible de créer de nouveaux joueurs. Comment alors ajouter des comportements supplémentaires au joueur, comme répondre à l'appui sur une touche du clavier ? C'est à cette problématique que répondent les plugins.

    Les plugins sont une des classes de composants (TPlugin). Le joueur retient une liste des plugins qui lui sont attachés. À chaque fois que le joueur doit effectuer une action (appuyer une touche, se déplacer, etc.), il demande à tous ses plugins s'ils prennent cette action en charge.

    Dans l'inspecteur d'objets, on peut choisir les plugins qui sont attachés au joueur dès le début du jeu. Il suffit de positionner à True la propriété dont le nom est l'ID d'un plugin pour que ce plugin soit rattaché au joueur.

    Parmi les choses que peuvent faire les plugins, on trouve :

  • Dessiner quelque chose en-dessous ou au-dessus du joueur (exemple : le plugin de la bouée dessine la bouée sous le joueur) ;
  • Dessiner sur la vue du joueur (exemple : le plugin d'affichage de message dessine le cadre du message sur la vue du joueur) ;
  • Réagir quand le joueur veut se déplacer d'une case à d'autre, ou s'est déplacé d'une case à une autre ;
  • Aider le joueur à réaliser une action, au même titre qu'un objet ;
  • Réagir lorsque le joueur appuie sur une touche du clavier.

    • En fait, les plugins peuvent modifier à peu près tous les comportements du joueur.

    Mode du joueur

    Si les plugins peuvent modifier tous les aspects du joueur, le mode est là pour donner une base de fonctionnement au joueur.

    Au contraire des plugins, le joueur ne peut avoir qu'un seul mode actif à la fois. Par défaut, le mode est TLabyrinthPlayerMode, c'est-à-dire le mode labyrinthe. Dans le mode labyrinthe, la vue du joueur est essentiellement déterminée par les cases de la zone courante. Et lorsque le joueur appuie sur une touche directionnelle, il se déplace.

    "Mais, si vous dites que le mode labyrinthe est par défaut, cela signifie-t-il que FunLabyrinthe peut ne plus être un labyrinthe, si on le remplace ?"

    Eh bien oui, c'est possible ! Si vous créez un autre mode et l'affectez au joueur, il est parfaitement possible que FunLabyrinthe ne ressemble plus du tout à un jeu de labyrinthe. Ceci n'est toutefois possible qu'avec des sources Delphi, et n'est pas une tâche simple, bien au contraire.

    Timers

    Les timers (prononcez taïmerz) sont des événements qui se déclenchent après un certain temps. Le maître retient une série de timers programmés. Lorsqu'ils arrivent à expiration, les événements sont déclenchés automatiquement.

    Les timers peuvent donc servir à programmer des événements qui réagissent à l'écoulement du temps.

    Consulter cette rubrique sur internet
    À suivre... Grandes classes de composants

    Voir aussi

    Aller à la page
    (C) 2000-2011 Sébastien Doeraene


Grandes classes de composants

Vous êtes ici : FunLabyrinthe > Créer ses propres labyrinthes > Concepts de FunLabyrinthe

Sommaire

  • le joueur
  • composants de case
  • les objets
  • les cartes
  • véhicules
  • composants autonomes

Cette section détaille les grandes classes de composants.

TPlayer : le joueur

La classe TPlayer contient le seul et unique composant qui représente le joueur (dont l'ID est Player). Le joueur est le composant le plus important de FunLabyrinthe, puisque tout tourne autour de lui. Après tout, si on fait un labyrinthe, c'est bien parce que quelqu'un va y jouer ;-)

Un joueur est un composant qui est autonome. Autonome du point de vue des autres composants, pas du point de vue du programme. En effet, il est en fait contrôlé par le joueur humain qui appuie sur des touches de son clavier. Les autres composants, comme les composants de case, ne sont pas autonomes : ils réagissent quand le joueur les sollicite.

En plus du mode et des plugins attachés au joueur, introduits dans les concepts généraux, le joueur a également une série d'attributs. Un attribut est comme une propriété supplémentaire, de type entier. Les différentes unités liées au labyrinthe peuvent ajouter les attributs qu'elles veulent au joueur. L'unité ViewRestriction.scu, par exemple, ajoute l'attribut ViewRestrictionRadius. Les attributs sont donc des données générales que l'ont peut ajouter au joueur.

Un joueur possède une vue. La vue du joueur est ce qui est effectivement affiché à l'écran quand on joue. Le mode du joueur détermine la vue de base, puis les plugins attachés au joueur peuvent ajouter leurs spécificités.

Lorsqu'une touche du clavier est appuyée, le joueur "envoie" cette information à tous ces plugins, jusqu'à ce que l'un d'entre eux signale qu'il a géré cette touche à son compte. Si aucun plugin ne prend la touche en compte, c'est le mode du joueur qui intervient.

Un joueur possède aussi des objets, du moins conceptuellement. Ses objets lui permettent d'effectuer certains actions. Lorsqu'une case demande au joueur d'effectuer une action donnée, celui-ci demande d'abord à tous ses plugins si l'un d'entre peut la prendre en charge. Dans le cas contraire, il demande à ses objets. Si plusieurs objets sont possibles, le joueur humain doit choisir l'un d'eux. Ainsi, s'il doit ouvrir un bloc en or, et qu'il a à disposition une clef d'or et un passe-partout, il peut choisir quelle clef il veut utiliser.

TSquareComponent : composants de case

La classe TSquareComponent englobe tous les composants qui entrent dans la confection d'une case, y compris la case elle-même. Les quatre sous-classes TField, TEffect, TTool et TObstacle regroupent les quatre composantes de case. La sous-classe TSquare englobe les cases elles-mêmes.

TObjectDef : les objets

TObjectDef est la classe des objets. Rappelez-vous qu'un objet est différent d'un outil, bien qu'il y ait une forte corrélation entre ces deux classes de composants.

Un objet a un nom, une image, et tient le compte du nombre qu'en possède le joueur. Il peut aider le joueur qui en possède à effectuer l'une ou l'autre action.

TMap : les cartes

TMap est la classe des cartes. Il n'y a pas grand chose à dire des cartes, si ce n'est que c'est elle qui sait quelle est la case à chacune des positions du jeu.

TVehicle : véhicules

La classe TVehicle regroupe les véhicules. Les barques en sont le seul exemple standard. Les véhicules, à l'instar du joueur, sont placés à un seul endroit maximum sur une des cartes. Ils peuvent modifier les conditions d'accès à la case où ils se trouvent.

Par exemple, la barque permet au joueur de venir dessus, malgré qu'il y a en fait de l'eau en-dessous.

Un véhicule peut être "accaparé" par le joueur. Il suit alors le joueur, se dessinant sous lui, jusqu'à ce qu'il soit détaché du joueur. Pendant qu'un véhicule est attaché à un joueur, il peut modifier ses mouvements comme le ferait un plugin.

TMobileComponent : composants autonomes

La classe TMobileComponent (dont TPlayer est une sous-classe) regroupe tous les composants autonomes, ceux qui peuvent agir d'eux-mêmes.

Consulter cette rubrique sur internet
À suivre... Créer des cases simples avec les SimpleSquares

Voir aussi

Aller à la page
(C) 2000-2011 Sébastien Doeraene


Créer des cases simples avec les SimpleSquares

Vous êtes ici : FunLabyrinthe > Créer ses propres labyrinthes

Il y a plusieurs niveaux de complexité dans la création de cases personnalisées. Créer des cases plus complexes est plus difficile, mais permet de faire des choses plus puissantes.

Cette section détaille la création de cases relativement simples, avec l'éditeur de cases nommé SimpleSquares.

  • Créer le fichier SimpleSquares et l'associer au labyrinthe
  • Créer un bouton ou autre effet
    • Modifier une case d'une carte
    • Activer/désactiver un effet
    • Afficher un message au joueur
    • Déplacer le joueur
    • Changer la couleur du pion du joueur
    • Faire gagner ou perdre le joueur
    • Rendre visible ou invisible le joueur
    • Temporiser
    • Modifier la direction du joueur
    • Continuer le déplacement
  • Créer un objet simple
  • Créer un obstacle simple
Consulter cette rubrique sur internet
À suivre... Créer le fichier SimpleSquares et l'associer au labyrinthe


Créer le fichier SimpleSquares et l'associer au labyrinthe

Vous êtes ici : FunLabyrinthe > Créer ses propres labyrinthes > Créer des cases simples avec les SimpleSquares

Sommaire

  • Créer le source SimpleSquares
  • Lier le source au labyrinthe
  • Recompiler et recharger

La première étape, lorsque vous voulez créer des SimpleSquares pour votre labyrinthe, est de créer le fichier SimpleSquares (extension .ssq) et de le lier à votre labyrinthe.

Créer le source SimpleSquares

Lorsque votre labyrinthe est ouvert, utilisez le menu Sources|Nouveau, qui vous amènera à la boîte de dialogue suivante :

Sélectionnez "Cases simples" puis validez. Les autres options correspondent aux autres niveaux de complexité disponibles. L'éditeur vous demande alors dès le départ de choisir un nom de fichier source.

La règle à suivre ici est que les fichiers sources spécifiques à un labyrinthe particulier soit placé dans un sous-dossier ad hoc. Par ailleurs, tous les noms de dossiers et de fichiers doivent respecter les règles de format des ID. C'est-à-dire uniquement des lettres non accentuées et des chiffres, et ne pas commencer par un chiffre.

Créez donc un nouveau dossier avec le bouton [image] et, si votre labyrinthe s'appelle "Mon très beau labyrinthe" par exemple, nommez-le "MonTresBeauLabyrinthe". À l'intérieur, indiquez comme nom de fichier "MonTresBeauLabyrinthe.ssq".

Vous vous retrouvez alors dans un nouvel onglet de l'éditeur, nommé "MonTresBeauLabyrinthe.ssq", qui ressemble à ceci.

Nouveau fichier source SimpleSquares
Nouveau fichier source SimpleSquares

Lier le source au labyrinthe

Maintenant que le source est créé, il faut le lier au labyrinthe. Ici, il est temps de faire la distinction entre un fichier source et une unité compilée. Les fichiers sources ont pour extension .ssq, .fnd ou .pas selon leur niveau de complexité. On dit que l'on compile un fichier source en une unité compilée, d'extension .scu.

Les fichiers sources peuvent être modifiés, mais ils sont inutilisables tels quels. À l'inverse, les unités compilées peuvent être liées au labyrinthe, mais ne peuvent pas être modiées. On produit les unités compilées à partir des fichiers sources (d'où le nom de fichier source, puisqu'ils sont la source d'une unité compilée).

Pour pouvoir lier l'unité compilée au labyrinthe, il faut donc qu'elle existe, ce qui n'est pas encore le cas. Cliquez donc sur le bouton [image] ou appuyez sur Ctrl+F9 pour compiler le source SimpleSquares (encore vierge). Maintenant, il existe un fichier MonTresBeauLabyrinthe.scu dans le dossier MonTresBeauLabyrinthe.

Pour le lier au labyrinthe utilisez le menu Fichier|Unités utilisées. La boîte de dialogue suivante apparaît.

Cliquez sur le bouton "Ajouter une unité", puis sélectionnez le fichier MonTresBeauLabyrinthe.scu dans le dossier MonTresBeauLabyrinthe. Ne touchez pas à la première ligne qui indique FunLabyBase.bpl : vous détruiriez votre labyrinthe (je pense à bloquer complètement cette ligne pour la version stable). Cette unité contient en effet les définitions de toutes les cases de base (herbe, murs, clefs, blocs, etc.). Après avoir ajouté votre unité, validez.

Le labyrinthe est alors enregistré et rechargé, avec l'unité SimpleSquares liée. Il ne reste plus qu'à créer vos cases.

Recompiler et recharger

Lorsque vous aurez créé les cases que vous désirez et les aurez configurées, elles n'apparaîtront pas encore dans la palette des composants de votre labyrinthe. Pour ce faire, il faut recompiler le fichier source, ce qui mettra à jour l'unité compilée.

Ensuite, il faut fermer et rouvrir le projet de labyrinthe, pour que la nouvelle unité compilée soit chargée à la place de l'ancienne.

Comme cette opération est fréquente et ennuyeuse, le menu Exécuter|Recharger permet, en un clic, d'enregistrer, de compiler, de fermer et de rouvrir le projet de labyrinthe. Cette opération est également accessible via le bouton [image] ou le raccourci Ctrl+Shift+F9.

Consulter cette rubrique sur internet
À suivre... Créer un bouton ou autre effet


Créer un bouton ou autre effet

Vous êtes ici : FunLabyrinthe > Créer ses propres labyrinthes > Créer des cases simples avec les SimpleSquares

Lorsque vous avez un source SimpleSquares lié à votre labyrinthe, vous pouvez créer de nouvelles cases pour celui-ci. Cliquez pour ce faire sur le bouton Nouveau dans la colonne de gauche.

Vous devez indiquer un identifiant (ID) pour votre composant, ainsi qu'un nom. L'ID ne pourra plus jamais être changé ! La liste vous permet de choisir le type de composant que vous voulez. Cette rubrique montre les possibilités offertes par les effets : Effet simple, Bouton poussoir et Interrupteur.

Dans cet exemple, je crée un effet simple d'ID "HelloWorld" et de nom "Hello World!". Une fois validé, vous obtenez ceci :

Écran de configuration d'un effet simple
Écran de configuration d'un effet simple

Au départ, votre composant n'a pas d'image (sauf si vous avez choisi un bouton poussoir ou un interrupteur). Vous pouvez choisir l'image de votre composant avec le bouton [image].

Non seulement il n'a pas d'image, mais il ne fait rien. Un effet, selon son type, peut répondre à différents événements. Les effets simples peuvent uniquement répondre à l'événement Execute, qui se produit lorsque le joueur passe sur l'effet. Les boutons peuvent réagir aux événements ButtonDown et ButtonUp, qui se déclenche respectivement quand le bouton est enfoncé et quand il est relâché. Les interrupteurs interceptent les événements SwitchOn et SwitchOff, déclenchés quand l'interrupteur est mis en position ON ou en position OFF, respectivement.

La boîte liste (encore vide) qui trône au centre de l'écran reprend les actions qu'effectuera l'effet lorsque l'événement sélectionné dans la liste déroulante sera déclenché. Pour ajouter une action à l'événement Execute de l'effet HelloWorld, utilisez la liste déroulante notée "Ajouter une action...".

Il existe plusieurs sortes d'actions :

Gardez à l'esprit que les actions seront effectuées dans l'ordre ou vous les voyez dans la boîte liste. Si un message apparaît après qu'une case a été modifiée, le joueur verra la nouvelle case pendant le message, par exemple[I] . Vous pouvez modifier l'ordre, ou supprimer des actions, avec les boutons situés à côté de la boîte liste des actions.

Les actions disponibles sont les suivantes :

  • Modifier une case d'une carte
  • Activer/désactiver un effet
  • Afficher un message au joueur
  • Déplacer le joueur
  • Changer la couleur du pion du joueur
  • Faire gagner ou perdre le joueur
  • Rendre visible ou invisible le joueur
  • Temporiser
  • Modifier la direction du joueur
  • Continuer le déplacement

Toutes ces actions ne sont pas encore implémentées.

1
  1. [I] Ceci constraste avec les versions précédentes (1.0 à 4.x) de FunLabyrinthe, dans lesquelles toutes les actions étaient effectuées avant que le joueur ne voie les changements.
Consulter cette rubrique sur internet
À suivre... Modifier une case d'une carte


Modifier une case d'une carte

Vous êtes ici : FunLabyrinthe > Créer ses propres labyrinthes > Créer des cases simples avec les SimpleSquares > Créer un bouton ou autre effet

Modifier une case d'une carte est probablement le type d'action le plus utilisé. Cette action vous permet de sélectionner une case quelconque d'une carte de votre labyrinthe, et de modifier tout ou partie des composantes de cette case.

Pour ajouter une nouvelle action de modification de case, cliquez sur la liste déroulante en-dessous de la liste d'actions et sélectionnez l'option "Modifier une case". L'éditeur vous propose alors l'écran suivant :

Action Modifier une case
Action Modifier une case

La boîte de gauche, intitulée "Case à modifier", vous permet de spécifier la case qui devra être modifiée. Soit vous choisissez la case courante (c'est-à-dire la case où se trouve l'effet que vous éditez), soit vous choisissez une position absolue sur l'une des cartes de votre labyrinthe.

Dans le dernier cas, vous pouvez vous évitez la peine de chercher les coordonnées exactes de la case. Il vous suffit d'afficher la vue des cartes avec le menu Voir|Cartes, sélectionner la case voulue en cliquant dessus (elle est encadrée de jaune), puis cliquer sur le bouton "Utiliser la case sélectionnée dans la fenêtre Cartes".

La boîte de droite, nommée "Modifications pour cette case", vous présente quatre combinaison case à cocher + liste déroulante, pour les quatre composantes de case. Cochez les composantes que vous souhaitez modifier, puis sélectionnez les composants à mettre à la place dans les listes déroulantes correspondantes.

À nouveau, il est possible de vous épargner quelque travail inutile avec le bouton "Imiter la case sélectionnée dans la fenêtre Cartes". Celui-ci recopiera les quatre composantes de la case actuellement sélectionnée dans cette fenêtre, et cochera par la même occasion les quatre cases à cocher.

Consulter cette rubrique sur internet
À suivre... Activer/désactiver un effet


Activer/désactiver un effet

Vous êtes ici : FunLabyrinthe > Créer ses propres labyrinthes > Créer des cases simples avec les SimpleSquares > Créer un bouton ou autre effet

Certains types d'effets ont la propriété de pouvoir être "désactivés". Lorsqu'un effet est désactivé, il ne réagit plus quand un joueur passe dessus. De plus, certains effets se dessinent différemment lorsqu'ils sont désactivés. Par exemple, un bouton désactivé se dessine comme un bouton enfoncé.

Le type d'action Activer/désactiver un effet permet, comme son nom l'indique, d'activer ou de désactiver un type d'effet qui a cette propriété.

L'écran permettant de configurer cette action est le suivant :

Dans la boîte supérieure, choisissez si vous voulez activer ou désactiver un effet. Dans la boîte inférieure, choisissez quel effet vous voulez modifier : soit l'effet courant, soit un autre effet qui gère cette capacité.

Un cas classique est de désactiver l'effet courant (par défaut). Cela permet de créer un effet "one-shot", c'est-à-dire qui s'exécute une et une seule fois.

Consulter cette rubrique sur internet
À suivre... Afficher un message au joueur


Afficher un message au joueur

Vous êtes ici : FunLabyrinthe > Créer ses propres labyrinthes > Créer des cases simples avec les SimpleSquares > Créer un bouton ou autre effet

Pour afficher un message au joueur, par exemple pour lui donner un indice ou pour lui donner une énigme, utilisez le type d'action "Afficher un message". L'écran de configuration de cette action est très simple :

Les contrôles parlent d'eux-mêmes. La case à cocher vous permet de spécifier que ce message ne doit être affiché que lorsque c'est la première fois que le joueur exécute cet effet.

Consulter cette rubrique sur internet
À suivre... Déplacer le joueur


Déplacer le joueur

Vous êtes ici : FunLabyrinthe > Créer ses propres labyrinthes > Créer des cases simples avec les SimpleSquares > Créer un bouton ou autre effet

Ce type d'action n'est pas encore disponible.

2
Consulter cette rubrique sur internet
À suivre... Changer la couleur du pion du joueur


Changer la couleur du pion du joueur

Vous êtes ici : FunLabyrinthe > Créer ses propres labyrinthes > Créer des cases simples avec les SimpleSquares > Créer un bouton ou autre effet

Si vous voulez changer la couleur du pion, le type d'action "Changer la couleur du pion" vous propose une liste déroulante avec quelques couleurs classiques.

Consulter cette rubrique sur internet
À suivre... Faire gagner ou perdre le joueur


Faire gagner ou perdre le joueur

Vous êtes ici : FunLabyrinthe > Créer ses propres labyrinthes > Créer des cases simples avec les SimpleSquares > Créer un bouton ou autre effet

Outre les deux moyens classiques de gagner que sont trouver le trésor ou la sortie du labyrinthe, il est possible de faire gagner le joueur avec une action d'un effet. Il est également possible de le faire perdre.

Utilisez le type d'action "Action simple" et cochez l'option adéquate.

Une fois qu'un joueur a gagné ou perdu, il ne peut plus bouger, et la partie est déclarée terminée. Il n'y a aucun signe visuel ou autre indiquant ce changement au joueur. On accompagnera donc souvent cette action d'un message de victoire, ou de défaite.

Il est recommandé de placer l'action Gagner ou Perdre avant l'action affichant un message au joueur.

1
Consulter cette rubrique sur internet
À suivre... Rendre visible ou invisible le joueur


Rendre visible ou invisible le joueur

Vous êtes ici : FunLabyrinthe > Créer ses propres labyrinthes > Créer des cases simples avec les SimpleSquares > Créer un bouton ou autre effet

Vous pouvez rendre invisible le joueur, ou au contraire le rendre à nouveau visible, avec les options adéquates du type d'action "Action simple". Cela permet, par exemple, de lui faire passer une épreuve "en aveugle", sans savoir où il se trouve.

Il est important de noter que le joueur possède un compteur de visibilité. C'est-à-dire qu'il retient combien de fois on l'a rendu invisible. Pour qu'il redevienne visible, il doit être rendu visible autant de fois. Inversement, s'il est rendu visible plusieurs fois, il doit être caché autant de fois, plus un, avant de devenir effectivement visible.

Ceci permet une "imbrication" des épreuves sans que l'une corrompe l'autre. Mais ce n'est pas un comportement évident à appréhender.

Consulter cette rubrique sur internet
À suivre... Temporiser


Temporiser

Vous êtes ici : FunLabyrinthe > Créer ses propres labyrinthes > Créer des cases simples avec les SimpleSquares > Créer un bouton ou autre effet

Temporiser signifie attendre, sans rien faire, pendant un certain temps. Le temps d'attente est égal, en millisecondes, à la valeur de la propriété DefaultTemporization du joueur. Cette action est une des options du type d'action "Action simple".

Pendant l'attente, le joueur humain qui contrôle le joueur n'a aucune prise sur le jeu : tout appui sur une touche sera ignoré. C'est exactement ce qui se passe lorsque le joueur tombe sur une flèche, par exemple.

Consulter cette rubrique sur internet
À suivre... Modifier la direction du joueur


Modifier la direction du joueur

Vous êtes ici : FunLabyrinthe > Créer ses propres labyrinthes > Créer des cases simples avec les SimpleSquares > Créer un bouton ou autre effet

Ce type d'action n'est pas encore disponible.

3
Consulter cette rubrique sur internet
À suivre... Continuer le déplacement

Voir aussi

Aller à la page
(C) 2000-2011 Sébastien Doeraene


Continuer le déplacement

Vous êtes ici : FunLabyrinthe > Créer ses propres labyrinthes > Créer des cases simples avec les SimpleSquares > Créer un bouton ou autre effet

L'action Continuer le déplacement (option du type d'action "Action simple") permet d'obtenir un comportement similaire au carrefour.

Pour être exact, elle spécifie que le joueur devra recommencer un déplacement après une temporisation automatique. La direction du déplacement est toujours la direction courante du joueur.

Pour obtenir un effet similaire à une flèche, combinez cette action avec une action Modifier la direction du joueur.

Consulter cette rubrique sur internet
À suivre... Créer un objet simple

Voir aussi

Aller à la page
(C) 2000-2011 Sébastien Doeraene


Créer un objet simple

Vous êtes ici : FunLabyrinthe > Créer ses propres labyrinthes > Créer des cases simples avec les SimpleSquares

Avec les SimpleSquares, il est possible de créer un nouvel objet simple. Un objet simple est capable d'effectuer un type d'action.

Pour créer un nouvel objet, choisissez l'option "Objet simple" dans la boîte de dialogue Nouveau composant de l'éditeur de cases simples. L'écran de configuration d'un objet est celui-ci :

Écran de configuration d'un objet simple
Écran de configuration d'un objet simple

La grande zone de texte contient le message qui sera affiché au joueur lorsqu'il ramassera cet objet. Il est possible de le laisser vide : aucun message n'appraîtra.

Les contrôles situés en-dessous de cette zone de texte permettent de configurer à quoi sert cet objet. Si la case à cocher est décochée, il ne "sert" à rien en soi.

Si vous cochez la case, vous devez indiquer un identifiant d'action dans la zone de texte située au dessous. Vous pouvez utiliser autant des actions standard que des actions de votre création.

Si vous modifiez le nombre minimum d'objets requis, et le positionnez par exemple sur 2, le joueur devra posséder au minimum 2 objets pour pouvoir effectuer l'action.

La dernière case à cocher indique si le joueur perd son objet lorsqu'il l'utilise pour effectuer l'action. Il perd autant d'objets qu'indiqué dans la boîte "Nombre minimum d'objets requis". Les clefs d'argent et d'or classiques suivent ce modèle : lorsque le joueur utilise une clef d'argent pour casser un bloc en argent, il perd une clef d'argent.

La capture d'écran montre une "clef d'argent éternelle" : une clef qui permet d'ouvrir les blocs en argent sans jamais la perdre.

Consulter cette rubrique sur internet
À suivre... Créer un obstacle simple

Voir aussi

Aller à la page
(C) 2000-2011 Sébastien Doeraene


Créer un obstacle simple

Vous êtes ici : FunLabyrinthe > Créer ses propres labyrinthes > Créer des cases simples avec les SimpleSquares

L'option "Obstacle simple" de la boîte de dialogue Nouveau composant crée un nouvel obstacle qui peut se détruire sous condition.

Écran de configuration d'un obstacle simple
Écran de configuration d'un obstacle simple

Selon l'une des trois options que vous choisissez, l'obstacle réagira différemment :

  • Il se détruira toujours, dès que le joueur pousse dessus. C'est le comportement du passage secret, par exemple ;
  • Il ne se détruira jamais, et bloque donc toujours le joueur. C'est le cas de cette pierre, comme dans le labyrinthe Ca glisse ;
  • Il se détruira seulement si le joueur peut effectuer une action donnée. Indiquez alors un identifiant d'action (standard ou pas).

    • La zone de texte du bas indique un message qui sera affiché lorsque le joueur pousse sur l'obstacle mais ne peut le détruire. Notez que ceci ne surviendra jamais si l'obstacle se détruit toujours, et arrivera toujours si l'obstacle ne se détruit jamais.

    Vous pouvez facilement créer une combinaison objet simple et obstacle simple. En utilisant le même identifiant d'action de part et d'autre, l'objet permettra de détruire l'obstacle.

    1
    Consulter cette rubrique sur internet
    À suivre... Aspects avancés avec le langage FunDelphi


Aspects avancés avec le langage FunDelphi

Vous êtes ici : FunLabyrinthe > Créer ses propres labyrinthes

Les SimpleSquares sont très simples et très adaptés à la création de cases très simples. Mais il arrive relativement rapidement un moment où cela ne suffit plus. Le langage FunDelphi est le deuxième niveau de complexités des sources.

Avec le FunDelphi, vous entrez dans un nouveau monde, celui de la programmation. Rassurez-vous cependant, ce langage est très simple, puisqu'il est directement orienté sur les opérations utiles dans FunLabyrinthe. De plus, de nombreux exemples sont disponibles dans les labyrinthes livrés avec FunLabyrinthe.

Cette section vous apprendra à construire des sources FunDelphi. Avec un peu d'expérience, vous pourrez faire de très nombreuses choses dans FunLabyrinthe avec ce langage.

  • Créer un source FunDelphi
  • Première approche : un terrain très simple
  • Événements et instructions
  • Objets et actions
  • Conditions avec if
  • Héritage et sous-classes
  • Plugins pour le joueur
Consulter cette rubrique sur internet
À suivre... Créer un source FunDelphi


Créer un source FunDelphi

Vous êtes ici : FunLabyrinthe > Créer ses propres labyrinthes > Aspects avancés avec le langage FunDelphi

Tout d'abord, tout comme pour les sources SimpleSquares, il faut créer un nouveau fichier source FunDelphi, le compiler une première fois et le lier au labyrinthe. Sélectionnez le menu Sources|Nouveau et choisissez l'option FunDelphi. Donnez un nom de fichier d'extension .fnd à votre source.

Un nouveau fichier source FunDelphi vide apparaît alors. Il contient uniquement ces quelques lignes :

unit FunDelphiSample;

uses
  FunLabyBase;

end.

La première indique le commencement de l'unité, et son nom. La dernière indique la fin de l'unité. Tout ce que vous écrirez doit être écrit au milieu de ces lignes.

La "clause" uses liste les unités utilisées par cette unité. Cela permet de faire référence aux composants déclarés dans cette unité. FunLabyBase est l'unité qui contient tous les composants de base de FunLabyrinthe, comme l'herbe, les flèches, etc.

Compilez le source, puis ajoutez-le au labyrinthe via le menu Fichier|Unités utilisées.

Consulter cette rubrique sur internet
À suivre... Première approche : un terrain très simple


Première approche : un terrain très simple

Vous êtes ici : FunLabyrinthe > Créer ses propres labyrinthes > Aspects avancés avec le langage FunDelphi

Sommaire

  • C'est quoi ce charabia ?
  • Identificateurs, mots-clef, symboles, etc.
  • Signification du code
  • Créer le composant
  • Recharger et placer le composant

La première chose la plus simple à faire est de créer un terrain très simple, qui permet toujours au joueur de venir dessus.

Le code suivant crée une nouvelle sous-classe de composant, appelée TSimpleField :

unit FunDelphiSample;

uses
  FunLabyBase;

field TSimpleField
  name 'Terrain simple';
  image 'Fields/WoodenFloor';
end;

end.

C'est quoi ce charabia ?

Identificateurs, mots-clef, symboles, etc.

Vous pouvez constater que plusieurs "mots" sont en bleau marine gras. Ces mots sont appelés des mots-clef. Notez qu'ils doivent être écrits en minuscules, sinon il ne seront plus des mots-clef.

Les mots qui sont en noir simple sont appelés des identificateurs. Les identificateurs suivent les mêmes règles que les ID de composants. De plus, une convention est de les écrire avec une majuscule au début de chaque mot.

Le texte plus libre qui se trouve entre des apostrophes est appelé une chaîne de caractères. À l'intérieur d'une chaîne de caractères, vous pouvez mettre un texte tout à fait libre, mais sur une seule ligne.

Les point-virgule (;) sont un des nombreux symboles du langage FunDelphi. Le point-virgule le plus important d'entre eux : il termine la plupart des lignes, c'est-à-dire toutes les lignes qui sont effectivement la fin de quelque chose. La ligne commençant par field n'est justement pas la fin de quelque chose, c'est le début de toutes les "explications" qui décrivent le terrain.

Signification du code

Le code ci-dessus est relativement simple. La ligne commençant par field déclare une nouvelle classe de composant, nommée TSimpleField. Tout ce qui se trouve entre cette ligne et la ligne end; de même niveau précise ce que fait ce composant.

La ligne name indique le nom du composant. La ligne image indique une liste, séparée par des virgules, de noms de fichiers image pour faire le dessin du terrain. Consultez le contenu du dossier Squares des documents de FunLabyrinthe (dans vos documents partagés) pour trouver de très nombreuses images.

Créer le composant

Le lecteur attentif se souviendra que le code ci-dessus crée une nouvelle classe de composant, pas le composant lui-même. Pour créer le composant de cette classe, il faut ajouter une section components, comme ceci :

unit FunDelphiSample;

uses
  FunLabyBase;

components
  SimpleField: TSimpleField;

field TSimpleField
  name 'Terrain simple';
  image 'Fields/WoodenFloor';
end;

end.

Ces deux nouvelles lignes précisent qu'il faut créer un composant dont l'ID est "SimpleField" et la classe est TSimpleField. Ceci peut vous paraître superflu : vous devez commencer à sentir qu'à chaque nouveau composant correspond sa classe, donc pourquoi ne pas tout faire en une seule fois.

La raison essentielle est que certaines classes de composants permettent de créer plusieurs composants de la même classe. Par exemple, les quatre flèches et le carrefour sont tous de la classe TArrow ; une propriété les différencie.

Recharger et placer le composant

Afin que votre nouveau composant apparaisse dans la palette des composants, rechargez avec Ctrl+Shift+F9 (pour rappel, cela enregistre, compile, et recharge tout).

Vous pourrez trouver un nouveau composant, avec un dessin de plancher, sous l'onglet Terrains.

Consulter cette rubrique sur internet
À suivre... Événements et instructions


Événements et instructions

Vous êtes ici : FunLabyrinthe > Créer ses propres labyrinthes > Aspects avancés avec le langage FunDelphi

Sommaire

  • Instructions de base
  • Changer le terrain, l'effet, l'outil ou l'obstacle d'une case
  • Changer complètement une case
  • Afficher un message au joueur
  • Donner et reprendre des objets au joueur
  • Déplacer le joueur
  • Changer de direction et continuer le déplacement
  • Faire gagner ou perdre le joueur
  • Afficher ou cacher le joueur

Après avoir fait un terrain tout simple qui ne fait rien, il est temps de créer un composant qui fait quelque chose. Pour cela, nous allons prendre l'exemple d'un effet. De même que le mot-clef field introduit un terrain, le mot-clef effect permet de créer une nouvelle classe d'effet. Vous aurez compris qu'existent également des mots-clef similaires tool et obstacle.

effect TSampleEffect
  name 'Effet exemple';
  image 'Buttons/Button';
end;

Pour que cet effet fasse quelque chose, il faut réagir aux différents événements qui surviennent dans FunLabyrinthe. Rappelez-vous que l'événement principal d'un effet est l'événement Execute, qui est déclenché lorsque le joueur tombe sur l'effet.

effect TSampleEffect
  name 'Effet exemple';
  image 'Buttons/Button';

  on Execute do
  begin
  end;
end;

Entre les lignes begin et end, vous pourrez écrire les instructions que FunLabyrinthe devra exécuter lorsque l'événement Execute surviendra.

Instructions de base

Les instructions du langage FunDelphi peuvent être très diverses. En réalité, ce sont les mêmes que le langage de programmation Delphi, avec quelques simplifications liées à FunLabyrinthe. Cette section vous présente une série d'instructions de base, classiques, que vous voudrez utiliser dans FunLabyrinthe.

Changer le terrain, l'effet, l'outil ou l'obstacle d'une case

Très souvent, vous voudrez modifier une des composantes d'une case de la carte courante. Ceci peut se faire comme suit :

  on Execute do
  begin
    Map[1, 3, 0].Effect := NorthArow;
  end;

Cette instruction place une flèche nord sur la case (1, 3, 0) de la carte courante. Les trois nombres sont les coordonnées (X, Y, Z) de la case sur la carte. Vous pouvez remplacer Effect par Field, Tool ou Obstacle, pour modifier respectivement le terrain, l'outil, ou l'obstacle.

NorthArrow indique quel est le nouvel effet. Il s'agit de l'ID du composant voulu.

Si vous essayez de compiler ce code tel quel, vous aurez une mauvaise surprise :

On appelle ce type d'erreur une erreur de compilation. Forcément, lorsqu'on programme dans un langage qui impose des règles, il arrive qu'on les enfreigne. Le compilateur est là, entre autres, pour vérifier qu'on a bien respecté toutes les règles. Quand ce n'est pas le cas, il affiche des erreurs.

Notez que l'erreur a un texte (Identificateur NorthArow non déclaré) et une position (la ligne mise en rouge), ce qui peut vous aider à localiser et à corriger l'erreur.

En l'occurrence, cette erreur signifie que le compilateur ne sait pas ce qu'est NorthArow. Soit il a été mal orthographié, soit il n'a pas été déclaré correctement. Il s'agit ici du premier cas. En effet, NorthArrow s'écrit bien avec deux 'r' et non un. Corrigeons donc cette erreur :

  on Execute do
  begin
    Map[1, 3, 0].Effect := NorthArrow;
  end;

Cette fois, si vous compilez, vous n'aurez plus d'erreur.

Changer complètement une case

Si la section précédente montrait comme changer une des composantes d'une case, celle-ci présente comment modifier entièrement une case :

  on Execute do
  begin
    Map[1, 3, 0] := Grass+NorthArrow;
  end;

Vous pouvez constater que vous pouvez combiner plusieurs composantes de case avec l'opérateur +. N'oubliez pas qu'il est nécessaire qu'il y ait un terrain. Sinon vous courrez à la catastrophe.

Afficher un message au joueur

Pour afficher un message au joueur utilisez l'instruction suivante :

  on Execute do
  begin
    Player.ShowMessage('Hello World!');
  end;

Le texte affiché au joueur est une chaîne de caractères. Si vous voulez mettre une vraie apostrophe au sein d'un message, doublez-la, comme dans 'Salut l''ami !'.

Si votre message est long, il risque fort de dépasser la ligne grise verticale qui se trouve à droite. De manière générale, il est raisonnable d'éviter de dépasser cette largeur de ligne, car la lecture devient difficile. Vous pouvez alors découper votre message en plusieurs morceaux, comme ceci :

  on Execute do
  begin
    Player.ShowMessage('Tu as trouvé un objet super méga cool. Il ne te reste '+
      'plus qu''à savoir comment tu vas l''utiliser.');
  end;

Donner et reprendre des objets au joueur

Ce petit exemple montre un échange, et par là montre comment donner des objets au joueur, ou lui en reprendre.

  on Execute do
  begin
    Player.ShowMessage('On va faire un échange : tu me donnes 2 clefs '+
      'd''argent et je te donne une clef d''or.');
    Player discards 2 SilverKeys;
    Player receives 1 GoldenKeys;
  end;

La grammaire n'est pas le point fort de FunDelphi : on écrit bien 1 GoldenKeys et non 1 GoldenKey. En effet, c'est l'ID du composant objet clefs d'or. Cependant, notez que la "phraséologie" ressemble à celle de l'anglais naturel.

Déplacer le joueur

Si voulez déplacer le joueur à un autre endroit du jeu, comme un téléporteur, utilisez l'instruction (la méthode en fait) MoveTo :

  on Execute do
  begin
    Player.MoveTo(Point3D(3, 2, 1));
  end;

Cette forme ne change pas de carte, et n'exécute pas non plus la case où le joueur arrive. Si vous voulez exécuter la case de destination, utilisez cette autre forme :

  on Execute do
  begin
    Player.MoveTo(Point3D(3, 2, 1), True);
  end;

Actuellement, changer de carte requiert d'utiliser des variables, et ne sera donc pas présenté ici.

Changer de direction et continuer le déplacement

L'effet de flèche s'obtient par la combinaison de deux opération : changer la direction du joueur, puis imposer de continuer le déplacement.

  on Execute do
  begin
    Player.Direction := diEast;
    GoOnMoving := True;
  end;

Pour obtenir un effet de carrefour, seule l'instruction GoOnMoving est nécessaire.

Faire gagner ou perdre le joueur

Les méthodes Win et Lose font respectivement gagner et perdre le joueur. Elles s'utilisent de manière similaire. Voici un exemple qui fait gagner le joueur.

  on Execute do
  begin
    Player.Win;
    Player.ShowMessage('Bravo ! Tu as gagné !');
  end;

Afficher ou cacher le joueur

Les méthodes Show et Hide, respectivement, montrent et cachent le joueur. Leur syntaxe est équivalente à Win et Lose, ci-dessus.

Consulter cette rubrique sur internet
À suivre... Objets et actions

Voir aussi

Aller à la page
(C) 2000-2011 Sébastien Doeraene


Objets et actions

Vous êtes ici : FunLabyrinthe > Créer ses propres labyrinthes > Aspects avancés avec le langage FunDelphi

Sommaire

  • Création d'un nouveau type d'action
  • Spécifier qu'un objet peut effectuer une action
  • Créer le composant objet et l'outil correspondant

Maintenant que les bases sont posées, cette rubrique montre les spécificités liées aux objets, et donc à l'utilisation d'actions. Un objet se déclare avec le mot-clef object.

Création d'un nouveau type d'action

En SimpleSquares, on peut marquer n'importe quel nom d'action, sans contrôle. Le FunDelphi, quant à lui, requiert que les actions soient déclarées. En fait, les SimpleSquares déclarent automatiquement les actions.

Le mot-clef actions introduit une liste de noms d'actions à déclarer, séparés par des virgules.

Les actions ont pour convention de nommage d'être des groupes verbaux, avec le verbe à l'infinitif. L'introduction de cette nouvelle action, OpenBronzeLock, va nous permettre de l'utiliser plus loin. Tout comme les composants, vous pouvez récupérer les actions déclarées dans d'autres unités en utilisant la clause uses.

Les actions standard GoOnWater, OpenSilverLock et OpenGoldenLock sont déclarées dans l'unité FLBCommon.

2

Spécifier qu'un objet peut effectuer une action

À présent que nous avons une classe d'objet et une action, on peut spécifier que la classe d'objet TBronzeKeys permet au joueur, s'il en a, d'effectuer l'action OpenBronzeLock.

Sous cette forme, dès que le joueur aura une clef de bronze, il pourra ouvrir des verrous en bronze... Et ne perdra pas sa clef ! Pour qu'il perde sa clef, on peut ajouter une clause then :

Self signifie soi-même en anglais. Il s'agit donc de l'objet de la classe TBronzeKeys que le joueur est en train d'utiliser pour ouvrir le verrou en bronze.

2

Finalement, si vous voulez que le joueur ait besoin de deux clefs de bronze pour ouvrir un verrou en bronze, vous pouvez ajouter une clause if.

Le mot-clef has peut optionnellement être suivi de at least, at most, more than, less than ou exactly, ce qui signifie que le joueur doit avoir respectivement au moins, au plus, plus que, moins que, ou exactement le nombre d'objets indiqués. Par défaut, at least est utilisé.

1

Créer le composant objet et l'outil correspondant

Après avoir déclaré la classe d'objet, il ne faut pas oublier de créer le composant objet de cette classe. De plus, il faut créer un outil permettant de ramasser cet objet. Les ID d'objets sont généralement mis au pluriel, la forme singulière étant réservée à l'outil correspondant. Si les deux formes sont homographes, on ajoute un suffixe Tool pour l'outil.

Il n'y a pas besoin de créer de nouvelle classe pour l'outil. Vous allez découvrir pour la première fois une classe réutilisable pour créer plusieurs composants : TObjectTool. C'est une classe d'outil "automatique", qui ramasse un objet et affiche un message. Pour spécifier quel est l'objet et quel est l'outil, on utilise des paramètres :

Consulter cette rubrique sur internet
À suivre... Conditions avec if


Conditions avec if

Vous êtes ici : FunLabyrinthe > Créer ses propres labyrinthes > Aspects avancés avec le langage FunDelphi

Sommaire

  • un obstacle de style bloc
  • Plusieurs instructions après then ou else
  • Comparer des valeurs
  • Combiner plusieurs tests

Ce qui a été présenté de FunDelphi jusqu'ici ne vous permet guère de faire plus que les SimpleSquares. Nous allons attaquer la partie réellement intéressante de FunDelphi : les conditions avec if. Les conditions permettent d'effectuer certaines instructions dans certains cas, et d'autres instructions sinon.

Un cas classique : un obstacle de style bloc

Commençons par un cas classique, la création d'un obstacle de style bloc, c'est-à-dire qui se détruit si le joueur peut effectuer l'action OpenBronzeLock.

L'événement Pushing se déclenche lorsque le joueur pousse sur l'obstacle.

La première instruction, inherited, effectue le comportement par défaut de tout obstacle, à savoir de bloquer le joueur.

Ensuite vient la première condition. La structure d'une condition est if Condition then Instruction. L'instruction n'est exécutée que si la condition est vraie (True). Le mot-clef not inverse la valeur de vérité de ce qui est à sa droite. Donc si c'est False (faux), cela devient True, et inversement. L'identificateur KeyPressed, en lui-même, vaut True si et seulement si le joueur a effectivement appuyé sur une touche (c'est par exemple False s'il vient d'une flèche).

Cette condition tout entière est donc vraie si KeyPressed vaut False, donc si le joueur vient d'une flèche ou d'un effet similaire. Dans ce cas, l'instruction Exit est exécutée. Celle-ci a pour effet de "partir", de terminer l'événement. Donc, tout ce qui ce trouve après le Exit ne sera pas exécuté.

Si par contre le joueur avait appuyé sur un touche, on arrive à la seconde condition. Si le joueur est capable d'ouvrir un verrou en bronze, il faut détruire le bloc. Sinon, il faut lui afficher un message. Le "sinon" se traduit en else en FunDelphi. C'est la deuxième forme de structure d'une condition : if Condition then InstructionSiVrai else InstructionSiFaux.

Contre toute attente, il ne faut pas de point-virgule à la fin de l'instruction InstructionSiVrai. Car bien que ce soit la fin de cette instruction, ce n'est pas la fin du if..then..else tout entier.

La condition ici est Player can OpenBronzeLock. Traduit littéralement de l'anglais au français, cela donne "Joueur peut OuvrirBlocEnBronze". On ne peut plus clair, si ?

Le nil veut dire "rien" ou "aucun". Donc, l'obstacle de la case courante devient "rien". Autrement, dit l'obstacle actuel est détruit.

Plusieurs instructions après then ou else

Normalement, seule la première instruction qui suit directement le then ou le else dépend de celui-ci. Par exemple, dans l'exemple précédent, seul le Exit dépend de la condition not KeyPressed. Pour exécuter plusieurs instructions, entourez-lez de begin et end, comme ceci :

Comparer des valeurs

Il existe plusieurs opérateurs permettant de comparer des valeurs.

  • = teste si ses opérandes sont égaux ;
  • <> teste si ses opérandes sont différents ;
  • < ou > testent si l'opérande de gauche est respectivement strictement plus petit ou strictement plus grand que l'opérane de droite ;
  • <= ou >= sont simpilaires pour plus petit ou égal et plus grand ou égal.

    • Par exemple, si vous devez tester si le tag du player est égal à 1, vous utiliserez le code suivant :

    L'instruction sous le then est en soi stupide ici ; comprenez qu'il s'agit d'un exemple de code sans intérêt.

    Combiner plusieurs tests

    Vous pouvez combiner plusieurs tests avec les opérateur and et or. Condition1 and Condition2 vaut True si et seulement si Condition1 et Condition2 valent tous les deux True. Inversement, Condition1 or Condition2 vaut True si au moins une des deux conditions vaut True.

    Dans la majorité des cas, vous devrez entourer les sous-conditions de parenthèses, comme dans l'exemple ci-dessus.

    3
    Consulter cette rubrique sur internet
    À suivre... Héritage et sous-classes


Héritage et sous-classes

Vous êtes ici : FunLabyrinthe > Créer ses propres labyrinthes > Aspects avancés avec le langage FunDelphi

Sommaire

  • Créer un bouton qui s'enfonce et se relâche
  • Créer un interrupteur
  • Un terrain qui accepte la planche

Dans les concepts de FunLabyrinthe est déjà expliquée la notion générale de classe et de sous-classes. Cette section vous montre qu'il est possible d'utiliser cette notion en FunDelphi de manière à réutiliser efficacement des classes déjà existantes, tout en les personnalisant pour votre propre usage.

Créer un bouton qui s'enfonce et se relâche

Dans la rubrique événements et instructions, l'effet construit en exemple avait une image de bouton. Mais il ne s'enfonce pas pour autant. En effet, ce n'était pas vraiment un bouton.

Les boutons font partie de la classe TPushButton, qui est une sous-classe de TEffect. Pour créer un véritable bouton, il suffit de spécifier qu'on veut hériter de TPushButton. Ceci se fait simplement en l'indiquant entre parenthèses, comme suit :

Il y a deux choses à noter ici, en plus de l'indication d'héritage : plus d'image, car TPushButton gère déjà l'image. Et l'événement intercepté n'est plus Execute, mais ButtonDown.

Le nom de la classe indiquée entre parenthèses doit être compatible avec le type de composant que l'on décrit. Ainsi, vous n'auriez pas pu mettre TPushButton si vous écriviez un outil. Autrement, vous pouvez utiliser n'importe quelle classe d'effet, y compris une classe que vous auriez vous-même écrite.

Créer un interrupteur

Un interrupteur a pour vocation d'avoir deux listes d'actions "inverses". Lorsqu'on appuie une première fois dessus, il transforme le jeu dans un sens. La deuxième fois, il le remet en place. Et cetera.

Vous pouvez créer très facilement un interrupteur en héritant de la classe TSwitch :

Un terrain qui accepte la planche

La rubrique Première approche proposait la création d'un terrain très simple avec dessin de plancher. Cependant, si un trou se trouvait au milieu de deux planchers de cette classe, le joueur n'aurait pas pu passer avec la planche. En effet, par défaut, les terrains n'acceptent pas que l'on "pose" la planche dessus.

Pour créer un terrain tout à fait similaire à l'herbe, et donc qui accepte la planche, vous pouvez hériter de TGround.

Consulter cette rubrique sur internet
À suivre... Plugins pour le joueur

Voir aussi

Aller à la page
(C) 2000-2011 Sébastien Doeraene


Plugins pour le joueur

Vous êtes ici : FunLabyrinthe > Créer ses propres labyrinthes > Aspects avancés avec le langage FunDelphi

Sommaire

  • un "sauveteur"

Une des choses très utiles qu'il est possible de faire en FunDelphi mais pas en SimpleSquares, est la création de plugins à greffer au joueur.

Les plugins ont déjà été introduits dans les concepts de FunLabyrinthe. Ils permettent de modifier de A à Z la réaction au joueur à tous les événements survenant dans FunLabyrinthe, y compris l'appui sur une touche du clavier. Ils permettent aussi de modifier l'aspect du joueur, ou sa vue. Les plugins sont indispensable à de nombreux cas de figures.

Premier exemple : un "sauveteur"

Imaginons un labyrinthe dans lequel il y a beaucoup d'impasses. On peut vouloir que le joueur puisse revenir facilement au début, s'il appuie sur la touche 'A' de son clavier par exemple. Un plugin très simple permet d'obtenir cet effet.

L'événement PressKey est déclenché lorsque le joueur appuie sur une touche quelconque de son clavier, et Key indique laquelle. Le point (1, 1, 0) est supposé être le point de départ.

N'oubliez pas que pour que cela fonctionne, le plugin doit être attaché au joueur. Ceci peut être fait dans l'inspecteur d'objets après avoir sélectionné le joueur.

Consulter cette rubrique sur internet
À suivre... Commandes classiques de l'interface

Voir aussi

Aller à la page
(C) 2000-2011 Sébastien Doeraene


Commandes classiques de l'interface

Vous êtes ici : FunLabyrinthe > Créer ses propres labyrinthes

Sommaire

  • Menu Fichier
  • Menu Cartes
  • Menu Sources
  • Menu Voir
  • Menu Exécuter
  • Menu Aide

L'éditeur de labyrinthe propose un certain nombre de commandes classiques qui sont détaillées ici.

Menu Fichier

Nouveau labyrinthe : crée un nouveau projet de labyrinthe.

Ouvrir : ouvre un projet de labyrinthe existant.

Enregistrer : enregistre le fichier ouvert ; si c'est l'onglet "Cartes et joueurs" (par défaut) qui est visible, le projet de labyrinthe est enregistré.

Enregistrer sous... : enregistre le projet de labyrinthe sous un autre nom de fichier.

Tout enregistrer : enregistre tous les fichiers ouverts, ainsi que le projet de labyrinthe courant.

Fermer : ferme le fichier courant ; si c'est l'onglet "Cartes et joueurs" (par défaut) qui est visible, ferme le projet de labyrinthe. (demande confirmation si le fichier a été modifié)

Propriétés... : permet de modifier les propriétés du projet (titre, description, difficulté et auteur).

Unités utilisées... : affiche une boîte de dialogue permettant d'ajouter et/ou retirer des unités utilisées.

Quitter : ferme tous les fichiers ouverts et quitte l'éditeur de labyrinthes. (demande confirmation si des fichiers ont été modifiés)

Menu Cartes

Ajouter... : ajoute une nouvelle carte au projet de labyrinthe ; une boîte de dialogue est affichée pour configurer la carte (choisir sa taille, notamment).

Retirer : supprime la carte actuellement visible dans l'éditeur de cartes. (demande confirmation)

Redimensionner/remplir : affiche une boîte de dialogue permettant de redimensionner la carte, remplir des zones avec des motifs, etc.

Menu Sources

Ajouter... : ajoute un fichier source existant au projet.

Retirer... : retire le fichier source ouvert du projet. (le fichier n'est pas supprimé du disque dur)

Voir tous : ouvre tous les fichiers source du projet.

Un sous-menu par fichier source : ouvre le fichier source correspondant.

Menu Voir

Messages du compilateur : affiche les messages du compilateur.

Cartes : affiche une fenêtre permettant de visualiser les cartes.

Menu Exécuter

Tester : enregistre le projet labyrinthe et le lance dans le programme de jeu afin de le tester. (tous les sources ouverts sont compilés avant)

Compiler : compile tous les sources ouverts.

Recharger : enregistre tout, compile tous les sources ouverts, puis ferme et rouvre le projet ouvert.

Menu Aide

Rubriques d'aide : affiche l'aide de FunLabyEdit.

À propos : affiche les informations de version du logiciel.

Consulter cette rubrique sur internet
À suivre... Maintenir des labyrinthes de la version 4.x

Voir aussi

Aller à la page
(C) 2000-2011 Sébastien Doeraene


Maintenir des labyrinthes de la version 4.x

Vous êtes ici : FunLabyrinthe > Créer ses propres labyrinthes

Cette section s'adresse aux auteurs de labyrinthes qui ont créé des labyrinthes avec une version antérieure de FunLabyrinthe (jusqu'à la 4.x). Si ce n'est pas votre cas, ne perdez pas votre temps à lire cette rubrique.

Comme vous l'avez constaté, FunLabyrinthe 5.0 est très différent des versions précédentes. À l'installation déjà, le logiciel vous a proposé d'importer vos anciens labyrinthes. Un gros effort a été fourni pour que les anciens labyrinthes continuent de fonctionner exactement comme ils fonctionnaient avant.

Toutefois, pour un tas de raisons (en particulier la décomposition des cases en quatre composantes), la structure des anciens labyrinthes est totalement incompatible avec les réelles nouveautés de FunLabyrinthe 5.0. Ils sont donc isolés de ces nouveautés.

Si vous devez maintenir d'anciens labyrinthes, vous pouvez le faire avec FunLabyEdit 5.0, quasiment comme avant. Seule la boîte de dialogue d'édition des actions des boutons (de l'éditeur de labyrinthes) a disparu. Vous retrouverez les actions des boutons version EditActions avec le menu Sources\VotreLabyrinthe.c4x.

Notez par ailleurs que vos labyrinthes auront conservé les graphismes de FunLabyrinthe 4.x. En particulier, l'eau est toujours fixe et avec ses vagues toutes moches :-p. Ceci était nécessaire pour un certain nombre de raisons, notamment le fait qu'il était possible de changer le fichier Cases.bmp de base, et aussi que certains auteurs ont fait des dessins de case qui pouvaient clocher avec les nouveaux graphismes (exemple : un courant sur de l'eau fixe à côté de la nouvelle eau animée).

La seule chose qui change réellement est que les messages ne sont plus affichés dans des boîtes de dialogue Windows mais bien avec le nouveau système. C'était une contrainte technique incontournable, et cela n'altère absolument pas ce que le joueur perçoit du labyrinthe.

Il est strictement impossible de créer un nouveau labyrinthe dans l'ancien style. Donc, pour tout nouveau labyrinthe, vous devrez créer vos cases spéciales avec les SimpleSquares ou avec le langage FunDelphi. Croyez bien que je regrette que le langage d'actions que vous avez appris ne vous serve plus à rien, mais il est malheureusement incompatible en soi avec la décomposition en quatre composantes de cases, qui est essentielle à FunLabyrinthe 5.0. Je vous encourage vivement à vous mettre au langage FunDelphi, qui, une fois que vous l'aurez appréhendé, est à la fois plus simple et plus puissant que le langage d'actions.

Consulter cette rubrique sur internet
À suivre... Experts : le nec plus ultra avec Delphi


Experts : le nec plus ultra avec Delphi

Vous êtes ici : FunLabyrinthe > Créer ses propres labyrinthes
Consulter cette rubrique sur internet


Résultat

Consulter cette rubrique sur internet
Aller à la page
(C) 2000-2011 Sébastien Doeraene