Para mover o teu personaxe necesitas un controlador de personaxes. O punto de partida é un ambiente con colisionadores. Tamén necesitas un personaxe. O personaxe necesita un dos seus Collider. O seguinte é engadir un 2D Corpo ríxido.
Crea un script para o teu personaxe e chámao Character2DController.
Cambia o script a private void:
Para o eixo x necesitamos unha entrada:
var movement = Input.GetAxis ("Horizontal")
1 representa a tecla de frecha dereita e -1 a tecla de frecha esquerda.
Necesitamos un novo vector 3 para o eixo x como valor de entrada:
transform.position + = newVector3 (movement, 0, 0) * Time.DeltaTime * MovementSpeed;
A nova posición calcúlase a partir do novo vector 3 * Time.DeltaTime * MovementSpeed
Polo tanto, a velocidade de movemento ten que ser engadida como variable:
flotación pública MovementSpeed = 1;
O guión ten este aspecto:
Se preme reproducir en Unity, agora pode mover a figura de esquerda a dereita. Podes aumentar a velocidade se o personaxe é demasiado lento.
Agora cree unha referencia ao corpo ríxido:
private rigidbody2D rigidbody;
Engade o seguinte ao compoñente inicial:
Rigidbody = GetComponent ();
Requírese outra entrada:
if (Input.GetButtonDown ("Saltar"))
Necesitas unha forza no eixo y que inicie o salto: isto chámase JumpForce:
Rigidbody.AddForce (novo Vector3 (0, JumpForce));
JumpForce insírese como variable:
carro público JumpForce = 1;
O compoñente dá o impulso de saltar:
Rigidbody.AddForce (novo Vector3 (0, JumpForce), ForceMode2D.Impulse);
Agora pódese comprobar o eixo Y para saltar só unha vez:
if (Input.GetButtonDown ("Jump") && Mathf.Abs (Rigidbody.velocity.y) <0.001f)
O guión rematado ten este aspecto:
Con esta compilación primeiro podes moverte. O guión faise máis complexo coa seguinte parte do tutorial. Para iso, ten que renomear os compoñentes rigidbody por Rigidbody2D.
Necesitas a seguinte variable para agacharte:
flotador privado CrouchSpeed = .36f;
O suavizado do movemento úsase para suavizar o movemento:
flotador privado MovementSmoothing = .05f;
Air Control define se un xogador pode controlar saltando ou non:
bool privado AirControl = falso;
WhatIsGround define o underground para o xogador:
LayerMask privado WhatIsGround;
Groundcheck comproba se o xogador está ou non no chan:
privado Transform GroundCheck;
O CeilingCheck comproba se hai un límite superior:
Private Transform CeilingCheck;
CrouchDisableCollider define que o colisionador estará desactivado se o xogador se agacha:
privado Collider2D CrouchDisableCollider;
Agora definíronse as primeiras variables:
Requírense outras variables:
const float GroundedRadius = .2f;
define o raio do círculo de superposición para determinar se se atopa no subsolo definido.
libro privado Grounded;
indica se o xogador está ou non no chan.
const float CeilingRadius = .2f;
é o raio do círculo de superposición para determinar se o xogador pode levantarse ou se hai unha manta sobre eles.
private bool FacingRight = verdadeiro;
Para determinar a que dirección está enfrontado o xogador.
privado Vector3 Velocidade = Vector3.cero;
A continuación necesitamos o sistema de eventos Unity:
Engades:
usando UnityEnginge.Events;
Ademais, é necesario un UnityEvent para recoñecer se o personaxe aterra despois de saltar ou non:
unidade pública Evento OnLandEvent;
O BoolEvent refírese a agacharse:
clase pública BoolEvent: UnityEvent {}
public BoolEvent OnCrouchEvent;
libro privado wasCrouching = false;
Non hai ningunha función de inicio no script, pero a función esperta:
O comezo comeza cando comeza o programa. Espertar refírese ao obxecto que se inicializa dentro do obxecto.
baleiro privado Esperta ()
{
Rigidbody2D = GetComponent ();
if (OnLandEvent == nulo)
OnLandEvent = novo UnityEvent ();
if (OnCrouchEvent == nulo)
OnCrouchEvent = BoolEvent ();
}
A continuación definimos a posición "Grounded" con máis detalle:
O xogador está conectado a terra cando un radio definido cumpre coa posición de control de terra, que se denomina chan:
private void FixedUpdate ()
{
bool wasGrounded = Conectado;
Grounded = falso;
Collider2D [] colliders = Physics2D.OverlapCircleAll (GroundCheck.position, GroundedRadius, WhatIsGround);
for (int i = 0; i <colliders.Lenght; i ++)
{
if (colisionadores [i] .gameObject! = gameObject)
{
Grounded = verdadeiro;
if (! wasRounded)
OnLandEvent.Invoke ();
}
}
}
O seguinte paso é comprobar que se o personaxe se agacha, pode estar de pé. Se non, debería agacharse:
public void Move (movemento flotante, agachamento bool, salto bool)
{
se (! agacha)
{
Se o personaxe ten unha manta que lles impide levantarse, segue agachado:
if (Physics2D.OverlapCircle (CeilingCheck.position, CeilingRadius, WhatIsGround))
{
agacharse = verdadeiro;
}
}
O xogador só pode controlar a figura se está no chan ou se airControl está activado:
se (conectado a terra || AirControl)
{
Cando a figura se agacha:
se (agachado)
{
se (estaba en dificultades)
{
wasCrouching = verdadeiro;
OnCrouchEvent.Invoke (verdadeiro);
}
senón se (estaba agachado)
{
wasCrouching = falso;
OnCrouchEvent.Invoke (falso)
}
Reduce a velocidade co multiplicador CrouchSpeed:
move * = CrouchSpeed;
Desactiva un dos colisionadores cando a figura se agacha ou agacha:
if (CrouchDisableCollider! = nulo)
CrouchDisableCollider.enabled = falso;
} máis
{
Active o colisionador cando a figura non está agachada ou agachada:
if (CrouchDisableCollider! = nulo)
CrouchDisableCollider.enabled = verdadeiro;
se (estaba en dificultades)
{
wasCrouching = falso;
OnCrouchEvent.Invoke (falso);
}
}
Move o personaxe atopando a velocidade obxectivo:
Vector3 targetVelocity = novo Vector2 (move * 10f, Rigidbody2D.velocity.y);
E despois aplácao e aplícao ao personaxe:
Rigidbody2D.velocity = Vector3.SmoothDamp (m_Rigidbody2D.velocity, targetVelocity, ref Velocity, MovementSmoothing);
Cando a entrada se move á dereita e o xogador apunta á esquerda:
if (mover> 0 &&! m_FacingRight)
dar a volta ao xogador:
Flip ();
Se non, se a entrada móvese á esquerda e o xogador mira á dereita:
else if (move <0 && FacingRight)
xira ao xogador:
Flip ();
Cando o xogador debe saltar:
if (Grounded && jump)
{
Engade unha forza vertical ao xogador.
Grounded = falso;
Rigidbody2D.AddForce (novo Vector2 (0f, JumpForce));
private void flip ()
{
Cambia a forma en que o xogador está marcado de cara:
FacingRight =! FacingRight;
Multiplica a escala x local do xogador por -1.
Vector3 theScale = transform.localScale;
theScale.x * = -1;
transform.localScale = a escala;
}
}
O guión rematado ten este aspecto:
