Introduction à JavaFX pour le développement du jeu
JavaFX est une boîte à outils graphique multi-plateforme pour Java, et est le successeur des bibliothèques Java Swing. Dans ce tutoriel, nous allons explorer les caractéristiques de JavaFX qui le rendent facile à utiliser pour commencer la programmation de jeux en Java.
12 moteurs et plates-formes Gamedev (et les meilleures façons d'apprendre chacun d'eux)
Michael James Williams
Installation
Classes de cadre de base
Création d'un programme JavaFX commence par la classe d'application, à partir de laquelle toutes les applications JavaFX sont étendues. Votre classe principale doit appeler la méthode lancement (), qui sera ensuite appeler la méthode init () et la méthode start (), attendez l'application pour terminer, puis appeler la méthode stop (). Parmi ces méthodes, seule la méthode start () est abstraite et doit être remplacée.
Sachant tout cela, nous pouvons écrire un exemple minimal qui lance une fenêtre dans JavaFX:
Contenu Structuration
Le contenu de JavaFX (tel que le texte, les images et les contrôles de l'interface utilisateur) est organisé en utilisant une structure de données arborescente connu sous le nom d'un graphe de scène. qui regroupe et organise les éléments d'une scène graphique.
Elément général d'un graphe de scène dans JavaFX est appelé un arbre. Chaque nœud dans un arbre a un seul nœud « parent », à l'exception d'un nœud spécial désigné comme la « racine ». Un groupe est un nœud qui peut avoir de nombreux « enfants » éléments de nœud. transformations graphiques (translation, rotation et échelle) et les effets appliqués à un groupe sont également applicables à ses enfants. Les nœuds peuvent être décorés à l'aide Feuilles JavaFX style en cascade (CSS), tout à fait similaire au CSS utilisé pour formater des documents HTML.
La classe Scene contient tout le contenu d'un graphe de scène, et nécessite un nœud racine à régler (dans la pratique, ce qui est souvent un groupe). Vous pouvez définir la taille d'une scène spécifique; sinon, la taille d'une scène sera calculé automatiquement en fonction de son contenu. Un objet de la scène doit être transmis à la scène (par la méthode setScene ()) afin d'être affiché.
rendu graphique
Le rendu graphique est particulièrement important pour les programmeurs de jeu! En JavaFX, l'objet Canvas est une image sur laquelle nous pouvons tirer du texte, des formes et des images, en utilisant son objet GraphicsContext associé. (Pour les développeurs familiers avec la boîte à outils Java Swing, ce qui est similaire à l'objet graphique transmis à la méthode de peinture () dans la classe JFrame.)
L'objet GraphicsContext contient une foule de capacités de personnalisation puissants. Pour choisir les couleurs pour le texte de dessin et formes, vous pouvez régler le remplissage (intérieur) et de la course des couleurs, qui sont des objets de peinture (frontière): ceux-ci peuvent être une couleur unie unique. un gradient défini par l'utilisateur (que ce soit LinearGradient ou RadialGradient), ou même un ImagePattern. Vous pouvez également appliquer un ou plusieurs objets de style d'effet, comme l'éclairage. Ombre. ou GaussianBlur. et modifier les polices de la valeur par défaut en utilisant la classe de police.
La classe d'image, il est facile de charger des images à partir d'une variété de formats de fichiers et de les tirer par la classe GraphicsContext. Il est facile de construire des images générées par la procédure en utilisant la classe WritableImage en même temps que les classes PixelReader et PixelWriter.
En utilisant ces classes, nous pouvons écrire beaucoup plus digne « Bonjour, monde » exemple de style comme suit. Par souci de concision, nous allons inclure la méthode start () ici (nous allons sauter les déclarations d'importation et la méthode principale ()); cependant, le code source complet de travail se trouve dans le repo GitHub qui accompagne ce tutoriel.
Le jeu en boucle
Ensuite, nous devons rendre nos programmes dynamiques. ce qui signifie que l'état du jeu change au fil du temps. Nous allons mettre en œuvre une boucle de jeu. une boucle infinie qui met à jour les objets de jeu et rend la scène à l'écran, idéalement à raison de 60 fois par seconde.
Utilisation de la classe AnimationTimer est un peu délicat: car il est une classe abstraite, il ne peut pas être créé directement-la classe doit être prolongée avant une instance peut être créée. Cependant, pour nos exemples simples, nous allons étendre la classe en écrivant une classe interne anonyme. Cette classe interne doit définir la poignée méthode abstraite (). qui sera passé un seul argument: l'heure du système actuel en nanosecondes. Après avoir défini la classe interne, nous invoquons immédiatement la méthode start (), qui commence la boucle. (La boucle peut être arrêté en appelant la méthode stop ()).
Avec ces classes, nous pouvons modifier notre « Bonjour, monde » par exemple, la création d'une animation composée de la Terre en orbite autour du Soleil contre une image de fond étoilé.
Il existe d'autres moyens pour mettre en œuvre une boucle de jeu dans JavaFX. Une approche légèrement plus long (mais plus flexible) comprend la classe de montage, qui est une séquence d'animation se composant d'un ensemble d'objets d'images clés. Pour créer une boucle de jeu, le scénario devrait être réglé pour répéter indéfiniment, et qu'un seul KeyFrame est nécessaire, avec sa durée fixée à 0.016 secondes (pour atteindre 60 cycles par seconde). Cette mise en œuvre se trouve dans le fichier Example3T.java dans le repo GitHub.
Cadre axé sur l'animation
Une autre composante de programmation de jeu généralement nécessaire est l'animation basé sur les images: l'affichage d'une séquence d'images en succession rapide pour créer l'illusion du mouvement.
En supposant que toutes les boucle d'animations et tous les cadres affichent le même nombre de secondes, une implémentation de base pourrait être aussi simple comme suit:
Pour intégrer cette classe dans l'exemple précédent, nous pourrions créer un OVNI animé. l'initialisation de l'objet en utilisant le code suivant:
et, dans le AnimationTimer, en ajoutant la seule ligne de code:
à l'endroit approprié. Pour un exemple de code de travail complet, consultez le fichier Example3AI.java dans le repo GitHub.
Manipulation d'entrée d'utilisateur
Détecter et traiter une entrée d'utilisateur dans JavaFX est simple. Actions de l'utilisateur qui peuvent être détectés par le système, comme touches et les clics de souris, sont appelés événements. Dans JavaFX, ces actions provoquent automatiquement la génération d'objets (tels que KeyEvent et MouseEvent) qui stockent les données associées (telles que la clé réelle pressée ou l'emplacement du pointeur de la souris). Toute classe JavaFX qui implémente la classe EventTarget, comme une scène, peut « écouter » pour les événements et les manipuler; dans les exemples qui suivent, nous allons vous montrer comment mettre en place une scène pour traiter divers événements.
En feuilletant la documentation de la classe de scène, il existe de nombreuses méthodes qui écoutent pour traiter différents types d'entrées provenant de différentes sources. Par exemple, la méthode setOnKeyPressed () peut attribuer un gestionnaire d'événements qui activera lorsqu'une touche est enfoncée, la méthode setOnMouseClicked () peut attribuer un gestionnaire d'événements qui s'active lorsqu'un bouton de la souris est pressée, et ainsi de suite. La classe de gestionnaire d'événements sert un seul but: encapsuler une méthode (appelée poignée ()) qui est appelée lorsque l'événement correspondant survient.
Gestion des événements de clavier
Entrée utilisateur est souvent traitée dans la boucle principale du jeu, et donc un dossier doit être conservé dont les clés sont actuellement actives. Une façon d'y arriver est en créant un ArrayList d'objets String. Lorsqu'une touche est enfoncée au début, on ajoute la représentation de chaîne de CodeTouche à la liste du KeyEvent; lorsque la touche est relâchée, on retire de la liste.
Dans l'exemple ci-dessous, la toile contient deux images de touches fléchées; chaque fois qu'une touche est enfoncée, l'image correspondante devient vert.
Le code source est contenu dans le fichier Example4K.java dans le repo GitHub.
Gestion des événements souris
Maintenant, regardons un exemple qui se concentre sur la classe MouseEvent plutôt que la classe KeyEvent. Dans ce mini-jeu, le joueur gagne un point à chaque fois que la cible est cliqué.
Étant donné que les gestionnaires d'événements sont les classes internes, toutes les variables qu'ils utilisent doivent être définitifs ou « efficacement finale », ce qui signifie que les variables ne peuvent pas être réinitialisés. Dans l'exemple précédent, les données ont été transmis au gestionnaire d'événements au moyen d'un ArrayList, dont les valeurs peuvent être modifiées sans réinitialisant (méthodes via l'add () et remove ()).
Toutefois, dans le cas des types de données de base, les valeurs ne peuvent pas être modifiés une fois initialisés. Si vous souhaitez que le gestionnaire d'événements pour accéder à des types de données de base qui sont modifiés ailleurs dans le programme, vous pouvez créer une classe wrapper qui contient soit des variables publiques ou méthodes getter / setter. (Dans l'exemple ci-dessous, IntValue est une classe qui contient une variable publique int valeur appelée.)
Le code source complet est contenu dans le repo GitHub; la classe principale est Example4M.java.
Création d'une classe de base Sprite avec JavaFX
Dans les jeux vidéo, une image-objet est le terme pour une seule entité visuelle. Voici un exemple d'une classe Sprite qui stocke une image et la position, ainsi que des informations de vitesse (pour les entités mobiles) et des informations de largeur / hauteur à utiliser lors du calcul de boîtes englobantes aux fins de la détection de collision. Nous avons aussi les méthodes standard getter / setter pour la plupart de ces données (omis par souci de concision), et des méthodes standards nécessaires dans le développement du jeu:
- mettre à jour(). calcule la nouvelle position en fonction de la vitesse du Sprite.
- rendre(). Dessine l'image associée à la toile (via la classe GraphicsContext) en utilisant la position de coordonnées.
- getBoundary (). retourne un objet Rectangle2D JavaFX, utile dans la détection de collision en raison de sa méthode intersecte.
- intersecte (). détermine si la zone de délimitation de cette sprites recoupe celle d'une autre image-objet.
Le code source complet est inclus dans Sprite.java dans le repo GitHub.
Utilisation de la classe Sprite
Avec l'aide de la classe Sprite, nous pouvons facilement créer un jeu simple de collecte dans JavaFX. Dans ce jeu, vous assumez le rôle d'une mallette dont le but est sensitif de recueillir les nombreux sacs d'argent qui ont été laissés traîner par un ancien propriétaire négligent. Les touches fléchées déplacent le joueur autour de l'écran.
Ce code emprunte beaucoup des exemples précédents: la mise en place des polices pour afficher le score, le stockage d'entrée du clavier avec un ArrayList, la mise en œuvre de la boucle de jeu avec un AnimationTimer, et la création de classes d'emballage pour des valeurs simples qui doivent être modifiés lors de la boucle de jeu.
Un segment de code d'un intérêt particulier consiste à créer un objet Sprite pour le joueur (porte-documents) et un ArrayList d'objets Sprite pour les objets de collection (sacs d'argent):
Un autre segment de code d'intérêt est la création du AnimationTimer. qui est chargé de:
- le calcul du temps écoulé depuis la dernière mise à jour
- réglage de la vitesse de lecture en fonction des touches pressées actuellement
- effectuer la détection de collision entre le lecteur et objets de collection, et mettre à jour la partition et la liste des objets de collection lorsque cela se produit (un itérateur est utilisé plutôt que le ArrayList directement pour éviter une modification concurrente Exception lors de la suppression des objets de la liste)
- rendre les sprites et le texte sur la toile
Comme d'habitude, le code complet se trouve dans le fichier de code ci-joint (Example5.java) dans le repo GitHub.
Prochaines étapes
Conclusion
Dans ce tutoriel, je vous ai présenté aux classes JavaFX qui sont utiles dans la programmation de jeux. Nous avons travaillé à travers une série d'exemples de complexité croissante, culminant dans un jeu collection de style basé sprite. Maintenant, vous êtes prêt à enquêter sur une ou l'autre partie des ressources énumérées ci-dessus, ou de plonger et commencer à créer votre propre jeu. La meilleure chance à vous dans vos efforts!
12 moteurs et plates-formes Gamedev (et les meilleures façons d'apprendre chacun d'eux)
Michael James Williams