Programación de Unity - Intermedio

1. Crear atributos

Para crear una propiedad, cree descriptores de acceso entre paréntesis después de la propiedad

using UnityEngine;
using System.Collections;

public class Player
{
    //成员变量可以称为
    //字段。
    private int experience;

    //Experience 是一个基本属性
    public int Experience
    {
        //访问属性的值
        get
        {
            //其他一些代码
            return experience;
        }
        //设置属性的值
        set
        {
            //其他一些代码
            experience = value;
        }
    }

    //Level 是一个将经验值自动转换为
    //玩家等级的属性
    public int Level
    {
        get
        {
            return experience / 1000;
        }
        set
        {
            experience = value * 1000;
        }
    }

    //这是一个自动实现的属性的
    //示例
    public int Health{ get; set;}
}

Crea la clase Game en otro archivo:

Los atributos en el Reproductor se pueden usar como variables en el Juego

using UnityEngine;
using System.Collections;

public class Game : MonoBehaviour 
{
    void Start () 
    {
        Player myPlayer = new Player();

        //属性可以像变量一样使用
        myPlayer.Experience = 5;
        int x = myPlayer.Experience;
    }
}

¿Por qué todavía se recomienda usar atributos cuando hay públicos y privados?

Porque el uso de atributos permite acceder y modificar de forma segura los datos encapsulados dentro de la clase. Por ejemplo, no queremos que los datos internos de la clase sean modificados a voluntad por el exterior de la clase. Se usa Private, pero a veces el código externo necesita usar los datos dentro de la clase. En este momento, configurando atributos, se puede proporcionar un acceso seguro y razonable para el código externo .

En términos simples, A puede dejar que B entre a su casa, pero B debe seguir la orden de A, qué tomar y cómo tomarlo, tiene que escuchar a A, en lugar de dejar que B entre a su antojo, o prohibir completamente a B. de entrar

2. estática

1. Variables estáticas

En general, cada objeto de una clase tiene las mismas variables, pero cada variable tiene su propio valor. Con variables estáticas, cada objeto de la clase tiene la misma variable y el mismo valor.

Por ejemplo, si desea saber cuántos objetos crea esta clase:

using UnityEngine;
using System.Collections;

public class Enemy
{
    //静态变量是在类的所有实例之间
    //共享的变量。
    public static int enemyCount = 0;

    public Enemy()
    {
        //通过递增静态变量了解
        //已创建此类的多少个对象。
        enemyCount++;
    }
}

2. Clase estática

Un método escrito en una clase estática se puede llamar en otra clase a través del nombre de clase de la clase estática y el operador punto

clase estática:

using UnityEngine;
using System.Collections;

public static class Utilities 
{
    //可以在没有类对象的情况下调用
    //静态方法。请注意，静态方法无法访问
    //非静态成员变量。
    public static int Add(int num1, int num2)
    {
        return num1 + num2;
    }
}

Para llamar a un método en una clase estática desde una clase no estática:

using UnityEngine;
using System.Collections;

public class UtilitiesExample : MonoBehaviour 
{
    void Start()
    {
        //可以使用类名和点运算符
        //来访问静态方法。
        int x = Utilities.Add (5, 6);
    }
}

3. Cobertura

Si la subclase tiene un método con el mismo nombre que la clase principal, cuando se llame a este método, se llamará a la versión de la clase principal. Debido a que es la declaración de la clase principal, la subclase se convierte implícitamente en la clase principal.

abuelo

using UnityEngine;
using System.Collections;

public class Humanoid
{
    //Yell 方法的基版本
    public void Yell()
    {
        Debug.Log ("Humanoid version of the Yell() method");
    }
}

padre

using UnityEngine;
using System.Collections;

public class Enemy : Humanoid
{
    //这会隐藏 Humanoid 版本。
    new public void Yell()
    {
        Debug.Log ("Enemy version of the Yell() method");
    }
}

subclase

using UnityEngine;
using System.Collections;

public class Orc : Enemy
{
    //这会隐藏 Enemy 版本。
    new public void Yell()
    {
        Debug.Log ("Orc version of the Yell() method");
    }
}

Cree una instancia en el formulario declarado por la clase principal y llame a estos métodos:

using UnityEngine;
using System.Collections;

