> 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/unreal-developer-guide.md).

# 언리얼 개발자용 가이드

## 개요

OVERDARE는 **멀티플레이 게임의 제작**부터 **배포**까지 한 번에 처리할 수 있는 강력한 **게임 제작 플랫폼**입니다. 언리얼 엔진5를 기반으로 제작되었지만, UGC 제작 환경에 최적화된 구조를 제공하여 언리얼5 대비 훨씬 낮은 학습 곡선과 크리에이터 친화적인 인터페이스, 그리고 간소화된 제작 파이프라인을 제공합니다.

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

## 인터페이스

<figure><img src="/files/tZSOHR6C8xfTs4nQDoDg" alt=""><figcaption><p>Unreal / OVERDARE Studio</p></figcaption></figure>

| Unreal          | OVERDARE      |
| --------------- | ------------- |
| Viewport        | Viewport      |
| Outliner        | Level Browser |
| Details         | Properties    |
| Content Browser | X             |
| Output Log      | Output Log    |

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

## 단축키 차이

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

## 3D 월드 좌표계

<figure><img src="/files/3WeA2GXSzQWVPvslLUjY" alt=""><figcaption><p>Unreal / OVERDARE Studio</p></figcaption></figure>

언리얼과 OVERDARE는 서로 다른 축 구성을 사용하기 때문에 좌표계가 완전히 다릅니다. 이러한 차이로 인해 캐릭터와 카메라의 Forward 방향을 설정하거나, 이동 및 회전을 계산할 때 기준이 되는 축이 반대가 될 수 있으며, 동일한 연산이라도 결과가 상이하게 나타납니다. 따라서 두 좌표계를 변환하거나 연동할 때는 각 축의 방향 차이를 명확히 이해하고, 적절한 변환 과정을 거쳐야 합니다.

## 에셋 임포트

<figure><img src="/files/MOSI9sN9A39I3kgv8iX7" alt=""><figcaption><p>Unreal / OVERDARE Studio</p></figcaption></figure>

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

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

## 오브젝트 구조 차이

<figure><img src="/files/rKVFkYMs6W5bhmPVs4Yr" alt=""><figcaption><p>Unreal / OVERDARE Studio</p></figcaption></figure>

OVERDARE Studio는 언리얼과 유사한 **오브젝트 기반 구조**를 사용합니다. 각 오브젝트는 용도에 따라 역할이 결정된 타입 기반 구조로 설계되어 있으며, 기능이 오브젝트 타입 안에 미리 정의되어 있습니다. 따라서 크리에이터는 적절한 타입의 오브젝트를 선택한 뒤 속성을 조정하는 방식으로 기능을 제어하게 됩니다.

예를 들어, 언리얼에서 StaticMeshActor에 Simulate Physics 속성으로 물리 기능을 제공하는 것처럼, 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

언리얼에서는 StaticMeshActor의 **Collision Preset**과 **Collision Response**를 통해 매우 세밀한 충돌 동작을 설정할 수 있습니다. 각 오브젝트는 여러 충돌 채널(Channel)에 대해 **Block/Overlap/Ignore** 등 서로 다른 반응 타입을 가질 수 있으며, 이러한 규칙들이 **매트릭스 형태**로 구성되어 높은 수준의 충돌 제어가 가능합니다.

OVERDARE에서도 언리얼의 Collision Preset과 유사한 **Collision Profile** 시스템을 제공합니다. 각 Part에 Collision Profile을 지정하여 Object Type(Collision Channel)과 채널별 Collision Response(Block/Overlap/Ignore)를 정의할 수 있으며, Part의 **CanCollide** 속성으로 충돌 여부를 직접 제어할 수도 있습니다. Hit이나 Overlap 같은 충돌 이벤트는 모두 **Touched 이벤트**로 처리됩니다.

자세히 알아보기

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

### Physics

언리얼에서는 StaticMeshActor의 **Simulate Physics** 속성을 활성화함으로써 물리 엔진(Chaos)의 영향을 받도록 설정합니다. 물리 제어는 AddForce, AddImpulse, AddTorque 같은 함수 호출을 통해\
힘·충격·회전력을 기반으로 자연스러운 물리 제어가 가능합니다.

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

자세히 알아보기

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

### Camera

언리얼에서는 씬 안에 여러 CameraActor를 배치해 두고, 플레이어가 바라보는 실제 시점은 PlayerCameraManager를 통해 결정됩니다. 특히 여러 개의 카메라를 미리 배치해두고 **카메라를 전환**하는 방식으로 시점을 변경할 수 있습니다.

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

자세히 알아보기

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

### Niaraga

언리얼에서는 **Niagara 시스템**을 사용해 고급 파티클 및 VFX를 구성합니다. Niagara System 안에서 여러 Emitter와 Spawn, Update, Render, Collision 등 다양한 모듈을 조합해 복잡한 이펙트를 제작할 수 있습니다.

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

