Développement de jeux 3D avec ShiVa3D Suite Montage de scènes

Curieux de développer des jeux en 3D? C'est le moment d'apprendre! Cette série de tutoriels en cinq parties montrera comment créer un jeu simple avec ShiVa3D Suite, un moteur de jeu 3D multiplate-forme et un outil de création. C’est le troisième volet de la série, où vous apprendrez à éditer les scènes d’un jeu et à commencer à coder les modèles AI..

Développer le jeu dans l'éditeur de ShiVa - suite

Dans la deuxième partie, nous avons commencé par décrire comment développer le jeu avec ShiVa Editor. Nous avons présenté les modules de l'éditeur ShiVa utilisés lors du développement de l'application du tutoriel, et nous avons parlé des fichiers de modèle Collada représentant les personnages principaux de l'application. Nous avons ensuite discuté des étapes initiales nécessaires à la création de l'application, telles que la création du jeu et de la scène et l'importation des modèles Collada. Dans la partie 3, nous montrerons comment modifier la scène de notre application. Nous allons également commencer à entrer le code pour les AIModels du jeu. En particulier, nous allons entrer le code pour le DuckAI.

Modifier la scène

Nous allons maintenant définir différentes propriétés de la scène.

Nous supposons que le fichier image marbre.jpg a été copié sous le dossier nommé D: \ temp \ skybox. Dans votre environnement, si vous copiez le fichier dans un autre emplacement, veillez à modifier les instructions ci-dessous en conséquence..

Dans l'explorateur de données, accédez à Importer -> Texture. Dans la boîte de dialogue, sélectionnez le fichier comme indiqué ci-dessous et cliquez sur Importer..

Figure 33. Importer la texture

Maintenant, dans le dossier Textures de DataExplorer, vous devriez voir une texture appelée marbre.

Figure 34. Dossier Textures

Modifions divers attributs de la scène à l'aide de l'éditeur d'ambiance. Placez Ambience Editor et Data Explorer côte à côte et double-cliquez sur MyScene dans le dossier Scenes. À ce stade, vous pouvez être invité à enregistrer la scène, comme indiqué ci-dessous. Cliquez sur oui et fermez la boîte de dialogue..

Figure 35. Enregistrer l'invite

Maintenant, l'éditeur d'ambiance et l'explorateur de données doivent apparaître côte à côte comme suit.

Figure 36. Éditeur d'ambiance

Dans la section éclairage, ajustez la couleur de la lucarne pour obtenir un ton jaune pâle, comme indiqué ci-dessous.

Figure 37. Couleur de la lucarne

Pour chacun des éléments skybox de la section Sky, sélectionnez le marbre.

Figure 38. Paramètres Skybox

Amenez Game Editor et Data Explorer côte à côte. Sélectionnez Canard -> Jeux dans l'explorateur de données et double-cliquez sur Canard. Cela fera apparaître le jeu dans l'éditeur de jeu. Sélectionnez Ressources -> Polices dans l'explorateur de données. Dans l'éditeur de jeu, appuyez sur l'onglet Ressources. Glissez et déposez la police par défaut de l'explorateur de données dans l'onglet Ressources (voir ci-dessous)..

Figure 39. Police par défaut

Nous allons maintenant ajouter un tag à egg. (Un objet peut être recherché et situé dans un jeu par programmation, en fonction de son tag.) Placez l'explorateur de scènes et l'explorateur de données côte à côte. Dans l'explorateur de données, sélectionnez Canard -> Scènes -> MyScene et double-cliquez sur. À ce stade, vous pouvez être invité à enregistrer MyScene comme suit. Cliquez sur oui et fermez la boîte de dialogue..

Figure 40. Enregistrer l'invite pour MyScene

Dans l'explorateur de scènes, mettez la sphère en surbrillance et dans le menu contextuel, sélectionnez la balise Modifier la sélection. Dans la boîte de dialogue, tapez "oeuf" pour la balise. Ces étapes sont montrées dans les deux images consécutives ci-dessous.

Figure 41. Modification de la balise de sélection

Figure 42. Dialogue de balises

AIModels et le code

Nous allons maintenant créer les AIModels et le code associé pour notre jeu. Rappelez-vous de la discussion précédente que les AIModels représentent le comportement des objets dans un jeu. Le canard et l'oeuf auront chacun leurs propres modèles, DuckAI et EggAI, respectivement. De plus, le jeu lui-même aura son propre AIModel, appelé MainAI. MainAI sera responsable de l’initialisation de la caméra et de la scène, ainsi que du traitement et de la distribution des événements utilisateur..

Passons d'abord en revue certains concepts relatifs aux AIModels, en empruntant des informations à la documentation d'aide de ShiVa Editor..

