[Unity ๊ธฐ์ดˆ] ๊ฒŒ์ž„ํ”„๋กœ๊ทธ๋ž˜๋ฐ BE1 ์ด๋ก  ์ •๋ฆฌ
๋ฐ˜์‘ํ˜•

 

ํ”„๋กœ์ ํŠธ ์ƒ์„ฑ: ์ฃผ๋กœ 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๊ฐ€ ๊ณ ์ •

 

๋ฐ˜์‘ํ˜•
 ๐Ÿ’ฌ C O M M E N T