자세히 알아보기

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

### UI

언리얼에서는 **UMG(User Widget)** 기반의 위젯 시스템을 사용하며, Widget Blueprint로 제작됩니다. UI 구성은 Canvas Panel, Vertical/Horizontal Box, Size Box 등 다양한 레이아웃 패널을 조합해 배치하며, 각 위젯의 위치와 크기는 앵커·정렬·오프셋으로 조정합니다.

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

자세히 알아보기

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

## 폰

언리얼에서는 게임 내에서 조작 가능한 캐릭터를 **Pawn 또는 Character 클래스**를 통해 구현합니다. Pawn은 플레이어 입력을 받을 수 있는 최소 단위의 조종 가능한 객체이며, Character는 여기에 CapsuleCollider, MovementComponent, 애니메이션, 이동 로직이 기본 포함된 확장형 클래스입니다.

반면 오버데어에서는 조작 가능한 캐릭터 개념이 **Humanoid를 포함한 Model**로 표현됩니다. Humanoid는 이동, 점프, 애니메이션, 체력 시스템 등 캐릭터가 갖는 대부분의 로직을 엔진 레벨에서 제공하며, 플레이어는 이 Humanoid가 포함된 캐릭터 모델을 자동으로 소유하게 됩니다. 이동 입력이나 카메라 제어 역시 기본적으로 Humanoid 시스템이 처리하며, 크리에이터는 Part를 추가하거나 Humanoid 속성을 수정하는 방식으로 캐릭터 동작을 확장합니다.

자세히 알아보기

{% content-ref url="/pages/gn6FTk2xMPVwXT1ozbKP" %}
[캐릭터](/korean/manual/studio-manual/character.md)
{% endcontent-ref %}

## 액터

언리얼에서는 게임 세계를 구성하는 기본 단위가 **Actor**이며, 월드에 배치되는 모든 오브젝트는 Actor를 기반으로 확장됩니다. Actor는 Transform(위치·회전·스케일)을 가지며, 여러 **컴포넌트**를 조합하여 기능을 구성하는 구조로 설계되어 있습니다.

반면 오버데어에서는 게임 오브젝트의 기본 단위가 **Part 또는 Model**로 구성됩니다. Part는 자체적으로 물리, 충돌, 렌더링 속성을 모두 포함한 기본 오브젝트이며, 언리얼처럼 컴포넌트를 조합하는 개념보다는 속성이 내장된 단일 객체에 가깝습니다. 여러 개의 Part를 묶어 기능을 구성할 때는 Model을 사용하며, 스크립트나 Attachment, Constraint 등을 추가해 동작을 확장합니다.

## Level Sequencer

언리얼에서는 **Level Sequencer**를 사용해 컷신, 카메라 연출, 애니메이션, 오브젝트 이동, 조명 변화 등 씬 전체의 타임라인 기반 연출을 구성할 수 있습니다. Sequencer는 여러 트랙을 조합해 Actor의 위치·회전, 머티리얼 파라미터, 카메라 변환, 사운드 재생까지 광범위하게 제어할 수 있으며, 복수의 오브젝트를 하나의 타임라인에서 동기화하는 **시네마틱 제작 도구**로 활용됩니다.

반면, 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# 스크립트보다 접근성과 생산성이 뛰어나며, 초보 개발자부터 숙련된 개발자까지 누구나 쉽게 활용할 수 있습니다.

### 특징

| 특징         | Unreal (C++)                             | OVERDARE (Luau)                                |
| ---------- | ---------------------------------------- | ---------------------------------------------- |
| 자료형 명시     | O                                        | X                                              |
| 한정자 종류     | private, public, static 등                | local, global                                  |
| 객체 지향(OOP) | 클래스, 인터페이스, 상속, 다형성 등을 통해 객체 지향 프로그래밍 지원 | 객체 지향을 직접적으로 지원하지 않으며, Metatable로 유사 객체 구현     |
| 코드 구조      | .h / .cpp 파일 구조, 클래스 단위 설계 필수            | 단순한 함수 기반 구조로 클래스가 없으며, Table을 통해 데이터와 함수를 구조화 |
| 함수         | 클래스 멤버 함수 중심                             | 함수를 변수처럼 사용 가능 (First-class function)          |
| Collection | TArray, TMap, TSet 등 언리얼 컨테이너 사용         | 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와 같은 클라이언트 전용 기능은 클라이언트에서만 동작하며, 게임 로직 처리나 오브젝트 이동 등 동기화가 필요한 기능은 서버에서 처리해야 합니다. 이러한 구조는 클라이언트와 서버 간 역할을 명확히 분리하여 효율적이고 안정적인 멀티플레이 동작을 보장합니다.

반면, 언리얼은 이러한 위치 기반 실행 구조를 사용하지 않습니다. 언리얼의 로직은 주로 이벤트 기반(Event-driven)으로 동작하며, BeginPlay, Input 이벤트, Delegate, Timer 등 개발자가 호출하는 순서나 이벤트 트리거에 따라 실행 흐름이 결정됩니다.

