> For the complete documentation index, see [llms.txt](https://docs.overdare.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.overdare.com/korean/manual/quick-start-guide/unity-developer-guide.md).

# 유니티 개발자용 가이드

## 개요

OVERDARE는 **멀티플레이 게임의 제작**부터 **배포**까지 한 번에 처리할 수 있는 강력한 **게임 제작 플랫폼**입니다. 클라이언트 기반의 유니티와 달리, 멀티플레이 환경을 기반으로 하기 때문에 유니티와는 다른 구조로 설계되어 있습니다.

이 문서는 유니티 개발자들이 OVERDARE Studio에 빠르게 적응할 수 있도록 돕기 위해 작성된 문서입니다. OVERDARE를 이용하여 멀티플레이 게임 제작의 **새로운 가능성**을 탐험해 보세요!

## 인터페이스

<figure><img src="/files/fkSHsYtlfLxrWzz0qybJ" alt=""><figcaption><p>Unity / OVERDARE Studio</p></figcaption></figure>

| Unity     | OVERDARE      |
| --------- | ------------- |
| Game      | X             |
| Scene     | Viewport      |
| Hierarchy | Level Browser |
| Inspector | Properties    |
| Project   | X             |
| Console   | Output Log    |

유니티와 달리 OVERDARE Studio에서는 Game View과 Project 패널을 제공하지 않습니다. 대신 플레이를 실행하면 **Viewport 패널이 플레이 화면으로 전환**됩니다.

유니티에서는 Script와 머테리얼, 메쉬 같은 모든 에셋들이 Project 패널에서 관리되지만, OVERDARE Studio에서는 Script도 **Level Browser**에서 관리되며, Mesh나 Image, Audio와 같은 외부에서 임포트한 에셋들은 **Asset Manager**를 통해 별도로 관리됩니다.

## 단축키 차이

| Unity    | OVERDARE   | 기능          |
| -------- | ---------- | ----------- |
| Q        | Ctrl + 1   | Select Tool |
| W        | Ctrl + 2   | Move Tool   |
| E        | Ctrl + 3   | Rotate Tool |
| R        | Ctrl + 4   | Scale Tool  |
| Ctrl + P | F5         | Play        |
| Ctrl + P | Shift + F5 | Stop        |

## 3D 월드 좌표계

<figure><img src="/files/XYmkhDrdUFqkST528oDJ" alt=""><figcaption><p>Unity / OVERDARE Studio</p></figcaption></figure>

유니티와 OVERDARE는 X축과 Y축의 방향이 같다는 점에서 좌표계 구조가 유사하지만, **Z축의 방향**에 차이가 있습니다. 유니티에서는 **정면 방향이 +Z**인 반면, OVERDARE에서는 **정면이 -Z 방향**입니다. 이 차이는 캐릭터나 카메라의 Forward 방향을 설정하거나, 이동 및 회전을 계산할 때 기준 축이 반대가 된다는 점에서 중요한 차이를 만듭니다.

## 에셋 임포트

<figure><img src="/files/HdA9EMYNb9nyjhJk6arV" alt=""><figcaption><p>Unity / OVERDARE Studio</p></figcaption></figure>

클라이언트 기반인 유니티에서는 드래그&드롭으로 외부 에셋을 간편하게 임포트할 수 있습니다. 반면, OVERDARE Studio는 **크리에이터를 위한 플랫폼**으로 외부 에셋을 사용할 때 **서버 업로드** 과정을 거치도록 설계되었습니다. 이를 통해 크리에이터는 에셋을 쉽게 공유하고 게임 제작에 활용할 수 있습니다.

외부 에셋을 임포트하려면 OVERDARE Studio 상단 메뉴에서 **Import 버튼**을 클릭해야 합니다. 에셋을 Import하면 서버로 업로드되고, **서버에서 처리가 완료되면 Asset Store에 표시**됩니다.

### 리소스 동적 로드

유니티에서는 런타임에서 **Resources.Load**를 사용해 리소스를 불러올 수 있으며, 이는 Project 패널 내 Resources 폴더에 있는 에셋을 경로 기반으로 로드하는 방식입니다. 예를 들어, Resources.Load로 텍스처 에셋을 불러온 뒤 머티리얼에 적용하는 식으로 사용됩니다.

반면, OVERDARE에서는 각 에셋에 할당된 고유한 **AssetId**를 통해 외부 에셋을 참조하며, 메시에 텍스처 자체를 할당하는 것이 아니라 해당 텍스처의 AssetId를 설정하는 방식으로 동작합니다. 이는 에디터 기반 내부 자원 관리에 중점을 둔 유니티와, **네트워크 기반 외부 자원 참조 구조**를 중심으로 하는 OVERDARE 간의 근본적인 시스템 차이에서 비롯됩니다.

자세히 알아보기

{% content-ref url="/pages/lMm2e5Zay4cMI4Ke6F8E" %}
[에셋 임포트](/korean/manual/studio-manual/asset-and-resource-creation/asset-import.md)
{% endcontent-ref %}

## 오브젝트 구조 차이

<figure><img src="/files/WgrF2sf8oq6RAqUACRtn" alt=""><figcaption><p>Unity / OVERDARE Studio</p></figcaption></figure>

유니티의 주요 기능은 컴포넌트 단위로 구성되므로, 카메라, 콜라이더, 오디오 등 다양한 컴포넌트를 조합하여 오브젝트의 기능을 자유롭게 구성할 수 있습니다. 반면, OVERDARE Studio에서는 **기능별로 오브젝트 타입이 고정**되어 있습니다.

예를 들어, 유니티에서는 오브젝트에 물리 기능을 추가하려면 Rigidbody 컴포넌트를 추가해야 하지만, OVERDARE Studio에서는 물리 기능이 내장된 Part 오브젝트에서 Anchored 속성을 비활성화해야 합니다.

### Transform

유니티에서는 **Transform 컴포넌트**를 통해 Position, Rotation, Scale 속성을 직접 제어하며, 로컬 및 월드 좌표계를 명확히 구분하여 사용할 수 있습니다.

반면 OVERDARE에서는 Position과 Orientation도 제공되지만, 일반적으로 **CFrame**을 통해 위치와 회전을 함께 다루며, 스케일은 별도로 Size 속성에서 관리됩니다. 특히 OVERDARE는 기본적으로 모든 위치와 회전 연산이 **월드 좌표 기준**으로 수행되며, 로컬 좌표 변환이 필요한 경우는 직접 계산해야 합니다.

이처럼 유니티는 구성 요소별 속성이 명확히 분리되어 있고, OVERDARE는 위치와 회전을 하나의 CFrame으로 묶어 처리한다는 점에서 구조적인 차이를 보입니다.

자세히 알아보기

{% content-ref url="/pages/mC9duPphkAklv8ZEUCpW" %}
[좌표계](/korean/manual/studio-manual/get-started/coordinate-system.md)
{% endcontent-ref %}

### Collision

유니티에서는 물리 기반 충돌 처리를 위해 **Collider 컴포넌트**를 사용하며, BoxCollider, SphereCollider, MeshCollider 등 다양한 형태의 콜라이더를 선택할 수 있습니다. 충돌 처리를 위해서는 오브젝트에 Collider와 함께 Rigidbody가 필요하며, **isTrigger 옵션**을 이용하여 트리거 처리도 가능합니다. 충돌 이벤트는 OnCollisionEnter, OnTriggerEnter 등으로 감지하며, 레이어 마스크를 통한 세밀한 충돌 필터링도 가능합니다.

반면, OVERDARE에서는 모든 Part는 기본적으로 **충돌 기능이 내장**되어 있으며, **CanCollide** 속성을 통해 충돌 여부를 제어합니다. OnCollisionEnter이나 OnTriggerEnter 같은 충돌 이벤트는 모두 **Touched 이벤트**로 처리되며, CanCollide가 비활성화 상태이면 유니티의 트리거 이벤트처럼 동작합니다. 또한 **Collision Profile**을 사용하여 Object Type(Collision Channel)과 채널별 Collision Response(Block/Overlap/Ignore)를 정의하면, 유니티의 레이어 충돌 매트릭스보다 세밀한 충돌 필터링을 구현할 수 있습니다.

자세히 알아보기

{% content-ref url="/pages/NEDY5MI9tTjRcAUp4DYC" %}
[Collision Profile](/korean/manual/studio-manual/game-development/collision-profile.md)
{% endcontent-ref %}

### Rigidbody (Physics)

유니티에서는 **Rigidbody 컴포넌트**를 오브젝트에 추가함으로써 해당 오브젝트가 물리 엔진의 영향을 받도록 설정할 수 있습니다. Rigidbody의 velocity, angularVelocity, AddForce, AddTorque 등을 통해 힘 기반의 정밀한 제어가 가능합니다.

OVERDARE에서는 모든 Part가 기본적으로 **물리 속성을 내장**하고 있습니다. **Anchored** 속성을 비활성화한 오브젝트는 중력, 충돌, 마찰 등 물리 영향을 받으며, 물리 기반의 동작 제어는 LinearVelocity, AngularVelocity, VectorForce 등과 같은 **전용 물리 객체**를 통해 구현됩니다.

자세히 알아보기

{% content-ref url="/pages/6CSY5MxAR0y1qTIDKtRz" %}
[물리](/korean/manual/studio-manual/object/physics.md)
{% endcontent-ref %}

### Camera

유니티에서는 Camera 컴포넌트를 씬 내에 자유롭게 배치하고, 씬 카메라 또는 UI 카메라 등 다양한 용도로 복수의 카메라를 구성할 수 있습니다. 특히 여러 개의 카메라를 미리 배치해두고 SetActive를 통해 활성화된 **카메라를 전환**하는 방식으로 시점을 변경할 수 있습니다.

반면 OVERDARE에서는 Workspace.CurrentCamera를 통해 현재 활성화된 **단일 카메라**를 제어하며, 시스템적으로 하나의 카메라만 존재하고 항상 활성 상태로 유지됩니다. 카메라는 기본적으로 플레이어의 Humanoid를 따라가지만, CameraType 속성을 Scriptable로 변경하면 직접 위치나 회전을 제어할 수 있습니다. 이때 유니티처럼 여러 카메라의 전환 구조가 아닌, CurrentCamera의 CFrame, FieldOfView 등의 **속성을 직접 변경**하는 방식으로 시점을 변경합니다.

자세히 알아보기

{% content-ref url="/pages/Yq05ujUqfHiW3sWsyNet" %}
[카메라](/korean/manual/studio-manual/object/camera.md)
{% endcontent-ref %}

### ParticleSystem

유니티에서는 **ParticleSystem 컴포넌트**를 오브젝트에 추가하여 다양한 이펙트를 구성할 수 있으며, ParticleSystem 컴포넌트 안에서 Emission, Shape, Velocity, Lifetime 등 여러 모듈을 조합해 복잡한 이펙트를 만들 수 있습니다.

반면 OVERDARE에서는 ParticleEmitter, Beam, Trail 등 **이펙트 객체**를 Part에 부착해서 사용하며, 각 이펙트 타입은 별도의 객체로 구분되어 있고 설정 가능한 속성도 제한적입니다. 예를 들어 ParticleEmitter는 속도, 방향, 색상, 생존 시간 등 일부 속성만 설정할 수 있으며, 유니티처럼 다중 모듈을 조합하는 방식은 지원되지 않습니다. 또한 파티클은 별도의 위치 설정 없이 파티클이 부착된 Part를 기준으로 방출됩니다.

자세히 알아보기

{% content-ref url="/pages/xSyoRShlKPjBIwbLoQMO" %}
[VFX](/korean/manual/studio-manual/object/vfx.md)
{% endcontent-ref %}

### UI

유니티에서는 UI 시스템의 루트로 **Canvas 컴포넌트**를 사용하며, 모든 UI 요소는 이 Canvas 하위에 배치되어 렌더링됩니다. UI는 일반적으로 RectTransform을 사용하여 배치되며, 앵커와 피벗, 패널 계층 구조를 통해 복잡한 반응형 UI도 설계할 수 있습니다.

반면 OVERDARE에서 모든 UI 요소는 **ScreenGui, SurfaceGui** 등으로 구성됩니다. ScreenGui는 HUD나 메뉴처럼 화면에 고정된 UI를 구현하며, UI 요소는 픽셀 값과 비율(스케일)로 구성된 UDim2 값을 통해 배치됩니다.

자세히 알아보기

{% content-ref url="/pages/K1g0tEWDJhh6a6E4UURk" %}
[GUI](/korean/manual/studio-manual/gui.md)
{% endcontent-ref %}

### RectTransform

유니티에서는 UI 요소의 위치, 크기, 정렬 등을 제어하기 위해 **RectTransform 컴포넌트**를 사용합니다. RectTransform은 일반 Transform과 달리 2D UI 전용으로 설계된 컴포넌트이며, 앵커(Anchor), 피벗(Pivot), 오프셋(Offset) 등을 통해 부모 기준 상대적 배치와 자동 정렬이 가능합니다. 특히 캔버스 내에서 반응형 UI를 구성할 때 중심 역할을 하며, 화면 해상도나 부모 크기에 따라 유동적으로 위치와 크기를 조정할 수 있습니다.

반면, OVERDARE에서는 UI 요소를 제어할 때 Position, Size, AnchorPoint 속성을 사용합니다. 여기서 Position, Size에 사용되는 **UDim2 타입**은 픽셀 값과 비율(스케일)을 혼합하여 정의할 수 있어, 유니티의 Anchored Position과 Stretch 속성 등을 부분적으로 대체합니다.

자세히 알아보기

{% content-ref url="/pages/mC9duPphkAklv8ZEUCpW" %}
[좌표계](/korean/manual/studio-manual/get-started/coordinate-system.md)
{% endcontent-ref %}

## 프리팹

유니티에서는 몬스터, UI 슬롯과 같이 반복적으로 사용하는 오브젝트를 **프리팹**으로 설정하여 효율적으로 관리하고 재사용할 수 있습니다. 프리팹은 에디터에서 구성한 오브젝트를 **Project 패널**에 리소스 형태로 저장하며, 런타임 중 필요한 시점에 **Instantiate()**&#xB85C; 동적 생성할 수 있습니다. 프리팹 시스템은 **재사용성**과 **유지보수 효율**에 중점을 두고 있으며, 원본 프리팹을 수정하면 해당 프리팹을 참조하는 모든 인스턴스에 일괄 반영되어 일관성을 유지할 수 있습니다.

반면, OVERDARE에서는 유니티의 Project와 같은 패널이 별도로 존재하지 않으며, 모든 오브젝트는 **LevelBrowser(Hierarchy)**&#xB97C; 통해 관리됩니다. 이에 따라 동적으로 생성할 오브젝트는 **ServerStorage**에 미리 배치해두고, 필요 시 **Clone()**&#xB85C; 생성하여 Workspace 등으로 옮기는 방식으로 활용됩니다. 이 방식은 런타임 객체 복제 및 보안에 초점을 맞추며, ServerStorage 내 오브젝트는 서버에서만 접근 가능하고 클라이언트에는 노출되지 않기 때문에 안전하게 보관할 수 있습니다.

## Animation

유니티에서는 **Animation 패널**을 통해 **카메라, 캐릭터, UI 등 모든 게임 오브젝트에 대한 애니메이션**을 제작할 수 있습니다. 제작된 애니메이션은 **Animator 패널**에서 **상태 머신(State Machine)** 기반으로 구성하여, 트랜지션 조건이나 파라미터를 활용한 시각적 제어가 가능합니다.

반면, OVERDARE에서는 **Animation Editor를 통해 캐릭터 애니메이션만 제작 가능**하며, UI나 기타 오브젝트에 대한 에디터 기반 애니메이션 제작은 아직 지원되지 않습니다. 또한, Animator 상태 머신이 존재하지 않으며, **모든 애니메이션 재생과 제어는 스크립트를 통해 직접 구현**해야 합니다. 예를 들어, 캐릭터의 이동, 공격, 감정 표현 등은 **코드 기반으로 애니메이션을 수동 재생**하거나 상태 관리를 로직으로 처리해야 합니다.

자세히 알아보기

{% content-ref url="/pages/NU5b90mJmoIlkGCj2hMe" %}
[애니메이션 에디터](/korean/manual/studio-manual/asset-and-resource-creation/animation-editor.md)
{% endcontent-ref %}

{% content-ref url="/pages/GWE1QQYA5ZKybkJcVPtz" %}
[캐릭터 애니메이션](/korean/manual/studio-manual/character/character-animation.md)
{% endcontent-ref %}

## 스크립트

OVERDARE Studio는 게임 개발 언어로 **Luau 스크립트**를 제공합니다. Luau는 경량화된 스크립트 언어로, 배우기 쉬운 간결한 문법과 빠른 실행 속도를 자랑하며 높은 유연성을 제공합니다. 이러한 특성 덕분에 Luau는 C# 스크립트보다 접근성과 생산성이 뛰어나며, 초보 개발자부터 숙련된 개발자까지 누구나 쉽게 활용할 수 있습니다.

### 특징

| 특징         | Unity (C#)                                   | OVERDARE (Luau)                                |
| ---------- | -------------------------------------------- | ---------------------------------------------- |
| 자료형 명시     | O                                            | X                                              |
| 한정자 종류     | private, public, static 등                    | local, global                                  |
| 객체 지향(OOP) | 클래스, 인터페이스, 상속, 다형성 등을 통해 객체 지향 프로그래밍 지원     | 객체 지향을 직접적으로 지원하지 않으며, Metatable로 유사 객체 구현     |
| 코드 구조      | Class 기반 구조로 모든 코드가 클래스 안에 작성되며, 메서드와 속성을 활용 | 단순한 함수 기반 구조로 클래스가 없으며, Table을 통해 데이터와 함수를 구조화 |
| 함수         | 함수는 클래스의 멤버                                  | 함수를 변수처럼 사용 가능 (First-class function)          |
| Collection | List, Dictionary 등                           | Table                                          |
| switch문 유무 | O                                            | X                                              |
| 주석         | //                                           | --                                             |
| 여러줄 주석     | /\*와 \*/                                     | --\[\[와 ]]--                                   |
| 세미콜론       | 필수                                           | 생략                                             |

자세히 알아보기

{% content-ref url="/pages/8ciIOrKvGqjmzUWvjMqP" %}
[루아 기초 가이드](/korean/manual/script-manual/get-started/basic-guide-to-lua.md)
{% endcontent-ref %}

### 코드의 흐름

루아 스크립트는 동적 타입 언어로, 스크립트가 위부터 순차적으로 실행됩니다. **전방 참조가 지원되지 않으며**, 참조하려는 함수나 변수가 먼저 정의되어 있어야 합니다. 이러한 특성은 Lua의 설계가 간결성과 런타임 성능을 중시하기 때문입니다.

```lua
PrintText("Hello, Lua Script!") -- 에러 발생 (전방 참조 불가)

local function PrintText(message)
    print(message)
end

PrintText("Hello, Lua Script!") -- 동작 가능
```

### 다른 스크립트의 변수/함수 호출

변수나 함수를 **global**으로 선언하면 어디서든 접근할 수 있습니다. 단, global 변수는 어디서든 수정 가능하므로, 코드의 안정성이 떨어질 수 있습니다.

```lua
_G.GlobalText = "Hello, World!" -- 전역 변수 선언

-- 전역 함수 선언
function _G.GlobalFunction()
    print("This is a global function!")
end
```

<pre class="language-lua"><code class="lang-lua">print(_G.GlobalText) -- 전역 변수 접근
<strong>_G.GlobalFunction()  -- 전역 함수 호출
</strong></code></pre>

**모듈 스크립트**를 이용하여 테이블에 변수와 함수를 담아서 반환하는 방식으로 외부에서 사용할 수 있습니다. 이는 전역 변수를 사용하는 것보다 안전하고, 코드의 구조화를 돕습니다.

```lua
local SomeModule = {} -- 테이블 생성

-- 모듈 변수
SomeModule.Text = "Hello from module!"

-- 모듈 함수
function SomeModule:Function()
    print("This is a function inside a module!")
end

return SomeModule -- 테이블 반환
```

```lua
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local SomeModule = require(ReplicatedStorage.SomeModule) -- 모듈 로드

print(SomeModule.Text) -- 모듈 변수 접근
SomeModule.Function()  -- 모듈 함수 호출
```

또는 BindableEvent를 사용하여 서버와 서버, 클라이언트와 클라이언트처럼 같은 환경에 있는 스크립트끼리 통신을 처리할 수 있습니다.

자세히 알아보기

{% content-ref url="/pages/VMaKzpoIe8ACwevkbtar" %}
[모듈 스크립트](/korean/manual/script-manual/advanced-gameplay-systems/modulescript.md)
{% endcontent-ref %}

{% content-ref url="/pages/ptRKYzEEsawEyvh6kskm" %}
[BindableEvent](/korean/manual/script-manual/events-and-communication/bindableevent.md)
{% endcontent-ref %}

### 실행 위치와 실행 순서

OVERDARE는 **멀티플레이 환경**을 기반으로 설계되었기 때문에, 스크립트의 위치에 따라 용도와 실행 여부가 달라집니다. 예를 들어, 카메라나 GUI와 같은 클라이언트 전용 기능은 클라이언트에서만 동작하며, 게임 로직 처리나 오브젝트 이동 등 동기화가 필요한 기능은 서버에서 처리해야 합니다. 이러한 구조는 클라이언트와 서버 간 역할을 명확히 분리하여 효율적이고 안정적인 멀티플레이 동작을 보장합니다.

유니티에서 스크립트의 실행 순서는 Script Execution Order 설정을 통해 명시적으로 지정할 수 있습니다. 반면, OVERDARE Studio에서는 Script나 LocalScript 같은 **스크립트의 종류**와 Workspace, ServerScriptService 같은 **스크립트의 실행 위치**에 따라 실행 순서가 자동으로 결정됩니다.

<figure><img src="/files/TlPVB5cdJFlurdnJDNA8" alt=""><figcaption><p>Unity / OVERDARE Studio</p></figcaption></figure>

자세히 알아보기

{% content-ref url="/pages/jNQmqSxrnewI7RpLbHBi" %}
[스크립트 개요](/korean/manual/script-manual/get-started/script-overview.md)
{% endcontent-ref %}

### 서버와 클라이언트간 통신

OVERDARE는 멀티플레이 게임 기반으로 설계되어 서버에서 실행되는 **Script**와 클라이언트에서 실행되는 **LocalScript**를 조합하여 게임이 구현됩니다. 서버와 클라이언트 간의 통신은 **RemoteEvent**를 사용하여 처리할 수 있습니다.

자세히 알아보기

{% content-ref url="/pages/rznBJB0DomrXzxffvYtu" %}
[서버-클라 통신](/korean/manual/script-manual/events-and-communication/remoteevent.md)
{% endcontent-ref %}

## 스크립트 기능 비교

### print

{% tabs %}
{% tab title="Unity (C#)" %}

```csharp
using UnityEngine;

public class Example : MonoBehaviour
{
    void Start()
    {
        print("Hello, World!");
    }
}
```

{% endtab %}

{% tab title="OVERDARE (Lua)" %}

```lua
print("Hello, World!")
```

{% endtab %}
{% endtabs %}

### Start Event

{% tabs %}
{% tab title="Unity (C#)" %}

```csharp
using UnityEngine;

public class Example : MonoBehaviour
{
    void Start()
    {
        print("Start!")
    }
}
```

{% endtab %}

{% tab title="OVERDARE (Lua)" %}

```lua
print("Start!")
```

{% endtab %}
{% endtabs %}

### Update Event

{% tabs %}
{% tab title="Unity (C#)" %}

```csharp
using UnityEngine;

public class Example : MonoBehaviour
{
    private float Timer = 0f;

    void Update()
    {
        Timer += Time.deltaTime;
    }
}
```

{% endtab %}

{% tab title="OVERDARE (Lua)" %}

```lua
local RunService = game:GetService("RunService")
local Timer = 0

local function UpdateEvent(deltaTime)
    Timer = Timer + deltaTime
end
RunService.Heartbeat:Connect(UpdateEvent)
```

{% endtab %}
{% endtabs %}

### 오브젝트 참조

{% tabs %}
{% tab title="Unity (C#)" %}

```csharp
using UnityEngine;

public class Example : MonoBehaviour
{
    void Start()
    {
        GameObject object = GameObject.Find("Monster/Orc");
    }
}
```

{% endtab %}

{% tab title="OVERDARE (Lua)" %}

```lua
local Workspace = game:GetService("Workspace")
local Orc = Workspace.Monster.Orc
```

{% endtab %}
{% endtabs %}

### Transform

{% tabs %}
{% tab title="Unity (C#)" %}

```csharp
using UnityEngine;

public class Example : MonoBehaviour
{
    void Start()
    {
        transform.position = new Vector3(500, 0, 0);
        transform.rotation = new Vector3(0, 90, 0);
        transform.localScale = new Vector3(0.5f, 0.5f, 0.5f);
    }
}
```

{% endtab %}

{% tab title="OVERDARE (Lua)" %}

```lua
local Part = script.Parent

Part.Position = Vector3.new(500, 0, 0)
Part.Orientation = Vector3.new(0, 90, 0)
Part.Size = Vector3.new(50, 50, 50)
```

{% endtab %}
{% endtabs %}

### 충돌 이벤트

{% tabs %}
{% tab title="Unity (C#)" %}

```csharp
using UnityEngine;

public class Example : MonoBehaviour
{
    private void OnCollisionEnter(Collision collision)
    {
        print("Collision started with : " + collision.gameObject.name);
    }

    private void OnCollisionStay(Collision collision)
    {
        print("Collision ongoing with : " + collision.gameObject.name);
    }

    private void OnCollisionExit(Collision collision)
    {
        Drint("Collision ended with : " + collision.gameObject.name);
    }
}
```

{% endtab %}

{% tab title="OVERDARE (Lua)" %}

```lua
local Part = script.Parent

local function onTouched(otherPart)
    print(Part.Name, "Touched :", otherPart.Name)
end
Part.Touched:Connect(onTouched)

local function onTouchEnded(otherPart)
    print(Part.Name, "Touch Ended :", otherPart.Name)
end
Part.TouchEnded:Connect(onTouchEnded)
```

{% endtab %}
{% endtabs %}

### Create & Destroy

{% tabs %}
{% tab title="Unity (C#)" %}

```csharp
using UnityEngine;

public class Example : MonoBehaviour
{
    public GameObject Prefab;

    void Start()
    {
        GameObject newObject = Instantiate(Prefab, new Vector3(300, 0, 0));
        newObject.name = "NewObject";
        newObject.transform.parent = transform;

        Destroy(newObject);
    }
}
```

{% endtab %}

{% tab title="OVERDARE (Lua)" %}

```lua
local Workspace = game:GetService("Workspace")
local Part = Workspace.Part

local ClonedPart = Part:Clone()
ClonedPart.name = "NewPart"
ClonedPart.Parent = Part
ClonedPart.Position = Vector3.new(300, 0, 0)

Part:Destroy()
```

{% endtab %}
{% endtabs %}

### Coroutine

{% tabs %}
{% tab title="Unity (C#)" %}

```csharp
using System.Collections;
using UnityEngine;

public class CoroutineExample : MonoBehaviour
{
    private IEnumerator co;

    void Start()
    {
        co = SomeCoroutine();
        StartCoroutine(co);
        print("2")
    }

    IEnumerator SomeCoroutine()
    {
        Debug.Log("1");
        yield return new WaitForSeconds(2.0f);
        Debug.Log("3");
    }
}
```

{% endtab %}

{% tab title="OVERDARE (Lua)" %}

```lua
local function SomeCoroutine()
    print("1")
    wait(2)
    print("3")
end

local co = coroutine.create(SomeCoroutine)
coroutine.resume(co)  
print("2")
```

{% endtab %}
{% endtabs %}

## 참고 자료

OVERDARE Studio에서 제공하는 스크립트 기능을 확인하려면 아래 문서를 참고하세요.

{% content-ref url="/pages/FfcNnL4WhTDAwbSDSabW" %}
[API Reference](/korean/development/api-reference.md)
{% endcontent-ref %}

## 개발지원

디스코드 [OVERDARE Creator Community Server](https://discord.com/invite/CbxxNTva98)에 참여하여 개발 관련 문의나 정보 공유, 커뮤니티 활동 등 게임 제작에 적극 활용하세요!