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.