UNE gestionnaire contient du code pour traiter un événement particulier. Outre un ensemble prédéfini de gestionnaires, vous pouvez également définir des gestionnaires personnalisés. Nous ne mettrons en œuvre qu'un sous-ensemble des gestionnaires prédéfinis, énumérés ci-dessous..

onInit: ce gestionnaire est appelé lors de la création de l'objet associé à l'AIModel. généralement utilisé pour les tâches d'initialisation.
onEnterFrame: Un jeu est une boucle de cadres. Ce gestionnaire est appelé sur chaque image. Vous utiliseriez principalement ce gestionnaire pour définir le mouvement d'un objet.
onTouchSequenceBegin: Ce gestionnaire est appelé lorsque l'utilisateur commence à toucher l'écran du périphérique. Ce gestionnaire d'événements est un moyen de notifier au code AIModel le démarrage d'une séquence d'événements tactiles..
onTouchSequenceChange: Ce gestionnaire est appelé pour chaque événement tactile de la séquence tactile en transmettant le nombre de contacts et les coordonnées de chaque contact..
onTouchSequenceEnd: ce gestionnaire est appelé lorsque l'utilisateur cesse de toucher l'écran du périphérique. Ce gestionnaire d'événements est un moyen de notifier au code AIModel que la séquence d'événements tactiles est terminée. Les événements tactiles devant être traités par onTouchSequenceBegin, onTouchSequenceChange et onTouchSequenceEnd sont disponibles uniquement pour un périphérique compatible multitouch.
onSensorCollisionBegin: Ce gestionnaire d'événements est appelé lorsqu'un capteur associé à l'objet entre en collision avec un autre capteur..

UNE une fonction contient du code pour le traitement de tâches spécifiques. Les fonctions ne sont pas prédéfinies, vous les définissez et les implémentez selon vos besoins. Une fonction peut envoyer ou poster des événements à un gestionnaire. (La différence fondamentale entre l'envoi et la publication d'un événement est que l'exécution d'un sendEvent est instantanée, alors que l'exécution d'un postEvent est effectuée après un délai demandé.) Une fonction peut être directement appelée à partir d'une autre fonction ou d'un autre gestionnaire. De plus, une fonction peut être la cible d'un sendEvent ou d'un postEvent.
UNE variable peut être accessible de manière globale à partir des fonctions et des gestionnaires d'un modèle AIModel particulier.
AIModels soutient également le concept de Etat qui n'est pas utilisé dans ce tutoriel.

Commençons maintenant à définir les AIModels dans notre jeu. Placez l’explorateur de scènes et l’explorateur de données côte à côte et double-cliquez sur MyScene dans l’explorateur de données sous le dossier Scènes. (Si vous y êtes invité, enregistrez MyScene et fermez la boîte de dialogue.) Dans l'explorateur de scènes, sélectionnez l'onglet Objets, sélectionnez Canard, puis cliquez avec le bouton droit de la souris sur Contrôleurs -> AI -> Créer une IA. Ceci est montré ci-dessous.

Figure 43. Créer le CanardAI

Nommez l'IA sous DuckAI dans la boîte de dialogue, comme indiqué ci-dessous, puis appuyez sur OK..

Figure 44. Créer un dialogue pour le DuckAI

De même, dans l'onglet Objets de l'explorateur de scène, sélectionnez une sphère, puis cliquez avec le bouton droit de la souris sur le menu Contrôleurs -> AI -> Créer une AI. Nommez l'IA sous EggAI dans la boîte de dialogue et cliquez sur OK..

Dans l'explorateur de données, sélectionnez Créer -> Ressource -> AIModel (voir ci-dessous). Nommez-le MainAI.

Figure 45. Créer le MainAI

Dans l'explorateur de données, vous devez maintenant voir trois modèles AIM dans le dossier Ressources -> Modèles: DuckAI, EggAI, MainAI. Ouvrez l'éditeur de jeu et l'explorateur de données côte à côte. Dans Game Editor, sélectionnez l'onglet Main. Dans le dossier Ressources -> AIModels, faites glisser MainAI dans la zone de texte de l'utilisateur MainAI dans Game Editor (voir ci-dessous)..

Figure 46. Le MainAI

Ouvrez maintenant l'éditeur AIModel Editor et l'explorateur de données. Double-cliquez sur DuckAI, EggAI et MainAI. Vous devriez voir un onglet distinct pour chacun des modèles AIM dans l'éditeur AIModel, comme indiqué ci-dessous..

Figure 47. AIModel Editor

Entrer des variables et du code pour DuckAI

Sous l'onglet DuckAI, cliquez sur Ajouter une variable et ajoutez une variable de type boolean. Nommez-le positif avec true comme valeur initiale (voir ci-dessous). Cliquez sur OK pour fermer la boîte de dialogue..