public class WarBand : MonoBehaviour 
{
    void Start () 
    {
        Humanoid human = new Humanoid();
        Humanoid enemy = new Enemy();
        Humanoid orc = new Orc();

        //注意每个 Humanoid 变量如何包含
        //对继承层级视图中
        //不同类的引用，但每个变量都
        //调用 Humanoid Yell() 方法。
        human.Yell();
        enemy.Yell();
        orc.Yell();
    }
}

Cuatro Interfaz

Una clase solo puede heredar de una clase principal, pero puede implementar múltiples interfaces. Las interfaces pueden definir una funcionalidad común en varias clases no relacionadas.

Implementar la interfaz:

using UnityEngine;
using System.Collections;

//这是只有一个必需方法的基本接口
public interface IKillable
{
    void Kill();
}

//这是一个通用接口，其中 T 是将由实现类提供的数据类型的占位符。
public interface IDamageable<T>
{
    void Damage(T damageTaken);
}

Implementar el método en la interfaz:

using UnityEngine;
using System.Collections;

//这是只有一个必需方法的基本接口
public interface IKillable
{
    void Kill();
}

//这是一个通用接口，其中 T 是将由实现类提供的数据类型的占位符。
public interface IDamageable<T>
{
    void Damage(T damageTaken);
}

5. Método de extensión

Si queremos restablecer los parámetros en el Transform a través de una función, la ubicación ideal para esta función es en la clase Transform, pero como no podemos acceder al código fuente del Transform integrado de Unity, podemos crear extensiones para él.

Tenga en cuenta que el método de extensión debe colocarse en una clase estática no genérica, y el método de extensión en sí también se declara como un método estático. Por lo general, se crea una clase específicamente para contenerlos.

using UnityEngine;
using System.Collections;

//创建一个包含所有扩展方法的类是很常见的做法
//此类必须是静态类
public static class ExtensionMethods
{
    //扩展方法即使像普通方法一样使用，也必须声明为静态
    //注意，第一个参数具有“this”关键字，后跟一个 Transform变量
    //此变量表示扩展方法会成为哪个类的一部分
    public static void ResetTransformation(this Transform trans)
    {
        //编写重置Transform的代码
        trans.position = Vector3.zero;
        trans.localRotation = Quaternion.identity;
        trans.localScale = new Vector3(1, 1, 1);
    }
}

Cabe señalar que, aunque la declaración del método de extensión tiene parámetros, no se pasarán parámetros al llamar a esta función. El objeto Transform que llama a este método se pasa automáticamente como el primer parámetro.

using UnityEngine;
using System.Collections;

public class SomeClass : MonoBehaviour 
{
    void Start () {
        //请注意，即使方法声明中
        //有一个参数，也不会将任何参数传递给
        //此扩展方法。调用此方法的
        //Transform 对象会自动作为
        //第一个参数传入。
        transform.ResetTransformation();
    }
}

5. Corrutina

Las funciones de rutina se pueden considerar como funciones ejecutadas en intervalos de tiempo. Las funciones de rutina se usan a menudo con la declaración de rendimiento. Cada ejecución de una función coroutine continuará donde se quedó. El uso de rutinas no necesita ejecutarse en cada cuadro como Actualizar, lo que mejora la eficiencia.

declaración de rendimiento:

rendimiento retorno nulo;	Ejecutar el código subsiguiente en el siguiente cuadro
descanso de rendimiento;	terminar la rutina
yield return new WaitForSeconds(0.5f);	Ejecutar código posterior después de esperar un tiempo fijo

using UnityEngine;
using System.Collections;

public class CoroutinesExample : MonoBehaviour
{
    public float smoothing = 1f;
    public Transform target;


    void Start ()
    {
    	//开启协程
        StartCoroutine(MyCoroutine(target));
    }

	//返回类型为IEnumerator
	//表示函数可以返回实现IEnumerator接口的任意内容
    IEnumerator MyCoroutine (Transform target)
    {
        while(Vector3.Distance(transform.position, target.position) > 0.05f)
        {
            transform.position = Vector3.Lerp(transform.position, target.position, smoothing * Time.deltaTime);

            yield return null;
        }

        print("Reached the target.");

        yield return new WaitForSeconds(3f);

        print("MyCoroutine is now finished.");
    }
}