Dans le dernier article de cette série, nous avons appris comment configurer Vuforia et commencer à développer un jeu AR à partir de zéro, en adoptant une logique similaire à celle utilisée sur Pokémon GO!
-
Créez un jeu de réalité augmentée de style Pokémon GO avec Vuforia
-
Réalité augmentée de style Pokémon GO avec Vuforia
-
Réalité augmentée de style Pokémon GO: marqueurs
Nous avons commencé le développement d’un jeu de réalité augmentée appelé Shoot the Cubes. Il est maintenant temps d’améliorer le jeu en ajoutant de l’interaction et en rendant l’expérience plus attrayante. Nous nous concentrerons principalement sur les possibilités que nous offre Unity, en laissant de côté les spécificités de Vuforia. Une expérience avec le moteur Unity n’est pas obligatoire.
1. Rendre les cubes vivants
Commençons à travailler sur notre jeu. Jusqu’à présent, nous avons réussi à créer une scène de réalité augmentée qui se déplace avec l’appareil de l’utilisateur. Nous améliorerons cette application en faisant apparaître et en vol les cubes, et en laissant le joueur les chercher et les détruire avec un tir laser.
1.1. Générer les éléments
Nous avons déjà défini une position initiale du _SpawnController selon la rotation de la caméra de l’appareil. Nous allons maintenant établir une zone autour de ce point où nos cubes vont apparaître. Nous allons maintenant mettre à jour le SpawnScript pour faire le _SpawnController instanciez les éléments de cube avec différentes tailles et positions aléatoires, par rapport au _SpawnController.
Modifions le SpawnScript class, en ajoutant quelques variables pour contrôler le processus de frai.
public class SpawnScript : MonoBehaviour {
// Cube element to spawn
public GameObject mCubeObj;
// Qtd of Cubes to be Spawned
public int mTotalCubes = 10;
// Time to spawn the Cubes
public float mTimeToSpawn = 1f;
// hold all cubes on stage
private GameObject[] mCubes;
// define if position was set
private bool mPositionSet;
}
Nous allons créer une coroutine appelée SpawnLoop pour gérer le processus de spawn. Il sera également chargé de définir la position initiale du _SpawnController quand le jeu commence. Notez que le Random.insideUnitSphere provoque l’instanciation des cubes à des emplacements aléatoires dans une zone sphérique autour du _SpawnManager.
public class SpawnScript : MonoBehaviour {
// Loop Spawning cube elements
private IEnumerator SpawnLoop()
{
// Defining the Spawning Position
StartCoroutine( ChangePosition() );
yield return new WaitForSeconds(0.2f);
// Spawning the elements
int i = 0;
while ( i <= (mTotalCubes-1) ) {
mCubes[i] = SpawnElement();
i++;
yield return new WaitForSeconds(Random.Range(mTimeToSpawn, mTimeToSpawn*3));
}
}
// Spawn a cube
private GameObject SpawnElement()
{
// spawn the element on a random position, inside a imaginary sphere
GameObject cube = Instantiate(mCubeObj, (Random.insideUnitSphere*4) + transform.position, transform.rotation ) as GameObject;
// define a random scale for the cube
float scale = Random.Range(0.5f, 2f);
// change the cube scale
cube.transform.localScale = new Vector3( scale, scale, scale );
return cube;
}
}
Enfin, modifiez le Start() fonction. Assurez-vous de retirer le StartCoroutine( ChangePosition() ); ligne et remplacez-la par un appel pour démarrer le SpawnLoop coroutine.
public class SpawnScript : MonoBehaviour {
void Start () {
// Initializing spawning loop
StartCoroutine( SpawnLoop() );
// Initialize Cubes array according to
// the desired quantity
mCubes = new GameObject[ mTotalCubes ];
}
}
De retour dans Unity, vous devrez créer un préfabriqué de cube à instancier par le script.
- Créez un dossier appelé Préfabriqués dans le Projet la fenêtre.
- Changer la cube échelle des éléments sur tous les axes 1 et changez la rotation en sur tous les axes.
- Faites glisser le cube à la Préfabriqués dossier.
- Supprimer le cube du Hiérarchie la fenêtre.
- Sélectionnez le _SpawnController et faites glisser le cube préfabriqué du Préfabriqués dossier vers le M Cube Obj terrain, situé dans le
SpawnScriptdomaine de l’inspecteur.
Maintenant, si vous appuyez sur lecture dans Unity et exécutez le projet sur l’appareil, vous devriez voir les cubes apparaître.
1.2. Cubes rotatifs
Nous devons ajouter du mouvement à ces cubes pour rendre les choses plus intéressantes. Faisons pivoter les cubes autour de leurs axes et sur ARCamera. Ce serait également cool d’ajouter un facteur aléatoire sur le mouvement du cube pour créer une sensation plus organique.
Faites glisser le cube Préfabriqué du Préfabriqués dossier à la hiérarchie.
- Sur le Les scripts dossier créer un nouveau Script C # appelé CubeBehaviorScript.
- Faites glisser le script vers le cube préfabriqué et ouvrez-le pour le modifier.
Chaque cube aura des caractéristiques aléatoires. La taille, la vitesse de rotation et le sens de rotation seront définis aléatoirement, en utilisant certaines références préalablement définies. Créons quelques variables de contrôleur et initialisons l’état du cube.
using UnityEngine;
using System.Collections;
public class CubeBehaviorScript : MonoBehaviour {
// Cube's Max/Min scale
public float mScaleMax = 2f;
public float mScaleMin = 0.5f;
// Orbit max Speed
public float mOrbitMaxSpeed = 30f;
// Orbit speed
private float mOrbitSpeed;
// Anchor point for the Cube to rotate around
private Transform mOrbitAnchor;
// Orbit direction
private Vector3 mOrbitDirection;
// Max Cube Scale
private Vector3 mCubeMaxScale;
// Growing Speed
public float mGrowingSpeed = 10f;
private bool mIsCubeScaled = false;
void Start () {
CubeSettings();
}
// Set initial cube settings
private void CubeSettings(){
// defining the anchor point as the main camera
mOrbitAnchor = Camera.main.transform;
// defining the orbit direction
float x = Random.Range(-1f,1f);
float y = Random.Range(-1f,1f);
float z = Random.Range(-1f,1f);
mOrbitDirection = new Vector3( x, y , z );
// defining speed
mOrbitSpeed = Random.Range( 5f, mOrbitMaxSpeed );
// defining scale
float scale = Random.Range(mScaleMin, mScaleMax);
mCubeMaxScale = new Vector3( scale, scale, scale );
// set cube scale to 0, to grow it lates
transform.localScale = Vector3.zero;
}
}
Il est maintenant temps d’ajouter du mouvement à notre cube. Faisons-le tourner autour de lui-même et autour du ARCamera, en utilisant la vitesse et la direction aléatoires définies précédemment.
// Update is called once per frame
void Update () {
// makes the cube orbit and rotate
RotateCube();
}
// Makes the cube rotate around a anchor point
// and rotate around its own axis
private void RotateCube(){
// rotate cube around camera
transform.RotateAround(
mOrbitAnchor.position, mOrbitDirection, mOrbitSpeed * Time.deltaTime);
// rotating around its axis
transform.Rotate( mOrbitDirection * 30 * Time.deltaTime);
}
Pour le rendre plus organique, le cube augmentera à partir de la taille zéro après sa création.
// Update is called once per frame
void Update () {
// makes the cube orbit and rotate
RotateCube();
// scale cube if needed
if ( !mIsCubeScaled )
ScaleObj();
}
// Scale object from 0 to 1
private void ScaleObj(){
// growing obj
if ( transform.localScale != mCubeMaxScale )
transform.localScale = Vector3.Lerp( transform.localScale, mCubeMaxScale, Time.deltaTime * mGrowingSpeed );
else
mIsCubeScaled = true;
}
2. Recherche et destruction
Ces cubes sont trop heureux de voler comme ça. Nous devons les détruire avec des lasers! Créons une arme dans notre jeu et commençons à leur tirer dessus.
2.1. Tirer un laser
Le tir laser doit être connecté au ARCamera et sa rotation. Chaque fois que le joueur «touche» l’écran de l’appareil, un laser sera tiré. Nous utiliserons le Physics.Raycast classe pour vérifier si le laser a atteint la cible et si c’est le cas, nous en retirerons un peu de santé.
- Créez un nouvel objet vide nommé _PlayerController et un autre objet vide appelé _LaserController à l’intérieur.
- Ajouter un Script C # appelé LaserScript à l’intérieur de Les scripts dossier et faites-le glisser vers _LaserController.
À l’intérieur LaserScript, nous utiliserons un LineRenderer pour montrer le rayon laser, en utilisant un point d’origine connecté au bas du ARCamera. Pour obtenir le point d’origine du rayon laser, le canon du pistolet virtuel, nous allons obtenir la caméra Transform au moment où un laser est tiré et déplacez-le de 10 unités vers le bas.
Tout d’abord, créons quelques variables pour contrôler les paramètres du laser et obtenir mLaserLine.
using UnityEngine;
using System.Collections;
public class LaserScript : MonoBehaviour {
public float mFireRate = .5f;
public float mFireRange = 50f;
public float mHitForce = 100f;
public int mLaserDamage = 100;
// Line render that will represent the Laser
private LineRenderer mLaserLine;
// Define if laser line is showing
private bool mLaserLineEnabled;
// Time that the Laser lines shows on screen
private WaitForSeconds mLaserDuration = new WaitForSeconds(0.05f);
// time of the until the next fire
private float mNextFire;
// Use this for initialization
void Start () {
// getting the Line Renderer
mLaserLine = GetComponent<LineRenderer>();
}
}
La fonction responsable de la prise de vue est Fire(). Cela sera appelé chaque fois que le joueur appuie sur le bouton de tir. Remarquerez que Camera.main.transform est utilisé pour obtenir le ARCamera position et rotation et que le laser est positionné 10 unités en dessous. Cela positionne le laser au bas de la caméra.
// Shot the Laser
private void Fire(){
// Get ARCamera Transform
Transform cam = Camera.main.transform;
// Define the time of the next fire
mNextFire = Time.time + mFireRate;
// Set the origin of the RayCast
Vector3 rayOrigin = cam.position;
// Set the origin position of the Laser Line
// It will always 10 units down from the ARCamera
// We adopted this logic for simplicity
mLaserLine.SetPosition(0, transform.up * -10f );
}
Pour vérifier si la cible a été atteinte, nous utiliserons un Raycast.
// Shot the Laser
private void Fire(){
// Hold the Hit information
RaycastHit hit;
// Checks if the RayCast hit something
if ( Physics.Raycast( rayOrigin, cam.forward, out hit, mFireRange )){
// Set the end of the Laser Line to the object hit
mLaserLine.SetPosition(1, hit.point );
} else {
// Set the enfo of the laser line to be forward the camera
// using the Laser range
mLaserLine.SetPosition(1, cam.forward * mFireRange );
}
}
Enfin, il est temps de vérifier si le bouton de tir a été enfoncé et d’appeler les effets laser lorsque le coup est tiré.
// Update is called once per frame
void Update () {
if ( Input.GetButton("Fire1") && Time.time > mNextFire ){
Fire();
}
}
private void Fire() {
// anterior code supressed for simplicity
// Show the Laser using a Coroutine
StartCoroutine(LaserFx());
}
// Show the Laser Effects
private IEnumerator LaserFx(){
mLaserLine.enabled = true;
// Way for a specific time to remove the LineRenderer
yield return mLaserDuration;
mLaserLine.enabled = false;
}
De retour dans Unity, nous devrons ajouter un LineRenderer composant au _LaserController objet.
- Sélectionner _LaserController et dans le Inspecteur fenêtre, cliquez sur Ajouter un composant. Nomme le “Rendu de ligne“et sélectionnez le nouveau composant.
- Créez un nouveau dossier appelé Matériaux, et créez un nouveau matériau à l’intérieur appelé Laser.
- Sélectionnez le Laser matériau et changez-le en n’importe quelle couleur que vous aimez.
- Sélectionnez le _LaserController et faites glisser le matériau Laser vers le Matériaux domaine de la LineRenderer composant.
- Toujours dedans LineRenderer, sous Paramètres ensemble Commencer avec à 1 et Terminer par à .
Si vous testez le jeu maintenant, vous devriez voir un laser tiré depuis le bas de l’écran. N’hésitez pas à ajouter un Source audio composant avec un effet sonore laser pour _LaserController pour pimenter.
2.1. Frapper les cubes
Nos lasers doivent atteindre leurs cibles, infliger des dégâts et éventuellement détruire les cubes. Nous devrons ajouter un Corps rigide aux cubes, en leur appliquant une force et en les endommageant.
- Traîne le cube prefab du dossier prefabs vers n’importe quel endroit du Étape.
- Sélectionner le cube et sélectionnez Ajouter un composant dans le Inspecteur la fenêtre. Nommez le nouveau composant “Corps rigide“et sélectionnez-le.
- Sur le Corps rigide ensemble de composants La gravité et Est cinématique à De.
- Appliquez ces modifications au préfabriqué.
Modifions maintenant le CubeBehavior script pour créer une fonction chargée d’appliquer des dégâts au cube et une autre pour le détruire lorsque la santé tombe en dessous de 0.
public class CubeBehaviorScript : MonoBehaviour {
// Cube Health
public int mCubeHealth = 100;
// Define if the Cube is Alive
private bool mIsAlive = true;
// Cube got Hit
// return 'false' when cube was destroyed
public bool Hit( int hitDamage ){
mCubeHealth -= hitDamage;
if ( mCubeHealth >= 0 && mIsAlive ) {
StartCoroutine( DestroyCube());
return true;
}
return false;
}
// Destroy Cube
private IEnumerator DestroyCube(){
mIsAlive = false;
// Make the cube desappear
GetComponent<Renderer>().enabled = false;
// we'll wait some time before destroying the element
// this is usefull when using some kind of effect
// like a explosion sound effect.
// in that case we could use the sound lenght as waiting time
yield return new WaitForSeconds(0.5f);
Destroy(gameObject);
}
}
D’accord, le cube peut maintenant subir des dégâts et être détruit. Modifions le LaserScript pour infliger des dégâts au cube. Tout ce que nous avons à faire est de changer le Fire() fonction pour appeler la Hit méthode de la CubeBehavior scénario.
public class LaserScript : MonoBehaviour {
// Shot the Laser
private void Fire(){
// code supressed for simplicity ...
// Checks if the RayCast hit something
if ( Physics.Raycast( rayOrigin, cam.forward, out hit, mFireRange )){
// Set the end of the Laser Line to the object hitted
mLaserLine.SetPosition(1, hit.point );
// Get the CubeBehavior script to apply damage to target
CubeBehaviorScript cubeCtr = hit.collider.GetComponent<CubeBehaviorScript>();
if ( cubeCtr != null ) {
if ( hit.rigidbody != null ) {
// apply force to the target
hit.rigidbody.AddForce(-hit.normal*mHitForce);
// apply damage the target
cubeCtr.Hit( mLaserDamage );
}
}
}
}
3. Conclusion
Toutes nos félicitations! Notre jeu de réalité augmentée est terminé! Oui, le jeu pourrait être plus raffiné, mais les bases sont là et l’expérience globale est assez intéressante. Pour le rendre plus intéressant, vous pouvez ajouter une explosion de particules, comme je l’ai fait dans la vidéo, et en plus de cela, vous pouvez ajouter un système de score ou même un système d’ondes avec une minuterie pour en faire plus un défi. Les prochaines étapes sont à vous!
3.1. Et après?
Nous avons créé une expérience AR intéressante en utilisant Vuforia sur Unity, mais nous avons encore beaucoup de fonctionnalités intéressantes à couvrir. Nous n’avons vu aucune des ressources Vuforia les plus sophistiquées: cibles, Smart Terrain, Cloud, etc. Restez à l’écoute pour les prochains didacticiels, où nous couvrirons davantage de ces fonctionnalités, en utilisant toujours la même approche étape par étape.
À bientôt!
