ํ๋ก์ ํธ ์์ฑ: ์ฃผ๋ก 2D URP
์์ฆ์ URP ์ง์์ ์ํด์ค์ 2D URP ์ ํํ๋ ๊ฒ์ด ์ข์
โญ ์ธํฐํ์ด์ค์ ์กฐ์๋ฒ

Project (ํ๋ก์ ํธ) ์ฐฝ
๊ทธ๋ํฝ, ์ฌ์ด๋ ๋ฑ ํ์ผ ๋ชจ๋. ๊ฒ์์ ๊ตฌ์ฑํ๋ ์ฐฝ

Hierachy (๊ณ์ธต๊ตฌ์กฐ) ์ฐฝ
๊ฒ์ ์ค๋ธ์ ํธ๋ฅผ ํ์ธํ๊ฑฐ๋ ์ง์ ๋ง์ง ์ ์์, ์ผ์ชฝ

Scene (์ฅ๋ฉด) ์ฐฝ
๊ฒ์ ์ค๋ธ์ ํธ๋ค์ ๋ํ๋ด๋ ์ฅ๋ฉด ์ฐฝ

Inspector (์ธ์คํํฐ) ์ฐฝ
๊ฒ์ ์ค๋ธ์ ํธ ์์ฑ๋ค์ ํ์ธํ๋ ์ฐฝ
์นด๋ฉ๋ผ ํ์ | ์ค๋ฅธ์ชฝ ํด๋ฆญ ํ ์ด๋ |
์นด๋ฉ๋ผ ์ถ ์ด๋ | Alt + ์ผ์ชฝ ํด๋ฆญ |
์นด๋ฉ๋ผ ์์ ์ด๋ | ๋ฐฉํฅํค (์๋๊ฐ ์กฐ๊ธ ๋น ๋ฅด๋ค) |
์นด๋ฉ๋ผ ์ด๋, ์ค | ๋ง์ฐ์ค ํ (์ด๋: ํ ๋๋ฅธ ์ํ / ์ค: ํ ๋น๊ธฐ๊ธฐ) |
๋ทฐ ์ด๋ | Q |
์ด๋ | W (๊ธฐ์ค ๋ชจ์ ํ์ดํ ๋๋ฅด๊ณ ์ด๋) |
ํ์ | E |
ํฌ๊ธฐ ์กฐ์ | R (ํ ๊ฐ์ด๋ฐ ๋๋ฅด๊ณ ์์ง์ด๋ฉด ์๋ ๋น์จ๋๋ก ์ปค์ง๊ฑฐ๋ ์์์ง) |
์ฌ๊ฐํด (3D๋ณด๋ค๋ 2D์ ์ ํฉ) | T |
โญ ๊ฒ์ ๊ตฌ์กฐ์ ํ๋ก๊ทธ๋๋ฐ
์ฐ๊ทน > ๋ง > ์ธ๋ฌผ&์ํ > ๋๋ณธ
๊ฒ์ > ์ฅ๋ฉด > ์ค๋ธ์ ํธ > ์คํฌ๋ฆฝํธ
ํ๋ก๊ทธ๋๋ฐ: ์ปดํจํฐ ์ธ์ด๋ก ๋๋๋ ๋ํ (๊ธฐ๊ณ์ด <-> ํ๋ก๊ทธ๋๋ฐ ๊ณ ๊ธ ์ธ์ด)
์ ๋ํฐ๋ c# ์ฌ์ฉ
โญ ์ ๋ํฐ ํ๋ก๊ทธ๋๋ฐ์ ์์, ์ฝ์์ฐฝ์ ๋ฉ์์ง ๋์๋ณด๊ธฐ
C# ์คํฌ๋ฆฝํธ
project ์ฐฝ ๋น ๊ณต๊ฐ ์ค๋ฅธ์ชฝ ํด๋ฆญ - create - c# script

