Walk ์ ๋๋ฉ์ด์ ๋ ์๊ฒผ๊ฒ ๋ค. ์ด์ ์บ๋ฆญํฐ ์ข์ฐ ์ด๋์ ๊ตฌํํ ์ฐจ๋ก๋ค. 2D ๊ฒ์์ด๊ธด ํ์ง๋ง, ์ง๊ธ ๊ฐ๋ฐํ๋ ๊ฒ์์ ์ํ ์ด๋์ ์๊ตฌ๋์ง ์๋๋ค. ๊ทธ๋์ ๊ฐ๋จํ๊ฒ ์ข์ฐ ์ด๋๋ง ๋จผ์ ๊ตฌํํด๋ณด๊ธฐ๋ก ํ๋ค.
- Rigidbody 2D์ Velocity(์๋)๋ฅผ ํตํด ์ข์ฐ ์ด๋ ๊ตฌํ
- Walk, Idle ์ ๋๋ฉ์ด์ ์ ์ ์ ํ ํ์ด๋ฐ์ ์ฌ์ฉํด์ฃผ๊ธฐ
- Transform์ Scale์ X ๊ฐ์ ๋ถํธ๋ฅผ ๋ฐ๊ฟ์ ์บ๋ฆญํฐ๊ฐ ๋ฐ๋ผ๋ณด๋ ๋ฐฉํฅ ์ ํ ๊ตฌํ
1. ํค ์ ๋ ฅ ๋ฐ๊ธฐ
Girl Controller๋ผ๋ ์คํฌ๋ฆฝํธ๋ฅผ ํ๋ ๋ง๋ค์ด์ Character ์ค๋ธ์ ํธ์ ๋ถ์ฐฉํด์คฌ๋ค.
ํค ์ ๋ ฅ์ ์ ๋ํฐ์์ ์ ๊ณตํ๋ Input.GetAxisRaw() ํจ์๋ฅผ ์ฌ์ฉํ์ฌ ๋ฐ์ ๊ณํ์ด๋ค.
Input.GetAxisRaw("Horizontal")๋ก ๋งค๊ฐ๋ณ์๋ก ์ฃผ๋ฉด ๋ค์๊ณผ ๊ฐ์ด ๊ฐ์ ๋ฆฌํด ํด์ค๋ค.
- Aํค ๋๋ ์ผ์ชฝ ํ์ดํ ํค๋ฅผ ๋๋ฅด๋ฉด -1 ๋ฆฌํด
- Dํค ๋๋ ์ค๋ฅธ์ชฝ ํ์ดํ ํค๋ฅผ ๋๋ฅด๋ฉด 1 ๋ฆฌํด
- ํค ์ ๋ ฅ์ด ์์ผ๋ฉด 0 ๋ฆฌํด
๋ค์๊ณผ ๊ฐ์ด ๋ฉค๋ฒ ๋ณ์๋ก ์ ์ธํ ๋ณ์์ ํค ์ ๋ ฅ ๋ฆฌํด ๊ฐ์ ์ ์ฅํด๋ ๊ฒ์ด๋ค.
private float walkDirection;
void Update()
{
walkDirection = Input.GetAxisRaw("Horizontal");
}
Rigidbody ์ปดํฌ๋ํธ๋ฅผ ํตํ ๋ฌผ๋ฆฌ ๊ธฐ๋ฐ์ผ๋ก ์์ง์์ ๊ตฌํํ ๊ฒ์ด๊ธฐ ๋๋ฌธ์ ํค ์ ๋ ฅ์ Update() ํจ์์์ ๋ฐ์๋ค.
2. ์ข์ฐ ์ด๋ ๊ตฌํํ๊ธฐ
์ค์ ๋ก ๋ฌผ๋ฆฌ ๊ธฐ๋ฐ ๋ก์ง์ด ์ด๋ฃจ์ด์ง๋ ๋ถ๋ถ, ์ฆ ์ด๋์ด ์ง์ ์ ์ผ๋ก ๊ตฌํ๋์ด์ง๋ ๋ถ๋ถ์ FixedUpdate() ํจ์์์ ์ฒ๋ฆฌํ๋ค. ํค ์ ๋ ฅ์ผ๋ก ๋ฐ์๋ "walkDirection" ๊ฐ์ -1, 0, 1 ๊ฐ ์ค ํ๋์ด๊ธฐ ๋๋ฌธ์ ๋จ์ ๋ฒกํฐ๊ฐ์ผ๋ก ์ฌ์ฉํด๋ ๋๋ค.
์ฌ๊ธฐ์ ์๋ ์ ์ด๋ฅผ ์ฒ๋ฆฌํ ๋ณ์ "walkSpeed"๋ฅผ ๊ณฑํด์ ์บ๋ฆญํฐ์ ์ด๋์๋๋ฅผ ์กฐ์ ํ๋ค.
public float walkSpeed;
private float walkDirection;
private Rigidbody2D _rigidBody;
...
void Start()
{
_rigidBody = GetComponent<Rigidbody2D>();
...
}
void FixedUpdate()
{
Walk();
}
private void Walk()
{
bool hasControl = !Mathf.Approximately(walkDirection, 0f); // ์ ๋๋ฉ์ด์
์ฒ๋ฆฌ์์ ์ฌ์ฉํ ์์
_rigidBody.velocity = new Vector2(walkDirection * walkSpeed, _rigidBody.velocity.y);
}
์ด๋ ๊ฒ ์์ฑํ์ผ๋, ์ข์ฐ ์ด๋์ ์ฐ์ ๊ตฌํ์ด ๋๋ค.
ํ์ง๋ง, ์์์ ๋ณด๋ฉด ์๊ฒ ์ง๋ง ์์ง "Walk" ์ ๋๋ฉ์ด์ ์ ์ ์ฉํด์ฃผ์ง ์์, ๊ฐ๋งํ ์์ ๊ฑท๋ ๋ชจ์ต์ ์ทจํ๊ณ ์๊ณ
์ด๋ ๋ฐฉํฅ์ ์ ํํ์ ๋, ์บ๋ฆญํฐ๋ ๋ฐ๋๋ก ๋์๋ณด์ง ์๋ ์ ์ด ์์ฝ๋ค.
ํ๋์ฉ ์ฐจ๊ทผ์ฐจ๊ทผ ํด๊ฒฐํ๋ค. ์ฐ์ ์ ๋๋ฉ์ด์ ๋ถ๋ถ๋ถํฐ ์ฒ๋ฆฌํ๋ค.
3. Walk ์ ๋๋ฉ์ด์ ์ ์ฉํด์ฃผ๊ธฐ
์ ๋ฒ ๊ธ์์ ๋งํ์ง๋ง, ํ์ฌ ์ฃผ์ธ๊ณต ์บ๋ฆญํฐ๋ "Character"๋ผ๋ ๋น ๊ฒ์ ์ค๋ธ์ ํธ๊ฐ ์ต์๋จ ๋ถ๋ชจ ์ค๋ธ์ ํธ์ด๊ณ ,
๊ทธ ๋ฐ์ "Girl"์ด๋ผ๋ ์ค์ ์บ๋ฆญํฐ ์ค๋ธ์ ํธ๊ฐ ์๋ค.
ํ์ฌ Girl Controller ์คํฌ๋ฆฝํธ๋ "Character" ์ค๋ธ์ ํธ์, ์ ๋๋ฉ์ดํฐ๋ "Girl" ์ค๋ธ์ ํธ์ ๋ถ์ฐฉ๋์ด ์๋ ์ํฉ์ด๋ค.
๊ทธ๋์ GetComponentInChildren() ํจ์๋ฅผ ์ฌ์ฉํด์ ์์์ ๋ถ์ด์๋ ์ ๋๋ฉ์ดํฐ ์ปดํฌ๋ํธ๋ฅผ ๋ด์์ฌ ๊ณํ์ด๋ค.
public float walkSpeed;
private float walkDirection;
private Rigidbody2D _rigidBody;
private Animator animator;
void Start()
{
_rigidBody = GetComponent<Rigidbody2D>();
animator = GetComponentInChildren<Animator>(); // ์ถ๊ฐ
}
void FixedUpdate()
{
Walk();
}
private void Walk()
{
bool hasControl = !Mathf.Approximately(walkDirection, 0f);
animator.SetBool("Walk", hasControl); // ์ถ๊ฐ
_rigidBody.velocity = new Vector2(walkDirection * walkSpeed, _rigidBody.velocity.y);
}
ํค ์ ๋ ฅ์ด ์๋ค๋ฉด "Idle" → "Walk"๋ก ์ํ ์ ์ด๊ฐ ์ผ์ด๋๊ณ , ํค ์ ๋ ฅ์ด ์๋ค๋ฉด ๋ค์ "Walk" → "Idle"์ด ๋ ๊ฒ์ด๋ค.
์บ๋ฆญํฐ๊ฐ ๋ฐ๋ฅ์์ ์กฐ๊ธ ๋ฏธ๋๋ฌ์ง๋ฏ ๊ฑธ์ด์, ์ ๋๋ฉ์ด์ ์ฌ์ ์๋๋ ์บ๋ฆญํฐ์ ์ด๋ ์๋๋ฅผ ์กฐ์ ํด์คฌ๋ค.
์ด์ ๋ง์ง๋ง์ผ๋ก ์บ๋ฆญํฐ๊ฐ ๋ณด๋ ๋ฐฉํฅ ์ ํ ๊ตฌํ๋ง ๋จ์๋ค.
4. ์บ๋ฆญํฐ๊ฐ ๋ฐ๋ผ๋ณด๋ ๋ฐฉํฅ ์ ํ ๊ตฌํํ๊ธฐ
๋ณธ ๋ธ๋ก๊ทธ์ Unity ์นดํ ๊ณ ๋ฆฌ์์ 2D ์บ๋ฆญํฐ๊ฐ ๋ฐ๋ผ๋ณด๋ ๋ฐฉํฅ ์ ํ์ ๋ํ ๊ธ์ ๋ค๋ฃฌ ์ ์ด ์์๋ค. ๋ณธ์ธ์ Transform์ Scale์ X ๊ฐ์ ๋ถํธ๋ฅผ ๋ฐ๊ฟ์ฃผ๋ ๋ฐฉ๋ฒ์ ํตํด ๊ตฌํํด์คฌ๋ค.
์ด๊ธฐ Transform.Scale.x์ ๊ฐ์ ์ ์ฅํด๋๊ณ , ์ด ๊ฐ๊ณผ ๋จ์ ๋ฒกํฐ๋ก ํ์ฉํ ์ ์๋ "walkDirection" ๊ฐ์ ๊ณฑํ ๊ฐ์ด ๋ค๋ฅด๋ค๋ฉด ๋ฐฉํฅ ์ ํ์ ํด์ฃผ๋ ๋ฐฉ์์ ์๊ฐํ๊ณ , ์ด๋๋ก ์ ์ฉํ๋ค.
public float walkSpeed;
public Transform girlTransform; // Transform์ ์ GetComponentInChildren์ด ์ ์ฉ๋์ง ์์๊น?
private Rigidbody2D _rigidBody;
private Animator animator;
private float walkDirection;
private float initScaleX; // ์ถ๊ฐ
void Start()
{
_rigidBody = GetComponent<Rigidbody2D>();
animator = GetComponentInChildren<Animator>();
initScaleX = girlTransform.localScale.x; // ์ถ๊ฐ
}
void FixedUpdate()
{
Walk();
}
private void Walk()
{
bool hasControl = !Mathf.Approximately(walkDirection, 0f);
TurnOtherSide(hasControl); // ์ถ๊ฐ
animator.SetBool("Walk", hasControl);
_rigidBody.velocity = new Vector2(walkDirection * walkSpeed, _rigidBody.velocity.y);
}
private void TurnOtherSide(bool hasControl) // ์ถ๊ฐ
{
if (!hasControl)
return;
var scaleX = girlTransform.localScale.x;
if (Mathf.Approximately(walkDirection * scaleX, initScaleX))
return;
var scaleY = girlTransform.localScale.y;
var scaleZ = girlTransform.localScale.z;
// ์ฝ๋๊ฐ ๋๋ฌด ๊ธธ์ด์ ธ์, ๊ฐ๋
์ฑ์ ์ํด ๋ณ์์ ๋ด์๋ค.
girlTransform.localScale = new Vector3(-scaleX, scaleY, scaleZ);
}
์ด๋ ๊ฒ ํจ์ผ๋ก์จ, ์ต์ข ์ ์ผ๋ก ์บ๋ฆญํฐ ์ข์ฐ ์ด๋์ด ๊ตฌํ ์๋ฃ๋์๋ค.
์ด ์ธ์๋ ๋ฌ๋ฆฌ๊ธฐ, ์ํธ์์ฉ, ์ ํ, ์จ๊ธฐ ์ ๋์ ์ ๋๋ฉ์ด์ ์ด ๋ ์๋๋ฐ ์ธ์ ๋ ๋ง๋ค์ง,,, ์ฒ์ฒํ ๋น ๋ฅด๊ฒ ํด๋ณด์,,,ใ ใ ใ
ํน์ ๋ชฐ๋ผ ๋์์ด ํ์ํ์ค ๋ถ๋ค์ ์ํด ์ ์ฒด ์์ค์ฝ๋ ์๋์ ์ฒจ๋ถํ๊ฒ ์ต๋๋ค.
"Girl Controller" ์ ์ฒด ์์ค์ฝ๋
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class GirlController : MonoBehaviour
{
public float walkSpeed;
private Animator animator;
private SpriteRenderer[] _sprite;
public Transform girlTransform;
private Rigidbody2D _rigidBody;
private float walkDirection;
private float initScaleX;
void Start()
{
_rigidBody = GetComponent<Rigidbody2D>();
//girlTransform = GetComponentInChildren<Transform>(); // Transform์ ์ ์ฉ์ด ์ ๋๋ค?
_sprite = GetComponentsInChildren<SpriteRenderer>();
animator = GetComponentInChildren<Animator>();
initScaleX = girlTransform.localScale.x;
}
void Update()
{
walkDirection = Input.GetAxisRaw("Horizontal");
}
void FixedUpdate()
{
Walk();
}
private void Walk()
{
bool hasControl = !Mathf.Approximately(walkDirection, 0f);
TurnOtherSide(hasControl);
animator.SetBool("Walk", hasControl);
_rigidBody.velocity = new Vector2(walkDirection * walkSpeed, _rigidBody.velocity.y);
}
private void TurnOtherSide(bool hasControl)
{
if (!hasControl)
return;
var scaleX = girlTransform.localScale.x;
if (Mathf.Approximately(walkDirection * scaleX, initScaleX))
return;
var scaleY = girlTransform.localScale.y;
var scaleZ = girlTransform.localScale.z;
girlTransform.localScale = new Vector3(-scaleX, scaleY, scaleZ);
}
}