Tutoriels, scripts et conseils pour développer des jeux avec Unity 3D.
 |
| Cliquer sur l'image pour l'agrandir. |
 |
| Cliquer sur l'image pour l'agrandir. |
 |
| La liste des régions. |
 |
| Cliquer sur l'image pour l'agrandir. |
//Un commentaire vraiment inutile. string action = "Commente moi!"ou pour un bloc de commentaires, avec "/*" et "*/":
/* Il était une fois, dans l'ouest, une princesse prisonnière dans une taverne miteuse gardée par des truands à la peau tannée par le soleil et au regard sauvage, etc., etc., etc. */ string action = "Commente, mais commente égal!"et aussi avec "///":
///Parce que // fait tellement 1990. string action = "Commente moi!"
///MonoDevelop crée un commentaire avec un tag XML. Ce code XML est utilisé par un programme externe pour générer automatiquement la documentation. Les générateurs de documentation sont des programmes qui lisent le code source et les commentaires, l'analysent et retournent une documentation en format texte, HTML, XML, Latex, etc. qu'il est possible de consulter et d'effectuer des recherches. C'est très pratique pour se retrouver dans un gros projet avec des centaines de scripts. Mon générateur de documentation favori est Doxygen. Je vais parler de Doxygen dans un prochain billet./// Du XML??? /// private string action = "Commente moi!"
 |
| Avant. |
 |
