Construire votre premier jeu 2D avec Flutter et Flame pour iOS et Android | Rahul Agarwal | Skillshare
Recherche

Vitesse de lecture


1.0x


  • 0.5x
  • 0.75x
  • 1 x (normale)
  • 1.25x
  • 1.5x
  • 1.75x
  • 2x

Construire votre premier jeu 2D avec Flutter et Flame pour iOS et Android

teacher avatar Rahul Agarwal, Flutter Developer & Trainer

Regardez ce cours et des milliers d'autres

Bénéficiez d'un accès illimité à tous les cours
Suivez des cours enseignés par des leaders de l'industrie et des professionnels
Explorez divers sujets comme l'illustration, le graphisme, la photographie et bien d'autres

Regardez ce cours et des milliers d'autres

Bénéficiez d'un accès illimité à tous les cours
Suivez des cours enseignés par des leaders de l'industrie et des professionnels
Explorez divers sujets comme l'illustration, le graphisme, la photographie et bien d'autres

Leçons de ce cours

    • 1.

      Vidéo d'introduction du cours

      1:01

    • 2.

      Créer un projet Flutter

      8:18

    • 3.

      Créer un cours de jeu

      11:47

    • 4.

      Ajouter des arrière-plans et des joueurs

      12:15

    • 5.

      Ajouter du mouvement avec Joystick

      10:28

    • 6.

      Écrire les limites de joueur

      8:51

    • 7.

      Ajouter un composant haltère

      3:24

    • 8.

      Ajouter des HitBoxes aux composants

      7:08

    • 9.

      Réagir à une collision

      5:19

    • 10.

      Positions aléatoires d'haltères

      5:24

    • 11.

      Ajouter des composants de virus

      5:10

    • 12.

      Ajouter des mouvements à des virus

      7:19

    • 13.

      Limites des éléments de virus

      12:44

    • 14.

      Collision entre le virus et le joueur

      8:46

    • 15.

      Composant texte pour la partition

      4:43

    • 16.

      Mettre à jour le score et l'heure

      4:41

    • 17.

      Menu de jeu sur le menu

      8:19

    • 18.

      Écran de menu principal

      5:01

    • 19.

      Écran de jeu

      10:25

    • 20.

      Changer de joueur Sprite conditionnellement

      11:41

    • 21.

      Créer un composant de vaccin

      6:28

    • 22.

      Ajouter un vaccin à intervalles aléatoires

      14:17

    • 23.

      Travailler sur les éléments protéiques

      18:10

    • 24.

      Ajouter un écran de touche éclaboussure

      4:51

    • 25.

      Modifier l'icône du lanceur

      7:18

    • 26.

      Tester le jeu complet

      0:39

  • --
  • Niveau débutant
  • Niveau intermédiaire
  • Niveau avancé
  • Tous niveaux

Généré par la communauté

Le niveau est déterminé par l'opinion majoritaire des apprenants qui ont évalué ce cours. La recommandation de l'enseignant est affichée jusqu'à ce qu'au moins 5 réponses d'apprenants soient collectées.

25

apprenants

--

À propos de ce cours

Vous souvenez-vous des jeux 2D classiques que nous jouions en tant qu'enfants ? Comme Mario, Contra, Donkey Kong, combat mortel, etc. Êtes-vous intéressé par le développement de vos propres jeux mobiles mais vous ne savez pas par où commencer ? Bonne bonne nouvelle est que vous pouvez maintenant construire votre propre jeu mobile 2D avec ce nouveau cours passionnant qui vous fera voyager dans un parcours de développement de jeu à partir de zéro à l'aide de flutter et de moteur de jeu de flamme ! Ce cours complet est conçu pour enseigner aux débutants les bases du développement de jeu en utilisant le cadre Flutter et le moteur de jeu Flame.

Avec des instructions et des explications étape par étape, vous apprendrez à créer vos propres jeux 2D pour les appareils iOS et Android. Vous commencerez par créer votre environnement de développement et par apprendre les bases de la conception de jeu, y compris les sprites, les animations et la détection des collisions. À partir de là, vous explorerez des sujets plus avancés, comme la gestion des saisons, les effets sonores et la mécanique du jeu.

Tout au long du cours, vous travaillerez sur un exemple de jeu, le construire, de zéro et de personnaliser cela à votre goût. À la fin de cela, vous aurez un jeu entièrement fonctionnel que vous pourrez partager avec vos amis et votre famille ou même publier sur les boutiques d'applications.

Que vous soyez un débutant ou un développeur expérimenté à la recherche d'élargir votre jeu de compétences, "Construire votre premier jeu 2D avec flutter et flame" est le guide idéal pour vous aider à commencer à développer des jeux.

Rencontrez votre enseignant·e

Teacher Profile Image

Rahul Agarwal

Flutter Developer & Trainer

Enseignant·e

Hello, I'm Rahul. I am skilled in building cross platform application using Flutter. I am freelance developer as well as conduct workshops to share my knowledge with the community.

Voir le profil complet

Level: Beginner

Notes attribuées au cours

Les attentes sont-elles satisfaites ?
    Dépassées !
  • 0%
  • Oui
  • 0%
  • En partie
  • 0%
  • Pas vraiment
  • 0%

Pourquoi s'inscrire à Skillshare ?

Suivez des cours Skillshare Original primés

Chaque cours comprend de courtes leçons et des travaux pratiques

Votre abonnement soutient les enseignants Skillshare

Apprenez, où que vous soyez

Suivez des cours où que vous soyez avec l'application Skillshare. Suivez-les en streaming ou téléchargez-les pour les regarder dans l'avion, dans le métro ou tout autre endroit où vous aimez apprendre.

Transcription