Debug.Log(); : ์ฝ์์ฐฝ์ ๋ฉ์์ง๋ฅผ ์ถ๋ ฅ |
๋ฑ์ฅ์ธ๋ฌผ(์ค๋ธ์ ํธ)์ ๋๋ธํด๋ฆญํ ๋ค,
ํด๋น ์ค๋ธ์ ํธ์ ์ธ์คํํฐ ์ฐฝ์ ๋๋ณธ(C# ์คํฌ๋ฆฝํธ)๋ฅผ ๋๋๊ทธํด์ ์ฎ๊ฒจ ์ค
์ค์ ์๋จ์ Play๋ฅผ ๋๋ฅด๋ฉด ์ฝ์์ฐฝ์ ์ฐ๋ฆฌ์ ๋๋ณธ์ด ๋์ด
โญ ์ ๋ํฐ C# ํ๋ก๊ทธ๋๋ฐ ๊ธฐ์ด, ํ ๋ฐฉ์ ์ ๋ฆฌํ๊ธฐ
1. ๋ณ์ Variable (int, float, string, bool)
๋ณ์: ๋ฐ์ดํฐ๋ฅผ ๋ฉ๋ชจ๋ฆฌ์ ์ ์ฅํ๋ ์ฅ์
int short long |
์ ์ํ ๋ณ์ |
float double |
์ค์ํ ๋ณ์ (๋ถ๋ ์์์ ์ซ์ ์ ์ฅ) float๋ ํญ์ ๋ค์ f๋ฅผ ๋ถ์ฌ์ค์ผ ํจ (15.5f) |
char | ๋ฌธ์ํ ๋ณ์ 'A' |
string | ๋ฌธ์์ด ๋ณ์ "Hello Unity" ํฐ ๋ฐ์ดํ ํ์ |
bool | ๋
ผ๋ฆฌํ ๋ณ์ boolean type true / false ๋ง์ ๋ฐํ |
๊ทธ ์ธ: object(๊ฐ์ฒดํ ๋ณ์), Nullable(nullํ ๋น), enum(์ด๊ฑฐํ ๋ณ์), struct(๊ตฌ์กฐ์ฒด ๋ณ์) ๋ฑ |
ํ๋ก๊ทธ๋๋ฐ: ๋ณ์ ์ ์ธ โ ์ด๊ธฐํ(๋ณ์์ ๊ฐ์ ๋ฃ์) โ ํธ์ถ(์ฌ์ฉ)
์ฃผ์(์คํ๋์ง ์๋ ๋ฉ๋ชจ) ์ฒ๋ฆฌ๋ //๋ก ๊ฐ๋ฅ
int level = 5;
float strength = 15.5f;
string playerName = "๋๊ฒ์ฌ";
bool isFullLevel = false;
Debug.Log("์ฉ์ฌ์ ์ด๋ฆ์?");
Debug.Log(playerName);
Debug.Log("์ฉ์ฌ์ ๋ ๋ฒจ์?");
Debug.Log(level);
Debug.Log("์ฉ์ฌ์ ํ์?");
Debug.Log(strength);
Debug.Log("์ฉ์ฌ๋ ๋ง๋ ์ธ๊ฐ?");
Debug.Log(isFullLevel);

2. ๊ทธ๋ฃนํ ๋ณ์ Group Variable (Array, List)
๊ทธ๋ฃนํ ๋ณ์: ๋ณ์๋ค์ ๋ฌถ์ ํ๋์ ์ฅ์
array(๋ฐฐ์ด) : ๊ฐ์ฅ ๊ธฐ๋ณธ์ ์ธ ๊ณ ์ ํ ๊ทธ๋ฃนํ ๋ณ์
string[] monsters = { "์ฌ๋ผ์", "์ฌ๋ง๋ฑ", "์ ๋ง" };
์ฌ๋ฌ ๊ฐ๋ฅผ ํ ๋ฒ์ ์์ ํ๊ณ ์ถ์ ๋ ์์ ๊ฐ์ด ์ค๊ดํธ์ ๋๊ดํธ๋ฅผ ์ด์ฉํ์ฌ ๋ฐฐ์ด ์ ์ธ ๋ฐ ์ด๊ธฐํ
๋ฐฐ์ด์ ๊ธธ์ด: ๋ฐฐ์ด๋ช .Length; |
string[] monsters = { "์ฌ๋ผ์", "์ฌ๋ง๋ฑ", "์
๋ง" };
Debug.Log("๋งต์ ์กด์ฌํ๋ ๋ชฌ์คํฐ");
Debug.Log(monsters[0]); // ํ๋ก๊ทธ๋๋ฐ์์ ๋ฐฐ์ด์ 0๋ถํฐ ์์
Debug.Log(monsters[1]);
Debug.Log(monsters[2]);
int[] monsterLevel = new int[3];
monsterLevel[0] = 1;
monsterLevel[1] = 6;
monsterLevel[2] = 20;
Debug.Log("๋งต์ ์กด์ฌํ๋ ๋ชฌ์คํฐ์ ๋ ๋ฒจ");
Debug.Log(monsterLevel[0]);
Debug.Log(monsterLevel[1]);
Debug.Log(monsterLevel[2]);
List(๋ฆฌ์คํธ) : ๊ธฐ๋ฅ์ด ์ถ๊ฐ๋ ๊ฐ๋ณํ ๊ทธ๋ฃนํ ํจ์
List<ํ์ > ๋ฆฌ์คํธ๋ช = new List<ํ์ >();
List<string> items = new List<string>();
items.Add("์๋ช
๋ฌผ์ฝ30");
items.Add("๋ง๋๋ฌผ์ฝ30");
Debug.Log("๊ฐ์ง๊ณ ์๋ ์์ดํ
");
Debug.Log(items[0]);
Debug.Log(items[1]);
// โ
๋ฆฌ์คํธ๋ ๋ฐฐ์ด๊ณผ ๋ค๋ฅด๊ฒ ์ญ์ ๋ฅผ ํ ์ ์์โ
items.RemoveAt(0);
Debug.Log("๊ฐ์ง๊ณ ์๋ ์์ดํ
");
Debug.Log(items[0]);
Debug.Log(items[1]);
๊ฐ๋ณํ์ด๋ฏ๋ก ์ญ์ ํ ๊ธฐ์กด์ ์๋ ๋ง๋๋ฌผ์ฝ์ด items[0] ์๋ฆฌ๋ก ์ด๋ํ๊ณ ,
items[1]์ ์กด์ฌํ์ง ์์ผ๋ฏ๋ก ์ค๋ฅ๊ฐ ์๊น โ ํฌ๊ธฐ๋ฅผ ๋ฒ์ด๋ ํ์์ ์ค๋ฅ๋ฅผ ๋ฐ์(์ธ๋ฑ์ค ์ค๋ฅ)
์ฝ์
: ๋ฆฌ์คํธ๋ช
.Add(""); ์ญ์ : ๋ฆฌ์คํธ๋ช .RemoveAt(0); ๋ฆฌ์คํธ์ ๊ธธ์ด: ๋ฆฌ์คํธ๋ช .Count; |
3. ์ฐ์ฐ์ Operator
์ฐ์ฐ์: ์์, ๋ณ์๊ฐ์ ์ฐ์ฐํด์ฃผ๋ ๊ธฐํธ (์ฌ์น์ฐ์ฐ + - / * %, ๋น๊ต์ฐ์ฐ < > <= >= ๋ฑ)
%(๋ชซ์ด ์๋ ๋๋จธ์ง๋ฅผ ์ถ๋ ฅ)
int exp = 1500;
exp = 1500 + 320;
level = exp / 300;
strength = level * 3.1f;
int nextExp = 300 - (exp % 300);
Debug.Log("๋ค์ ๋ ๋ฒจ๊น์ง ๋จ์ ๊ฒฝํ์น๋?");
Debug.Log(nextExp);
string title = "์ ์ค์";
Debug.Log("์ฉ์ฌ์ ์ด๋ฆ์?");
Debug.Log(title + " " + playerName);
int fullLevel = 99;
isFullLevel = level == fullLevel;
Debug.Log("์ฉ์ฌ๋ ๋ง๋ ์
๋๊น? " + isFullLevel);
bool isEndTutorial = level > 10;
Debug.Log("ํํ ๋ฆฌ์ผ์ด ๋๋ ์ฉ์ฌ์
๋๊น?" + isEndTutorial);
int health = 30;
int mana = 25;
bool isBadCondition = health <=50 && mana <=20 ; // and ์ฐ์ฐ์ - ๋ ๊ฐ์ด ๋ชจ๋ true์ผ ๋๋ง true ์ถ๋ ฅ
// or ์ฐ์ฐ์ - ||์ ๊ฒฝ์ฐ ๋ ๊ฐ ์ค ํ๋๊ฐ true์ผ ๋ true ์ถ๋ ฅ
// ? A:B ์ฐ์ฐ์ - true์ผ ๋ A, false์ผ ๋ B ์ถ๋ ฅ
Debug.Log("์ฉ์ฌ์ ์ํ๊ฐ ๋์ฉ๋๊น?" + isBadCondition);
string condition = isBadCondition ? "๋์จ" : "์ข์";
Debug.Log("์ฉ์ฌ์ ์ํ๊ฐ ๋์ฉ๋๊น?" + condition);
4. ํค์๋ Keyword
ํค์๋ : ํ๋ก๊ทธ๋๋ฐ ์ธ์ด๋ฅผ ๊ตฌ์ฑํ๋ ํน๋ณํ ๋จ์ด
๋ณ์ ์ด๋ฆ์ผ๋ก๋ ์ฌ์ฉํ ์ ์๊ณ , ๊ฐ์ผ๋ก๋ ์ฌ์ฉํ ์ ์์
์: int, float, string, bool, new, List ์ ๊ฐ์ ์์ฝ์ด๋ค
5. ์กฐ๊ฑด๋ฌธ Condotional (if-else, switch-case)
1. IF~ELSE ๋ฌธ
: bool์ ์กฐ๊ฑด์ผ๋ก ์ฌ์ฉ
if (condition == "๋์จ") // () ์์ ์๋ ์กฐ๊ฑด์ด true์ผ ๋ {} ์ ์คํ
{
Debug.Log("ํ๋ ์ด์ด ์ํ๊ฐ ๋์๋ ์์ดํ
์ ์ฌ์ฉํ์ธ์.");
}
else
{
Debug.Log("ํ๋ ์ด์ด ์ํ๊ฐ ์ข์ต๋๋ค.");
}
if (isBadCondition && items[0] == "์๋ช
๋ฌผ์ฝ30")
{
items.RemoveAt(0);
health += 30;
Debug.Log("์๋ช
ํฌ์
30์ ์ฌ์ฉํ์์ต๋๋ค.");
}
if (isBadCondition && items[0] == "๋ง๋๋ฌผ์ฝ30")
{
items.RemoveAt(0);
mana += 30;
Debug.Log("๋ง๋ํฌ์
30์ ์ฌ์ฉํ์์ต๋๋ค.");
}
2. SWITCH~CASE๋ฌธ
: ๋ณ์์ ๊ฐ์ ์กฐ๊ฑด์ผ๋ก ์ฌ์ฉ
switch (monsters[0])
{
case "์ฌ๋ผ์":
case "์ฌ๋ง๋ฑ":
Debug.Log("์ํ ๋ชฌ์คํฐ๊ฐ ์ถํ!");
break;
case "์
๋ง":
Debug.Log("์คํ ๋ชฌ์คํฐ๊ฐ ์ถํ!");
break;
case "๊ณจ๋ ":
Debug.Log("๋ํ ๋ชฌ์คํฐ๊ฐ ์ถํ!");
break;
default: // ๋ชจ๋ case๊ฐ ์ํ์ง ์์ ๋ ํต๊ณผํ ํ ์คํ
Debug.Log("??? ๋ชฌ์คํฐ๊ฐ ์ถํ!");
break;
}
6. ๋ฐ๋ณต๋ฌธ Loop (while, for, foreach, break)
๋ฐ๋ณต๋ฌธ: ์กฐ๊ฑด์ ๋ง์กฑํ๋ฉด ๋ก์ง์ ๋ฐ๋ณตํ๋ ์ ์ด๋ฌธ
1. while๋ฌธ
: ์กฐ๊ฑด์ด ์ฐธ์ด๋ฉด ๊ณ์ ๋ฐ๋ณต
while (health > 0) { //while๋ฌธ์ ์กฐ๊ฑด์ด true์ผ ๋๊น์ง {} ๋ก์ง ๋ฐ๋ณต ์คํ
health--;
if (health > 0)
Debug.Log("๋
๋ฐ๋ฏธ์ง๋ฅผ ์
์์ต๋๋ค. " + health);
else
Debug.Log("์ฌ๋งํ์์ต๋๋ค.");
if (health == 10) {
Debug.Log("ํด๋
์ ๋ฅผ ์ฌ์ฉํฉ๋๋ค.");
break;
}
}
2. for๋ฌธ
: ๋ณ์๋ฅผ ์ฐ์ฐํ๋ฉด์ ๋ก์ง ๋ฐ๋ณต ์คํ
for (์ฐ์ฐ๋ ๋ณ์; ์กฐ๊ฑด; ์ฐ์ฐ) //for๋ฌธ์ ๋ณ์๋ฅผ ์ฐ์ฐํ๋ฉด์ ๋ก์ง ๋ฐ๋ณต ์คํ
{
๋ก์ง
}
for (int count = 0; count<10; count++) {
health++;
Debug.Log("๋ถ๋๋ก ์น๋ฃ ์ค..." + health);
}
// for๋ฌธ์ ๊ฐ์ ์ ๊ทธ๋ฃนํ ๋ณ์์์ ์กฐํฉ์ ์์
// ๊ทธ๋ฃนํ ๋ณ์ ๊ธธ์ด: .Length(๋ฐฐ์ด ๊ธธ์ด) .Count(๋ฆฌ์คํธ ๊ธธ์ด)
for (int index = 0; index < monsters.Length; index++)
{
Debug.Log("์ด ์ง์ญ์ ์๋ ๋ชฌ์คํฐ" + monsters[index]);
}
}
3. foreach๋ฌธ
: for์ ๊ทธ๋ฃนํ ๋ณ์ ํ์ ํนํ
foreach (string monster in monsters) // ๊ทธ๋ฃนํ๋ณ์ ์์ ์๋ ๋ณ์๋ฅผ ๊บผ๋ด์ ํ๋์ฉ ๊ณ์ ๋ฐ๋ณต
{
Debug.Log("์ด ์ง์ญ์ ์๋ ๋ชฌ์คํฐ : " + monster);
}
7. ํจ์ Function
ํจ์ : ๊ธฐ๋ฅ์ ํธ๋ฆฌํ๊ฒ ์ฌ์ฉํ๋๋ก ๊ตฌ์ฑ๋ ์์ญ
ex) ์ ๋ํฐ์ Start, Update ๋ฑ
8. ํด๋์ค Class
ํ๋์ ์ฌ๋ฌผ(์ค๋ธ์ ํธ)์ ๋์ํ๋ ๋ก์ง
ex) Unity์ MonoBehaviour
class๋ฅผ ๋ง๋ค ๋๋ ์คํฌ๋ฆฝํธ๋ฅผ ์๋ก ๋ง๋ค์ด์ค๋ค.
๋ฉค๋ฒ๋ณ์์ ๋ฉค๋ฒํจ์๋ฅผ ๋ง๋ค๋ฉด ๋ค๋ฅธ ์คํฌ๋ฆฝํธ์์ class ์ด๋ฆ์ ํ๋์ ๋ณ์๋ก ๋ง๋ค ์ ์๋ค.
โญ ์ ๋ํฐ ๊ฒ์์ค๋ธ์ ํธ์ ํ๋ฆ

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class Lifecycle : MonoBehaviour
{
// ์ด๊ธฐํ ์์ญ //
void Awake() // ๊ฒ์ ์ค๋ธ์ ํธ ์์ฑํ ๋ ์ต์ด ์คํ, ๋ฑ ํ ๋ฒ๋ง ์คํ
{
Debug.Log("ํ๋ ์ด์ด ๋ฐ์ดํฐ๊ฐ ์ค๋น๋์์ต๋๋ค.");
}
// ์ด๊ธฐํ ์์ญ๊ณผ ๋ฌผ๋ฆฌ ์์ญ ์ฌ์ด์ ์ค๋ธ์ ํธ ํ์ฑํ // Awake์ Start ์ฌ์ด
void OnEnable() // ๊ฒ์ ์ค๋ธ์ ํธ๊ฐ ํ์ฑํ ๋์์ ๋
{
Debug.Log("ํ๋ ์ด์ด๊ฐ ๋ก๊ทธ์ธํ์์ต๋๋ค.");
}
void Start() // ์
๋ฐ์ดํธ ์์ ์ง์ , ์ต์ด ์คํ
{
Debug.Log("์ฌ๋ฅ ์ฅ๋น๋ฅผ ์ฑ๊ฒผ์ต๋๋ค.");
}
// ๋ฌผ๋ฆฌ ์์ญ //
void FixedUpdate() // ๋ฌผ๋ฆฌ ์ฐ์ฐ์ ํ๊ธฐ ์ ์ ์คํํ๋ ์
๋ฐ์ดํธ.
ํ๊ฒฝ๊ณผ ์๊ด ์์ด ๊ณ ์ ๋ ์คํ์ฃผ๊ธฐ(์ฝ 1์ด 50ํ)๋ก ๊พธ์คํ ํธ์ถํ์ฌ CPU๋ฅผ ๋ง์ด ์ฌ์ฉ
๋ฐ๋ผ์ CPU๋ถํ๊ฐ ์ค๊ธฐ ์ฝ๊ธฐ ๋๋ฌธ์ ์ด ์์๋ ๋ฌผ๋ฆฌ๋ก์ง๋ง ๋ณดํต ๋ฃ์
{
Debug.Log("์ด๋ํ๋ค!");
}
// ๊ฒ์ ๋ก์ง ์์ญ //
void Update() // ๊ฒ์ ๋ก์ง์ ์
๋ฐ์ดํธ ๋ฌผ๋ฆฌ ์ฐ์ฐ ๋ถ๋ถ์ ์ ์ธํ ์ฃผ๊ธฐ์ ์ผ๋ก ๋ณํ๋ ๋ก์ง์ ๋ฃ์ ๋ ์ฐ๋ ํจ์.
// ํ๊ฒฝ(์ฑ๋ฅ)์ ๋ฐ๋ผ ์คํ ์ฃผ๊ธฐ๊ฐ ๋จ์ด ์ง ์ ์์
{
Debug.Log("๋ชฌ์คํฐ ์ฌ๋ฅ!");
}
void LateUpdate() // ๋ชจ๋ ์
๋ฐ์ดํธ๊ฐ ๋๋ ๋ค ๋ง์ง๋ง์ผ๋ก ํธ์ถ๋๋ ํจ์
// ์บ๋ฆญํฐ๋ฅผ ๋ฐ๋ผ๊ฐ๋ ์นด๋ฉ๋ผ๋ผ๋ ๊ฐ, ๋ก์ง์ ํ์ฒ๋ฆฌ๋ฅผ ๋ด๋ ๊ณณ
{
Debug.Log("๊ฒฝํ์น ํ๋!");
}
// ๊ฒ์ ๋ก์ง ์์ญ๊ณผ ํด์ฒด ์์ญ ์ฌ์ด์ ์ค๋ธ์ ํธ ๋นํ์ฑํ //
void OnDisable() // ์ค๋ธ์ ํธ๊ฐ ๋นํ์ฑํ ๋์์ ๋ ์๋
// ์
๋ฐ์ดํธ๊ฐ ๋ชจ๋ ์๋ฃ๋๊ณ ๋ ํ ์์น. cylinder์ ์๋ Lifecycle ์คํฌ๋ฆฝํธ๋ฅผ ๋๋ฉด ์ถ๋ ฅ๋จ.
{
Debug.Log("ํ๋ ์ด์ด๊ฐ ๋ก๊ทธ์์ํ์์ต๋๋ค.");
}
// ํด์ฒด ์์ญ //
void OnDestroy() // ์ด ์ค๋ธ์ ํธ๊ฐ ์ญ์ ๋๊ธฐ ์ง์ ๋ฌด์ธ๊ฐ ๋จ๊ธฐ๊ณ ์ญ์ ๋๋ค๋ ์๋ฏธ. Awake์ ๋ฐ๋
// cylinder ์ค๋ธ์ ํธ์ ์ด ์คํฌ๋ฆฝํธ๋ฅผ ๋ฃ์๋ค๊ฐ cylinder๋ฅผ ๋นํ์ฑํํ๋ฉด(์ญ์ ํ๋ฉด) ์ด ์์ญ์ด ์ถ๋ ฅ๋จ
{
Debug.Log("ํ๋ ์ด์ด ๋ฐ์ดํฐ๋ฅผ ํด์ฒดํ์์ต๋๋ค.");
}
}
โญ ํค๋ณด๋ ๋ง์ฐ์ค๋ก ์ด๋์์ผ๋ณด์
Input ํด๋์ค: ๊ฒ์ ๋ด ์
๋ ฅ์ ๊ด์ฅํ๋ ํด๋์ค
์ ๋ํฐ ๋ด์ฅ ํด๋์ค๋ก Bool ๊ฐ์ ๋ฐํํจ
ํค ์ ๋ ฅ |
anyKeyDown : ์๋ฌด ํค๋ฅผ ๋๋ฅผ ๋ (ํ ๋ฒ) anyKey : ์๋ฌด ํค๋ฅผ ๊พน ๋๋ฅด๊ณ ์์ ๋ anyKeyUp : ์๋ฌด ํค๋ฅผ ๋์ ๋ (ํ ๋ฒ) GetKeyDown() : ๋งค๊ฐ๋ณ์๋ก KeyCode๋ฅผ ๋ฐ๋ ํจ์ ex) Input.GetKeyDown(KeyCode.Return) -> ์ํฐํค๋ฅผ ๋๋ ์ ๋ ex) Input.GetKeyDown(KeyCode.Escape) -> ESC๋ฅผ ๋๋ ์ ๋ |
๋ฒํผ ์ ๋ ฅ |
GetMouseButtonDown() : ๋งค๊ฐ๋ณ์๋ก 0,1,2๋ฅผ ๋ฐ๊ณ 0์ ์ขํด๋ฆญ, 1์ ์ฐํด๋ฆญ, 2๋ ํ ์ ๋ํ๋ธ๋ค. ex) GetMouseButtonDown(0) -> ๋ง์ฐ์ค ์ขํด๋ฆญ ๋๋ ์ ๋ ex) GetMouseButton(0) -> ์ขํด๋ฆญ์ ๋๋ฅด๊ณ ์์ ๋ ex) GetMouseButtonUp(0) -> ์ขํด๋ฆญ์ ๋์ ๋ GetButton() : ๋ฌธ์์ด์ ๋งค๊ฐ๋ณ์๋ก ๋ฐ๊ณ , Edit -> ProjectSettings -> Input -> InputManager์ ๋ฑ๋ก๋ ๋ฒํผ์ ์ฌ์ฉ๊ฐ๋ฅ ์๋ฅผ ๋ค์ด ๊ธฐ๋ณธ์ผ๋ก "Jump"๋ ์คํ์ด์ค๋ฐ๋ก ์ค์ ์ด ๋์ด ์๋๋ฐ, Input.GetButtonDown("Jump")๋ฅผ ์ ๋ ฅํ๋ฉด ์คํ์ด์ค๋ฐ๋ฅผ ๋๋ ์ ๋ ์๋ํ๋ค. "Horizontal"๊ณผ "Vertical" : ํก์ด๋๊ณผ ์ข ์ด๋์ผ๋ก Input.GetAxis("Horizontal") ์ด๋ฐ ์์ผ๋ก float๊ฐ ๋ฐํ์ด ๊ฐ๋ฅํ๋ค. GetAxis๋ ์ ์ ๋์ด๋๋ ๊ฐ์ค์น๊ฐ ์๊ณ 1์ ํฅํด ์๋ ดํ๋ค. ์ผ์ชฝ์ - ์ค๋ฅธ์ชฝ์ + Input.GetAxisRaw("Horizontal") -> ๊ฐ์ค์น๊ฐ ์์ด ๋ฌด์กฐ๊ฑด ๋๋ฅด๋ฉด 1์ ๋ฐํํ๋ค. |
Transform : ์ค๋ธ์ ํธ ํํ์ ๋ํ ๊ธฐ๋ณธ ์ปดํฌ๋ํธ
์ค๋ธ์ ํธ์ Transform์ 1:1 ๊ด๊ณ์ด๋ฏ๋ก ์๋ฌด๋ฆฌ ๋น์ด์๋๋ผ๋ transform์ ์กด์ฌํ๋ค.
์ค๋ธ์ ํธ๋ transform ๋ณ์๋ฅผ ํญ์ ๊ฐ์ง๊ณ ์๋ค.
Translate() |
๋ฒกํฐ๊ฐ์ ํ์ฌ์์น(ํ์ฌ transform)์ ๋ํ๋ ํจ์ (์ด๋ํ๋ค) 2์ฐจ์์ Vector2๋ฅผ ์ฌ์ฉํ๊ณ 3์ฐจ์์ Vector3๋ฅผ ์ฌ์ฉํ๋ค. void Update() { Vector3 vec = new Vector3(5,0,0); //์ฐจ๋ก๋ก x์ถ y์ถ z์ถ transform.Translate(vec); } // x์ position๊ฐ์ด 5 ์ฆ๊ฐํ๋ค. ๋ฐ๋๋ก (0,0,0) ์ผ๋ก ์ ๋ ฅํด๋์ผ๋ฉด ์ด๋ํ์ง ์๋๋ค. Vector3 vec = new Vector3(Input.GetAxis("Horizontal"),0,0) transform.Translate(vec); // ์ ๊ฐ์ ๋ฐฉ์์ผ๋ก ๋ฒํผ์ ๋ ฅ์ ํตํด Translate ์ด๋์ด ๊ฐ๋ฅํ๋ค. |
โญ ๋ชฉํ ์ง์ ์ผ๋ก ์ด๋์ํค๊ธฐ
์ ๋ํฐ Vector3 ํด๋์ค์์ ๊ธฐ๋ณธ์ ์ผ๋ก ์ ๊ณตํ๋ ์ด๋ํจ์ 4๊ฐ์ง
MoveTowards (์ผ์ ํ ์๋๋ก ์ด๋) |
Vector3.MoveTowards(ํ์ฌ์์น, ๋ชฉํ์์น, ์๋) Update๋ฌธ ์์ ์ฌ์ฉ , ๋ง์ง๋ง ๋งค๊ฐ๋ณ์์ "๋น๋ก"ํ์ฌ ์๋ ์ฆ๊ฐ Vector3 target = new Vector3(8, 1.5f, 0); transform.position = Vector3.MoveTowards(transform.position, target, 1f) : transform.position์์ target์ผ๋ก 1f์ ์๋๋ก ์ผ์ ํ๊ฒ ์ด๋ |
SmoothDamp (๋ถ๋๋ฌ์ด ๊ฐ์์ด๋) |
Vector3.SmoothDamp(ํ์ฌ์์น, ๋ชฉํ์์น, ์ฐธ์กฐ์๋(ํ์ฌ์๋), ํ๊ฒ์ ๋๋ฌํ๊ธฐ ์ํ ์๊ฐ = ๋ฎ์ ์๋ก ๋น ๋ฆ) -> ๊ณต์๋ฌธ์์ ๋งค๊ฐ๋ณ์ -> ๋ง์ง๋ง ๋งค๊ฐ๋ณ์์ "๋ฐ๋น๋ก"ํ์ฌ ์๋ ์ฆ๊ฐ. ํ์ฌ์๋์ ref๋ฅผ ์จ์ ๋ฃ์ด์ผ ํ๋ค (์ฐธ์กฐ์ ๊ทผ -> ์ค์๊ฐ์ผ๋ก ๋ฐ๋๋ ๊ฐ ์ ์ฉ ๊ฐ๋ฅ) Vector3 target = new Vector3(8, 1.5f, 0); Vector3 velo = Vector3.zero; transform.position = Vector3.SmoothDamp(transform.position, target, ref velo, 0.1f) ๋ณดํต SmoothDamp๋ฅผ ์ธ ๋ ์ฐธ์กฐ์๋์๋ Vector3.zero๋ฅผ ๋ฃ๋๋ค. Vector3.up*50์ผ๋ก ์๋ก ๋ณด๋ด๊ฑฐ๋ํ๋ ์ ๋ ฅ๋ ๊ฐ๋ฅํ์ง๋ง, ๊ทธ๋ผ target์ผ๋ก ๊ฐ๋ ์๋ฏธ๊ฐ ์์ผ๋ฏ๋ก ๋ณดํต .zero ์ฌ์ฉ |
Lerp (์ ํ ๋ณด๊ฐ, SmoothDamp๋ณด๋ค ๊ฐ์์๊ฐ์ด ๊ธธ๋ค) |
Vector3.Lerp(ํ์ฌ์์น, ๋ชฉํ์์น, ์๋) ๋ง์ง๋ง ๋งค๊ฐ๋ณ์์ "๋น๋ก"ํ์ฌ ์๋ ์ฆ๊ฐ (์ต๋๊ฐ 1) Vector3 target = new Vector3(8, 1.5f, 0); transform.position = Vector3.Lerp(transform.position, target, 0.005f) |
Slerp (๊ตฌ๋ฉด ์ ํ ๋ณด๊ฐ, ํธ๋ฅผ ๊ทธ๋ฆฌ๋ฉด์ ์ด๋) |
Vector3.Slerp(ํ์ฌ์์น, ๋ชฉํ์์น, ์๋) Lerp๊ฐ ์ผ์ง์ ์ด๋ผ๋ฉด Slerp๋ ํธ๋ฅผ๊ทธ๋ฆฌ๋ฉด์ ์ด๋ํ๋ ํํ, ๋งค๊ฐ๋ณ์๋ Lerp์ ๋์ผํ๋ค. Vector3 target = new Vector3(8, 1.5f, 0); transform.position = Vector3.Slerp(transform.position, target, 0.005f) |

โญ ์ด๋๊ฑฐ๋ฆฌ๋ฅผ ๊ณตํํ๊ฒ, ๋ธํํ์
Time.deltaTime |
์ด์ ํ๋ ์์ ์๋ฃ๊น์ง ๊ฑธ๋ฆฐ ์๊ฐ. ์ปดํจํฐ์ ์ฑ๋ฅ์ด ๋ฌ๋ผ๋ ์จ๋ผ์ธ์์๋ ๋ฐ๋์ ๊ฐ์์ผ ๋๋ค. (์ปดํจํฐ ์ข์ ์ฌ๋๋ง ์ ๋ฐ์ดํธ 1์ด๋น 60๋ฒ ํ๋ฉด ๊ณค๋ํจ) deltaTime๊ฐ์ ํ๋ ์์ด ์ ์ผ๋ฉด ํฌ๊ณ , ํ๋ ์์ด ๋ง์ผ๋ฉด ์๋ค. -> ๊ทธ๋์ ๋ธํํ์์ ๊ณฑํ๋ฉด ๋์ค๋ ๊ฐ์ด ๋์ผํด์ง๋ค Vector3 vec = new Vector3(Input.GetAxisRaw("Horizontal") * Time.deltaTime, Input.GetAxisRaw("Vertical") * Time.deltaTime, 0); transform.Translate(vec); <Time.deltaTime ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ> Translate : ๋ฒกํฐ์ ๊ณฑํ๊ธฐ transform.Translate(Vec * Time.deltaTime); Vector ํจ์ : ์๊ฐ ๋งค๊ฐ๋ณ์์ ๊ณฑํ๊ธฐ Vector3.Lerp(Vec1, Vec2, T * Time.deltaTime); |
โญ ์ค์ ์ ๊ฐ์ ๋ฌผ์ฒด๋ฅผ ๋ง๋ค๊ธฐ
์ ๋ํฐ๋ ์ปดํฌ๋ํธ ๊ธฐ๋ฐ ์์ง
์ค๋ธ์ ํธ๋ฅผ ํด๋ฆญํด์ ๋์ค๋ inspector ์ฐฝ์์ Add Component๋ก ์ฌ๋ฌ ์ปดํฌ๋ํธ๋ฅผ ๋ฃ์ ์ ์๋ค.
1. ๐ฎ๋ฌผ๋ฆฌํจ๊ณผ์ ์ฉ ์ปดํฌ๋ํธ
์ค๋ ฅ ์ ์ฉํ๊ธฐ: Rigidbody |
๋ฌผ๋ฆฌ ํจ๊ณผ๋ฅผ ๋ฐ๊ธฐ ์ํ, ์ค๋ ฅ์ ์ํฅ์ ๋ฐ๋ ์ปดํฌ๋ํธ๋ก ์๋์ ๊ฐ์ ์์ฑ์ด ์๋ค. Mass (๋ฌด๊ฒ) -> ๋ฌด๊ฒ ๋๋ฆฐ๋ค๊ณ ํด์ ๋ ๋นจ๋ฆฌ ๋จ์ด์ง์ง ์๋๋ค! (์๋ ฅ์ ๋๊ฐ์) -> Mass ์์น๊ฐ ๋์์๋ก ์ถฉ๋์ด ๋ฌด๊ฑฐ์์ง๋ค. -> Mass 1000์ธ ์ค๋ธ์ ํธ์ Mass 1์ธ ์ค๋ธ์ ํธ๊ฐ ์ถฉ๋ํ๋ฉด Mass1 ์ค๋ธ์ ํธ๊ฐ ๋ ๋ผ๊ฐ. Use Gravity -> ์ค๋ ฅ์ ์ฌ์ฉํ ์ง ์ ํ ์ง ์ฒดํฌ Is Kinematic -> ์ฒดํฌํ๋ฉด ์ธ๋ถ ๋ฌผ๋ฆฌํจ๊ณผ๋ฅผ ๋ฌด์ํ๋ค. -> Mass1์ธ ๊ณต์ ์ฒดํฌํ๊ณ Mass1000์ธ ๊ณต์ ์ฒดํฌํด์ ํ๊ณ ๋ถ๋ชํ๋ฉด Mass1000๊ณต๋ง ๋ฌผ๋ฆฌํจ๊ณผ๋ก ํ๊ฒจ๋๊ฐ๋ค. -> ์์ง์ด๋ ํจ์ ์ ๋ง๋ค ๋ ์ ์ฉํ๋ค. |
์ถฉ๋์์ญ: Collider |
ex) Sphere๋ฅผ ๋ง๋ค๋ฉด Sphere Collider๊ฐ ์๋์ผ๋ก ์์ฑ๋๊ณ ๊ณต ์ฃผ์๊ฐ ์ฐ๋์์ผ๋ก ๋์ด์๋ค. -> ์ด ์ฝ๋ผ์ด๋๊ฐ ์์ผ๋ฉด ๋ค๋ฅธ ์ค๋ธ์ ํธ๋ฅผ ๋ฌด์ํ๊ณ ํต๊ณผ๋๋ค. -> ์ฝ๋ผ์ด๋๊ฐ ์์ผ๋ฉด ์ค๋ ฅ์ ํจ๊ณผ๋ ๋ฐ์ ์ ์์ง๋ง ๋ค๋ฅธ ์ค๋ธ์ ํธ๋ ์ถฉ๋์ ๋ถ๊ฐํ๋ค. -> Radius๋ฅผ ์กฐ์ ํด์ ์ถฉ๋์์ญ ์ค์ ์ด ๊ฐ๋ฅํ๊ณ Radius๋ฅผ ํฌ๊ฒํด ์ฐ๋ฆฌ ๋์ ๊ณต์ด ๋ ์๋ ๊ฑฐ์ฒ๋ผ ํํ์ด ๊ฐ๋ฅํ๋ค. -> ์ถฉ๋๊ธฐ์ค์ ๋ณด์ด๋ ๊ฒ์ด ์๋ ์ฝ๋ผ์ด๋์ ๋ฐ๋ฅด๊ธฐ ๋๋ฌธ |
2. ๐ฎ์ค๋ธ์ ํธ์ ์ฌ์ง์ ๊ฒฐ์ ํ๋ ์ปดํฌ๋ํธ
Material |
์ค๋ธ์ ํธ์ ํ๋ฉด ์ฌ์ง์ ๊ฒฐ์ ํ๋ ์ปดํฌ๋ํธ (๋์ ๋ณด์ด๋ ์ฌ์ง) ๊ธฐ๋ณธ์ ์ผ๋ก ์ค์ ๋์ด ์๋ Default - Material์ ์์ ์ด ๋ถ๊ฐ๋ฅํ๋ค. Assets์์ ์ฐํด๋ฆญ -> Create -> Material์ ๋๋ฅด๋ฉด ์์ ๊ฐ๋ฅํ Material ์์ฑ ๊ฐ๋ฅ ์์ ์ฐฝ์ Material์ ์์ ํ๊ณ ์ค๋ธ์ ํธ์ ๋์ด๋ฃ์ผ๋ฉด Material ๋ณ๊ฒฝ์ด ๊ฐ๋ฅ Albedo : ์์๋ณ๊ฒฝ -> Albedo ๊ธ์จ ์ผ์ชฝ์ ๋ค๋ชจ์ Asset ์ฌ์ง์ ๋๋๊ทธํ๋ฉด Texture๋ฅผ ๋ฃ์ ์ ์์. (Texture : ์ฌ์ง์ ๋ค์ด๊ฐ๋ ์ด๋ฏธ์ง) Metalic : ๊ธ์์ฌ์ง ์์น -> ๋์์๋ก ๊ธ์๊ณผ ๋น์ทํด์ง๋ค. Smoothness : ๋น ๋ฐ์ฌ ์์น (0๋ฉด ๋น๋ฐ์ฌ๊ฐ ์์ ์์) Tiling : ํ ์ค์ณ ๋ฐ๋ณต ํ์ผ ๊ฐ์ Emission : ํ ์ค์ณ ๋ฐ๊ด(๋ฐ๊ธฐ) ์กฐ์ -> ๋น์ด ํ ์ค์ณ์ ์ ์ฉ๋๋ ๊ฒ์ด์ง ๋ฌผ๋ฆฌ์ ์ผ๋ก ๋์ค๋๊ฑด ์๋๋ค. (๋น์ Light๋ผ๊ณ ๋ฐ๋ก ์์) |
Physic Material |
ํ์ฑ๊ณผ ๋ง์ฐฐ์ ๋ค๋ฃจ๋ ๋ฌผ๋ฆฌ ์ฌ์ง์ ๊ฒฐ์ ํ๋ ์ปดํฌ๋ํธ (๋ฌผ๋ฆฌ์ ์ธ ์ฌ์ง) Assets์์ ์ฐํด๋ฆญ -> Create -> Physic Material ์ค๋ธ์ ํธ์ ๋์ด๋น๊ฒจ์ ์ง์ด๋ฃ์ผ๋ฉด ๊ธฐ์กด์ ์๋ Collider ์ปดํฌ๋ํธ์ Material์ ๋ค์ด๊ฐ๋ค. Bounciness : ํ์ฑ๋ ฅ, ๋์์๋ก ๋ง์ด ํ์ด์ค๋ฅธ๋ค. 0 ~ 1 Bounce Combine : ๋ค์ ํ์ฑ์ ๊ณ์ฐํ๋ ๋ฐฉ์ Average์ ๊ฒฝ์ฐ ๊ณ์ ์ค๊ฐ๊ฐ ๋ฐ์ด์ค - ์ค๊ฐ๊ฐ ๋ฐ์ด์ค ๋ฐ๋ณต. / Maximum์ ์ค์ง ์์ผ๋ ๋ฌด์ ํ Bounce Friction : ๋ง์ฐฐ๋ ฅ, ๋ฎ์์๋ก ๋ง์ด ๋ฏธ๋๋ฌ์ง๋ค - Dynamic Friction: ์์ง์ผ ๋ ์ ์ฉ๋๋ ๋ง์ฐฐ๋ ฅ - Static Friction: ๊ฐ๋งํ ์์ ๋ ์ ์ฉ๋๋ ๋ง์ฐฐ๋ ฅ ๋ณดํต ํ์ค์ธ๊ณ์ ์ ์ง ๋ง์ฐฐ๋ ฅ์ ์์ง์ด๋ ๋ง์ฐฐ๋ ฅ๋ณด๋ค ํผ ๋ชจ๋ ๋ง์ฐฐ๋ ฅ์ 0์ ์ฃผ๊ณ Friction Combine(๋ค์ ๋ง์ฐฐ๋ ฅ์ ๊ณ์ฐํ๋ ๋ฐฉ์)์ Minimum์ผ๋ก ์ฃผ๋ฉด ๋นํ๊ฐ์ ๋๋์ ์ค๋ค. ๋งํ์ ์ธ ๋๋์ ์ฃผ๊ธฐ ์ํด์ Bounciness ํฉ์ฐ์ ์ต๋๋ก, Friction ํฉ์ฐ์ ์ต์๋ก ํ๋๊ฒ ์ข๋ค. |
๋ฌผ์ฒด ํ์ 4๋ ์ปดํฌ๋ํธ : Mesh , Material , Collider , RigidBody
โญ ํ์ ์ด์ฉํ์ฌ ๋ฌผ์ฒด ์์ง์ฌ๋ณด๊ธฐ
์ด๋ฒ ๊ฐ์ข๋ RigidBody ์ปดํฌ๋ํธ์ ์ง์ค
C# ์คํฌ๋ฆฝํธ๋ฅผ ๋ง๋ค์ด์ My ball์ ๋ฃ์ด์ฃผ๊ธฐ
my ball์ ๋ด๊ฒจ์๋ Rigidbody์ ์ปดํฌ๋ํธ ์์๋ค์ ๋ณ์๋ก ์คํฌ๋ฆฝํธ์ ๋ด์์ผ ํจ
์ฝ๋ ํ๋ฆ์ ํญ์ ์ ์ธ(ํ ๋น) -> ์ด๊ธฐํ -> ํธ์ถ(์ฌ์ฉ)
์คํฌ๋ฆฝํธ์ ์ปดํฌ๋ํธ ๊ฐ์ ธ์ค๊ธฐ |
public class NewBehaviourScript : MonoBehaviour { Rigidbody rigid; // ๋ฆฌ์ง๋๋ฐ๋ ์ปดํฌ๋ํธ ์ ์ธ (Start ๋ฐ์์) void Start() { rigid = GetComponent<Rigidbody>(); // ์ด๊ธฐํ (2D๋ 2D, 3D๋ 3D๋ก ๋ง์ถฐ์ผํจ.) } ์ฐธ๊ณ : GetComponent<A>(); -> ์์ ์ Aํ์ ์ปดํฌ๋ํธ๋ฅผ ๊ฐ์ ธ์จ๋ค. |
๐ฎ๋ฆฌ์ง๋๋ฐ๋๋ฅผ ์ด์ฉํด ์ด๋์ํค๊ธฐ
์๋๋ฅผ ์ด์ฉํด์ ์์ง์ด๊ธฐ rigid.velocity = Vector3.right; |
Rigidbody rigid; void Start() { rigid = GetComponent(); rigid.velocity = Vector3.right; } |
์ค๋ฅธ์ชฝ๋ฐฉํฅ์ผ๋ก ์๋ ฅ์ ๊ฐํจ. velocity: ํ์ฌ ์ด๋์๋(์๋ ฅ) -> ๋ฒกํฐ ๊ณ์ด ์์) rigid.velocity = new Vector3(2, 4, 3); ๋ฑ Update์ ๋ฃ์ผ๋ฉด ๊ณ์ํด์ ์๋๋ฅผ ๋ฐ๋๋ค. rigidbody๋ ๋ฌผ๋ฆฌํ์์ด์ง๋ง FixedUpdate๊ฐ ์๋๋ผ Input ํค ์ ๋ ฅ์ ๋ฐ๋ผ ์ ํํ๋ ๊ฑฐ๋ฉด Update์ ๋ฃ์ด์ผ ์ ์๋ ๋จ. |
ํ์ผ๋ก ๋ฐ๊ธฐ rigid.AddForce(Vector3.up*5, ForceMode.~); |
Rigidbody rigid; void Start() { rigid = GetComponent<Rigidbody>(); rigid.AddForce(Vector3.up * 50, ForceMode.Impulse); } |
AddForce(Vec) : Vec์ ๋ฐฉํฅ๊ณผ ํฌ๊ธฐ๋ก ํ์ ๋ํจ ForceMode : ํ์ ์ฃผ๋ ๋ฐฉ์ (๊ฐ์, ๋ฌด๊ฒ ๋ฐ์ ๋ฑ / Acceleration, Force, Impulse, VelocityChange) - ๊ฐ์ฅ ๋ง์ด ์ฌ์ฉํ๋ ๊ฒ์ Impulse (์บ๋ฆญํฐ์ ์ ํ๋ฅผ ๊ตฌํํ ๋ ์ฃผ๋ก ์ฌ์ฉ) - Rigidbody ์ปดํฌ๋ํธ ์ Mass ๋ฌด๊ฒ๊ฐ์ด ํด์๋ก ์์ง์ด๋๋ฐ ๋ ๋ง์ ํ์ด ํ์ํ๋ค. (Impulse ์ฌ์ฉ ์) - AddForce์ ํ ๋ฐฉํฅ์ผ๋ก ๊ณ์ ์๋๊ฐ ์ฆ๊ฐํจ. |
AddForce ForceMode ์ข
๋ฅ 1. ์ฐ์์ ์ธ ํ (๊ฐ์์ ์ถ๊ฐ, ์ด๋ฏธ ๊ตด๋ฌ๊ฐ๊ณ ์๋ ๊ฒ์ ์ฌ์ฉํ๊ธฐ ์ ํฉ) ๋ฌด๊ฒ์ ์ฉ -> ForceMode.Force ๋ฌด๊ฒ๋ฌด์ -> ForceMode.Acceleration 2.์๊ฐ์ ์ธ ํ (๋ง์น ๋ค์์ ๋๊ฐ ๋ฐ๋ฏ์ด ์๊ฐ์ ์ผ๋ก ์๋๊ฐ ๋ถ์ด์ฃผ๋ ๋ฐฉ์, ์ ์ง ์ํ์์ ์ ํฉ) ๋ฌด๊ฒ์ ์ฉ -> ForceMode.Impulse ๋ฌด๊ฒ๋ฌด์ -> ForceMode.VelocityChange |
AddForce: ๋ฐฉํฅํค์ ์ ํํค๋ฅผ ์ด์ฉํ ์์ฐ์ค๋ฌ์ด ์ด๋ ์์ |
Rigidbody rigid; void Start() { rigid = GetComponent<Rigidbody>(); } void Update() { if (Input.GetButtonDown("Jump")) { rigid.AddForce(Vector3.up * 10, ForceMode.Impulse); } Vector3 vec = new Vector3(Input.GetAxisRaw("Horizontal"), 0, Input.GetAxisRaw("Vertical")); rigid.AddForce (vec, ForceMode.Impulse); } = Transform์ ์ด์ฉํ ์ด๋๊ณผ ์ฐจ์ด๊ฐ ๋ง์ด ๋จ |
AddTorque: ํ์ ๋ ฅ ์ฃผ๊ธฐ |
rigid.AddTorque(Vec) : Vec ๋ฐฉํฅ์ ์ถ์ผ๋ก ํ์ ๋ ฅ์ด ์๊น (๋ฐํด๊ฐ ํ์ ํ๋ฏ ํ์ ) ex) rigid.AddTorque(Vector3.back); ์ฒ๋ผ ๋ฒกํฐ๋ฅผ ๋ณ์๋ก ๋ฐ์์ ์ฌ์ฉํ๋ฉด ๋๋ค. ๋ฒกํฐ๋ฅผ ์ถ์ผ๋ก ์ผ๊ธฐ ๋๋ฌธ์ ์ด๋ ๋ฐฉํฅ์ ์ฃผ์ํด์ผํจ. |
โญ ๋ฌผ๋ฆฌ ์ถฉ๋ ์ด๋ฒคํธ
๋ถ๋ชํ ๋์์ธ otherball์ C# ์คํฌ๋ฆฝํธ ์์ฑํ๊ณ ๋ฃ์ด์ฃผ๊ธฐ
๋ฌผ๋ฆฌ์ถฉ๋ ์ด๋ฒคํธ๋ฅผ ์ด์ฉํด์ ์ถฉ๋ํ ๋ณผ์ ์์์ ๋ณ๊ฒฝํ๊ธฐ. |
์ค๋ธ์ ํธ์ ์ฌ์ง์ ๊ทผ์ Mesh Renderer ์ปดํฌ๋ํธ๋ฅผ ํตํด์ ํ ์ ์๋ค. Mesh Renderer - Materials - Albedo๋ฅผ ์ฐ๋ฆฌ๋ ๋ณ๊ฒฝํด ์ฃผ๊ณ ์ถ์ ๊ฒ OnCollision ํจ์๋ 3๊ฐ์ง๊ฐ ์๋ค. 1.void OnCollisionEnter(Collision collision){} (๋ฌผ๋ฆฌ์ ์ถฉ๋์ด ์์ํ ๋ ํธ์ถ๋๋ ํจ์) 2.void OnCollisionStay(Collision collision){} (๋ฌผ๋ฆฌ์ ์ถฉ๋์ ํ๊ณ ์์ผ๋ฉด ํธ์ถ๋๋ ํจ์) 3.void OnCollisionExit(Collision collision){} (๋ฌผ๋ฆฌ์ ์ถฉ๋์ด ๋๋ฌ์ ๋ ํธ์ถ๋๋ ํจ์) OnCollisionํจ์๋ ์ค์ ๋ฌผ๋ฆฌ์ ์ถฉ๋๋ก ๋ฐ์ํ๋ ์ด๋ฒคํธ |
public class Otherball : MonoBehaviour { MeshRenderer mesh; Material mat; void Start() { mesh = GetComponent<MeshRenderer>(); //MeshRenderer ์ปดํฌ๋ํธ๋ฅผ ๊ฐ์ ธ์ด mat = mesh.material; } // ์ด๋ฒคํธ์ฑ ํจ์์ ๋ณดํต ์์ On์ด ๋ค์ด๊ฐ // CollisionEnter : ๋ฌผ๋ฆฌ์ ์ถฉ๋์ด ์์๋ ๋ ํธ์ถ๋๋ ํจ์ // Collision : ์ถฉ๋ ์ ๋ณด ํด๋์ค private void OnCollisionEnter(Collision collision) // ์ถฉ๋ ํ์ ๋ { if(collision.gameObject.name == "My Ball") // My ball ์ค๋ธ์ ํธ์ ์ถฉ๋ํ์ ๋๋ง ๋ณ๊ฒฝ ์ํจ mat.color = new Color(0, 0, 0); // Color : ๊ธฐ๋ณธ ์์ ํด๋์ค, Color32 : 255 ์์ ํด๋์ค } private void OnCollisionStay(Collision collision) // ์ถฉ๋ ์ค์ผ ๋ { } private void OnCollisionExit(Collision collision) // ์ถฉ๋์์ ๋ฒ์ด ๋ฌ์ ๋. ์ด 3๊ฐ๊ฐ ์ธํธ { if (collision.gameObject.name == "My Ball") mat.color = new Color(1, 1, 1); // 0,0,0์ ๊ฒ์์, 1,1,1์ ํฐ์ } } |
ํธ๋ฆฌ๊ฑฐ ์ด๋ฒคํธ(์ฝ๋ผ์ด๋ ์ถฉ๋)๋ฅผ ํตํด ๋ณผ์ ์๋ก ๋ฐ์ด์ค๋ฅด๊ฒ ํ๊ธฐ. |
ํธ๋ฆฌ๊ฑฐ๊ฐ ๋ ์ค๋ธ์ ํธ(Cube)์ ์ธ์คํํฐ ์ฐฝ์์, Colider์ 'Is Trigger'๋ฅผ ์ฒดํฌํด์ค ํธ๋ฆฌ๊ฑฐ ์ด๋ฒคํธ๋ ๋ฌผ๋ฆฌ ์ถฉ๋์ด ์๋ ์ฝ๋ผ์ด๋ ์ถฉ๋๋ก ๋ฐ์ํ๋ ์ด๋ฒคํธ ์๋๋ฐฉ์ ์ฝ๋ผ์ด๋๋ฅผ ๋งค๊ฐ๋ณ์๋ก ์ฌ์ฉ. ํธ๋ฆฌ๊ฑฐ ํจ์๋ Collisionํจ์์ ๋ง์ฐฌ๊ฐ์ง๋ก 3๊ฐ์ง๊ฐ ์๋ค. 1.void OnTriggerEnter(Collider other){} (์ฝ๋ผ์ด๋์ ์ถฉ๋์ด ์์ํ ๋ ํธ์ถ๋๋ ํจ์) 2.void OnTriggerStay(Collider other){} (์ฝ๋ผ์ด๋์ ์ถฉ๋์ ํ๊ณ ์์ผ๋ฉด ํธ์ถ๋๋ ํจ์) 3.void OnTriggerExit(Collider other){} (์ฝ๋ผ์ด๋์ ์ถฉ๋์ด ๋๋ฌ์ ๋ ํธ์ถ๋๋ ํจ์) ๋งค๊ฐ๋ณ์๋ Collider๋ฅผ ์ฌ์ฉํ๋ค. -> ๋ฌผ๋ฆฌ์ ์ถฉ๋์ด ์๋ ์ฝ๋ผ์ด๋๊ฐ ๊ฒน์ณค๋๋ฅผ ๋ณด๊ธฐ๋๋ฌธ์ ์ถฉ๋์ ๋ณด๊ฐ ์๋ค. |
private void OnTriggerStay(Collider other) { if (other.name == "Cube") rigid.AddForce(Vector3.up * 10, ForceMode.Impulse); } |
(์ฐธ๊ณ ) ํฌ๋ช
ํ ๋ฌผ์ฒด๋ฅผ ๋ง๋๋ ๋ฒ
Material์์ Rendering Mode๋ฅผ Transparent๋ฅผ ํ๊ณ Albedo Color์์ Alpha๊ฐ์ ๋ด๋ ค์ค๋ค.
โญ ๊ฒ์ ์ธํฐํ์ด์ค UGUI ๊ธฐ์ด
๐ฎUI (User Interface) |
Hierachy์ฐฝ์์ ์ฐํด๋ฆญ -> UI -> Canvas ์์ฑ Canvas : UI๊ฐ ๊ทธ๋ ค์ง๋ ๋ํ์ง ์ญํ ์ธ ์ปดํฌ๋ํธ Scene์ฐฝ์ 2D ๋ฒํผ์ ๋๋ฅด๋ฉด ์คํฌ๋ฆฐ (ํ์์ ์ง์ฌ๊ฐํ) ์ 2D๋ก ๋ณด์ฌ์ค๋ค. Screen -> ๊ฒ์์ด ํ์๋๋ ํ๋ฉด, ํด์๋๋ก ํฌ๊ธฐ ๊ฒฐ์ |

๐ฎ์ ๋ํฐ๋ 2๊ฐ์ ์ขํ๊ณ๊ฐ ์๋ค.
1. World ์ขํ๊ณ: ์นด๋ฉ๋ผ๊ฐ ์๋ ๊ตฌ์ญ
2. Screen ์ขํ๊ณ: ์นด๋ฉ๋ผ๊ฐ ์๋ ๊ตฌ์ญ. ๋ง์ฐ์ค ์ปค์๋ ์คํฌ๋ฆฐ์ขํ๊ณ์ ํฌํจ๋๋ค.
๐ฎ UI์ ์ข ๋ฅ
1. Text (ํฐํธ ์ ์๊ถ ๋ฐ๋์ ์ฃผ์. ๋ฐฐ๋ฌ์ ๋ฏผ์กฑ ๋ง์ด ์) |
๋ฌธ์์ด์ ํ์ํ๋ UI Canvas -> ์ฐํด๋ฆญ -> UI -> Text๋ก ์์ฑ Font Size: ํฐํธํฌ๊ธฐ Line Spacing: ํ๊ฐ(์ค ๊ฐ๊ฒฉ) Alignment: ์ ๋ ฌ Horizontal/Vertical Overflow ์ค์ : Wrap์ ํ ์คํธ๋ฐ์ค ๋ฐ์ ์งค๋ฆผ / Overflow๋ ๋งํ์ ๋ฐ๊นฅ์ผ๋ก ํ์๊ฐ ๊ฐ๋ฅ ๋ค๋ง Overflow๋ ํฐํธ๊ฐ ๊นจ์ง ์ ์์ผ๋ฏ๋ก ํน์ํ ์ํฉ์ด ์๋๋ฉด ์์ฐ๋๊ฑธ ๊ถ์ฅ. |
2. Image |
์ฒ์์ ๋น์ด ์๋ ์ํ๋ก ๋์ค๊ธฐ ๋๋ฌธ์, ์ ์ ํ ์ด๋ฏธ์ง๋ฅผ ๋ฃ์ด์ ์ฌ์ฉํ๋ค. Canvas -> ์ฐํด๋ฆญ -> Image๋ก ์์ฑ ๊ทธ ๋ค์ ํ์ํ ์ด๋ฏธ์ง ํ์ผ์ ์์ ์ฐฝ์ ๋์ด ๋น๊ธฐ๋ฉด , TextureType์ด Default๋ก ๋์ด์๋๋ฐ, ๊ทธ๋ฌ๋ฉด ์ด๋ฏธ์ง ์ฐฝ์ ์ฌ์ฉ์ด ๋ถ๊ฐ๋ฅ ํ๋, Sprite(2D and UI)๋ก ๋ณ๊ฒฝ ํ Apply ํด๋ฆญ. ์ดํ ์ด๋ฏธ์ง๋ฅผ Image์ Source image์ ๋๋๊ทธํด์ ๋ฃ์ด์ค๋ค. Preserve Aspect: ๋น์จ๊ณ ์ ์ด ๊ฐ๋ฅํ๋ค (์์์ ๋น์จ์ ๋ง์ถฐ์ค) Set Native Size: ์ค์ ํฌ๊ธฐ๋ก ๋ง์ถ ์ ์๋ค. <Image Type ์ด 4๊ฐ์ง> 1. Simple : ๊ฐ๋ก ์ธ๋ก ๋งํผ ๋จ์ํ ๋์ด๋๋ ๊ฒ 2. Sliced : ์ด๋ฏธ์ง๋ฅผ ์๋ผ์ ์ ์์ผ๋ก ๋ฐฐ์นํ๊ณ ๊ฐ์ด๋ฐ๋ฅผ ์ฑ์ฐ๋ ๊ฒ 3. Tiled : ํธ๋์คํผ์ ๋ง์ถฐ์ค ํฌ๊ธฐ๋งํผ ๋ณต์ฌํ๋ ๊ฒ. ํ์ผ ๋๋ ๊ฒ 4. Filled : ์ด๋ฏธ์ง๊ฐ ์ด๋ป๊ฒ ์ฑ์์ง ์ง ์ค์ -> Fill Method : Radial 360์ ๋ณดํต ๋ง์ด์ฌ์ฉํ๋ค Fill Amount๋ฅผ ์ค์ด๋ฉด ๋ฐ์๊ณ๋ฐฉํฅ 360๋(180๋ ๋ฑ)๋ก ๊ณต๊ฐ์์ ์ฌ๋ผ์ง Fill Method์ Fill Amount๋ฅผ ์ฌ์ฉํด์, ์ด๋์ ๋ ๋ณด์ฌ์ง์ง ํํ์ด ๊ฐ๋ฅํ๋ค. -> ์ด๊ธฐ๋ฅ์ ์ฌ์ฉํด ์คํฌ์ ์ฟจํ์ ํจ๊ณผ ๊ตฌํ์ด ๊ฐ๋ฅํ๋ค. (๋ค์ ํ์ ๋๊ณ , ์์ ์๊น ๋๊ณ ํด์ ๊ตฌํ) -> UI๋ Hierachy์์ Canvas์ ๊ฐ๊น์ธ ์๋ก ๋จผ์ ๊ทธ๋ ค์ง๊ณ , ๋ฉ์ด์ง์๋ก ๋์ค์ ๊ทธ๋ ค์ง๋ฏ๋ก Filled๋ฅผ ์ด์ฉ ํ ์ด๋ฏธ์ง๋ฅผ ์บ๋ฒ์ค์์ ๋ฉ์ด์ง๊ฒ ์ค์ ํ๊ณ ์ฌ์ฉํ๋ฉด ๋๋ค. |
3. Button ํด๋ฆญ ์ด๋ฒคํธ๋ฅผ ๊ฐ์ง๊ณ ์๋ ๋ฐ์ํ UI |
Canvas -> ์ฐํด๋ฆญ -> Button์ผ๋ก ์์ฑ Button์์ Text๋ ํจ๊ป ์์ฑ๋๋ค. ImageType: ๋ณดํต Sliced -> ๋ชจ์๋ฆฌ์ชฝ์ ์ ์ง๋ฅผ ํ๊ณ ์์ชฝ์ ํฌ๊ธฐ๋ง ๊ฑด๋๋ฆฌ๊ฒ ๋ค. -> Fill Center๋ฅผ ์ฒดํฌํด์ ํ๋ฉด ๋ชจ์๋ฆฌ ๋ถ๋ถ์ด ์๋ณธ์์ ํ์ธ์ด ๊ฐ๋ฅ -> ๊ฐ์ด๋ฐ ๋ถ๋ถ์ด ๋น์ด์ ธ ๋ณด์ธ๋ค. Sliced ๊ธฐ๋ฅ์ผ๋ก ์์ ์์ฌ ํฌ๊ธฐ๋ก ์ด๋ฏธ์ง ๊ตฌํ ๊ฐ๋ฅ Interactable: ๋ฐ์์ ํ ์ง ๋ง ์ง -> ์ฒดํฌํด์ ํ๋ฉด ๋ฒํผ์ ์ฌ์ค์ ๋ฌด์ฉ์ง๋ฌผ์ํ. Transition: ๋ฐ์ํ ๋ ์ด๋ป๊ฒ ๋ฐ์ํ๋๊ฐ? 0) Navigation -> ์ฌ๋ฌ๊ฐ ๋ฒํผ์ด ์์ ๋ ํค๋ณด๋๋ก ์ด๋ํค๋ฅผ ๋๋ฅผ ์ ์ด๋ ๋ฒํผ์ผ๋ก ์ด๋ํ ์ง ์ง์ ํ๋ค. 1.Color Tint: ์๊น์ ๋ฐ๊ฟ์ค๋ค. 1-1 Normal (๊ธฐ๋ณธ ์ํ) 1-2 Highlighted (๋ง์ฐ์ค๋ฅผ ๊ฐ์ ธ๋ค ๋์ ๋) 1-3 Pressed (๋๋ ์ ๋) 1-4 Disabled (๋ฒํผ์ด ๋นํ์ฑํ ๋์ด ์์ ๋)-> Interactable ์ฒดํฌํด์ ํ์ ๋ ์์ -> Color Multiplier ์๊น์ ์๋ ๊ฐ๋ (๋ณดํต 1๋ก ๋ ๋ ) 2. Sprite Swap ๋ฒํผ์ ํด๋ฆญํ๋ฉด ๊ธฐ์กด์ Sprite๊ฐ ์ง์ ํด ๋์ Sprite๋ก ๋ณํ๋ ๊ธฐ๋ฅ 3. Animation ๋ฒํผ์ ์ค์ผ์ผ์ด ์ปค์ง๋ ์ ๋๋ฉ์ด์ ๊ฐ์๊ฑธ ํํํ ๋ ์ฌ์ฉ |
๐ฎButton์ OnClick() ์ด๋ฒคํธ : ๋ฒํผ ํด๋ฆญ ์ ํธ์ถ๋๋ ์ด๋ฒคํธ ํจ์ +๋ฅผ ๋๋ฌ Hierachy์ ์กด์ฌํ๋ ์ค๋ธ์ ํธ๋ฅผ ๋๋๊ทธ ํ์ฌ ๋ฃ๊ณ ์ค๋ธ์ ํธ์ ์ ์ฉ๋ ์คํฌ๋ฆฝํธ๋ฅผ ์์ ํด์ ํจ์๋ฅผ ๋ง๋ค๊ณ (์์์์๋ Jump), ๋ฒํผ์ ๋งคํ์ ์ํจ๋ค. (No Function - NewBehaviorScript-Jump()) -> ๊ทธ๋ผ ๋ฒํผ์ ๋๋ฅผ ์ ์ค์ ํ ํจ์๊ฐ ์คํ๋๋ค. -> ๋ฒํผํด๋ฆญ์ ๋๋ฅด๊ธฐ-๋ผ๊ธฐ ์ด๋ ๊ฒ ํ์ธํธ๋ก ์น๋ค. |
๐ฎ์ต์ปค ์ค์ํ ๋จ๊ณ. ํด์๋์ ๋ณ๊ฒฝ์ ๋ฐ๋ผ UI๊ฐ ๋ฐ๋์ง ์๊ฒ ์ต์ปค ์ค์ ์ด ์ค์ํ๋ค. ์๋ ์ฐ๋ฆฌ๊ฐ ๊ทธ๋์ ๋ดค๋ ์ค๋ธ์ ํธ๋ค์ Transform๋ง ๊ฐ์ง๊ณ ์์์ง๋ง, Canvas์ ๊ตฌ์ฑ์์๋ค์๋ RectTransform(UI ํธ๋์คํผ) ์ด ๋ฐ๋ก ์์ React Transform ์๋์ ์ญ์์ ๊ทธ๋ฆผ์ ๋๋ฅด๋ฉด Anchor Presets์ด ๋์ด - ๊ทธ๋ฅ ํด๋ฆญ: ๊ทธ๋ฅ ์ต์ปค ๊ธฐ์ค ์ค์ (์บ๋ฒ์ค์์์ ๊ธฐ์ค์ ์ ๋นจ๊ฐ์ ) - shift์ ํจ๊ป ํด๋ฆญ: ์ปดํฌ๋ํธ์ ๊ธฐ์ค์ ์ ํ๋์ ์ ๋ฐ๋ฆ - Shift+Alt๊ณผ ํจ๊ป ํด๋ฆญ: ์ปดํฌ๋ํธ์ ๊ธฐ์ค์ ๋ณ๊ฒฝ + ์ปดํฌ๋ํธ์ ์์น๊น์ง ์๋์ผ๋ก ๋ง์ถฐ์ค ์ด๋ ๊ฒ ์ค์ ํ๋ฉด ๊ฒ์ ํ๋ฉด ํด์๋๊ฐ ๋ฐ๋์ด๋ ๊ธฐ์ค์ ์ UI๊ฐ ๊ณ ์ |