| Après. |
using UnityEngine;
using System.Collections;
public class ScreenShot : MonoBehaviour
{
// Update is called once per frame
void Update ()
{
if ( Input.GetKeyUp( KeyCode.F3 ) )
{
Debug.Log("Screen captured.");
Application.CaptureScreenshot("Screenshot.png");
}
}
}
et le résultat (j'ai utilisé le Prefab Big Tree dans Standard Asset/Tree Creator pour l'arbre):
[AddComponentMenu("SousMenuName/SousSousMenuName/NomDuScript")]
Reprenons le script
RandomObjectsCreator.cs
utilisé pour instancier des prefabs lorsque la touche "Espace" est pressée. Je veux que ce script apparaisse dans le
menu Component->Mentalogicus->Creator. J'ajoute l'attribut AddComponentMenu de la manière suivante:
using UnityEngine;
using System.Collections;
[AddComponentMenu("Mentalogicus/Creator/RandomObjectsCreator")]
public class RandomObjectsCreator : MonoBehaviour
{
public Transform _prefab;
public float _radius = 10;
// Update is called once per frame
void Update ()
{
if ( Input.GetKey("space") )
{
//Create a random position.
//The insideUnitSphere return a random
//position inside a sphere of radius 1.
Vector3 rndPos = Random.insideUnitSphere * _radius;
//Create a random rotation.
Quaternion rndRotation = Random.rotation;
//Instantiate a new object at a random
//position with a random rotation.
Transform newGameObj = Instantiate( _prefab,
rndPos, rndRotation) as Transform;
}
}
}
Quaternion rotation = Quaternion.Euler( a,b,0 );
transform.rotation = rotation;
transform.position = rotation * r + p;
void Rotate( float x, float y )
{
Quaternion rotation = Quaternion.Euler(y,x,0.0f);
Vector3 position =
rotation * _distanceVector + _target.position;
transform.rotation = rotation;
transform.position = position;
}
void RotateControls()
{
if ( Input.GetButton("Fire1") )
{
}
}
void RotateControls()
{
if ( Input.GetButton("Fire1") )
{
_x += Input.GetAxis("Mouse X") * _xSpeed;
_y += -Input.GetAxis("Mouse Y") * _ySpeed;
this.Rotate(_x,_y);
}
}
using UnityEngine;
using System.Collections;
/**
* Change the camera into an orbital camera. An orbital is a camera
* that can be rotated and that will automatically reorient itself to
* always point to the target.
*
* The orbit camera allow zooming and dezooming with the mouse wheel.
*
* By clicking the mouse and dragging on the screen, the camera is moved.
* The angle of rotation correspond to the distance the cursor travelled.
*
* The camera will keep the angular position when the button is pressed. To
* rotate more, simply repress the mouse button et move the cursor.
*
* This script must be added on a camera object.
*
* @author Mentalogicus
* @date 11-2011
*/
public class OrbitCamera : MonoBehaviour
{
//The target of the camera. The camera will always point to this object.
public Transform _target;
//The default distance of the camera from the target.
public float _distance = 20.0f;
//Control the speed of zooming and dezooming.
public float _zoomStep = 1.0f;
//The speed of the camera. Control how fast the camera will rotate.
public float _xSpeed = 1f;
public float _ySpeed = 1f;
//The position of the cursor on the screen. Used to rotate the camera.
private float _x = 0.0f;
private float _y = 0.0f;
//Distance vector.
private Vector3 _distanceVector;
/**
* Move the camera to its initial position.
*/
void Start ()
{
_distanceVector = new Vector3(0.0f,0.0f,-_distance);
Vector2 angles = this.transform.localEulerAngles;
_x = angles.x;
_y = angles.y;
this.Rotate(_x, _y);
}
/**
* Rotate the camera or zoom depending on the input of the player.
*/
void LateUpdate()
{
if ( _target )
{
this.RotateControls();
this.Zoom();
}
}
/**
* Rotate the camera when the first button of the mouse is pressed.
*
*/
void RotateControls()
{
if ( Input.GetButton("Fire1") )
{
_x += Input.GetAxis("Mouse X") * _xSpeed;
_y += -Input.GetAxis("Mouse Y")* _ySpeed;
this.Rotate(_x,_y);
}
}
/**
* Transform the cursor mouvement in rotation and in a new position
* for the camera.
*/
void Rotate( float x, float y )
{
//Transform angle in degree in quaternion form used by Unity for rotation.
Quaternion rotation = Quaternion.Euler(y,x,0.0f);
//The new position is the target position + the distance vector of the camera
//rotated at the specified angle.
Vector3 position = rotation * _distanceVector + _target.position;
//Update the rotation and position of the camera.
transform.rotation = rotation;
transform.position = position;
}
/**
* Zoom or dezoom depending on the input of the mouse wheel.
*/
void Zoom()
{
if ( Input.GetAxis("Mouse ScrollWheel") < 0.0f )
{
this.ZoomOut();
}
else if ( Input.GetAxis("Mouse ScrollWheel") > 0.0f )
{
this.ZoomIn();
}
}
/**
* Reduce the distance from the camera to the target and
* update the position of the camera (with the Rotate function).
*/
void ZoomIn()
{
_distance -= _zoomStep;
_distanceVector = new Vector3(0.0f,0.0f,-_distance);
this.Rotate(_x,_y);
}
/**
* Increase the distance from the camera to the target and
* update the position of the camera (with the Rotate function).
*/
void ZoomOut()
{
_distance += _zoomStep;
_distanceVector = new Vector3(0.0f,0.0f,-_distance);
this.Rotate(_x,_y);
}
} //End class
Rambo = 1; Lili = 1; John = 1; Ada = 1; Linus = 1; Steve = 1;C'est assez long! Imaginer maintenant qu'il y a une centaine de personnes sur cette rue. Toutes les maisons sont occupées par des célibataires, donc, une personne par maison. Vous allez devoir manuellement indiquer qu'il y a une personne dans chaque maison! Ce n'est pas très pratique. Heureusement, il y a les tableaux.
Rambo = Tabaga[0];Je mémorise la valeur de l'index 0 du tableau Tabaga dans la variable Rambo. Remarquer que les caractères [] sont utilisés au lieu des parenthèses habituelles utilisées en mathématique. En mathématique, pour accéder à un élément d'un vecteur, la notation est a(1), a(2), etc. En C# et pour tous les langages de la famille du C, les crochets sont utilisés. En Fortran, la notation mathématique est utilisée.
Rambo = Tabaga[9];La question que vous vous posez sûrement est: pourquoi les concepteurs du C (l'ancêtre du C++ et du C#) n'ont-ils pas commencé les tableaux à 1, comme dans le vrai monde (ou comme en Fortran). Les éléments d'un tableau C sont enregistrés dans des espaces mémoire contigus. En sachant l'adresse du premier élément, les autres éléments sont atteints en additionnant l'index du tableau. Ainsi, le tableau n'a pas besoin de mémoriser l'adresse mémoire de tous les éléments, mais seulement du premier, sauvant de la mémoire. Un index en C est un décalage par rapport au premier élément du tableau. Le tableau contient l'adresse du premier élément du tableau. Disons que l'adresse du premier élément est 987. L'adresse du premier élément est: 987 + 0, le second est 987 + 1, le troisième est 987 + 2, le nième est 987 + i où i est l'index du tableau.
Tabaga[1] = 1;Il est désormais possible de dire que chaque maison de la rue Tabaga possède une seule personne. En C#, le code est:
for each maison in Tabaga
{
maison = 1;
}
L'instruction for each est une boucle. Une boucle répète l'action entre
les {} plusieurs fois. Dans le cas d'une boucle for each, la boucle se
répète tant qu'il y a des éléments dans Tabaga. maison est une
variable de la boucle for each avec l'adresse d'une maison de la rue
Tabaga. En assignant 1 à maison, j'assigne 1 à un élément de Tabaga.
La boucle visitant toutes les maisons, le résultat final est que chaque maison
à désormais 1 d'assigné. Une boucle est un peu comme le facteur. Le facteur
visite chaque maison une à la fois et délivre le courrier en fonction de
l'adresse de la maison.
int[] Tabaga; Tabaga = new int[5];ou en une seule instruction:
int[] Tabaga = new int[5];Ici encore, le C# est contre-intuitif. La notation la plus naturelle serait:
int Tabaga(5) = new int(5);Pour les admirateurs de cette notation, sachez que Visual Basic ressemble un peu à cela. De même que Fortran.
int[] Tabaga;crée un pointeur à un tableau de int. Un pointeur est une variable qui contient une adresse mémoire qui, elle, contient des données. Dans le cas présent, le pointeur ne contient pas d'adresse. Pour revenir à notre analogie, Tabaga est une rue vide, sans maison. La rue est vide, mais je peux construire des maisons par la suite.
Tabaga = new int[5];L'instruction new indique aux programmes de créer un tableau de int contenant 5 éléments. new crée l'espace mémoire nécessaire au tableau et retourne l'adresse mémoire qui est enregistrée dans Tabaga. Pour revenir à notre analogie, la commande new construit des maisons dans notre rue.
PlayerPrefs.SetString( "PlayerName", playerName );Le premier paramètre est la clé qui va permettre de retrouver la valeur et le second, la variable que nous voulons enregistrer. PlayerPrefs est un dictionnaire. Nous lui fournissons une valeur et une clé. Pour lire le nom du joueur, le code est simplement:
playerName = PlayerPrefs.GetString( "PlayerName");Il n'y a rien de plus à faire. Unity se charge automatiquement d'enregistrer dans un fichier les valeurs de PlayersPrefs lors de la fermeture du jeu, que ce soit sur Windows ou en mode Web. Par contre, il est possible de forcer l'enregistrement à l'aide de la fonction:
PlayerPrefs.Save();Passons à un exemple concret pour voir comment appliquer PlayerPrefs dans une application. Voici un simple cube avec un bouton qui change sa couleur aléatoirement:
using UnityEngine;
using System.Collections;
/**
* Change the color of a cube and save the data using PlayerPrefs.
*
* @author Mentalogicus
* @date 11-2011
*
* Copyright (C) 2011, Mentalogicus
* All rights reserved
*
*/
public class StatsMenu : MonoBehaviour
{
//The current color of the cube.
Color _current = new Color(1,1,1,1);
// Use this for initialization
void Start ()
{
//Load the saved color.
Load();
//Change the shader to transparent diffuse.
this.renderer.material.shader = Shader.Find("Transparent/Diffuse");
//Apply the current color to our cube.
this.renderer.material.color = _current;
}
/**
* Show a button to change the color and 4 labels to show
* the color RGBA component.
*/
void OnGUI ()
{
GUI.BeginGroup( new Rect(50,50, 200,150) );
GUI.Box( new Rect(0,0, 200,150), "Change Color" );
if ( GUI.Button( new Rect( 10,25,100, 20), "Change Color" ) )
{
ChangeColor();
AutoSave();
}
ShowColor();
GUI.EndGroup();
}
/**
* Show the current color used on your cube.
*/
void ShowColor()
{
GUI.Label( new Rect( 10, 50, 150,20), "Red: " + _current.r );
GUI.Label( new Rect( 10, 75, 150,20), "Green: " + _current.g );
GUI.Label( new Rect( 10, 100, 150,20), "Blue: " + _current.b );
GUI.Label( new Rect( 10, 125, 150,20), "Alpha: " + _current.a );
}
/**
* Change the color to a random one.
*/
void ChangeColor()
{
_current = new Color( Random.value, Random.value, Random.value, Random.value );
this.renderer.material.color = _current;
}
/**
* Save the color with the PlayerPrefs class.
*/
void AutoSave()
{
PlayerPrefs.SetFloat( "Color_Red", _current.r );
PlayerPrefs.SetFloat( "Color_Green", _current.g);
PlayerPrefs.SetFloat( "Color_Blue", _current.b );
PlayerPrefs.SetFloat( "Color_Alpha", _current.a );
}
/**
* Load the color with the PlayerPrefs class.
*/
void Load()
{
if ( PlayerPrefs.HasKey("Color_Red") )
{
_current.r = PlayerPrefs.GetFloat( "Color_Red" );
}
if ( PlayerPrefs.HasKey("Color_Green") )
{
_current.g = PlayerPrefs.GetFloat( "Color_Green");
}
if ( PlayerPrefs.HasKey("Color_Blue") )
{
_current.b = PlayerPrefs.GetFloat( "Color_Blue" );
}
if ( PlayerPrefs.HasKey("Color_Alpha") )
{
_current.a = PlayerPrefs.GetFloat( "Color_Alpha" );
}
}
}
Ce script est appliqué sur le cube. La classe PlayerPrefs est limitée dans ces capacités.
Heureusement, il existe une extension nommée PlayerPrefsX qui étend les capacités de PlayerPrefs.
Ce script est à l'adresse suivante:
 |
| L'éditeur d'Unity. |
 |
| Menu pour la création d'un prefab. |
 |
| Création d'un cube dans Unity. |
 |
| Ajout d'un objet au prefab. |
using UnityEngine;
using System.Collections;
public class RandomObjectsCreator : MonoBehaviour
{
// Use this for initialization
void Start ()
{
}
// Update is called once per frame
void Update ()
{
}
}
Instantiate( _prefab, position, rotation);La fonction Instantiate va créer un clone du prefab contenu dans la variable _prefab, l'afficher dans la scène à la position "position" avec la rotation "rotation" et va retourner une référence de l'objet avec le type Object. Le type Object est le type de base en C#. Dans le précédent code, nous n'avons pas mis de variable pour récupérer la référence à l'objet. Pour ce faire, le code sera:
Transform newGameObj =
Instantiate( prefab, position, rotation) as Transform;
Transform est un type générique d'Unity qui permet d'accéder à toutes les
propriétés de l'objet de la scène. Le as Transform est un casting. Instantiate
retourne une référence de type Object. Or, nous voulons une référence de type
Transform. Nous indiquons la transformation de la référence de type Object
en une référence de type Transform avec le as Transform. Il est à remarquer
que cette notation est identique à la suivante:
Transform newGameObj =
(Transform)Instantiate( _prefab, position, rotation);
Personnellement, je préfère le as, car c'est plus proche de l'anglais que
l'opérateur de casting avec parenthèse.
Input.GetKey("space");
Cette fonction retourne vrai si la touche espace est enfoncée et faux autrement.
La position de notre cube sera choisi aléatoirement dans une sphère d'un rayon
déterminé par la variable _radius:
Vector3 rndPos = Random.insideUnitSphere * _radius;et avec une rotation aléatoire:
Quaternion rndRotation = Random.rotation;Le script complet est le suivant:
using UnityEngine;
using System.Collections;
public class RandomObjectsCreator : MonoBehaviour
{
public Transform _prefab;
public float _radius = 10;
// Update is called once per frame
void Update ()
{
if ( Input.GetKey("space") )
{
//Create a random position.
//The insideUnitSphere return a random position inside a sphere of radius 1.
Vector3 rndPos = Random.insideUnitSphere * _radius;
//Create a random rotation.
Quaternion rndRotation = Random.rotation;
//Instantiate a new object at a random position with a random rotation.
Transform newGameObj = Instantiate( _prefab, rndPos, rndRotation) as Transform;
}
}
}
 |
| Ajout d'un script et assignation de la variable prefab aux prefab Cube. |