Figure 48. Définir une variable

De la même manière, ajoutez une variable nommée 'score' où le type est 'nombre' et la valeur initiale est 0. Même si vous le tapez 0, la variable sera initialisée en tant que float, c'est-à-dire 0.000.

Toujours sur l'onglet DuckAI, cliquez sur Ajouter un gestionnaire -> onEnterFrame, comme indiqué ci-dessous.

Figure 49. Ajout d'un gestionnaire

De même, cliquez sur Ajouter un gestionnaire -> onInit. Enfin, cliquez sur Ajouter un gestionnaire -> Gestionnaire d’objets -> onSensorCollisionBegin (voir ci-dessous)..

Figure 50. Ajout d'un gestionnaire pour le capteur de collision

Maintenant, l'onglet DuckAI ressemblera à ceci.

Figure 51. DuckAI Tab

Amenez l'éditeur AIModel Editor et l'éditeur de script côte à côte. Dans l'onglet DuckAI de l'éditeur AIModel Editor, double-cliquez sur OnInit (). Un code squelette pour cela sera ouvert dans l'éditeur de script comme indiqué ci-dessous.

Figure 52. code squelette onInit ()

Copiez et collez le texte suivant dans l’éditeur de script, en remplaçant complètement le code existant (une révision du code sera donnée dans une section ultérieure). Dans l'éditeur de script, cliquez sur Ctrl + S pour enregistrer le script..

 fonction DuckAI.onInit () ------------------------------------------------ ------------------------------------ object.setTranslation (this.getObject (), 2, 3, 2, object.kGlobalSpace) local lUser = application.getCurrentUser () local lComp = hud.newComponent (lUser, hud.kComponentTypeLabel, "HUD.disp") si (lComp ~ = nil) puis hud.setComponentPosition (lComponentPosition, 75, 75, ) hud.setComponentSize (lComp, 30, 10) hud.setComponentBackgroundColor (lComp, 0, 0, 0, 0) hud.setComponentBorderColor (lComp, 0, 0, 0, 0) hud.setComponentVorder (LComp, 0, 0, 0, 0) (lComp, 255) hud.setLabelText (lComp, string.format ("Score:% 2i", this.score ())) hud.setDefaultFont (lUser, "DefaultFont") hud.setLabelTextHeight (lComp, 100) hud.setLabelTextAlignment (lComp, hud.kAlignCenter, hud.kAlignCenter) fin -------------------------------------- ------------------------------------------ fin --------------------------------------------------------------------------------

De la même manière, remplacez le code pour onEnterFrame comme suit.

 fonction DuckAI.onEnterFrame () ------------------------------------------------ ------------------------------------ local lObject = this.getObject () if (this.isPositive ( )) puis object.rotateAroundTo (lObject, 0,0,0,0,0,75,0, object.kGlobalSpace, 0.5) sinon object.rotateAroundTo (lObject, 0,0,0,0, -0,75,0, object.kGlobalSpace , 0.5) fin local x, y, z = object.getRotation (lObject, object.kLocalSpace) object.setRotation (lObject, x + 0.3, y + 0.5, z + 1, object.kLocalSpace) ------- -------------------------------------------------- ----------------------- fin --------------------------------------------------------------------------------

Ensuite, remplacez le code pour onSensorCollisionBegin par le suivant:

 fonction DuckAI.onSensorCollisionBegin (nSensorID, hTargetObject, nTargetSensorID) ------------------------------------------- ----------------------------------------- this.score (this.score () +1) local lComp = hud.getComponent (application.getCurrentUser (), "HUD.disp") if (lComp), puis hud.setLabelText (lComp, string.format ("Score:% 2i", this.score ()) ) end if (this.isPositive ()) alors this.isPositive (false) sinon this.isPositive (true) end system.openURL ("http://www.stonetrip.com", "") ------ -------------------------------------------------- ------------------------ fin --------------------------------------------------------------------------------

Maintenant, nous avons terminé avec les variables et le code pour DuckAI.

Mot de la fin de la partie 3

Dans la troisième partie, nous avons montré comment modifier la scène de notre application. Nous avons également commencé à saisir le code des AIModels du jeu. Jusqu'à présent, nous avons terminé le code pour le DuckAI. Dans la partie 4, nous terminerons le codage des modèles AIM restants, EggAI et MainAI, et effectuerons des tests unitaires en animant le jeu. Nous exporterons ensuite le jeu à partir de l'éditeur ShiVa pour l'importer dans l'outil de création de Shiva. Enfin, nous allons discuter de deux options de création différentes dans l'outil de création de Shiva: une pour générer un exécutable Android et une autre pour générer un projet Eclipse..

Code