1. Vidéo d'introduction du cours: Vous souvenez-vous des jeux 2D classiques auxquels nous jouions étant enfants, tels que Mario Contract, Donkey Kong, Mortal Combat, etc. bonne nouvelle, c'est que vous pouvez désormais créer votre propre jeu mobile en 2D grâce à ce nouveau cours passionnant qui vous emmènera dans le développement de jeux à partir de zéro à l'aide de Florida et Flame Game Engine Nous allons commencer par les bases telles que comment pour configurer un projet. Découvrez ensuite comment créer et ajouter des sprites. Implémentez les entrées utilisateur telles que les commandes par joystick, configurez une boucle de jeu pour que notre jeu fonctionne correctement. Vous apprendrez également à détecter les collisions entre objets et à ajouter des effets sonores pour améliorer leur expérience de jeu. Que vous soyez un programmeur débutant ou expérimenté. Ce cours est conçu pour vous aider à maîtriser les compétences dont vous avez besoin pour créer vos propres jeux 2D. À la fin du cours, vous aurez un jeu complet que vous pourrez partager avec vos amis, famille et même le publier sur l'App Store. Alors, sans perdre plus de temps, allons-y. 2. Vidéo 1 Créer un projet de flotteur: Bonjour, bienvenue sur la toute première vidéo du cours, où nous allons apprendre à créer un jeu en utilisant le moteur de jeu Flutter and Flame. J'espère donc que vous savez déjà ce qu'est une flamme. Flame est un framework de jeu 2D construit au-dessus de la Floride, dans lequel nous pouvons créer n'importe quel type de jeu 2D et l'exécuter sur lequel nous pouvons créer n'importe quel type de jeu 2D et l'exécuter toutes les plateformes compatibles avec la Floride comme le mobile, le Web et les ordinateurs de bureau. Avec Flame, nous pouvons créer une large gamme de jeux, notamment des jeux de plateforme, des jeux de puzzle et moins de courses, RPG, des jeux d'aventure et bien d'autres encore. Je ne veux donc pas trop entrer dans la partie théorique. Mais au moins, nous devrions savoir ce que nous allons construire. À la fin du cours. Nous allons créer un jeu dans lequel un homme doit collecter des haltères pour rester en forme, ainsi que pour éviter les virus afin ne pas perdre sa masse musculaire avant la fin du temps imparti. De plus, nous introduirons des vaccins, que vous pourrez immuniser vous-même pendant quelques secondes, ainsi que des boissons protéinées, qui lui donneront de l'énergie supplémentaire. Commençons par créer un nouveau projet en Floride. Accédez donc au répertoire de votre choix ouvrez votre terminal et créez un nouveau projet en Floride avec ce code Flutter. Créez. Je vais nommer le jeu Fighter. Appuyez sur Entrée. D'accord. C'est fait, nous avons créé le projet k. De plus, puisque je ne facturerai pas pour Windows, Linux et Mac OS. Je vais donc simplement supprimer ce fichier juste pour rendre propre et consommer moins d'espace. Maintenant, ajoutez l'éditeur VSCode et ajoutez un nouveau dossier de jeu. La semaine de cours pour K. OK. Maintenant, la première chose que je vais faire est d'installer les packages requis. Alors passez à dev. Et d'abord, recherchez le blâme. Juste une flamme. Celui-ci est obligatoire. Flame fournit un ensemble d'outils pour créer les jeux, y compris des widgets pour saisir des sprites et des émissions, et gérer la logique du jeu. Je vais simplement le copier et le coller dans le fichier YAML pub spec dot ci-dessous, dans la section des dépendances. Il suffit de le sauvegarder. Et l'autre package requis est celui-ci qui est responsable de l'audio. Flame audio est un package qui fournit des outils pour gérer l' audio et les jeux. Il inclut des utilitaires permettant de charger et de jouer des effets sonores et de la musique, gérer les canaux audio et de contrôler la lecture audio. Copiez également celui-ci. Et collez-le ici. Sauvegardez-le. OK, je suppose que ça marche bien. Nous avons les colis. Ensuite, je vais créer un nouveau dossier, actifs à la racine de notre projet qui se trouve ici, je vais simplement créer des actifs. Ici, nous avons besoin de deux nouveaux dossiers, audio et images. Il s'agit de la structure de dossiers proposée ou du jeu Fake Flame, c' est-à-dire de la structure visuelle. Notre dossier, des dossiers de ressources comme celui-ci, c' est-à-dire du son, des images. Et j'ai joint les ressources nécessaires dans cette vidéo, ainsi que dans la dernière vidéo où vous pouvez télécharger l'intégralité, c' est-à-dire le code source complet. J'ai ces acides. Je vais simplement le copier et le coller dans notre dossier de projet. Comme vous pouvez le voir, nous avons l'arrière-plan, le logo du jeu d' haltères, différents types de physique de joueur, le vaccin protéiné et le virus. Et pour le son, nous avons un son d'haltère, un son protéiné. C'est-à-dire que si nous entrons en collision, collectons des objets , nous collectons des objets , des sons seront émis. Si vous souhaitez rechercher vos propres images, vous pouvez rechercher directement en ligne des haltères pour homme soulevant des haltères, vaccin de dessin animé, je peux PNG, shake protéiné, je peux du PNG. Et pour l'audio, vous pouvez simplement effectuer une recherche gratuite pour créer de l'audio du jeu. Maintenant, nous avons le dossier, le dossier des ressources, mais nous devons nous assurer de spécifier les emplacements des dossiers nouvellement créés dans le fichier YAML Pub spec point. Donc, ici, vous pouvez voir ci-dessous, vous avez cette ligne intérieure 64, vous avez ces atouts. Il suffit donc de supprimer, d' accéder à cette ligne et de supprimer, d'appuyer deux fois sur Supprimer, descendre et d' appuyer deux fois. J'espère que vous savez que ce procès est très délicat. Tout espace ou onglet supplémentaire générera une erreur. Voici simplement mentionnés, les actifs, les images, et l' autre, les actifs audio. Et enregistrez-le. C'est tout pour cette vidéo. Lors de la prochaine session, nous créerons notre classe de jeu. Merci 3. Vidéo 2 Créer un cours de jeu: Bonjour. Nous allons donc maintenant apprendre le concept de classe de jeu Flame. Ce sera le cœur, ou vous pouvez dire, le point d'entrée de notre jeu. Nous allons créer et gérer tous nos autres composants à partir d'ici, accédez au fichier point principal. Et supprimons, supprimons simplement tout. D'accord ? Je veux tout supprimer ici. Créons une classe distincte pour notre classe de jeu, qui soit un dossier distinct dans leur vie. Créez simplement un nouveau dossier et nommez-le games. Et à l'intérieur, créez un nouveau fichier. Poids. Jeu de combat. Ni fléchette. La classe Playing Game implémente un jeu basé sur des composants. Il possède une arborescence de composants et appelle les méthodes de mise à jour et de rendu de tous les composants qui ont été ajoutés au jeu. Donc, pour créer une classe gagnée par Flame, il vous suffit de créer une classe, ce jeu de combat F8, et de l'étendre au jeu Flame comme celui-ci. C'est ainsi que vous créez une classe de jeu. Il a donc une méthode de chargement, ou la méthode définie l'est également, mais déchargez. Et ici, je vais simplement en faire un futur. Et un évier : ici, je fais le lien entre les composants d'un évier et n' importe quel autre fond d'image. Ce sont tous des composants qui peuvent être ajoutés directement à la classe de jeu à l' aide de ce déchargement. Et ici, nous allons utiliser la méthode add juste pour ajouter ce composant à notre classe. Et ce déchargement n'est exécuté qu' une seule fois lors du démarrage de notre jeu. Voici donc la classe de jeu Flame. Parlons de ce widget de jeu. Chaque jeu que vous lancez avec Flame est rigide. Dans notre application Florida, comme n'importe quel texte ou bouton, le widget du jeu est un widget Flutter qui est utilisé pour insérer ce jeu dans l'arborescence des widgets de Floride. C'est donc très simple. Accédez simplement au fichier principal à points et supprimez ce code qui est ma classe et tout autre élément qui reste est la classe principale. Nous pouvons directement transmettre le widget du jeu ici dans l'application Run. Et cela nécessite une instance de jeu qui désigne simplement l' objet de notre jeu, comme ce combat final, leur jeu. Le jeu ici. Transmettez simplement la variable. Et pour s'assurer qu'il est prêt. Nous écrirons cette Floride, un widget Florida liant et déliant, sans garantir son initialisation. Tout est donc initialisé par le flutter. Maintenant, sauvegardez tout, ouvrez un appareil VR, c'est-à-dire que j'utilise un émulateur, mais vous pouvez également utiliser votre propre appareil. Maintenant, attends, ça. Commencez simplement le débogage. Cela peut prendre un certain temps. Voyons quelle est l'erreur ? Je ne pense pas qu'il y ait d'erreur ici, d'accord, j'ai oublié de donner une barre oblique. C'est une erreur très stupide. Il ne vous reste plus qu' à développer l'application. Ce sont de très petites erreurs stupides, ce qui arrive. Donc, comme vous pouvez le voir, notre application fonctionne, mais elle ne fera rien. Nous disons simplement écran noir vide sur notre appareil. Comme nous savons que nous avons déjà les actifs audio, ajoutez des images dans le dossier des actifs. Mais au lieu d'appeler ces fichiers par leur nom partout, créons un fichier distinct pour eux. Créons donc un dossier. Le nom est une constante, et à l'intérieur, créez un fichier. Points globaux. Nous enregistrerons tous les noms des actifs dans des variables statiques. Cette approche évite toute faute d'orthographe et permet de modifier n'importe quel actif ultérieurement. Créons une classe globale. La première chose que je vais faire est de rendre ce constructeur privé afin que nous n'ayons pas à créer d'objet ou d'instance de cette classe. Nous appellerons directement les images à l'aide cette chaîne statique statique. Sac moulu. Le sprite est égal au nom du sprite d'arrière-plan est le point d'arrière-plan JPG. Dense, aussi épais que ça. Jetait un coup d'œil. Apportez de la lumière aux haltères. Est-ce que ça va faire du PNG avec des haltères ? Puis statique, constant, lecteur à cordes. Maigre. Sprite est égal à la couche Skinny Dot PNG. Maintenant, copiez-le et collez-le comme ceci. Ensuite, nous avons Player Sprite. Ce sera du format Player Fit Dot PNG. Ensuite, nous avons Sprite, un joueur musclé. Il s'agit d'un Muscular Dot PNG. Tu as de la fièvre. C'est-à-dire que s'il a été attaqué, alors nous avons la fièvre des couches en PNG. Ensuite, nous avons le sprite pour virus. Virus. Et le nom du spray est Virus Dot PNG. J'ai collé encore un peu de temps. Ensuite, nous allons vacciner, vacciner cette PNG. Et puis nous avons les protéines Sprite. Et le nom est protein ik dot PNG. Voici les images. C'est maintenant l'heure de l'audio. Il suffit de le coller et ce sera un son numérique. Le nom du son est Number, le son MP3. Au fur et à mesure, copiez-le, collez-le quatre fois. Le suivant est le son sans fil. Ce sera mon PNG de moins. Le prochain son du vaccin, le point sonore. C'est une vague, c'est une vague. Et enfin, nous avons le son protéiné. Voici Protein Sound Dot, mp3. Oui. Nos constantes sont donc prêtes. Il nous sera très pratique d'appeler n'importe quel actif plus tard dans notre application. Et Q 4. Vidéo 3 Ajout de fond et de lecteur: Bonjour, bon retour. Dans cette vidéo, nous allons créer notre premier composant. Les composants sont les éléments de base d'un jeu Flame. N'importe quelle entité ou objet du jeu peut être représenté en tant que composant. C'est assez similaire aux widgets en Floride. Tout ce que nous voyons en haut de l'écran, c' est-à-dire tous les composants, par exemple l'image d' arrière-plan, les anciens personnages , les objets à l'écran, etc. Passons donc au dossier lib. Créez un nouveau dossier appelé Come ponens. Et à l'intérieur, si vous créez un nouveau fichier et que vous le nommez composant d'arrière-plan k, il suffit de créer une classe. Mais composante terrestre. Cela étendra le composant Sprite de cette manière. Maintenant, dans ce moteur de jeu de blâme, un composant sprite est un objet graphique qui représente une image ou une animation 2D. Il est généralement utilisé pour représenter des personnages, des objets ou d'autres objets du monde du jeu. Le composant Sprite peut être positionné, pivoté et redimensionné, et peut être mis à jour en fonction des différentes images d'une animation. Ici. Cela possède sa propre méthode de déchargement. Ainsi, chaque composant doit être déchargé, déchargé, mis à jour. Toutes ces méthodes sont prédéfinies. Nous allons simplement écrire sprite, c'est-à-dire la valeur de ce composant sprite. Ici. Maintenant, comprenez bien qu' il ne s'agit que du composant et que nous devons ajouter ce composant à notre classe de jeu principale. Nous devons donc certainement avoir une référence qui peut être faite en utilisant un mixin appelé width, qui possède un jeu comme celui-ci et dont le nom est fistfight. Leur classe. C'est la classe de jeu qui a référence de jeu qui est utilisée pour indiquer qu'un objet a une référence à la classe de jeu en cours. C'est-à-dire que cela fait référence à la classe de jeu actuelle. Cela est utile car de nombreux objets de jeu ont besoin d'accéder à des variables globales. Toute variable qui se trouve ici dans cette classe, par exemple les scores ou quoi que ce soit d'autre, les entrées gérant la lecture audio. En d'autres termes, nous pouvons accéder aux propriétés et aux méthodes cette classe de jeu à partir de cette classe, aussi simple que cela. Et nous pouvons accéder à nos contenus d'envoi ou de chargement en utilisant cette référence de jeu, le point de référence du jeu de société, charge très clairement. Alors quel sprite voulons-nous ? Arrière-plans de départ mondiaux. Sprite, celui-ci. Et quelle devrait être la taille de ce luminaire ? Cela devrait être de la taille de ce jeu. C'est l'écran complet. OK, maintenant, si je le sauvegarde, rien ne se passera. D'accord ? J'espère que vous comprenez que ce déchargement correspond au cycle de vie de ce composant. Nous utilisons l' événement OnLoad pour obtenir le même résultat que cette classe de jeu. Qu'il s' assurera que tout est prêt lorsqu'il sera appelé pour la première fois. Et la taille des points de développement du jeu prend la largeur et la hauteur complètes de la machine utilisateur. Maintenant, pour y montrer ce composant , dans ce jeu, nous devons simplement utiliser cette méthode d'ajout, qui est utilisée pour ajouter un nouvel objet de jeu au monde du jeu. La méthode d'ajout est donc utile pour ajouter de nouveaux objets de jeu tels qu'un joueur ennemi ou lorsqu' un nouveau niveau est chargé. Pour toutes ces choses. La publicité est utilisée. Il suffit d'écrire un composant d'arrière-plan comme celui-ci. Encore une fois, je dis que cela s'appelle lorsque le jeu est chargé pour la première fois et qu'il crée une nouvelle instance du composant d' arrière-plan. Maintenant, sauvegardons-le. Nous avons le jeu Rigid Fit pour leur jeu est-il Leur schéma référence ? Oui, c'est tout ce que je vais juste dominer. Et recommence. Je pense que j'aurais dû actualiser l'ajout plusieurs fois. Voyons ce qui se passe si Fred et encore une fois, nous voyons que nous avons cette image d' arrière-plan. Donc, cette erreur était la suivante. Nous avons dû supprimer, redémarrer ou parfois arrêter et démarrer notre application car nous n'utilisions pas le chargement Hartree. De la même manière que cet arrière-plan, créons également un composant sprite pour notre joueur. Accédez simplement au dossier des composants, créez un nouveau fichier point. Composant de couche. Point, point. Oui, un composant similaire à la couche légère étend le composant brillant et possède un mixin qui sert de référence au jeu. Comme leur jeu, comme celui-ci. Grotte. Maintenant, nous devons utiliser le déchargement. Mon père a dit qu'il fallait décharger à l'avenir. Alors. De même, nous utiliserons la propriété sprite de ce composant de diffusion car nous voulons que le sprite soit chargé. Ce sprite de chargement et qui est le nom de l'image, joueur de démarrage global. Lot mondial. Nous avons le joueur maigre, celui-ci. Alors. Maintenant, il existe également d'autres propriétés d'un composant sprite. C'est ce que devrait être la position de cette image, n'est-ce pas, dans le jeu. Nous devrions donc le mettre, nous allons simplement le mettre au milieu de l'écran. C'est-à-dire que nous prenons l' écran complet et le divisons par deux. Montrons-le au centre de l'écran, sur les axes X et Y. Maintenant, quelle devrait être la hauteur ? Nous allons simplement mentionner la hauteur ici dans une variable afin de pouvoir la modifier. Quand on veut. Sprite, la hauteur va être de 100. Écrivez simplement, la taille est égale au poids est égal à psi. Donc, le surélevé, qui devrait être le même point d'ancrage. Ancrez où et où. Ainsi, l'ancre des composants d'un sprite fait référence au point situé à l'intérieur. Cela est donc utilisé, tout comme l'origine ou le point central des sprites. C'est-à-dire qu'il est utilisé comme référence pour partitionner, faire pivoter et redimensionner le sprite. Par défaut, le point d'ancrage est situé en haut à gauche, mais pour le moment, nous l'avons déplacé au centre. Maintenant. Maintenant, sauvegardons tout. Et de même, nous devons également l'ajouter dans notre composant d'arrière-plan. Nous allons donc ajouter un composant de couche comme celui-ci. Et n'oubliez pas que les composants sont ajoutés dans cette séquence. Nous les avons mentionnés, c'est-à-dire que si nous écrivons l'arrière-plan sous le joueur, nous ne pourrons pas voir ce composant du joueur à l'écran. Et aussi, je vais simplement changer les choses à l'échelle mondiale. Étant donné que le nom de fichier est global, je vais simplement le changer en global et apporter les modifications. Par. Maintenant. Nous démarrons l'application et voyons, vous pouvez voir le composant joueur au milieu de l'écran. Et quand je dis taille ou position, il s'agit de l'axe X et de l'axe Y. J'espère que vous avez appris à créer vos premiers composants. Dans la vidéo suivante, nous allons travailler sur l'ajout d'un joystick dans notre jeu. Merci. 5. Ajouter du mouvement avec Joystick: Bonjour, bon retour. Il est donc temps d' ajouter du mouvement à notre composante joueur. Plane nous offre différentes options de saisie telles que le clavier , les gestes, le glissement, etc. Mais comme nous avons l'intention de créer un jeu mobile, la plupart des appareils mobiles ne disposent pas de clavier ni de boutons matériels. Pour cette raison, nous allons créer un joystick virtuel, quelle flamme ? Cela peut être fait en utilisant le composant joystick. Créons donc un nouveau dossier dans lib appelé inputs. À l'intérieur, créez un fichier. Joystick point, point. Maintenant, créez simplement une instance du composant Joy Stick. joystick est égal au composant joystick de k. Le composant du joystick est composé de trois éléments principaux. Ce bouton, le fond et la marge. Alors, maintenant, le bouton sera un composant circulaire. Ensuite, EDS attendra 30. Peignons-le. Palette de base, ce point rouge avec alpha deux et peinture rouge. Il s'agit du cercle intérieur que l'utilisateur va faire glisser. Ce bouton, c'est celui-ci. Ensuite, nous avons le contexte. Contexte. Encore une fois. J'ai une composante circulaire. Le rayon sera supérieur à 80. Peindre. Basic, palette à pois rouges. Modifions-en un peu son opacité, quelque sorte cette peinture. OK, maintenant, celui-ci est le cercle extérieur. Vous le comprendrez lorsqu'il sera rendu. Enfin, laissons cette marge. Inserts de bord Const. Des inserts de bord dont je suis le seul à avoir besoin. Ici. La gauche sera combattue. modem D sera pour T. Donc voici quoi, c'est la position du joystick. Position du joystick. Voici donc ce composant du joystick. Sauvegardons notre fichier. Ajoutons ce joystick à notre jeu. Accédez au fichier F8 Fighter ici. Cliquez juste en dessous du composant du lecteur. Joystick. Il est importé depuis les entrées. Et n'oubliez pas que nous devons utiliser un mixage déplaçable dans le fichier principal du jeu, dans la classe de jeu principale, lorsque nous utilisons n'importe quel type de choix, les composants, donc comme cette largeur a fait glisser parce que, puisque vous le comprenez également, nous faisons glisser le bouton ici. Allons-y et repartons. D'accord. Désolée encore une fois, je dois me rafraîchir. Voir. Nous l'avons maintenant. Je n'ai tout simplement pas aimé la couleur du cercle extérieur. Allons-y encore une fois. Le cercle extérieur doit être écrit à la main. Ça a l'air tellement beau. Maintenant, ajoutons que ce coup a été ajouté à notre composant joueur. Accédez au fichier des composants de la couche. Tout d'abord, nous aurons une variable composant le joystick. C'est-à-dire que nous accepterons ce joystick ici. Dans ce dossier. Composant de couche requis, ce type de joystick à points. D'accord ? Nous devons donc envoyer ce joystick ici. Également. Mentionnons la vitesse à laquelle le joueur se déplacera. Il y en aura 500. Nous allons maintenant utiliser la méthode de mise à jour. Maintenant, la mise à jour est une sorte de boucle de jeu. Nous avons deux boucles de jeu, principalement la mise à jour et le rendu. Nous utiliserons donc la méthode de mise à jour la plupart du temps. La flamme appelle la méthode de mise à jour d'un composant chaque image cochée de la boucle d'événements pour redessiner chaque composant du jeu qui a changé. Cela ressemble à des battements. Construis mon tour. Nous ajouterons de la logique ici dans cette mise à jour mon poste de réalisateur, le personnage ou les mouvements des personnages. La méthode de mise à jour prend un seul paramètre , à savoir ce temps delta. C'est-à-dire que celui-ci d t est mesuré en secondes. Ce temps delta est utilisé pour garantir que les objets du jeu se déplacent et se comportent de manière cohérente sur différents appareils et à différentes fréquences d'images. Par exemple, si un joueur est censé se déplacer à une vitesse de cent pixels par seconde. Et le temps écoulé depuis la dernière image était de 0,02 s, l'objet devrait se déplacer de deux pixels dans cette image. Cela correspond à 100 pixels par seconde multipliés par 0,02 seconde. Dans ce jeu, les développeurs peuvent créer des jeux fluides et réactifs sur différents appareils. Maintenant, ajoutons-le. Je vais le faire. Tout d'abord, je vais juste vérifier si le joystick, cette direction est égale à la direction, direction du joystick est inactive . Rien ne se passe, puis revenez simplement d'ici. Si l'utilisateur ne fait pas glisser le bouton. Ailleurs, il suffit de changer la position que ce point variable ajoute. Nous ajouterons le delta relatif du joystick à la fête du printemps. Je vais vous montrer ce qui se passe si je ne multiplie pas le delta. Nous allons donc simplement envoyer un bâton comme celui-ci. Jetons un coup d'œil à notre application. Maintenant. Si je le fais glisser vers le haut, tu vois, c'est allé si vite. Mais si je passe à la composante joueur ici, si je multiplie d T également, alors vous verrez que c'est tellement fluide. Le mouvement. C'est tellement agréable. Notre mouvement se déroule donc correctement. C'est tout pour cette vidéo. Rendez-vous lors de la prochaine session. 6. Bandes d'écran de vidéo 5 à lecteur: Bonjour. Comme vous pouvez le constater, notre joueur se déplace bien, mais s'il s'approche de la limite, il la dépasse. C'est-à-dire qu'il franchit la limite. Nous devons donc créer ou implémenter une logique afin que cet utilisateur ne puisse pas déplacer la limite du joueur. C'est pour cela qu'il doit arrêter. Ici, il doit arrêter comme ça. Nous devons donc nous assurer que le joueur ne peut se déplacer que sur l'écran de cet appareil. Composant incontournable pour les joueurs. Oui. Tout d'abord, créons des variables limites pour les quatre côtés. En retard, double, à droite, en retard, à gauche, en bas, à bord. Maintenant, comme il s'agit de variables tardives, nous devons évidemment les initialiser lors du chargement. À droite, il y aura un jeu de cette taille, PAS x -60. Je vais donc vous expliquer cette valeur. C'est donc la bonne limite. D'accord ? Donc, tout d'abord, nous avons fait quel jeu rho f dot size x, the x. De ce côté. Nous avons pris toute la taille verticale ou horizontale ici, puis -60 pour qu'elle ne passe pas de ce côté. C'est-à-dire que je ne veux pas que ce soit bleu sarcelle ici. Si je ne donne à la référence du jeu qu'un point x, ce sera Delia, donc je donne -60, donc ça s'arrêtera ici. Nous soustrayons 60. Cela va donc s'arrêter là. C'était donc la logique pour la borne droite ou la borne gauche. Ce sera simplement 60. Autrement dit, si nous écrivons zéro, nous reprenons le même concept. Ça ira jusqu'au bout. Mais je donne juste une sorte de marge, vous pouvez dire 60. La limite supérieure sera la même. 60. Puisque y commence, y commence par zéro, nous ajoutons simplement zéro plus 60. Ici, puisque la direction x commence par zéro. Et ici, nous ne faisons que soustraire. J'espère que vous comprenez la taille complète de l'écran -16. Et la gauche part de zéro, puis nous l'avons vers le bas. Référence du jeu Dot Size Dot. Pourquoi est-ce allé jusqu'à la verticale, jusqu'au bas, puis soustrait six Grotte. Nous avons maintenant les variables. Dans la méthode de mise à jour. Nous allons simplement vérifier si les axes X et Y du Sprite dépassent les limites d'achat, puis nous rendrons les valeurs des axes X et Y constantes. C'est-à-dire que c'est cette valeur qui est le bord de la limite. Je vais implémenter et expliquer à nouveau. Donc ci-dessous. Et nous allons simplement dire que si ce n'est pas l'idéal, alors ne vérifiez pas les limites. Vérifiez si l'axe X du composant sprite est supérieur ou égal à la limite de surlignage, puis placez l'axe X vers le faisceau de droite, cela n'ajoutera aucune valeur à cet emplacement. Encore une fois, je voudrais m'expliquer. Cela signifie donc qu'ici, l' accès du joueur à l'axe X est nul. Ensuite, il commence à augmenter, à augmenter. Ensuite, c'est dans la droite qui se trouve ici. Maintenant, nous devons simplement assurer que l' axe x n'augmente pas. Nous attribuons simplement le XX, droite de la mention, cette valeur lui est attribuée encore et encore. De même. Vérifions si l' axe x est inférieur à la limite gauche, alors x est égal à la limite gauche. Maintenant, si l'axe y est supérieur à la limite supérieure, alors y est égal à la liaison. Et si y est supérieur à la blessure vers le bas, alors y est égal à K. Nous n'avons rien à modifier ici pour redémarrer. Maintenant, si j'essayais d' aller dans n'importe quelle direction, veillerais à ce que les limites fonctionnent parfaitement. Maintenant. Ici, comme je l'ai dit, si l'axe x est supérieur à la liaison droite, assurez-vous simplement que la valeur x est la limite droite. D'accord ? Maintenant, je vais juste changer la valence. Montrez quelle est la différence. Si j'appuie dessus la dernière fois , si je l'écris, par exemple , que se passera-t-il si je passe directement à write exists c, d'accord ? C'était trop cher, d'accord ? Si j'écris juste relié, je pense que cela ne devrait être que plus, ça devrait être moins -60 de plus. Voyons voir. Si je passe à C. Nous sommes poussés à -60 ici. C'est -60. Mais je veux, je ne veux pas un -60. C'est pourquoi je veux juste que l' axe X aille jusqu'à la fin. C'est celui-ci. C'est ça. Il en va de même pour toute autre direction. J'espère que vous avez compris le concept. Si vous ne créez qu' une ou deux applications, vous vous habituerez à ces concepts et à tout. Merci. À bientôt dans la vidéo suivante. 7. Vidéo 6 Ajout de composant haltère: Bonjour. Créons maintenant un nouveau composant sprite pour ces haltères. Dans le dossier des composants, créez un nouveau fichier. Composant de Ponens, point, point. D'accord, donc de même, nous allons ajouter LastName. Lorsque l'adversaire étend le composant Sprite. Le jeu de mixage sera adapté à leur jeu. K. Des chiffres, non ? La taille sera jouée. La hauteur est égale à 60. Faisons décharger mon total. Encore une fois, c'est un sprite. La valeur vous attendra. Jeu Ref Dot Load Sprite, Globals Dot Dumbbell Sprite. La taille sera égale au poids, qui sera égal à 60. Il s'agit de la variable de hauteur du sprite. La partition sera le vecteur deux, c'est-à-dire uniquement l'axe X et l'axe Y. Je vais juste donner la valeur x à 200, 200. Nous modifierons cela plus tard. Et l'ancre sera au centre du point d'ancrage. Sauvegardez-le. Ajoutons maintenant ce composant d'haltères à notre jeu. Accédez au tarif FIT Fight. Par. Ensuite, en dessous du composant de la couche. Ajoutez simplement ici un composant d' haltère, k. Redémarrons l' application et vérifions-la. Tu vois, nous avons l'haltère ici. De toute évidence, rien ne se passera si nous touchons l'haltère en ce moment. Mais au moins, notre application de jeu est plutôt jolie. Les gens peuvent voir et dire, d'accord, c'est une sorte de jeu. Voilà, c'est tout pour cette vidéo. Dans la vidéo suivante, nous travaillerons sur cette détection de collision. Merci 8. Vidéo 7 Ajout de HitBoxes aux composants: Bonjour. Il est donc temps de travailler sur la logique selon laquelle chaque fois que le joueur s' approche de l'haltère, quelque chose devrait se passer à l'écran, savoir si nous devons être capables de les saisir toutes les deux et toutes. Ces fonctionnalités peuvent être réalisées à l'aide du concept de détection de collision. détection des collisions est nécessaire dans la plupart des jeux pour détecter et agir sur deux composants qui se croisent, par exemple une flèche et un autre joueur ramassant une pièce. Ainsi, pour détecter une collision sur n'importe quel composant, il doit y avoir un cadre de délimitation précis autour de ce composant. Et techniquement, c'est ce que l' on appelle les hit boxes. Maintenant, mettons-le en œuvre. La première étape consiste donc à activer détection des collisions dans notre classe de jeu principale. Et dans cette classe, nous pouvons le faire en ajoutant un appel de mixage. Dispose d'une détection de collision, c' est aussi simple que cela. Cela fera en sorte que notre jeu désormais à l'écoute de toute collision entre les composants. Maintenant, pour nous assurer que nos composants peuvent entrer en collision les uns avec les autres, nous devons ajouter la combinaison connue sous le nom de rappels de collagène. Tu dois juste te souvenir de ces choses, c'est tout. Encore une fois, il en va de même pour eux. Rappels en cas de collision de composants de couche. Maintenant, nous devons ajouter des boîtes de chauffage à un composant. Ce système de détection de collision prend en charge trois types de formes différents que vous pouvez créer. Boîtes à haine de. Cela forme notre polygone, notre rectangle et notre cercle. Plusieurs zones de haine peuvent être ajoutées à un composant pour trouver la zone qui peut être utilisée pour détecter les collisions. Sans ajouter la boîte principale, ce composant n'aura aucune idée qu'ils peuvent entrer en collision. Nos intérêts se recoupent. Maintenant, puisque notre haltère est la structure de notre haltère est une sorte de rectangle. Nous allons donc ajouter la boîte rectangulaire à notre composant haltère. Nous pouvons simplement l'ajouter comme ceci. Lorsque la fonction onload est utilisée, elle est très similaire à tout ajout d'un autre composant. Accédez au composant joueur et faites de même. Dans le OnLoad. Il suffit d'ajouter Tangle Head Box Lady. OK, maintenant, si je sauvegarde et que j'accède à notre application, vous ne verrez aucune différence. Mais nous pouvons, au moins dans ce mode de débogage, utiliser une fonctionnalité fournie par le moteur Lemma. C'est-à-dire que nous pouvons faire passer le De Beauvoir à vrai. Il s'agit d'un outil qui permet aux développeurs de visualiser et de corriger les collisions entre les objets du monde du jeu. Lorsque le mode de débogage est activé, les objets de collision sont surlignés affichés de manière à ce que les développeurs puissent voir où ils se trouvent et comment ils interagiront les uns avec les autres. Passez simplement à l'haltère. Et ici, le simple fait d'écrire le mode debug est égal à vrai. Et il en va de même pour le joueur. Ci-dessous, ici. Le simple fait d'écrire le mode debug est égal à vrai. Maintenant, enregistrez et redémarrez. Vous pouvez maintenant voir une sorte de boîte rectangulaire. Maintenant, vous pouvez au moins visualiser la boîte de tête. Voici donc la boîte principale. De toute évidence. Encore une fois, rien ne se passera pour l' instant. Nous devons ajouter d'autres fonctionnalités pour nous assurer que la collision se poursuit. Mais au moins, nous savons que nous avons mis en place le headbox. Et voyez, si j'y vais, l'axe X est aux deux neuvièmes, un, si je vais ici, l'axe X est évidemment nul, mais vous ne pouvez pas le voir. Il en va de même pour l'axe Y. Voir ici. Tout comme le mode de débogage lequel les zones de réponse contiennent un champ appelé collision de type C, comme celui-ci, type de collision point , nous avons actif, inactif et passif. Le terme passif désigne un type d'objet de collision qui ne bouge pas et ne réagit pas aux collisions. Exemple. Disons que nous créons un jeu dans lequel la balle rebondit dans la pièce. Les murs de la pièce seront de type collision passive. Ensuite, nous avons un type de collision actif par défaut, un type d'objet de collision qui peut se déplacer et réagir aux collisions avec d'autres objets. Par exemple, dans un jeu où nous contrôlons un vaisseau spatial volant dans l'espace, de nombreuses balles ne peuvent pas entrer en collision les unes avec les autres. Dirigez-vous vers le vaisseau spatial. vaisseau spatial sera réglé sur le type de collision point actif, mais les balles seront réglées sur type de collision point passif. Ensuite, nous avons les inactifs. Inactif, en revanche, fait référence à un type d'objet de collision qui n' est actuellement pas actif dans le monde du jeu. Cela peut être utile pour optimiser les performances, car les objets inactifs n' ont pas besoin d'être contrôlés pour détecter toute collision avant qu'ils ne soient actifs. Ajustez un YouTube. Je voulais juste vous informer que ce concept est disponible afin que, dans les prochains jeux, si vous voyez une sorte de collision passive à points et tout le reste, vous sachiez au moins que cela est lié aux collisions et aux zones de frappe. Merci C'est tout pour cette vidéo. Rendez-vous lors de la prochaine session. 9. Vidéo 8 Réagir à une collision: La prochaine étape consiste donc à être averti en cas de collision entre deux composants. Flame le fait pour vous à chaque boucle de mise à jour. Dès que vous touchez des cases, interagissez ou que vous vous croisez, cela fera appel à la méthode de collision que nous devons éviter. Cette surcharge est possible en raison de cette collision appelée mixage inverse. Ci-dessous, téléchargez, juste au moment de la collision, ici. Comme ça. Nous obtenons donc deux paramètres à ce sujet, sur la méthode de collision. La première est une liste de points qui se chevauchent entre les zones de réponse, c' est-à-dire les points d'intersection. Et l'autre est le composant lequel ce composant est entré en collision. C'est un haltère, entre en collision avec ce joueur. Maintenant, nous allons simplement écrire la logique. Si cet autre composant, l' autre est un composant clair. Ensuite, supprimez simplement ce composant qui est un composant haltère du parent qui provient de ce jeu, faites-le simplement disparaître. Essayons-le. Je me dirige vers l'haltère et je vois. Il a disparu. Cela donne donc l'impression ou un effet que le joueur a saisi cet haltère, qu'il a collecté ce numéro. Tu peux le dire. Notre système de détection des collisions fonctionne parfaitement. Nous pouvons supprimer ce mode de débogage car nous n'en avons pas besoin. Maintenant. Recommencez et voyez si je me dirige vers elle, elle disparaît. Donc ça a l'air sympa. Émettons maintenant un son lorsque les composants du lecteur entrent en collision avec eux. Composant haltère. Le package Flame Audio, que nous avons déjà ajouté à notre dépendance de projet, est un outil conçu pour rendre la gestion audio beaucoup plus facile et plus efficace. De cette façon, nous devons précharger tous nos fichiers audio dans la méthode des nœuds de notre classe de jeu qui conviendra au jeu Fighter. Ici, dans la classe de jeu, dans la méthode onload. Il suffit d'écrire Flame Audio, audio, cash, de charger par points toute la résolution. Cela signifie simplement que nous allons tout charger dans la mémoire, la mémoire cache. Cela accepte une liste ou un tableau dont les noms sonores sont des sons globaux, des sons d'haltères à points. Mondiaux. Nous avons le son du virus. Ensuite, il y a le son du vaccin Global Dot. Et enfin, nous avons Lovers Dot Protein Sound. D'accord ? Ce chargement est recommandé car si nous essayions de faire jouer des sons directement dans le jeu qui n' ont pas été ajoutés au cache. Voilà, alors, il peut qu'il y ait un certain retard dans la diffusion du son. Ensuite, jouez le son. C'est chose faite. Émettons ce son dans le composant haltère après la collision. Ici. Nous allons simplement écrire avant que vous ne vous déplaciez, le son de la flamme droite qui retentit. Et le nom que nous voulons jouer, le son d'haltère. K. Mettons-le à l'essai. Si je m'en approche. Oui Le son fonctionne-t-il correctement ? J'espère que tu as pu écouter ce son. Cela se fait également. Merci d'avoir regardé la vidéo. J'espère que vous appréciez la création de ce jeu. Rendez-vous lors de la prochaine session. 10. Vidéo 9 positions d'haltères aléatoires: Bonjour, bon retour. Ainsi, jusqu'à présent, la position du composant haltère était fixe. Et une fois que le joueur entre en collision avec elle, elle disparaît. Modifions et laissons haltères apparaître à des positions aléatoires. Ainsi, lorsque le joueur le saisira en premier, nous supprimerons cet haltère et créerons un nouvel haltère et le placerons au hasard sur l'écran. Et cela continuera jusqu'à la fin de la partie. Oh, accédez au fichier à points du composant de l'haltère. Tout d'abord, créez une instance de la classe aléatoire. C'est cela qui nous donne la bibliothèque mathématique qui peut être utilisée pour générer des nombres aléatoires. C'est tout simplement aléatoire comme ça. Et vous voyez, vous avez importé ce mat foncé. Créons une nouvelle fonction qui renverra un objet vectoriel à deux, c' est-à-dire des valeurs x et y, et nous les ferons auditionner. Maintenant, d'abord, nous allons obtenir la valeur x, c'est-à-dire que x est égal à l' entier aléatoire suivant un int. D'accord ? Maintenant, si vous voyez la description ici, sachez même que nous avons Random Next Intense. La valeur est donc supérieure à zéro et inférieure à dix. Alors c'est comme ça qu'on y arrive, entier aléatoire, d'accord ? Nous allons simplement obtenir cet entier aléatoire de X comme référence du jeu, taille point x point vers int, et le doubler. D'accord ? Cela signifie donc que l'axe x peut être compris entre zéro la fin de l'écran, valeur n'importe quel entier aléatoire pour le x. De même pour le y, nous avons un point aléatoire. Ensuite, int, game Raf, raf point, size point y. Intégral depuis, sauf entier, mais nous devons le changer pour le doubler à nouveau. Ensuite, nous retournerons un objet vectoriel à deux avec les x et y. Donc, j'espère que vous comprenez que c'est juste pour obtenir une valeur x et y aléatoire. C'est ça. La prochaine étape, t-shirt, vous pouvez également me comprendre ici. À quoi ça sert ? Nous devons maintenant appeler cette fonction dans la méthode onload du composant haltère ici. Maintenant, lorsque nous attribuons la valeur, cette position ici, nous allons simplement écrire obtenir une position aléatoire. D'accord ? De plus, après la collision, nous supprimerons le composant d' haltère actuel, puis ajouterons à nouveau un composant d'haltère aléatoire à ce jeu . Ce numéro occupera une position aléatoire par défaut, comme nous l'avons déjà mentionné ici dans la méthode onload. Maintenant, sauvegardons tout et voyons maintenant que ce parapluie est là. Et si je le fais à nouveau, le rafraîchis à nouveau, il y ira. Et si je le prends, tu vois, ça génère juste des positions aléatoires. Maintenant, je dois dire que c'est amusant. Et c'est évidemment le cas. Un son d'haltère retentit. Mais puisque j' enregistre l'écran, vous ne pourrez peut-être pas l'entendre, mais je suis sûr que vous pouvez l'entendre dans votre propre système. J'espère que vous avez compris le concept de détection des collisions. C'est tout pour cette vidéo. Rendez-vous lors de la prochaine session. 11. Vidéo 10 Ajout de composants virus: Bonjour, bon retour. Donc, jusqu'à présent, le jeu est très simple. Le joueur peut facilement saisir les haltères sans faire face à aucun obstacle. Nous devons ajouter une sorte de défi à notre jeu. Nous allons ajouter deux virus que le joueur doit esquiver. Alors maintenant, dans le dossier des composants, créez un nouveau fichier de données. Composant du virus, point ici. De même, comme avant, le composant Great Virus, le composant X Dense Sprite ont une référence au jeu. Jeu Fit Fighter. Nous avons la hauteur du sprite. Est-ce que nous allons mentionner le sprite I-T pour terminer. Et nous prendrons la position de départ comme argument. C'est un vecteur pour démarrer la partition. Et nous considérerons qu'il est construit, tel qu'il est requis. Maintenant, le OnLoad est mon troisième, oui. Attendre. Et je pense que la couche est là. Oui, et j'ai juste oublié le bon débat. Un vol sera rouge vif, sombre et lumineux. Point bleu point y. Cette position du sprite sera la position de départ qui sera envoyée à ce composant. Ensuite, le poids sera identique à la taille, qui sera affichée à la hauteur de 200. Voyons voir combien ça fait 200. Et n est égal au centre des points d'ancrage. Maintenant, ajoutez simplement ce composant viral nouvellement créé à la classe de jeu. Ajoutez simplement des composants sans fil. Position de départ pour le moment, je suis juste coder en dur. Valoriser. Nous devons envoyer et lire 150. Et ajoutez de la même manière pourquoi c'est ici. X aura la taille du point x -50 et la taille du point y -200. Vous pouvez simplement jouer avec ces valeurs et comprendre à quoi elles servent. Tout le monde le fait, non ? La hauteur est bien trop élevée. Donnons-lui 100. Il est également très grand. Donnons-lui un D. T. Alors. Si je lui donne 60, évidemment. Oui. Les années 60 ont l'air décentes. N° 2 et ça avait l'air très mauvais. Oui. Nous avons également le virus sur notre écran. Dans la vidéo suivante, nous travaillerons sur le mouvement de ces composants du virus. Merci 12. Vidéo 11 Ajouter des mouvements au virus: Bonjour. Nous pouvons voir nos deux virus dans leur coin de l'écran, mais ils ne se déplacent nulle part. Nous allons donc maintenant travailler à leur ajouter du mouvement afin que le joueur doive les esquiver et saisir les haltères. Commençons par accéder au fichier point point du composant du virus ici. Et créons quelques variables. Tout d'abord, il s'agira de vélocité. Ce sera la vélocité et la vitesse. Ils vont le déplacer, 300. Évidemment, nous allons le multiplier par D, D et L. Créons une fonction. Dans quelle direction ils ont tourné un vecteur pour se déplacer. Hein ? Maintenant, la première ligne de code va générer un angle aléatoire en radians par zéro. L'angle est alors égal au point de classe aléatoire suivant le double en deux. À Dubaï. Ensuite, nous devons écrire Kool-Aid. Le sinus et le cosinus de l'angle. L'angle sinusoïdal est égal au signe. Et l'angle cosinus final du manga est égal à l'angle cosinus aléatoire. Maintenant, la valeur finale de la vitesse à x est égale à l' angle cosinus par rapport à la vitesse. Par un autre. La double vitesse à y est égale à l'angle sinusoïdal dans ces vitesses. Enfin, nous y reviendrons. Ce sera, eh bien, voyons d x, eh bien, voyons DY. Sauvegardez-le. Alors, quelle est cette fonction ? Pour déplacer un sprite selon un angle aléatoire, nous devons d'abord générer un angle aléatoire. L'angle est généralement mesuré en radians , unité de mesure utilisée en géométrie pour décrire les angles. Un cercle complet est égal à deux radians pi, soit environ 6,28 rad. Donc, pour générer l'angle aléatoire en radians, nous pouvons utiliser un nombre aléatoire pour générer un nombre 0-2 pi, comme ceci. Point aléatoire. Le double suivant est que ma technologie va à l'université, c'est-à-dire qu' elle génère une valeur aléatoire comprise entre 0,0 et 1,0 en multipliant le résultat de NextDouble par deux et Pi, nous générons effectivement un angle aléatoire ingrédients de 0 à 2 pi. Une fois que nous avons un angle aléatoire, nous utilisons la trigonométrie pour calculer la vitesse x et y La vitesse x est calculée comme le cosinus de l'angle multiplié par la vitesse. Et la vitesse y est calculée au sinus de l'angle multiplié par la vitesse. Je dois donc dire que cette chaîne i2 utilise Google et effectue des recherches dans StackOverflow et tout le reste. Il vous suffit donc de vous souvenir de cette ligne de code. Et évidemment, si vous le souhaitez, vous pouvez également faire des recherches à ce sujet. Maintenant, la prochaine chose que nous devons faire est que la méthode onload écrira simplement que la vélocité est égale à celle du mouvement du sprite. Nous allons donc obtenir la vitesse correspondant à l'angle sous lequel il se déplacera. Et maintenant, nous devons créer une méthode de mise à jour. Et à la troisième place, nous remplacerons la position par la vélocité, vitesse multipliée par d t. Comme vous le savez, en multipliant la variable de vitesse par d t, nous nous assurons que le sprite déplace EdTech à une vitesse constante, quelle que soit la fréquence d'images, par exemple si la fréquence d'images tombe à 30 images par seconde, le paramètre T sera un paquet d'octets du deuxième sprite, nous allons augmenter la vélocité d'une unité par 30 dans cette image. Et de même, si nous l' augmentons à 60, ce sera en, c' est-à-dire la vitesse multipliée par un par 60 unités. Cela garantit simplement que le jeu se comporte de manière cohérente sur différents appareils et écrans. Maintenant, sauvegardons tout et redémarrons. Et comme vous pouvez le constater, les virus se déplacent. Alors c'est ça. Pour cette vidéo. Dans les prochaines vidéos, nous travaillerons à définir des limites à la composante virale ainsi qu'aux collisions. Merci 13. Vidéo 12 limites du composant de virus: Bonjour. Comme nous pouvons le constater, certains virus dépassent les limites. Assurons-nous qu'il y ait une détection de collision entre eux. Pour ce faire, ajoutez une boîte de chauffage au composant sans fil ainsi qu'à la classe de jeu. Accédez donc à la composante virale ici. Et ici, en dessous de la vélocité, il suffit d'ajouter une case à cocher circulaire. Dans le fichier de jeu Fit Fighter. Ici. Je vais ajouter une zone d'accès à l'écran. C'est-à-dire que celui-ci est nouveau. En cas de collision aux limites de la fenêtre d'affichage. Enflammer. La zone de haine d'écran est un objet qui représente les limites de cette zone visible à l'écran. Il est utilisé pour déterminer si notre autre composant du jeu se trouve dans la zone visible de l'écran et doit être affiché à l'écran. Maintenant, enregistrez-le. Maintenant, dans le composant viral. Dans les composants sans fil. Sur la méthode de collision. Tout d'abord, nous allons vérifier si l'objet entré en collision est une boîte thermique à écran ou non. Il suffit donc d'aller au bas de l'échelle. À quatre, en cas de collision. Nous devons ajouter des rappels pour les lésions. Et puis en cas de collision. Nous allons maintenant vérifier s'il s'agit de la case d'accès à l'écran. Ici. Nous obtiendrons les points d' intersection. Comme tu le sais, il y a celui-ci. À l'aide de cela, nous vérifierons conditionnellement dans quelle direction l'écran est entré en collision, puis nous modifierons la vitesse opposée à celle-ci. Ici. Faisons-le comme si un autre vecteur pour atteindre le point de collision. Est-ce qu'il va créer des points d'intersection, des fichiers de points ? C'est le premier point d' intersection. C'est-à-dire dès qu'il entré en collision avec l'écran. Nous allons vérifier si la valeur du point de collision point x, x est égale à zéro. C'est-à-dire tout à gauche. Ensuite, je vais changer la vitesse de l'axe X en vitesse négative de l'axe X. Et la vitesse point y axe. Le même, c' est le point de vitesse y. Je vais donc simplement changer la direction de l'axe X. De même, si point de lésion .xx est égal au point x de référence du jeu, c'est tout à fait à droite. Alors je ferai de même. point de vitesse x est égal à moins le point de vitesse x il suffit de modifier la même valeur de vitesse. Point de vitesse y. Est égal au point de vitesse y. Ensuite, je vérifierai si point de coalition point y est égal à zéro. Le point de vélocité x sera le même. Mais le point de vitesse y serait négatif. Velocity point y. Et enfin, souvenez-vous que celui-ci se trouve tout en haut de l'écran. Si le point de collision point y est égal à game of.size.y.xy et à deux moins le point y de vélocité. OK, sauvegardons tout et jetons un œil à notre application. Href est égal à zéro. Voyons ce qui se passe ici. Donc, ce top fonctionne. OK, celui-ci ne fonctionne pas. Voyons voir. C fonctionnait bien. La gauche, c'est-à-dire tout à droite, ne fonctionne pas. Est supérieur à égal à, voyons voir. Alors je vais changer. Maintenant, vélocité K. Non, elle ne le sera pas. Dans cette section. Premier point. Cela permet de voir que ce ne sont pas points d'intersection des lésions qui sont les premiers. D'accord. Donc, le modèle gauche et le modèle supérieur fonctionnent du côté droit. Et selon la norme, ce calcul n'est pas correct ici. Set de Dulles. Comme je l'ai dit en bas. Le fond fonctionne également K. Comme vous pouvez le voir. En fin de compte, je dirais qu'ils y travaillent. Le côté droit ne fonctionne pas. Cela ne devrait pas être moins, car évidemment, voyons voir. Voir référence du jeu, taille du point k. Une petite erreur. Il doit être supérieur à cela. Voyons voir, -60 cc. À l'heure actuelle, cela fonctionne parce que -60 est l'avantage. Comme nous avons la tête du sprite à 60 ans. C'est pourquoi. Ces calculs sont donc un peu complexes. Je ne dirai pas grand-chose, mais oui. Donc, comme vous pouvez le constater, cela fonctionne parfaitement. Nos virus entrent en collision et se déplacent sur tout l'écran. Merci 14. Vidéo 13 Collision entre virus et joueur: Bonjour. Il est maintenant temps de travailler sur la fonctionnalité. La grippe est le mouvement du joueur. Comme il a eu de la fièvre après être entré en collision avec l'un des deux composants du virus. Nous avons déjà le virus de la fièvre et l'actif sonore du virus. Maintenant, créons quelques variables à l'intérieur de ce composant de lecteur. Ici. Tout d'abord, voyons voir. Ils ont posé un composant brillant. Joueur, maigre, béatitude. Des notes ? Écrivons d'abord Player Skinny It. C'est brillant. Fièvre de couche. J'écris le joueur maigre et plein de fièvre ici parce que nous allons le modifier en fonction des collisions. Tout à l'heure, nous sortions juste le sprite directement ici. Maintenant, en ce qui concerne la méthode onload, je vais écrire que Player Skinny est égal à celui-ci. Juste ici. La fièvre des joueurs revient à la même chose, mais nous ne changerons que le sprite. C'est-à-dire que les fièvres des couches sont vives. Et maintenant, dans le Sprite principal, il sera maigre au tout début du jeu. D'accord ? Il est maintenant temps d' écrire une logique selon laquelle le joueur ne pourra pas se déplacer pendant 3 s. après avoir heurté le virus. Nous allons également modifier cette image de sprite. Créons de nouvelles variables d'état ainsi qu'une fonction pour geler et débloquer les mouvements du joueur. Donc, ici, je vais ajouter un fichier FASTA lorsque le virus booléen attaqué est égal à faux. Et je vais m'en servir. Dimère. Dimer est égal à 3 s, donc c'est comme si le joueur était bloqué pendant 3 s. Nous démarrerons ce compte à rebours lorsque le virus et le joueur entreront en collision. Maintenant, créons une fonction : annuler, geler le joueur et chuter. Nous vérifierons si si c' est vrai. Et nous écrirons, non, je posterai la vérification du niveau alpha. Si le virus attaqué est faux, ne le gelez que, car si c' est vrai, cela signifie qu'il est déjà gelé. Tout d'abord, nous allons jouer le son Global Start Virus Sound. Émet le son au moment de la lésion. Ensuite, nous écrirons que l'attaque virale est égale à vraie. Ensuite, We'll Gene corrige la fièvre des couches. Modifiez l'image du sprite. Et enfin, nous allons démarrer le chronomètre C. D'accord ? Et nous allons également créer une fonction pour dégeler la couche. Nous allons simplement modifier que l' attaque du virus est égale à fausse. Et remplacez-le à nouveau par Player Skinny. J'espère que vous avez compris ces deux fonctions. Elles sont très simples et simples. Maintenant, dans la méthode de mise à jour, nous vérifierons conditionnellement si joueur est attaqué par un virus ou non. d'autres termes, si la valeur booléenne est fausse, autorisez les mouvements du joystick. Et si la valeur est trois, c' est-à-dire si la valeur est vraie, mettez à jour ce chronomètre et appelez la fonction Unfreeze Player au bout de 3 s. Donc, ici, tout d'abord, nous allons simplement vérifier si l'attaque virale est fausse. Si c'est faux, autorisez uniquement ces codes. C'est-à-dire tout ce code. Il suffit de le couper et de le coller ici. Parce que si c'est le cas, si, s'il n'est pas attaqué par un virus, alors seuls les mouvements sont autorisés. Et au fur et à mesure que nous mettrons à jour ce dimère, nous vérifierons cela en quelques secondes. Et si le dimère est terminé, est-à-dire que 3 s se sont écoulées, alors seule la fonction de refroidissement et de congélation est activée. Maintenant, c'est également fait. Enfin, écrivez cela sur la méthode de collision pour ce composant de joueur. Nous avons déjà le rappel en cas de collision. Voici donc simplement le traîneau en collision. Et nous allons simplement écrire si c'est pour cela que ce composant s'appelait simplement fonction Freeze Player. D'accord. Redémarrez maintenant l'application et regardez le son. Y a-t-il. L'image du joueur, le sprite se fige et on ne peut plus bouger pendant 3 s. Et s'il prend l' haltère, alors ça marche. Et encore une fois, s'il touche, ses mouvements sont restreints. Ça a l'air très joli. J'espère que vous avez compris le fonctionnement de l'application et que avez apprécié de la créer jusqu'à présent. Merci 15. Composant de texte vidéo 14 pour la partition: Bonjour. présent, les fonctionnalités de notre jeu fonctionnent parfaitement, mais nous devons indiquer à l'utilisateur combien d'haltères il a saisis sous forme de score, ainsi que le temps qu'il lui reste pour terminer le jeu. Nous ne voulons pas que le jeu dure indéfiniment. Pour cela, passons au combat principal, à ce gros combat, à leur classe de jeu principale. Nous devons créer deux nouvelles variables. Le premier sera le score, qui partira de zéro, puis le dimère tardif, le dimère, puis le nt. Restant. Le temps est égal à 30. En d'autres termes, nous voulons que le jeu dure 30 s. Maintenant, nous allons utiliser cette composante fiscale de Flame juste pour communiquer le score et le temps à l'utilisateur. Le composant suivant, le texte de dix cents. Maintenant, lors du déchargement, nous allons d'abord mentionner ce mode minuteur. Fais en sorte que ça se répète un peu. À chaque fois, à chaque fois. À chaque répétition, il vérifiera. Si le temps restant est égal à zéro. Si c'est vrai, mettez en pause le moteur qui est en pause, le moteur de jeu, tout restera bloqué. Sinon, nous allons déduire ou décrémenter le temps qu'il leur reste à se distraire pendant 28 ou 27 ans, comme ça. Et lorsque le jeu démarrera, nous lancerons également ce chronomètre automatiquement selon la méthode de téléchargement dans NCL. Donc, lors du déchargement, une fois que tout aura été modifié, ce composant viral, tout le chronomètre démarrera. Maintenant, créons un composant de texte pour afficher les scores et positionnons-le en haut à gauche. Ainsi, cette composante de texte, ce texte sera note d'audition, où ils seront dus tout en haut de l'axe X pour d, l'axe y pour t. ancre sera un point d'ancrage. Gauche. Le rendu des decks, le texte, la peinture. Il s'agit des propriétés du composant texte dont vous devez simplement vous souvenir ou du style de la liste, du style dec. Nous allons changer cette couleur. Bulletin de vote de base, point noir 25. Ensuite, nous ajouterons le composant texte de la partition à l'écran. Allons-y, c'est commencé. Et comme vous pouvez le voir, nous avons la composante score à l'écran. De toute évidence, il est nul et il n'augmentera pas pour le moment. Nous devons écrire un peu plus de logique dans les fonctions de mise à jour, ce que nous ferons dans la prochaine vidéo. Merci 16. Vidéo 15 Mise à jour du score et de l'heure: Bonjour, Continuons et créons un autre composant de texte pour le temps restant. Pareil, non ? Le texte temporel est un composant de texte. X2 restera mourant. Deuxième lésion. Là-bas aussi. Nous venons de parler de jours de bureau verts moins quatre jours. Et pour le DDT, c'est tout à fait à droite. L'ancre sera ancrée en haut à droite. Et puis il y aura du texte, la peinture, puis de la coiffure. Style, couleur, bulletin de vote similaire à celui de base. Maintenant, couleur noire. La taille de police indiquera une quantification. Ensuite, ajoutez simplement ce composant au texte du nom d'écran. Tu vois, le temps passe aussi, et je vais juste colorier ici. 30 secondes. Nous pouvons voir le score et le temps restant à l'écran, mais les valeurs ne sont pas mises à jour. Travaillons là-dessus. Dans le jeu Fleet Fighter. Créez la fonction de mise à jour. Après le OnLoad. Créez la fonction de mise à jour. De toute évidence, il fonctionnera même manière que n'importe quel autre composant. La première chose à faire est jour cet objet de temporisation. Ensuite, nous mettrons à jour le score, ce score x point x est égal à, nous dirons simplement score. Et comme la valeur du score est automatiquement mise à jour ici, c' est-à-dire à cette époque ou pas, où nous allons évidemment le faire, nous devons faire quelque chose dans ce composant haltère pour le mettre à jour ? Des ponts dans le temps, c'est-à-dire le temps. Cela peut. Et ici, c'est du texte en temps réel, le texte. D'accord ? Maintenant, dans le composant haltère, lorsque l'haltère entre en collision avec le joueur, nous l'avons simplement retiré. Mais maintenant, assurez-vous d'augmenter cette valeur de score pour que le score de points de référence du jeu soit égal à un. Et la variable score se trouve dans la classe de jeu principale à laquelle nous accédons lorsque le jeu aura comme d'habitude. Maintenant, redémarrons et voyons le deuxième set, 26, 25. Et si je regarde les chiffres , ils augmentent. Si tu ne peux pas entendre ce son, c'est bon parce que je suis juste handicapé. Mais dans votre système, je suis sûr à cent pour cent que vous pouvez entendre votre son. Voilà pour ce module. À bientôt dans la vidéo suivante. Merci. 17. Vidéo 16 jeu sur le menu: Bonjour, bon retour. Dans cette vidéo, nous allons travailler sur les superpositions et les superpositions et permettre à n'importe quel widget de Floride d'être affiché au-dessus d'une instance de jeu. Cela permet de créer très facilement des éléments tels que des pauses, des affichages d'avertissement ou un écran d'inventaire. Cette gestion se fait donc via les surcharges de points du jeu, cette publicité et les points de jeu superposent les méthodes de suppression des points. Créons donc un nouveau dossier, des écrans dans lib et créons un nouveau fichier de données. Menu Dot Dot Dot. Cet écran fera office d'écran de superposition. Importer. Mon jeu TTL Glass sur mon nouveau widget Etend Stateless. Nous avons une double méthode. Ici. La première chose que je vais faire est de créer un identifiant constant. String ID indique qu'ils vont créer Game Over Menu. Cet ID de superposition est un identifiant unique associé à chaque superposition de cet écran. Il est utilisé pour identifier et manipuler une superposition spécifique, par exemple pour l'ajouter ou la supprimer de l'écran ou du jeu. L'idée de superposition est généralement attribuée lorsque les superpositions sont créées avec une chaîne Canvas ou une valeur entière. Ensuite, nous utiliserons la référence du jeu Fighter game, game href comme paramètre du constructeur. Tu dis juste const. Menu Gameover. Super Dot T nécessitait ces jeux de fléchettes, réf. Maintenant, dans le double de mon troisième, retournons à l'échafaudage. Ce sont tous des widgets de Floride. J'espère que tu connais ce corps. Nous aurons un conteneur. La déclaration aura alors une image de déclaration. Aura une image de déclaration. Ensuite, il acceptera une image. Ce sera une décoration de boîte, donc ils ont encadré l'équation et ici ce sera une image de déclaration. Image. Nous avons l'image d'arrière-plan, les actifs, les barres obliques boules bleues, les globals, les arrière-plans, le sprite. Et la housse s'adaptera parfaitement à la boîte et à pois. Ce sera la déclaration. Ensuite, cet enfant aura le contenant au centre. Enfant. Ensuite, la matrice des colonnes matrice est l'alignement, l'alignement au centre des points. Ensuite, chez ces enfants, la première chose que je vais avoir, c'est un widget de texte. Et n'oubliez pas que ce n' est pas un composant mérite des widgets Flutter. Style, style, taille de police 50. Les autres textes seront le score, qui sera le jeu, le score par points de référence du jeu. Et voici, le style sera constant, textile sur mesure. Ils sont partis. Nous allons donc donner une taille d'espace, encadrée, hauteur 200. Ensuite, nous aurons deux boutons, l'un pour jouer, l' autre pour permettre à l'utilisateur de rejouer ou pour revenir au menu principal. Comme je l'ai dit, c'est la boîte. Nous emballerons la boîte de la taille des boutons uniquement pour la largeur et la hauteur. Largeur 200, hauteur 50. Enfant. Bouton surélevé. Et appuyez sur. Cela ne servira à rien pour le moment. Et nous allons à nouveau utiliser la couche de texte const. Style, style de texte, taille de police, unification. Ensuite, prenez une taille juste pour laisser un peu d'espace, encore une fois, la taille de la boîte pendant D. Et en dessous de cette taille de boîte. Nous chargeons une Vox de cette taille. Prévoyons une boîte d'une autre taille pour le bouton. Hauteur. 50. Bouton surélevé pour enfant. Sous presse. Et encore une fois, un texte de const pour enfants. Menu principal, decks. Il n'y a pas de taille 25. Voilà pour le menu Game Over. Nous afficherons cette sortie, ce menu plus tard. Dans la vidéo suivante, nous travaillerons sur l'écran du menu principal. Merci. 18. Vidéo 17 écran de menu principal: Bonjour, bon retour. Nous avons donc créé le menu Game over. Maintenant, créons un autre écran et nommez-le menu principal. Le menu principal, point, point. Commençons par importer du matériel. Il sera apatride, rigide. Nommez-le menu principal. Et le retour est un échafaudage. Dans ce corps. Prenons un contenant. Donnons-lui une décoration de boîte. De même, nous allons lui donner une image de fond. Cette image de décoration. Il s'agit simplement d'une image fixe. Les actifs, les images barres, les éléments globaux. Ce sprite d'arrière-plan. Et une boîte B avec couvercle à points, point mosfet au-dessus de k. Maintenant, l'enfant du conteneur, ayons un centre. Alors. Donnez-lui le micro principal de la colonne. X est la matrice d'éléments est le centre du point m. Que les enfants qui l'ont aient aient un texte qui est le nom du jeu et aussi le bouton de jeu. Et n'oubliez pas qu'il ne s'agit pas d'une superposition, il s' agit directement d'un écran. C'est-à-dire que ce sera le premier écran sur lequel l'utilisateur ouvrira l'application et verra Const Budding. Ce n'est que le style. Tu peux faire ce que tu veux. Tout dépend de toi. Inserts de bord, symétriques, verticaux 50. Puis enfant avec le style textile. Taille unique 50. D'accord ? Et après ce widget de rembourrage, passons à une boîte de taille. Ils offrent un certain espacement. Puisque je sais déjà que tu l'es. C'est pourquoi je peux écrire directement ce rembourrage et le tout accentuer. Évidemment, lorsque vous essayez de créer quelque chose à partir de zéro, vous devez essayer de tester les widgets de l'interface utilisateur Alda et tout le reste. J'en fais une centaine. Ce sera donc, ce n'est qu'un bouton. Je préfère le bouton surélevé pour enfant. Sous presse. Ne faisons rien pour l'instant. Et dans cet enfant, nous avons une const. Text to X est simplement un jeu et un style, tandis le style Dec est disponible en taille 25. C'est donc tout pour le menu principal. Dans la vidéo suivante, nous allons créer l'écran de jeu et connecter tous les écrans ensemble. Merci 19. Écran de jeu vidéo 18: Bonjour, bon retour. Ainsi, au lieu d'appeler le widget du jeu directement dans ce fichier principal à points, nous allons créer un nouveau fichier à l'intérieur des écrans et le nommer. Point, point ou matériau de jeu. Than est moins rigide. Ajustement limité. Leur jeu. Maintenant, nous ne le qualifierons pas d'apte à la diarrhée. Nous allons simplement le nommer game play. D'accord, nous allons l'appeler gameplay. Ensuite, il transformera un widget de jeu, comme ce widget de jeu. Et évidemment, nous devons envoyer une instance de jeu. Nous allons initialiser le jeu Street Fighter ici. Je ne me bats jamais contre Deadly Game. Pour un jeu comme celui-ci. Et nous l'enverrons ici. Nous ne l'initialisons pas directement ici, car si nous sauvegardons, si quelque chose se produit ou si cette nous sauvegardons, si quelque chose méthode de facturation est appelée, nous perdons toutes les données car cela créera à nouveau une nouvelle instance du jeu Fruit Fighter. D'accord ? Et maintenant, nous allons travailler ou utiliser la propriété du jeu. C'est ce que nous avons fait, avec cette carte du bâtiment superposée. Ici, il suffit d' attribuer la superposition, l'identifiant, l'écran, la facture, les contextes, le contexte, le jeu, la référence du jeu. Et voici le menu Game Over. Dans notre application, le seul écran superposé est l'écran Il s'agit donc simplement d'attribuer l'identifiant. Il est vert. C'est ce que nous devons montrer lorsque cette idée est invoquée. Maintenant, nous l'avons fait. Passons au fichier Dot Dot principal. Et ici, dans l'application. Tout d'abord, je vais supprimer cette application matérielle d'initialisation . Ils déplacent la bannière et la page d'accueil est le premier écran qui deviendra le menu principal. Et maintenant, allez au menu principal. Ici. Lorsque l'utilisateur clique sur le bouton Play, il doit accéder à l'écran de jeu. C'est un navigateur contextuel. Le système de remplacement de la poussée. Laissons le jeu jouer. Comme vous le savez, le gameplay. Voyons voir, jouez à ceci, à ce jeu. Le jeu va commencer. Maintenant, redémarrons notre application. Comme vous pouvez le voir, le vert est l'écran d'introduction du jeu, c'est le nom. Ce logo est déjà là, déjà en arrière-plan. Et nous avons le bouton Play. Si nous cliquons sur Play C, nous pouvons maintenant jouer. D'accord. Je vais juste mettre le moteur de jeu en pause. Nous devons maintenant utiliser le schéma de superposition, c' est-à-dire le jeu sur écran. Nous devons l'arrêter après ce temps, sinon la partie se termine. Alors allez au jeu Weight Fighter ici. Et ici. Lorsque c'est le cas, lorsque nous coupons le moteur de pause il suffit de superposer des points et d'ajouter des points. Et nous devons donner au jeu d'identification un identifiant à points de menu comme celui-ci. Et cela lui montrera Game Over Menu. Et aussi, créons une fonction tout en bas pour réinitialiser le jeu. C'est-à-dire que si l'utilisateur souhaite y jouer à nouveau , nous allons simplement commencer. Nous allons simplement attribuer ce score à zéro et le temps restant est égal à 30 s. Enfin, allez dans le menu GameOver et permettre à l'utilisateur de rejouer , accédez à l'écran du menu principal. Ici. Lorsque l'utilisateur clique à nouveau sur Play. Au premier arrêt, nous allons déplacer la superposition. C'est le jeu, c'est notre menu qui l'identifiant. Ensuite, nous appellerons la fonction de réinitialisation, dont nous venons de parler, est créée. Et après cela, nous reprendrons le moteur. C'est ça Voici les trois étapes. Et si l'utilisateur souhaite revenir au menu principal ? Tout d'abord, nous allons à nouveau supprimer l'identifiant GameOver superposé comme suit. Ensuite, il faut appeler le plateau. Ensuite, nous reprendrons le jeu. Mais après cela, nous utiliserons simplement le système de remplacement Pus Push et enverrons un menu principal à l'utilisateur. Comme ça. J'espère que vous pouvez voir le code. C'est le code. Lorsque l'utilisateur souhaite accéder au menu principal. Redémarrons et vérifions toutes les fonctionnalités. Si je clique sur Play. Et voyons voir après 30 s. Alors, que se passera-t-il ? Cette finale, je dirais. Maintenant, tu vois, nous avons le menu Game Over. Nous pouvons voir ce score. Et si nous cliquons simplement sur Rejouer, le score est nul. Et nous avons ce dimère. Encore une fois, cela vient de Tatu. Et maintenant, que se passe-t-il si vous cliquez sur le menu principal, nous sommes renvoyés à l'écran du menu principal. C'est ça C'est tout pour ce jeu. Superpositions. À bientôt dans la vidéo suivante. 20. Vidéo 19 Changer de lecteur Sprite conditionnellement: Donc, jusqu'à présent, lorsque le joueur l'attrape, nous augmentons ce score. Mais pourquoi ne pas le rendre intéressant ? Changeons également l'image du sprite. Plus il marque, plus il devient musclé. Puisque tout le monde connaît les ceintures d' haltérophilie, les muscles. Essayons donc de mettre cela en œuvre. Fichier des composants du lecteur Go-to. Créons deux nouvelles variables d'état pour d'autres sprites. Par couche. Poids. Late Sprite, Blair, Muscular, K. Chargons l' image du sprite dans ces variables. Téléchargez-les ici. Il suffit de copier et coller deux fois. poids sera le joueur s'adaptant clairement et clairement, musclé Live Player muscle sprite k. Maintenant, au lieu d'appeler des sprites ici, directement, ceci ici. Et aussi dans la fonction de congélation. Ici, nous modifions l'image du sprite. Créons la fonction qui a rendu le sprite de manière conditionnelle. Ce que je veux dire, c'est qu'à k, créons ici un sprite pour joueurs multiples. Nous allons d'abord vérifier s'il est attaqué par un virus. Alors le sprite sera la fièvre des joueurs. Ensuite, nous vérifierons si le score du point de référence du jeu est supérieur cinq et inférieur à dix, il est de 5 à 10. Dance est devenue joueuse pour cela. D'accord ? De même, Jack Else-si le score du point de référence du jeu est supérieur à dix, alors changez le sprite en joueur musclé. Ou bien, enfin, signez le sprite de départ, le skin de l'écran fera du sprite. Maintenant que nous avons mentionné cette fonction, appelons-la afin de rendre les sprites partout. Tout d'abord, passez à la méthode onload. Ici. Au lieu d'appeler Sprayed comme ça, appelez simplement la fonction. Ensuite, passez à la mise à jour. Nous allons juste nous assurer d' appeler la fonction ici. est-à-dire que s'il n'est pas attaqué par un virus, il vérifiera ce score et cette fonction sera appelée encore et encore. Alors allez dégeler ici. Appelons cette fonction. Ainsi, une fois l' attaque virale fausse, encore une fois, le sprite changera. De même, passez au congélateur. Ici. Nous allons modifier l'image du sprite comme ceci. Et pourquoi ne pas réduire ce score lorsqu'il est attaqué par le virus, ce qui signifie qu'il perdra ses muscles après avoir attrapé un castor ou un rhume à cause de ce virus. Comme le score diminuera, le sprite deviendra également trop maigre. À la fin. À qui nous allons simplement vérifier si le jeu est marqué par un point de référence. S'il est supérieur à zéro, alors seulement décrémenté, il deviendra négatif. Comme ça. C'est aussi simple que cela. OK, rafraîchissons-nous. Ou vous pouvez définir un départ. Et voyons ce qui se passe. OK, tu vois, le score a baissé. Mais maintenant que j'ai six ans, mon image de sprite change pour s'adapter. Et évidemment, je vois que, comme vous pouvez le voir, l'image du sprite a été modifiée et elle a de nouveau été modifiée. Et enfin, la partie est terminée. Mais maintenant, vous allez voir ce qui se passera si je rejoue. La plupart du temps. Je vais te montrer ce que je veux dire. Poids. Allez chez FIT, combattez encore une fois. Je vais supprimer le ou les virus . Voyons voir. Je vais vous montrer qu'ils ont ce sprite musclé en ce moment. Waouh, s'il n'y a pas d'adresse, alors on peut marquer beaucoup de points. Mais maintenant, que se passe-t-il si je clique à nouveau sur Effacer, regarde si nous rejouons ou si nous accédons au menu principal, alors l'image du sprite n'est pas modifiée par défaut. C'est le Skinny. Au tout début. Comme lorsque la fonction de mise à jour précédente de Gaming Genie a cessé de fonctionner pour tous les composants. Pour résoudre ce problème, créons une variable d'état pour le composant Player. Notes. Accédez à notre code. Accédez à fit by delta. Ici. Disons un composant de la couche de grille, un composant du joueur, d'accord ? Ensuite, téléchargez. Nous allons d'abord initialiser le composant du lecteur comme ceci, puis l'ajouter afin de pouvoir modifier ce composant de couche directement puisqu' il s'agit d'une variable d'état qui modifier ce composant de couche directement puisqu' il s'agit ne fait pas partie de la fonction. D'accord. Remplaçons cette image de sprite par défaut dans la fonction de réinitialisation. Ici. Réinitialisons les points du joueur sprite est égal à attendre des charges brillantes. Faisons-en un évier. Mondiaux. Skinny Sprite. La série principale a commencé. Et revoyons ce jeu. Disons 4/32. Sois indulgent avec moi. Je vais créer un score élevé comme celui-ci. Bien, maintenant, attendons la fin du compte à rebours. Maintenant, cette fois, si je clique à nouveau sur Lire, constate que l'image est à nouveau réinitialisée en skin. J'espère donc que vous avez compris les concepts, pourquoi je fais cela, pourquoi je le fais. Et encore une fois, je vais décommenter le composant viral. Voilà, c'est tout pour cette vidéo. Rendez-vous lors de la prochaine session. 21. Vidéo 20 Créer un composant de vaccin: Bonjour, rendons le jeu plus intéressant. Nous ajouterons un composant vaccinal à intervalle aléatoire et l'utilisateur du fournisseur s'en emparera. Il sera immunisé contre le virus pendant quelques secondes. Cela semble tellement intéressant, non ? Mettons-le en œuvre. Composants intérieurs. Créez un nouveau fichier. Composant du vaccin, point, point, copier-coller le code complet du composant viral. Allons donc tout copier. Collez-le ici. Laisse-nous voir. Changez-le en composant vaccinal. Composant de la peau. Nous avons la vitesse du vecteur dans le changement OnLoad, donc brillant pour les vaccins Sprite. Position, position de départ. Le poids est égal à la taille, d'accord ? Et tout cela pour ancrer le centre. D'accord ? Tout va bien. Ce code est très similaire à la division de ce composant, nous ne modifierons que l'image du sprite et nominale de la pièce de détection de collision est la même. D'accord, nous avons le spray Move, c'est pareil. Passons à la collision. Ici. dessous de la barre verte , il suffit de vérifier s'il existe un composant de couche. Ensuite, retirez-le du parent, vous supprimerez simplement ce composant du vaccin. OK, enregistre-le. Maintenant, nous allons travailler sur la collision entre le joueur et un vaccin. Composant incontournable pour les joueurs. Nous devons également apporter des modifications ici pour que le vaccin fonctionne. Tout d'abord, créons une variable d'état. Ce booléen est vacciné, est égal à faux. Nous allons donc simplement vérifier si le joueur est vacciné, ce qui signifie qu'il est immunisé contre la raison pour laquelle il en est ainsi. Nous n'en avons aucune en cas de collision et ça, oui. S'il y a un virus, nous dirons simplement que s' il n'est pas vacciné, ne ferons que le libérer. Les adultes ne congèlent pas le joueur parce qu'il l'est, il a déjà reçu le vaccin. Et nous écrirons également s'il existe un composant vaccinal, nous créerons une fonction d'injection de cire. Créons des fonctions pour les vaccins. Tout en bas, je vais écrire en gros, et je vais créer ce vaccin injectable. Plus les quatre niveaux. Chèque. C'est-à-dire qu'il suffit d'écrire le commentaire en premier. N'exécutez pas si y, c'est si Blade est déclenché par le virus, il l'est s'il n'est pas attaqué. pas pour cela que cette attaque, alors James est vacciné, est égale à celle de Drew. Et écoutez le son. Le vaccin mondial sonne 0, K. Et une autre fonction supprime x in. Nous allons juste changer, si vacciné équivaut à faux ici. Rien de grand. Donc, oui, nous avons apporté de nombreux changements. Voilà, c'est tout pour cette vidéo. Continuons à apporter les modifications nécessaires dans la vidéo suivante. Merci 22. Vidéo 21 Ajouter un vaccin à intervalles aléatoires: Continuons et apportons les modifications nécessaires à la classe de jeu pour que le composant vaccinal fonctionne. Passons au jeu Fit Fighter. Nous devons créer de nouvelles variables d'état. Tout d'abord, je vais initialiser le composant vaccinal. C'est très bien. Composant vaccinal, composant z. Nous venons de mentionner la position de départ. Je vais simplement écrire le vecteur deux, axe x pour enrichir l'axe y 200. Ensuite, j'écrirai dans immunité vaccinale, dy est égal à quatre. Cela signifie que le vaccin conférera une immunité, ou vous pouvez dire que nous travaillerons sur ce joueur en congé pendant 4 s. Ensuite, il sera affecté par le virus plutôt que par le dimère du vaccin tardif. Il s'agit donc de l' objet chronométré pour le vaccin. Nous vérifierons si la seconde est terminée ou non. Ensuite, il sera temps de se faire vacciner. Les parents rendront les choses plus intéressantes, car nous donnerons au hasard du temps pour le vaccin au SPF. Nous ne savons donc même pas quand le vaccin apparaîtra dans le jeu. Et chaque fois qu'il apparaîtra à une heure différente, vous pouvez dire parce que ce joueur n'est pas là pour jouer quelques secondes. Maintenant. Passons au déchargement. Ici. Lors du téléchargement, nous écrirons simplement vaccin. L'apparence du temps est égale au point aléatoire suivant un entier. Et nous écrirons le temps restant -20 plus 20. C'est ainsi que le premier vaccin apparaîtra. Voyez ici, comme vous pouvez le voir, random next donne un entier aléatoire. Si nous écrivons directement ici la valeur dix, cela donnera une valeur supérieure à, égale à zéro et inférieure à dix. Mais comme le jeu dure 30 secondes, je veux que le premier apparaisse à tout moment entre 20/32 afin qu'il nous reste encore du temps pour qu' un autre vaccin apparaisse. Supposons ici le vaccin, si le hasard a été choisi 5 s, alors dans tout le jeu, un seul vaccin apparaîtra. C'est mon propre choix. C'est à vous de décider. Et voici ce qui se passe. Si je fais quelque chose comme le suivant dans les cent plus 50, la valeur est supérieure à 50, puisque j'ai également ajouté 20. La valeur sera donc supérieure à 20, et ici elle sera inférieure à 150, ajoutant les deux. Supposons donc que le temps restant soit étiqueté t moins 2010 plus 2030. Donc, tout simplement, ce calcul signifie qu'il doit être supérieur à 20 et inférieur à 30. Maintenant, après cela, nous devons apporter des modifications à cet objet de temporisation précédent. Ici, cet objet de temporisation. Et vérifiez si le temps restant à jouer est égal au type d'apparition aléatoire du vaccin. Si c'est le cas, ajoutez le composant vaccinal. Donc, ce que je vais faire c'est vérifier d'abord si le temps restant est égal à zéro. Faites une pause à Qian, d'accord ? Eh bien, je vais juste l'éteindre. Ici, je vais vérifier si le temps restant est égal à celui des parents dimères du vaccin. Ajoutez ensuite le composant vaccinal. Et nous avons le composant vaccinal et ce haut comme celui-ci. D'accord ? Supposons donc la manie, temps de se faire vacciner contre le virus, c' est-à-dire que celui-ci était censé être supposé Indy Five. Ainsi, lorsque ce chronomètre tournera à 302-920-8206, puis à 25, nous ajouterons la composante vaccinale à ce jeu. Et aussi, créons un nouvel objet de temporisation pour le vaccin. Ici. En dessous de ce chronomètre. Écrivons que le temps de vaccination est égal à un. Répétez l'opération sur****. Ça devrait être vrai. Sur chaque tique, on vérifiera si le temps d'immunité vaccinale est égal à zéro. C'est-à-dire que le vaccin est terminé. Si ce n'est pas le cas, diminuez le temps d'immunité vaccinale d'une unité, le goût pour les trois secondes, les deux secondes, 1 s. Et si c' est terminé, tout d'abord, j'écrirai un composant joueur qui supprime la fonction vaccinale. C'est-à-dire, j'espère que vous vous en souvenez. C, Nous allons changer chaque vaccin qui est égal à faux. D'accord ? Après cela, j'écrirai à nouveau temps d'immunité vaccinale est à nouveau égal à quatre. Ensuite, j'ajouterai le vaccin. Apparence, lier le temps d'essai du vaccin et les parents est nul. Ceci est fait pour le contrôle conditionnel. Nous le ferons plus tard pour montrer à nouveau le vaccin. Ici. Encore une fois l'immunité, il est temps de la supprimer. Fonction vaccinale dans la classe des joueurs. D'accord. Alors je veux juste que ce chronomètre, le chronomètre des vaccins, s'arrête. C'est-à-dire que je ne veux pas que cela disparaisse encore et encore pour toujours. D'accord. Enfin, dans la méthode de mise à jour, vérifiez si le joueur est vacciné et si VS, continuez à exécuter cet objet chronomètre. Et si le temps de vaccination, la valeur d'un parent est nulle, cela signifie que l' effet immunitaire est terminé. Encore une fois, cela crée un temps aléatoire pour le vaccin par paire dans ce jeu. Vous l'aurez compris, attendez, passons à la fonction de mise à jour. Vérifiera si le composant est vacciné. Ensuite, nous mettrons simplement à jour le chronomètre de vaccination. Cette semaine. Nous dirons alors qu'il aura des fonctions Enda. Et sinon, si l'apparence de la mort vaccinale est égale à zéro. Ensuite, nous vérifierons si le temps restant à jouer est supérieur à 3 s au moins. Puis encore une fois ADA. Encore une fois, ajoutez le vaccin au jeu qui est aléatoire. Point suivant. Temps restant -3 s plus trois. Ce nouveau vaccin. Les parents. C'est l'heure des locations. D'accord ? Nous lisons donc ici au moins la durée pendant laquelle le jeu doit durer plus de 3 s. Au moins. Ici, j'espère que vous comprenez à nouveau. Donc plus de 3 s et quel que soit le temps restant censé durer dans cette seconde ou quoi que ce soit d'autre. Il obtiendra à nouveau un nombre aléatoire. est pourquoi nous avons toujours ce chronomètre qui vérifiera si temps restant est égal au temps de vaccination et il le fera à nouveau au niveau du composant vaccinal. La boucle se poursuivra donc encore et encore jusqu' à la fin de la partie. Et dans cette méthode de réinitialisation, nous donnons la couche de score. Il nous reste le temps qui nous reste. Écrivons la requête sept. Le temps d'immunité est égal à quatre. Et nous allons retirer le composant vaccinal d'ici. Je connais beaucoup de code, mais il faut comprendre le concept. Enfin, le vaccin injectable est un élément incontournable. Je vais vérifier si ça ne va pas. Après avoir joué, il vous suffira d'écrire la référence du jeu, chronomètre du vaccin, le point de départ. J'espère que tu l'as vu. Ici. Nous écrivons le chronomètre des vaccins, mais nous ne l'appelons pas ici. C'est-à-dire que nous ne lançons pas le chronomètre pour la vaccination. Nous ne commencerons que si le composant de la couche supérieure entre en collision avec le composant vaccinal. Disons : Eh bien, d'accord, recommençons. Voyons voir, nous avons un éditeur quelconque ou le jeu fonctionne. Croisons les doigts. Jouons. voyez, nous avons ce composant vaccinal, mais comme j'ai été attaqué par le virus, il n'a pas fonctionné. Mais attendons. Je suppose qu' il y aura une autre fois que le composant vaccinal apparaîtra. Ils y sont à nouveau jumelés. Jouons à nouveau. Voir. Maintenant, j'ai la composante vaccinale et rien ne m'arrive. Mais au bout de 4 s, encore une fois, je suis attaqué. Cela signifie donc que nous sommes au moins le composant du vaccin. Il fonctionne parfaitement. Voyons voir. Le vaccin est-il réapparu ou non ? Ça ne va pas forcément, c'est apparu. Vous voyez enfin, cette fonctionnalité fonctionne parfaitement. J'espère que vous avez apprécié et compris ce concept. Si ce n'est pas le cas, essayez à nouveau de vérifier ces codes avant de passer à une autre section. Merci 23. Vidéo 22 Travail sur le composant protéique: Bonjour, bon retour. Le dernier rebondissement que nous ajouterons au jeu est donc un composant protéique. Car le renforcement musculaire et l'apport en protéines vont de pair. En gros, ici, un supplément de protéines n' apparaîtra au hasard qu'une fois par jeu. Et si le joueur le représente graphiquement avant qu'il ne disparaisse, il obtient un incrément de code bonus aléatoire qui peut prendre n'importe quelle valeur de 0 à 8. Cela va créer de la curiosité. Alors allons-y. Créons un nouveau fichier à l'intérieur des composants, à savoir le traitement par points des composants protéiques . Copiez et collez le code complet du vaccin. Ici. Il suffit de tout copier et de le coller. Évidemment, changeons-le en protéine. Prenez un n, k. k. Et dans OnLoad, nous aurons des protéines dub brillantes ici et finirons par entrer en collision. Nous écrirons simplement si l'autre est un composant Player, supposons. Ensuite, évidemment, nous supprimerons ce composant ou cet objet de l'écran, mais nous augmenterons également le score. Donc, pour obtenir le score aléatoire, nous l'avons déjà implémenté tant de fois. Et mon score bonus est que nous allons créer un point de classe aléatoire à côté de neuf. Alors voilà, 0-8. Puisque neuf est exclu, 0 à 8, cela peut générer n'importe quel bonus aléatoire. Et nous allons simplement incrémenter les points appelés référence du jeu, score par points, bobine en plastique, bonus aléatoire. Imaginez donc que l' utilisateur ne sache pas qu'il pourrait avoir un noyau de zéros malchanceux, dépend de sa chance. Nous devons maintenant apporter à nouveau les modifications nécessaires à la classe de jeu. Passons donc au jeu Fit Fighter. Ici. Créons de nouvelles variables d'état pour les protéines. Voici donc exactement ce que le composant protéique. Tout d'abord, initialisons-le. La composante protéique est égale à et donnons la position de départ. Comme 200.400 K. Et si vous le souhaitez, vous pouvez également générer des positions de départ aléatoires, mais vous savez comment l'implémenter, c'est à vous de décider. Écrivons Protein. Protéines. Heure. La gauche est égale à quatre, ce qui signifie que la protéine disparaîtra automatiquement automatiquement au bout de 4 s. Donc, ici, l'utilisateur doit la récupérer en 4 s. Nous aurons également un dimère de protéine. Aujourd'hui. Doyen. Dimère. Alors, passons une journée. Mes parents, ce sera un moment aléatoire pour la production de protéines. OK. Et enfin, nous parlerons simplement de bonus protéiné. Voyons voir. Qu'est-ce que le bonus protéique pour que nous puissions garder cette trace, garder une trace de tout bonus afin de pouvoir le montrer à l'utilisateur plus tard. Ça, quel est le montant exact du bonus qu'il a obtenu ? Donc, en dessous de la durée du vaccin, mes parents, écrivons que les parents dimères protéiques sont égaux au point aléatoire à côté d'un int, temps restant moins cinq plus cinq. Ce qui signifie simplement que le temps doit être supérieur à 5 s et inférieur à 30 s. D'accord ? De même, cela se produit. Faisons en sorte que ce soit bien. C'est la routine, mes parents sont ici. Comme précédemment, nous apporterons des modifications à ce chronomètre de jeu. Objet à vérifier. Si ce temps de jeu restant est égal au temps d'apparition aléatoire des protéines. Si VS, ajoutez le composant protéique à l'écran. Alors allons-y. D'abord. Nous vérifions comme si le temps restant était égal à celui du vaccin. Et là encore, nous allons vérifier si temps restant est égal au temps d'apparition habituel. Ajoutez ensuite le composant protéique et nous commencerons également à créer ce dimère protéique. D'accord ? Maintenant, créons le minuteur de protéines. Tout cela fonctionne de la même manière que nous avons créé le dimère du vaccin plus tôt. Une répétition est égale à vrai. Au tac. Nous vérifierons si le centime de protéine restant est égal à zéro, ce temps est écoulé, puis retirerons simplement le composant protéique. Mais le jeu suivant vient de dire que le temps restant est égal à faux, r est égal à quatre. Nous ne devrions pas le rendre définitif. Et nous allons arrêter le minuteur de protéines. Si c'est zéro. Sinon, il suffit de décrémenter que j'imaginais que ces 4321, comme celui-ci, laissaient moins égal à 10 k. Nous avons donc implémenté l' ajout de ce composant protéique. Démarrez la minuterie au moment où le variateur démarrera. Mettons à jour ce dimère si un composant protéique est ajouté au jeu. Ici. Nous allons simplement écrire si le composant protéique est chargé, c' est-à-dire s'il est dans le jeu. Ensuite, Protein Timer Dot met à jour DT. D'accord, et ensuite nous devons apporter quelques modifications. Maintenant c'est réglé. Parce que nous avons vraiment dit qu'il restait du temps à manger des protéines, supprimez le composant et attribuez un temps aléatoire pour la prochaine partie. Si le joueur a joué, encore une fois. Simplement, VS Code est égal à ce composant ouvert, le composant vaccinal. Comme Dean, il reste du temps pour retirer le composant protéique du parent. Routine. Diamond Princess est égal à random. Ensuite, le temps restant moins cinq plus cinq. J'espère que vous comprenez que nous sommes à nouveau en train de réinitialiser l'heure car si l'utilisateur la joue à nouveau, la méthode de chargement ne sera pas appelée. C'est la raison. Maintenant, après cela, disons que lorsque nous passons à la composante protéique, nous devons surnommer Dub Protein Timer. Si une protéine entre en collision avec le composant du joueur, émettez le son et mettez également à jour cette valeur de bonus dans cette variable de bonus protéique. Ici. Si c'est le cas, alors nous diffuserons du son, diffuserons des globals, les protéines sonneront. Ensuite, nous arrêterons simplement le minuteur de protéines. Et puisque nous le sommes, puisque la protéine n' apparaîtra qu'une seule fois, il n'y a aucun problème d' arrêt et de redémarrage encore et encore. Et nous dirons simplement que le jeu de ce bonus protéiné donnera un score bonus aléatoire. Et nous afficherons cette valeur bonus dans le menu de cette partie. Passons donc au match avec mon nouveau inférieur à ce score. En dessous de ce score. Disons un texte. À l'intérieur de ce pont. Dans la biosynthèse, émulez le bonus protéique. Ensuite, Game OF Protein Bonus. Donnez un formulaire, dit const. Textile en taille 20. Faites-le petit. Sauvegardons tout et voyons si la protéine est là ou non. Et par souci de simplicité, je vais supprimer les vaccins antiviraux ou un virus afin de faciliter les tests. Le jeu. Nous avons ici est là. C'est vérifié. Je vais jouer, disons évidemment King. Mais j'ai pris du delta x en C. Le composant protéique est là. Et si je le prends, je suppose que j'ai obtenu un très bon score. Et cela, nous pouvons le vérifier. Dans le jeu sur C, j'obtiens huit bonus de protéines. Si je rejoue. Laissez-nous voir ça. Évidemment, si je prends le vaccin, nous ne voyons rien non plus. Maintenant, je suppose que le bonus en protéines était nul, je crois. Je dois donc dire que c'est très amusant. Tu vois, le bonus en protéines était nul cette fois. Tout dépend donc de sa chance. Je vais rejouer. Et cette fois, si je ne prends pas le vaccin, voyons ce qui va se passer. Nous allons juste attendre que le vaccin apparaisse. OK, par erreur, j'ai pris le vaccin. Vaccin, désolé, protéines. Donc, les protéines étaient pour moi suffisantes. Tout fonctionne très bien. Je suis satisfait du jeu. Tout tourne donc autour de ce jeu. Dans la vidéo suivante, nous allons simplement travailler sur l'écran de démarrage juste pour le rendre magnifique. Merci. 24. Vidéo 23 Ajouter un écran de touche: Bonjour, bon retour. Notre jeu est terminé. Ajoutons quelques éléments supplémentaires, comme un écran de démarrage. Ce jeu sera magnifique et professionnel avec ces petits modules complémentaires. Accédez à bob point dev et saisissez un écran d'accueil animé. Nous avons ici celui-ci. Oui. Copiez la dépendance et ajoutez-la au fichier YAML Pub spec point. Quoi qu'il en soit, cet inverseur de package d' écran de démarrage est une solution prédéfinie qui fournit un écran de démarrage animé personnalisable pour notre écran. Jusqu'à présent, les Verts créent simplement un nouveau fichier et le nomment jeu. Verre. points verts Matériel d'importation à points verts. Créez ensuite un jeu de dénomination rigide et apatride. Écran d'accueil. Ici, nous allons retourner l'écran de démarrage animé. Voici donc certaines des propriétés et arguments courants que nous pouvons rencontrer lorsque nous travaillons avec un écran de démarrage animé, notre durée, une valeur de durée. La valeur d'itération indique la durée pendant laquelle l'écran de démarrage restera là. Écrivons donc la durée à 2 s. Ensuite. Le suivant est la barre oblique, n'importe quel widget qui spécifie l'image, logo ou le texte à afficher sur l'écran de démarrage. Donc, Splash, nous allons simplement écrire une image, un ensemble de points, puis des actifs, des images, un jeu, un logo, un point PNG. Ensuite, nous avons l'écran suivant. Cela signifie où naviguer. Après cela, la durée des éclaboussures s'arrête au bout de 2 s. Avec un peu, allez au menu principal de Const. Cela changera ensuite la taille de l'icône, 25250, et changera la couleur d'arrière-plan en noir foncé. Et écrivons également Splash Transition. C'est l'effet d'une transition moins agréable. Commençons par la transition d' échelle. D'accord ? Assignons ce menu à la page d'accueil. Écrivez simplement jeu, écran de démarrage. Sauvegardons tout et vérifions. Vous voyez, y a-t-il des écrans d' accueil là-bas et au bout de 2 s, notre menu de jeu est là. Je vais donc recommencer et voir que c'était l'effet des rituels et que ça a l'air très joli. Je dirais que si vous le souhaitez, vous pouvez essayer différentes transitions. C'est à vous de décider. Et vous pouvez également modifier le logo de l'application, n'importe quel arrière-plan ou cette couleur. De toute évidence, c'est votre propre créativité. Voilà, c'est tout pour cette vidéo. Dans la vidéo suivante, nous allons modifier cette icône de lancement, la file d'attente. 25. Vidéo 24 Modifier l'icône du lanceur: Bonjour, bienvenue sur la vidéo finale de ce cours. Nous travaillerons à la modification du nom de l'application ainsi que de l'icône du lanceur. Donc, si vous accédez à l' application et si vous sortez, vous pouvez voir ici le nom de l'application et l'icône du lanceur. Pour changer le nom de notre application sur Android. Accédez au répertoire de l'application Android plutôt que de la source, puis de la moyenne. Puis fichier manifeste Android. Et ici, vous pouvez trouver cette étiquette d'application ici. Changez-le simplement en Weight Fighter. C'est-à-dire qu'il a de l'espace et des majuscules. C'était donc pour le nom de l'application. Maintenant, pour modifier l'icône par défaut de l'application Platter, nous allons utiliser le nom du package is plotter launcher icons. Alors allons-y. Hein ? Lanceur. Maintenant, je suis sûr que je peux. Il s'agit d'une approche recommandée qui se charge de la mise à jour des icônes du lanceur d'applications pour différentes plateformes. Nous allons donc simplement copier la dépendance dans vos fichiers .puffs dans ce fichier YAML. Il suffit de le coller. Mais n'oubliez pas que nous devons coller cela dans les dépendances et non dans les dépendances. Donc, ci-dessous, en dessous de l'objectif de loterie, il suffit de le coller et de l'enregistrer. Maintenant. OK, attends, tout va toujours bien, instantanément. Maintenant, pour que cela fonctionne, nous devons ajouter quelques configurations de Floride dans ce fichier YAML Pub spec point. Donc, ci-dessous, nous devons aller exactement en dessous de ces dépendances de développement. N'oubliez pas et écrivez des icônes de lettres. Et je vous le répète encore et encore, ce Pub indique que le fichier YAML est très sensible. Si vous faites un peu plus d' espace, vous pourriez nous trouver. Maintenant, cliquez sur un espace. Nous donnerions notre note, d'accord. Donnez un onglet. Et écrivez Android pour iOS. Par le biais de l'image. Séparez cette partie de l'icône. Je déciderai des actifs, des images, du logo du jeu, point PNG, puis minimum comme le K and Ride. Et nous en utiliserons 21. Et je reçois ces codes dans la section Read Me. C. Vous pouvez comprendre comment cela fonctionne, comment cela se passe, en raison des dépendances des développeurs, de cette inondation, icônes de Floride et de tout . Nous avons tout enregistré. Après avoir configuré la configuration, il ne reste plus qu'à exécuter ce package à l'aide d'un terminal à commande ajoutée et à simplement écrire. Évidemment, nous avons ce plateau à récupérer encore et encore. Et après cela, écrivez simplement une lettre. Bob. Run, Flutter, lanceur, icônes et présentateur. Oh, hé, voyons voir. Je suppose que je crois que c'est fait. Je ne suis pas sûr que Wesley ait réussi à générer des icônes de lancement. Nous devons arrêter ce mode de débogage, puis le relancer. Voyons voir. Daikon est mis à jour ou non. Si je vais voir, nous avons la bouchée de fruits, nom de leur application et l'icône, et elle est vraiment magnifique. Je dirais que si j'y vais, nous pouvons évidemment jouer le jeu. De toute évidence, je vais le répéter. Les composants du virus, c'est le jeu auquel nous pouvons jouer. Nous avons une lecture. Alors c'est tout. Pour ce cours. J'espère que vous avez apprécié et appris beaucoup de choses. Continuez à vous entraîner. Et je vais m'assurer de créer plus de cours sur un moteur de jeu boiteux et de créer de beaux jeux. Ou vous pouvez parler de jeux plus interactifs à l'avenir. En attendant. Vous pouvez également consulter mes autres cours . Passe une bonne journée. 26. Tester le jeu complet: Waouh.