자세히 알아보기

{% 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="Unreal (C++)" %}

```cpp
#include "Example.h"

void AExample::BeginPlay()
{
    Super::BeginPlay();
    UE_LOG(LogTemp, Warning, TEXT("Hello, World!"));
}
```

{% endtab %}

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

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

{% endtab %}
{% endtabs %}

### Start Event

{% tabs %}
{% tab title="Unreal (C++)" %}

```cpp
#include "Example.h"

void AExample::BeginPlay()
{
    Super::BeginPlay();
    UE_LOG(LogTemp, Warning, TEXT("Start!"));
}
```

{% endtab %}

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

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

{% endtab %}
{% endtabs %}

### Update Event

{% tabs %}
{% tab title="Unreal (C++)" %}

```cpp
#include "Example.h"

void AExample::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);
    Timer += 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="Unreal (C++)" %}

```cpp
#include "Example.h"
#include "EngineUtils.h" 

void AExample::BeginPlay()
{
    Super::BeginPlay();

    AActor* Found = nullptr;

    for (TActorIterator<AActor> It(GetWorld()); It; ++It)
    {
        if (It->GetName() == TEXT("Orc"))
        {
            Found = *It;
            break;
        }
    }
}
```

{% endtab %}

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

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

{% endtab %}
{% endtabs %}

### Transform

{% tabs %}
{% tab title="Unreal (C++)" %}

```cpp
#include "Example.h"

void AExample::BeginPlay()
{
    Super::BeginPlay();

    SetActorLocation(FVector(500.f, 0.f, 0.f));
    SetActorRotation(FRotator(0.f, 90.f, 0.f));
    SetActorScale3D(FVector(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="Unreal (C++)" %}

```cpp
#include "Example.h"
#include "Components/BoxComponent.h"

AExample::AExample()
{
    UBoxComponent* Box = CreateDefaultSubobject<UBoxComponent>(TEXT("Box"));
    RootComponent = Box;

    Box->OnComponentHit.AddDynamic(this, &AExample::OnHit);
    Box->OnComponentBeginOverlap.AddDynamic(this, &AExample::OnBeginOverlap);
    Box->OnComponentEndOverlap.AddDynamic(this, &AExample::OnEndOverlap);
}

void AExample::OnHit(UPrimitiveComponent*, AActor* OtherActor, UPrimitiveComponent*, FVector, const FHitResult&)
{
    if (OtherActor)
    {
        UE_LOG(LogTemp, Warning, TEXT("Collision started with : %s"), *OtherActor->GetName());
    }
}

void AExample::OnBeginOverlap(UPrimitiveComponent*, AActor* OtherActor, UPrimitiveComponent*, int32, bool, const FHitResult&)
{
    if (OtherActor)
    {
        UE_LOG(LogTemp, Warning, TEXT("Collision ongoing with : %s"), *OtherActor->GetName());
    }
}

void AExample::OnEndOverlap(UPrimitiveComponent*, AActor* OtherActor, UPrimitiveComponent*, int32)
{
    if (OtherActor)
    {
        UE_LOG(LogTemp, Warning, TEXT("Collision ended with : %s"), *OtherActor->GetName());
    }
}
```

{% 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="Unreal (C++)" %}

```cpp
#include "Example.h"
#include "Engine/World.h"

void AExample::BeginPlay()
{
    Super::BeginPlay();
    
    if (!PrefabClass) return;

    FActorSpawnParameters Params;
    AActor* NewObj = GetWorld()->SpawnActor<AActor>(PrefabClass, FVector(300.f, 0.f, 0.f), FRotator::ZeroRotator, Params);

    if (!NewObj) return;

    NewObj->SetActorLabel(TEXT("NewObject"));
    NewObj->AttachToActor(this, FAttachmentTransformRules::KeepWorldTransform);
    
    NewObj->Destroy();
}
```

{% 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 %}

### SetTimer

{% tabs %}
{% tab title="Unreal (C++)" %}

```cpp
#include "Example.h"
#include "TimerManager.h"

void AExample::BeginPlay()
{
    Super::BeginPlay();

    GetWorld()->GetTimerManager().SetTimer(
        TimerHandle,
        this,
        &AExample::OnTimer,
        2.0f,
        false
    );
}

void AExample::OnTimer()
{
    UE_LOG(LogTemp, Warning, TEXT("Hello, World!"));
}
```

{% endtab %}

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

```lua
local function SomeCoroutine()
    wait(2)
    print("Hello, World!")
end

local co = coroutine.create(SomeCoroutine)
coroutine.resume(co)  
```

{% endtab %}
{% endtabs %}

## 참고 자료

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

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

## 개발지원

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


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.overdare.com/korean/manual/quick-start-guide/unreal-developer-guide.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.