---
title: ZEPETO.Character.Controller
slug: world-sdk-guide-th/ooTG-zepetocharactercontroller
docTags: 
createdAt: 2026-09-04T06:57:16.911Z
---

| ประเภท                                                           | คำอธิบาย                                                                                                                                                                |
| ---------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [ZepetoPlayers](./#zepetoplayers)                                | คลาสตัวจัดการที่ออกแบบมาเพื่อควบคุมทั้งผู้เล่น ZEPETO และตัวละคร ZEPETO                                                                                                 |
| [SpawnInfo](./#spawninfo)                                        | แทนตำแหน่งการเกิดของตัวละคร ZEPETO                                                                                                                                      |
| [ZepetoCharacter](./#zepetocharacter)                            | แทนตัวละคร ZEPETO ที่สามารถโหลดและควบคุมได้ภายใน ZEPETO World                                                                                                           |
| [CameraData](./#cameradata)                                      | แทนการตั้งค่าเริ่มต้นของ `ZepetoCamera`                                                                                                                                 |
| [CharacterData](./#characterdata)                                | แทนการตั้งค่าเริ่มต้นของ `ZepetoCharacter`                                                                                                                              |
| [ControllerData](./#controllerdata)                              | แทนการตั้งค่าของ `ZepetoPlayerControl`                                                                                                                                  |
| [FloatingUIData](./#floatinguidata)                              | คลาสที่รับผิดชอบการจัดการการตั้งค่า UI ที่เกี่ยวข้องกับตัวละคร                                                                                                          |
| [LocalPlayer](./#localplayer)                                    | คลาสที่ออกแบบมาเพื่อจัดการการกระทำของ local player รวมถึงการเคลื่อนที่ การปรับแต่งชุด และการโต้ตอบกับกล้อง ZEPETO                                                       |
| [ZepetoCamera](./#zepetocamera)                                  | คลาสควบคุมกล้องที่ออกแบบมาสำหรับใช้งานภายใน ZEPETO Character Controller                                                                                                 |
| [ZepetoPlayer](./#zepetoplayer)                                  | แทนผู้เล่น ZEPETO                                                                                                                                                       |
| [ZepetoPlayerControl](./#zepetoplayercontrol)                    | จัดการการควบคุมอินพุตสำหรับผู้เล่น ZEPETO                                                                                                                               |
| [ZepetoCameraControl](./#zepetocameracontrol)                    | จัดการการควบคุมกล้องในสภาพแวดล้อม ZEPETO รวมถึงการจัดการอินพุตสำหรับการเคลื่อนกล้องและการซูม                                                                            |
| [CharacterState](./#characterstate)                              | แทนสถานะของตัวละคร ZEPETO                                                                                                                                               |
| [CharacterMoveState](./#charactermovestate)                      | แทนสถานะการเคลื่อนที่โดยละเอียดของตัวละคร ZEPETO                                                                                                                        |
| [CharacterJumpState](./#characterjumpstate)                      | แทนสถานะการกระโดดโดยละเอียดของตัวละคร ZEPETO                                                                                                                            |
| [CharacterLandingState](./#characterlandingstate)                | แทนสถานะการลงพื้นโดยละเอียดของตัวละคร ZEPETO                                                                                                                            |
| [KnowSockets](./#knowsockets)                                    | กำหนดชุดของจุดยึดที่รู้จัก ซึ่งเรียกว่า socket บนตัวละคร                                                                                                                |
| [MotionState](./#motionstate)                                    | คลาสสำหรับจัดการสถานะและการตั้งค่าโมชันของตัวละคร                                                                                                                       |
| [CharacterStateMachine](./#characterstatemachine)                | คลาสที่รับผิดชอบการซิงโครไนซ์ animator กับสถานะตัวละครของตัวละคร ZEPETO                                                                                                 |
| [StateMachine](./#statemachine)                                  | `StateMachine` จัดการ `States` `Transitions` และ `Events` โดยการอัปเดตสถานะตามเงื่อนไขที่กำหนดและเวลาที่ผ่านไป ทำให้สามารถกำหนดและควบคุมสถานะที่หลากหลายของอ็อบเจกต์ได้ |
| [StateStatus](./#statestatus)                                    | แทนสถานะที่เป็นไปได้ของ state ภายใน state machine ซึ่งบ่งบอกช่วงปัจจุบันของวงจรชีวิตของ state นั้น                                                                      |
| [CustomMotionData](./#custommotiondata)                          | แทนการตั้งค่าที่กำหนดเองสำหรับโมชันของตัวละคร                                                                                                                           |
| [CharacterShadow](./#charactershadow)                            | คลาสที่รับผิดชอบการจัดการเงาของตัวละคร ZEPETO                                                                                                                           |
| [CameraState](./#camerastate)                                    | แทนสถานะของ `ZepetoCamera`                                                                                                                                              |
| [ZepetoScreenStick](./#zepetoscreenstick)                        | คลาสที่ออกแบบมาเพื่อจัดการการโต้ตอบด้วยสติ๊กในสภาพแวดล้อม ZEPETO                                                                                                        |
| [ZepetoScreenControl](./#zepetoscreencontrol)                    | คลาสนามธรรมที่ออกแบบมาสำหรับสร้างตัวควบคุม UI ในสภาพแวดล้อม ZEPETO                                                                                                      |
| [ZepetoScreenButton](./#zepetoscreenbutton)                      | คลาสที่ออกแบบมาเพื่อจัดการการโต้ตอบด้วยปุ่มในสภาพแวดล้อม ZEPETO                                                                                                         |
| [ZepetoScreenTouchpad](./#zepetoscreentouchpad)                  | คลาสที่ออกแบบมาเพื่อจัดการการโต้ตอบด้วยทัชแพดในสภาพแวดล้อม ZEPETO                                                                                                       |
| [UIZepetoPlayerControl](./#uizepetoplayercontrol)                | คลาสที่ให้การควบคุมตัวละครของ local player ผ่าน UI                                                                                                                      |
| [InputHelper](./#inputhelper)                                    | คลาสอรรถประโยชน์ที่ออกแบบมาเพื่อช่วยในการจัดการอินพุต                                                                                                                   |
| [EventReceiver](./#eventreceiver)                                | คลาสที่รับผิดชอบการจัดการอีเวนต์ที่เกี่ยวข้องกับตัวละครหรืออีเวนต์ทั่วไปภายใน ZEPETO World                                                                              |
| [TransitionBase](./#transitionbase)                              | คลาสพื้นฐานสำหรับกำหนดการเปลี่ยนผ่านระหว่าง state ใน state machine                                                                                                      |
| [State](./#state)                                                | แทน state หนึ่งภายใน state machine                                                                                                                                      |
| [Transition](./#transition)                                      | คลาสเจเนอริกสำหรับกำหนดการเปลี่ยนผ่านระหว่าง state ใน state machine                                                                                                     |
| [ZepetoCharacter.LoadingStatus](./#zepetocharacterloadingstatus) | สถานะการโหลดของตัวละคร ZEPETO                                                                                                                                           |
| [PlayerControlMode](./#playercontrolmode)                        | *enum*                                                                                                                                                                  |

## ZepetoPlayers

`class`

คลาสตัวจัดการที่ออกแบบมาเพื่อควบคุมทั้งผู้เล่น ZEPETO และตัวละคร ZEPETO

### พร็อพเพอร์ตี้

| ชื่อ              | ประเภท                              | คำอธิบาย                                |
| ----------------- | ----------------------------------- | --------------------------------------- |
| cameraData        | [CameraData](./#cameradata)         | การตั้งค่าของ `ZepetoCamera`            |
| characterData     | [CharacterData](./#characterdata)   | การตั้งค่าของ `ZepetoCharacter`         |
| controllerData    | [ControllerData](./#controllerdata) | การตั้งค่าของ `ZepetoPlayerControl`     |
| floatingUIData    | [FloatingUIData](./#floatinguidata) | การตั้งค่า UI ที่เกี่ยวข้องกับตัวละคร   |
| instance (static) | [ZepetoPlayers](./#zepetoplayers)   | อินสแตนซ์ singleton ของ `ZepetoPlayers` |
| LocalPlayer       | [LocalPlayer](./#localplayer)       | Local player                            |
| ZepetoCamera      | [ZepetoCamera](./#zepetocamera)     | กล้อง ZEPETO                            |

### อีเวนต์

| ชื่อ               | ประเภท               | คำอธิบาย                                                       |
| ------------------ | -------------------- | -------------------------------------------------------------- |
| OnAddedLocalPlayer | `UnityEvent`         | อีเวนต์ที่ถูกทริกเกอร์เมื่อมีการสร้างอินสแตนซ์ของ local player |
| OnAddedPlayer      | `UnityEvent<string>` | อีเวนต์ที่ถูกทริกเกอร์เมื่อมีการสร้างอินสแตนซ์ของผู้เล่น       |
| OnRemovedPlayer    | `UnityEvent<string>` | อีเวนต์ที่ถูกทริกเกอร์เมื่อมีการลบอินสแตนซ์ของผู้เล่น          |

### เมธอด

### add\_onInitialized

`static add_onInitialized(value: Action) → void`

เพิ่มฟังก์ชัน handler ให้กับอีเวนต์ที่ถูกเรียกเมื่อ `ZepetoPlayers` เริ่มต้นการทำงาน

| พารามิเตอร์ | ประเภท   |
| ----------- | -------- |
| value       | `Action` |

### remove\_onInitialized

`static remove_onInitialized(value: Action) → void`

ลบฟังก์ชัน handler ออกจากอีเวนต์ที่ถูกเรียกเมื่อ `ZepetoPlayers` เริ่มต้นการทำงาน

| พารามิเตอร์ | ประเภท   |
| ----------- | -------- |
| value       | `Action` |

### HasPlayer

`HasPlayer(id: string) → boolean`

ตรวจสอบว่ามีอินสแตนซ์ของผู้เล่นที่เชื่อมโยงกับ ID เซสชันที่ระบุอยู่หรือไม่

| พารามิเตอร์ | ประเภท   | คำอธิบาย  |
| ----------- | -------- | --------- |
| id          | `string` | ID เซสชัน |

**ค่าที่คืนกลับ:** `boolean`

### GetPlayer

`GetPlayer(id: string) → ZepetoPlayer`

ดึงอินสแตนซ์ของผู้เล่นที่เชื่อมโยงกับ ID เซสชันที่ระบุ

| พารามิเตอร์ | ประเภท   | คำอธิบาย  |
| ----------- | -------- | --------- |
| id          | `string` | ID เซสชัน |

**ค่าที่คืนกลับ:** [ZepetoPlayer](./#zepetoplayer) — อ็อบเจกต์ผู้เล่นที่เชื่อมโยงกับ ID ที่ระบุ
หากไม่มีผู้เล่นที่ตรงกับ ID ที่ระบุ จะคืนค่า `null`

### GetPlayerWithUserId

`GetPlayerWithUserId(userId: string) → ZepetoPlayer`

ดึงอินสแตนซ์ของผู้เล่นที่เชื่อมโยงกับ ID ผู้ใช้ที่ระบุ

| พารามิเตอร์ | ประเภท   | คำอธิบาย  |
| ----------- | -------- | --------- |
| userId      | `string` | ID ผู้ใช้ |

**ค่าที่คืนกลับ:** [ZepetoPlayer](./#zepetoplayer) — อ็อบเจกต์ผู้เล่นที่เชื่อมโยงกับ ID ผู้ใช้ที่ระบุ

### RemovePlayer

`RemovePlayer(id: string) → void`

ลบอินสแตนซ์ของผู้เล่นที่เชื่อมโยงกับ ID เซสชันที่ระบุ

| พารามิเตอร์ | ประเภท   | คำอธิบาย  |
| ----------- | -------- | --------- |
| id          | `string` | ID เซสชัน |

### DeformDefaultCostume

`DeformDefaultCostume() → void`

ลบไอเทมปรับรูปร่างที่ตัวละครของผู้เล่นทุกคนสวมใส่อยู่
คืนค่ากลับเป็นรูปร่างเริ่มต้นและใช้ชุด ZEPETO เริ่มต้น

### DeformDefaultProperties

`DeformDefaultProperties() → void`

ลบไอเทมปรับรูปร่างที่ตัวละครของผู้เล่นทุกคนสวมใส่อยู่

## SpawnInfo

`class`

แทนตำแหน่งการเกิดของตัวละคร ZEPETO

### พร็อพเพอร์ตี้

| ชื่อ             | ประเภท                    | คำอธิบาย                           |
| ---------------- | ------------------------- | ---------------------------------- |
| Default (static) | [SpawnInfo](./#spawninfo) | ตำแหน่งการเกิดเริ่มต้น             |
| position         | `Vector3`                 | ตำแหน่งของตัวละคร ZEPETO เมื่อเกิด |
| rotation         | `Quaternion`              | การหมุนของตัวละคร ZEPETO เมื่อเกิด |

## ZepetoCharacter

`class`

แทนตัวละคร ZEPETO ที่สามารถโหลดและควบคุมได้ภายใน ZEPETO World

### พร็อพเพอร์ตี้

| ชื่อ                | ประเภท                                            | คำอธิบาย                                                                          |
| ------------------- | ------------------------------------------------- | --------------------------------------------------------------------------------- |
| additionalWalkSpeed | `number`                                          | ดึงค่าความเร็วการเดินที่เพิ่มเข้ามา                                               |
| additionalRunSpeed  | `number`                                          | ดึงค่าความเร็วการวิ่งที่เพิ่มเข้ามา                                               |
| additionalJumpPower | `number`                                          | ดึงค่าแรงกระโดดที่เพิ่มเข้ามา                                                     |
| constraintRotation  | `boolean`                                         | กำหนดว่าการหมุนของตัวละครถูกจำกัดหรือไม่                                          |
| ZepetoAnimator      | `Animator`                                        | Animator ของตัวละคร ZEPETO                                                        |
| WalkSpeed           | `number`                                          | ดึงค่าความเร็วการเดินรวม ซึ่งเป็นผลรวมของความเร็วพื้นฐานและความเร็วที่เพิ่มเข้ามา |
| RunSpeed            | `number`                                          | ดึงค่าความเร็วการวิ่งรวม ซึ่งเป็นผลรวมของความเร็วพื้นฐานและความเร็วที่เพิ่มเข้ามา |
| JumpPower           | `number`                                          | ดึงค่าแรงกระโดดรวม ซึ่งเป็นผลรวมของแรงพื้นฐานและแรงที่เพิ่มเข้ามา                 |
| baseWalkSpeed       | `number`                                          | ดึงค่าความเร็วการเดินพื้นฐาน                                                      |
| baseRunSpeed        | `number`                                          | ดึงค่าความเร็วการวิ่งพื้นฐาน                                                      |
| baseJumpPower       | `number`                                          | ดึงค่าแรงกระโดดพื้นฐาน                                                            |
| tryMove             | `boolean`                                         | ระบุว่าตัวละครกำลังพยายามเคลื่อนที่หรือไม่                                        |
| tryJump             | `boolean`                                         | ระบุว่าตัวละครกำลังพยายามกระโดดหรือไม่                                            |
| tryDoubleJump       | `boolean`                                         | ระบุว่าตัวละครกำลังพยายามกระโดดสองชั้นหรือไม่                                     |
| motionState         | [MotionState](./#motionstate)                     | สถานะและการตั้งค่าโมชันของตัวละคร                                                 |
| loadingStatus       | [LoadingStatus](./#zepetocharacterloadingstatus)  | สถานะการโหลดของตัวละคร                                                            |
| Context             | `ZepetoContext`                                   | ZEPETO Context ของตัวละคร                                                         |
| StateMachine        | [CharacterStateMachine](./#characterstatemachine) | State machine ของตัวละคร                                                          |
| CurrentState        | [CharacterState](./#characterstate)               | สถานะปัจจุบันของตัวละครที่กำหนดไว้ใน state machine                                |
| CurrentStateStatus  | [StateStatus](./#statestatus)                     | สถานะย่อยของ state ปัจจุบันของตัวละคร ซึ่งกำหนดไว้ใน state machine                |
| ElapsedTime         | `number`                                          | เวลาที่ผ่านไปเป็นวินาทีนับตั้งแต่ตัวละครเริ่มต้นการทำงาน                          |

### อีเวนต์

| ชื่อ           | ประเภท                                       | คำอธิบาย                                                                                                                                                                                              |
| -------------- | -------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| OnChangedState | `UnityEvent<CharacterState, CharacterState>` | อีเวนต์ที่ถูกทริกเกอร์เมื่อสถานะตัวละครเปลี่ยนแปลง listener ที่ลงทะเบียนไว้จะได้รับพารามิเตอร์สองตัว: - สถานะตัวละครใหม่ (ประเภท: `CharacterState`) - สถานะตัวละครก่อนหน้า (ประเภท: `CharacterState`) |
| OnUpdateState  | `UnityEvent<CharacterState>`                 | อีเวนต์ที่ถูกทริกเกอร์เมื่อสถานะตัวละครอยู่ในสถานะ `StateStatus.Update` listener ที่ลงทะเบียนไว้จะได้รับพารามิเตอร์หนึ่งตัว: - สถานะตัวละครปัจจุบัน (ประเภท: `CharacterState`)                        |

### เมธอด

### SyncStateAnimation

`SyncStateAnimation() → void`

ซิงโครไนซ์ animator กับสถานะปัจจุบันของตัวละคร ZEPETO

### ChangeStateAnimation

`ChangeStateAnimation(state: CharacterState) → void`

เล่นแอนิเมชันที่เชื่อมโยงกับสถานะตัวละครที่ให้มาบน animator

| พารามิเตอร์ | ประเภท                              | คำอธิบาย                             |
| ----------- | ----------------------------------- | ------------------------------------ |
| state       | [CharacterState](./#characterstate) | สถานะตัวละครที่แทนแอนิเมชันที่จะเล่น |

### ChangeStateAnimation

`ChangeStateAnimation(state: CharacterState, moveState: CharacterMoveState) → void`

เล่นแอนิเมชันที่เชื่อมโยงกับสถานะตัวละครที่ให้มาบน animator

| พารามิเตอร์ | ประเภท                                      | คำอธิบาย                                                                              |
| ----------- | ------------------------------------------- | ------------------------------------------------------------------------------------- |
| state       | [CharacterState](./#characterstate)         | สถานะตัวละครที่แทนแอนิเมชันที่จะเล่น                                                  |
| moveState   | [CharacterMoveState](./#charactermovestate) | สถานะการเคลื่อนที่สำหรับแอนิเมชันเมื่อ `state` เป็น `CharacterState.Move` (ไม่บังคับ) |

### ChangeStateAnimation

`ChangeStateAnimation(state: CharacterState, jumpState: CharacterJumpState) → void`

เล่นแอนิเมชันที่เชื่อมโยงกับสถานะตัวละครที่ให้มาบน animator

| พารามิเตอร์ | ประเภท                                      | คำอธิบาย                                                                          |
| ----------- | ------------------------------------------- | --------------------------------------------------------------------------------- |
| state       | [CharacterState](./#characterstate)         | สถานะตัวละครที่แทนแอนิเมชันที่จะเล่น                                              |
| jumpState   | [CharacterJumpState](./#characterjumpstate) | สถานะการกระโดดสำหรับแอนิเมชันเมื่อ `state` เป็น `CharacterState.Jump` (ไม่บังคับ) |

### ChangeStateAnimation

`ChangeStateAnimation(state: CharacterState, landingState: CharacterLandingState) → void`

เล่นแอนิเมชันที่เชื่อมโยงกับสถานะตัวละครที่ให้มาบน animator

| พารามิเตอร์  | ประเภท                                            | คำอธิบาย                                                                             |
| ------------ | ------------------------------------------------- | ------------------------------------------------------------------------------------ |
| state        | [CharacterState](./#characterstate)               | สถานะตัวละครที่แทนแอนิเมชันที่จะเล่น                                                 |
| landingState | [CharacterLandingState](./#characterlandingstate) | สถานะการลงพื้นสำหรับแอนิเมชันเมื่อ `state` เป็น `CharacterState.Landing` (ไม่บังคับ) |

### Move

`Move(dir: Vector2) → void`

เคลื่อนที่ตัวละครไปในทิศทางที่ระบุ

| พารามิเตอร์ | ประเภท    | คำอธิบาย                        |
| ----------- | --------- | ------------------------------- |
| dir         | `Vector2` | ทิศทางที่ตัวละครควรเคลื่อนที่ไป |

### Move

`Move(dir: Vector3) → void`

เคลื่อนที่ตัวละครไปในทิศทางที่ระบุ

| พารามิเตอร์ | ประเภท    | คำอธิบาย                        |
| ----------- | --------- | ------------------------------- |
| dir         | `Vector3` | ทิศทางที่ตัวละครควรเคลื่อนที่ไป |

### MoveContinuously

`MoveContinuously(dir: Vector2) → void`

เคลื่อนที่ตัวละครอย่างต่อเนื่องไปในทิศทางที่กำหนด โดยอิงจากทิศที่ตัวละครหันหน้าอยู่ในปัจจุบัน

| พารามิเตอร์ | ประเภท    | คำอธิบาย                                                                    |
| ----------- | --------- | --------------------------------------------------------------------------- |
| dir         | `Vector2` | ทิศทางที่ตัวละครควรเคลื่อนที่ไป โดยอิงจากทิศที่ตัวละครหันหน้าอยู่ในปัจจุบัน |

### MoveContinuously

`MoveContinuously(dir: Vector3) → void`

เคลื่อนที่ตัวละครอย่างต่อเนื่องไปในทิศทางที่กำหนด โดยอิงจากทิศที่ตัวละครหันหน้าอยู่ในปัจจุบัน

| พารามิเตอร์ | ประเภท    | คำอธิบาย                                                                    |
| ----------- | --------- | --------------------------------------------------------------------------- |
| dir         | `Vector3` | ทิศทางที่ตัวละครควรเคลื่อนที่ไป โดยอิงจากทิศที่ตัวละครหันหน้าอยู่ในปัจจุบัน |

### MoveToPosition

`MoveToPosition(pos: Vector3) → void`

เคลื่อนที่ตัวละครไปยังตำแหน่งที่ระบุ

| พารามิเตอร์ | ประเภท    | คำอธิบาย                         |
| ----------- | --------- | -------------------------------- |
| pos         | `Vector3` | ปลายทางที่ตัวละครควรเคลื่อนที่ไป |

### StopMoving

`StopMoving() → void`

หยุดการเคลื่อนที่ของตัวละคร

### Jump

`Jump() → void`

ทำให้ตัวละครกระโดด

### DoubleJump

`DoubleJump() → void`

ทำให้ตัวละครกระโดดสองชั้น

### Teleport

`Teleport(pos: Vector3, rot: Quaternion) → void`

ย้ายตัวละครไปยัง transform ที่ระบุในทันที

| พารามิเตอร์ | ประเภท       | คำอธิบาย                          |
| ----------- | ------------ | --------------------------------- |
| pos         | `Vector3`    | ตำแหน่งที่ตัวละครจะถูกเทเลพอร์ตไป |
| rot         | `Quaternion` | การหมุนของตัวละครหลังจากเทเลพอร์ต |

### SetGesture

`SetGesture(gesture: AnimationClip) → void`

เล่นโมชันของตัวละครสำหรับท่าทางที่ระบุ

| พารามิเตอร์ | ประเภท          | คำอธิบาย               |
| ----------- | --------------- | ---------------------- |
| gesture     | `AnimationClip` | ท่าทางที่ตัวละครจะแสดง |

### CancelGesture

`CancelGesture() → void`

หยุดการเล่นท่าทาง

### GetSocket

`GetSocket(socket: KnowSockets) → Transform`

ดึง `Transform` ของ socket บนตัวละคร

| พารามิเตอร์ | ประเภท                        | คำอธิบาย        |
| ----------- | ----------------------------- | --------------- |
| socket      | [KnowSockets](./#knowsockets) | Socket (จุดยึด) |

**ค่าที่คืนกลับ:** `Transform` — คอมโพเนนต์ `Transform` ที่เชื่อมโยงกับ socket ที่ระบุ

### GetSocket

`GetSocket(socket: string) → Transform`

ดึง `Transform` ของ socket บนตัวละคร

| พารามิเตอร์ | ประเภท   | คำอธิบาย                |
| ----------- | -------- | ----------------------- |
| socket      | `string` | ชื่อของ socket (จุดยึด) |

**ค่าที่คืนกลับ:** `Transform` — คอมโพเนนต์ `Transform` ที่เชื่อมโยงกับ socket ที่ระบุ

### GetBodyModifierProperties

`GetBodyModifierProperties() → ZepetoPropertyFlag[]`

ดึงพร็อพเพอร์ตี้ของตัวละครที่เชื่อมโยงกับไอเทมปรับรูปร่างที่ตัวละครสวมใส่อยู่

**ค่าที่คืนกลับ:** `ZepetoPropertyFlag[]` — พร็อพเพอร์ตี้ของตัวละครที่เชื่อมโยงกับไอเทมปรับรูปร่างที่ตัวละครสวมใส่อยู่

### DeformDefaultProperties

`DeformDefaultProperties() → void`

ลบไอเทมปรับรูปร่างที่ตัวละครสวมใส่อยู่ และคืนค่ากลับเป็นรูปร่างเริ่มต้น

### DeformDefaultCostume

`DeformDefaultCostume() → void`

ลบไอเทมปรับรูปร่างที่ตัวละครสวมใส่อยู่ คืนค่ากลับเป็นรูปร่างเริ่มต้น และใช้ชุด ZEPETO เริ่มต้น

### add\_loadedCharacter

`add_loadedCharacter(value: Action) → void`

เพิ่มฟังก์ชัน callback เพื่อจัดการเมื่อการโหลดตัวละครเสร็จสิ้น

| พารามิเตอร์ | ประเภท   |
| ----------- | -------- |
| value       | `Action` |

### remove\_loadedCharacter

`remove_loadedCharacter(value: Action) → void`

ลบฟังก์ชัน callback ที่ใช้จัดการเมื่อการโหลดตัวละครเสร็จสิ้น

| พารามิเตอร์ | ประเภท   |
| ----------- | -------- |
| value       | `Action` |

## CameraData

`class`

แทนการตั้งค่าเริ่มต้นของ `ZepetoCamera`

### พร็อพเพอร์ตี้

| ชื่อ                   | ประเภท       | คำอธิบาย                                                                                       |
| ---------------------- | ------------ | ---------------------------------------------------------------------------------------------- |
| cameraPrefab           | `GameObject` | พรีแฟบสำหรับเริ่มต้น `ZepetoCamera`                                                            |
| maxZoomDistance        | `number`     | ระยะสูงสุดเริ่มต้นที่กล้องสามารถซูมออกจากเป้าหมายได้                                           |
| minZoomDistance        | `number`     | ระยะต่ำสุดเริ่มต้นที่กล้องสามารถซูมเข้าหาเป้าหมายได้                                           |
| maxPitch               | `number`     | มุมแนวตั้งสูงสุดที่กล้องหมุนรอบเป้าหมาย                                                        |
| minPitch               | `number`     | มุมแนวตั้งต่ำสุดที่กล้องหมุนรอบเป้าหมาย                                                        |
| offset                 | `Vector3`    | ออฟเซ็ตเริ่มต้นของกล้องเทียบกับเป้าหมาย                                                        |
| lockXAxis              | `boolean`    | ระบุว่าการหมุนของกล้องในแกน X ถูกล็อกหรือไม่                                                   |
| layer                  | `LayerMask`  | กำหนดเลเยอร์ที่กล้องสามารถชนได้                                                                |
| collisionTimeThreshold | `number`     | ค่าเกณฑ์เวลาสำหรับการตรวจจับการชนของกล้อง ซึ่งมีผลต่อความเร็วในการตอบสนองต่อการชน              |
| zoomSpeed              | `number`     | ความเร็วในการซูมเข้าและซูมออก                                                                  |
| zoomDampSpeed          | `number`     | ความเร็วการอินเทอร์โพเลตสำหรับการซูมเข้าและซูมออก                                              |
| rotationSpeed          | `number`     | ความเร็วในการหมุน                                                                              |
| rotationDampSpeed      | `number`     | ความเร็วการอินเทอร์โพเลตสำหรับการหมุน                                                          |
| characterCulling       | `boolean`    | ระบุว่าจะเปิดใช้งาน character culling เพื่อป้องกันปัญหาการเรนเดอร์เมื่อกล้องอยู่ใกล้มากหรือไม่ |
| targetScaleWeight      | `number`     | ค่าน้ำหนักที่ใช้กับสเกลของเป้าหมาย เพื่อปรับตำแหน่งและพฤติกรรมของกล้อง                         |

## CharacterData

`class`

แทนการตั้งค่าเริ่มต้นของ `ZepetoCharacter`

### พร็อพเพอร์ตี้

| ชื่อ               | ประเภท                                  | คำอธิบาย                                                                              |
| ------------------ | --------------------------------------- | ------------------------------------------------------------------------------------- |
| slopeLimit         | `number`                                | ความชันสูงสุดที่ตัวละครสามารถปีนขึ้นได้                                               |
| stepOffset         | `number`                                | ความต่างของระดับความสูงในแนวตั้งสูงสุดที่ตัวละครสามารถข้ามได้                         |
| skinWidth          | `number`                                | ความหนา skin สำหรับการตรวจจับการชน ซึ่งป้องกันไม่ให้ตัวละครทะลุเข้าไปใน collider อื่น |
| minMoveDistance    | `number`                                | ช่องว่างที่เล็กที่สุดที่ตัวละครสามารถเคลื่อนที่ผ่านได้                                |
| center             | `Vector3`                               | จุดศูนย์กลางของ collider ของตัวละคร                                                   |
| radius             | `number`                                | รัศมีของแคปซูล collider ของตัวละคร                                                    |
| height             | `number`                                | ความสูงของแคปซูล collider ของตัวละคร                                                  |
| layer              | `LayerMask`                             | กำหนดเลเยอร์ที่ตัวละครสามารถชนได้                                                     |
| shadow             | `GameObject`                            | การแสดงผลเชิงภาพของเงาตัวละคร                                                         |
| animatorController | `RuntimeAnimatorController`             | Animator controller ของตัวละคร                                                        |
| walkSpeed          | `number`                                | ความเร็วการเดินของตัวละคร                                                             |
| runSpeed           | `number`                                | ความเร็วการวิ่งของตัวละคร                                                             |
| jumpPower          | `number`                                | แรงกระโดดของตัวละคร                                                                   |
| customMotionData   | [CustomMotionData](./#custommotiondata) | การตั้งค่าที่กำหนดเองสำหรับโมชันของตัวละคร                                            |

## ControllerData

`class`

แทนการตั้งค่าของ `ZepetoPlayerControl`

### พร็อพเพอร์ตี้

| ชื่อ                        | ประเภท             | คำอธิบาย                                                                                                     |
| --------------------------- | ------------------ | ------------------------------------------------------------------------------------------------------------ |
| inputAsset                  | `InputActionAsset` | คอนเทนเนอร์สำหรับ input action และ binding ที่ใช้จัดการการตั้งค่าอินพุตที่ซับซ้อน                            |
| eventSystem                 | `GameObject`       | ประมวลผลอินพุตของผู้ใช้และส่งต่อไปยังคอมโพเนนต์ UI โดยจัดการการโต้ตอบ เช่น การคลิกปุ่ม การลาก การวาง เป็นต้น |
| useDefaultVirtualController | `boolean`          | กำหนดว่าจะใช้ V-Pad เริ่มต้นหรือไม่                                                                          |
| useDefaultInputController   | `boolean`          | กำหนดว่าจะใช้ input controller เริ่มต้นหรือไม่                                                               |
| verticalController          | `GameObject`       | พรีแฟบ V-pad controller สำหรับการวางแนวหน้าจอแนวตั้ง                                                         |
| horizontalController        | `GameObject`       | พรีแฟบ V-pad controller สำหรับการวางแนวหน้าจอแนวนอน                                                          |

## FloatingUIData

`class`

คลาสที่รับผิดชอบการจัดการการตั้งค่า UI ที่เกี่ยวข้องกับตัวละคร

### พร็อพเพอร์ตี้

| ชื่อ                       | ประเภท    | คำอธิบาย                                                       |
| -------------------------- | --------- | -------------------------------------------------------------- |
| showNickNameLocalPlayer    | `boolean` | กำหนดว่าจะแสดง UI ชื่อเล่นของตัวละคร local player หรือไม่      |
| showNickNameOtherPlayers   | `boolean` | กำหนดว่าจะแสดง UI ชื่อเล่นของตัวละครผู้เล่นคนอื่นหรือไม่       |
| showBubbleChatLocalPlayer  | `boolean` | กำหนดว่าจะแสดง UI แชทบับเบิลของตัวละคร local player หรือไม่    |
| showBubbleChatOtherPlayers | `boolean` | กำหนดว่าจะแสดง UI แชทบับเบิลของตัวละครผู้เล่นคนอื่นหรือไม่     |
| useMiniProfileOnApp        | `boolean` | กำหนดว่าจะแสดง UI ป๊อปอัปมินิโปรไฟล์เมื่อคลิกที่ตัวละครหรือไม่ |

## LocalPlayer

`class`

คลาสที่ออกแบบมาเพื่อจัดการการกระทำของ local player รวมถึงการเคลื่อนที่ การปรับแต่งชุด และการโต้ตอบกับกล้อง ZEPETO

### พร็อพเพอร์ตี้

| ชื่อ         | ประเภท                          | คำอธิบาย                                               |
| ------------ | ------------------------------- | ------------------------------------------------------ |
| movingAxis   | `Transform`                     | แกนกลางการเคลื่อนที่ของตัวละคร ZEPETO ของ local player |
| zepetoCamera | [ZepetoCamera](./#zepetocamera) | อินสแตนซ์กล้อง ZEPETO ที่เชื่อมโยงกับ local player     |
| zepetoPlayer | [ZepetoPlayer](./#zepetoplayer) | อินสแตนซ์ผู้เล่น ZEPETO ที่เชื่อมโยงกับ local player   |

### เมธอด

### SetCostume

`SetCostume(itemCode: string, complete?: Action) → void`

เปลี่ยนชุดของตัวละคร ZEPETO ของ local player โดยจะโยน `Exception` ทั่วไป

| พารามิเตอร์          | ประเภท   | คำอธิบาย                                              |
| -------------------- | -------- | ----------------------------------------------------- |
| itemCode             | `string` | ID ไอเทมของชุด                                        |
| complete (ไม่บังคับ) | `Action` | ฟังก์ชัน callback สำหรับจัดการเมื่อดำเนินการเสร็จสิ้น |

### Jump

`Jump() → void`

ทำให้ตัวละคร ZEPETO ของ local player กระโดด

### DoubleJump

`DoubleJump() → void`

ทำให้ตัวละคร ZEPETO ของ local player กระโดดสองชั้น

### Move

`Move(dir: Vector2) → void`

เคลื่อนที่ตัวละคร ZEPETO ของ local player ไปในทิศทางที่ระบุ

| พารามิเตอร์ | ประเภท    | คำอธิบาย                        |
| ----------- | --------- | ------------------------------- |
| dir         | `Vector2` | ทิศทางที่ตัวละครควรเคลื่อนที่ไป |

### Move

`Move(dir: Vector3) → void`

เคลื่อนที่ตัวละคร ZEPETO ของ local player ไปในทิศทางที่ระบุ

| พารามิเตอร์ | ประเภท    | คำอธิบาย                        |
| ----------- | --------- | ------------------------------- |
| dir         | `Vector3` | ทิศทางที่ตัวละครควรเคลื่อนที่ไป |

### StopMoving

`StopMoving() → void`

หยุดตัวละคร ZEPETO ของ local player

## ZepetoCamera

`class`

คลาสควบคุมกล้องที่ออกแบบมาสำหรับใช้งานภายใน ZEPETO Character Controller

### พร็อพเพอร์ตี้

| ชื่อ                      | ประเภท                                        | คำอธิบาย                                                                                       |
| ------------------------- | --------------------------------------------- | ---------------------------------------------------------------------------------------------- |
| additionalMaxZoomDistance | `number`                                      | ระยะเพิ่มเติมที่บวกเข้ากับค่าซูมสูงสุดเริ่มต้น                                                 |
| additionalMinZoomDistance | `number`                                      | ระยะเพิ่มเติมที่บวกเข้ากับค่าซูมต่ำสุดเริ่มต้น                                                 |
| additionalOffset          | `Vector3`                                     | ออฟเซ็ตเพิ่มเติมที่ใช้กับตำแหน่งของกล้องเทียบกับเป้าหมาย                                       |
| currentState              | [CameraState](./#camerastate)                 | ดึงสถานะปัจจุบันของกล้อง                                                                       |
| currentStateStatus        | [StateStatus](./#statestatus)                 | ดึงสถานะย่อยของ state กล้องปัจจุบัน                                                            |
| position                  | `Vector3`                                     | ดึงค่าตำแหน่งปัจจุบันของกล้อง                                                                  |
| rotation                  | `Quaternion`                                  | ดึงค่าการหมุนปัจจุบันของกล้อง                                                                  |
| distance                  | `number`                                      | ระยะห่างจากเป้าหมาย                                                                            |
| cameraParent              | `Transform`                                   | `Transform` ของอ็อบเจกต์แม่ของกล้อง                                                            |
| isFollow                  | `boolean`                                     | ดึงแฟล็กที่ระบุว่ากล้องกำลังติดตามเป้าหมายอยู่หรือไม่                                          |
| StateMachine              | [StateMachine\<CameraState>](./#statemachine) | ดึง state machine ของกล้อง                                                                     |
| FollowTarget              | `Transform`                                   | ดึง `Transform` ของเป้าหมาย โดยค่าเริ่มต้นจะถูกกำหนดเป็น `HEAD_UPPER` ของตัวละคร local player  |
| MaxZoomDistance           | `number`                                      | ระยะสูงสุดที่คำนวณได้ซึ่งกล้องสามารถซูมออกจากเป้าหมาย                                          |
| MinZoomDistance           | `number`                                      | ระยะต่ำสุดที่คำนวณได้ซึ่งกล้องสามารถซูมเข้าหาเป้าหมาย                                          |
| LookOffset                | `Vector3`                                     | ออฟเซ็ตที่คำนวณได้ของกล้องเทียบกับเป้าหมาย                                                     |
| LockXAxis                 | `boolean`                                     | ระบุว่าการหมุนของกล้องในแกน X ถูกล็อกหรือไม่                                                   |
| CollisionLayer            | `LayerMask`                                   | กำหนดเลเยอร์ที่กล้องสามารถชนได้                                                                |
| targetScaleWeight         | `number`                                      | ค่าน้ำหนักที่ใช้กับสเกลของเป้าหมาย เพื่อปรับตำแหน่งและพฤติกรรมของกล้อง                         |
| useCharacterCulling       | `boolean`                                     | ระบุว่าจะเปิดใช้งาน character culling เพื่อป้องกันปัญหาการเรนเดอร์เมื่อกล้องอยู่ใกล้มากหรือไม่ |
| zoomSpeed                 | `number`                                      | ความเร็วในการซูมเข้าและซูมออก                                                                  |
| zoomDampSpeed             | `number`                                      | ความเร็วการอินเทอร์โพเลตสำหรับการซูมเข้าและซูมออก                                              |
| rotationSpeed             | `number`                                      | ความเร็วในการหมุน                                                                              |
| rotationDampSpeed         | `number`                                      | ความเร็วการอินเทอร์โพเลตสำหรับการหมุน                                                          |
| camera                    | `Camera`                                      | `Camera` ของ Unity                                                                             |

### อีเวนต์

| ชื่อ           | ประเภท                                 | คำอธิบาย                                                                                                                                                                                  |
| -------------- | -------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| OnChangedState | `UnityEvent<CameraState, CameraState>` | อีเวนต์ที่ถูกทริกเกอร์เมื่อสถานะกล้องเปลี่ยนแปลง listener ที่ลงทะเบียนไว้จะได้รับพารามิเตอร์สองตัว: - สถานะกล้องใหม่ (ประเภท: `CameraState`) - สถานะกล้องก่อนหน้า (ประเภท: `CameraState`) |
| OnUpdateState  | `UnityEvent<CameraState>`              | อีเวนต์ที่ถูกทริกเกอร์เมื่อสถานะกล้องปัจจุบันอยู่ในสถานะ `StateStatus.Update` listener ที่ลงทะเบียนไว้จะได้รับพารามิเตอร์หนึ่งตัว: - สถานะกล้องปัจจุบัน (ประเภท: `CameraState`)           |

### เมธอด

### Create

`static Create(camera: Camera, data: CameraData) → ZepetoCamera`

สร้างอินสแตนซ์ `ZepetoCamera`

| พารามิเตอร์ | ประเภท                      | คำอธิบาย                                                           |
| ----------- | --------------------------- | ------------------------------------------------------------------ |
| camera      | `Camera`                    | อ็อบเจกต์ `Camera` ของ Unity ที่จะใช้เป็นพื้นฐานของ `ZepetoCamera` |
| data        | [CameraData](./#cameradata) | การตั้งค่าเริ่มต้นสำหรับ `ZepetoCamera`                            |

**ค่าที่คืนกลับ:** [ZepetoCamera](./#zepetocamera) — อินสแตนซ์ใหม่ของ `ZepetoCamera`

### SetFollowTarget

`SetFollowTarget(target: Transform, scaleReference?: Transform) → void`

กำหนดเป้าหมายที่กล้องจะติดตาม

| พารามิเตอร์                | ประเภท      | คำอธิบาย                                                                                                                                      |
| -------------------------- | ----------- | --------------------------------------------------------------------------------------------------------------------------------------------- |
| target                     | `Transform` | `Transform` ที่แทนอ็อบเจกต์ที่กล้องควรติดตาม                                                                                                  |
| scaleReference (ไม่บังคับ) | `Transform` | `Transform` ที่ใช้เป็นข้อมูลอ้างอิงในการปรับสเกลพฤติกรรมการติดตามของกล้อง หากระบุไว้ กล้องจะปรับระยะห่างจากเป้าหมายตามสเกลของข้อมูลอ้างอิงนี้ |

### Rotate

`Rotate(delta: Vector2) → void`

หมุนกล้อง

| พารามิเตอร์ | ประเภท    | คำอธิบาย      |
| ----------- | --------- | ------------- |
| delta       | `Vector2` | ปริมาณการหมุน |

### DoZoom

`DoZoom(delta: number) → void`

ซูมกล้อง

| พารามิเตอร์ | ประเภท   | คำอธิบาย     |
| ----------- | -------- | ------------ |
| delta       | `number` | ปริมาณการซูม |

## ZepetoPlayer

`class`

แทนผู้เล่น ZEPETO

### พร็อพเพอร์ตี้

| ชื่อ          | ประเภท                                | คำอธิบาย                                                                   |
| ------------- | ------------------------------------- | -------------------------------------------------------------------------- |
| userId        | `string`                              | ID ผู้ใช้ของผู้เล่น ซึ่งเป็น ID สุ่มที่ไม่ซ้ำกันและกำหนดให้เมื่อสร้างบัญชี |
| name          | `string`                              | ชื่อผู้ใช้ของผู้เล่น ซึ่งผู้ใช้กำหนดไว้ในแอป ZEPETO                        |
| character     | [ZepetoCharacter](./#zepetocharacter) | ตัวละคร ZEPETO ของผู้เล่น                                                  |
| isLocalPlayer | `boolean`                             | ระบุว่าเป็น local player หรือไม่                                           |

### เมธอด

### GetProfileTextureAsync

`GetProfileTextureAsync(complete: Action<Texture2D>) → void`

ดึงภาพโปรไฟล์ของผู้เล่น โดยจะโยน `Exception` ทั่วไป

| พารามิเตอร์ | ประเภท              | คำอธิบาย                                         |
| ----------- | ------------------- | ------------------------------------------------ |
| complete    | `Action<Texture2D>` | ฟังก์ชัน callback สำหรับจัดการภาพโปรไฟล์ที่ดึงมา |

### Release

`Release() → void`

ปล่อยอ็อบเจกต์ผู้เล่น ZEPETO

## ZepetoPlayerControl

`class`

จัดการการควบคุมอินพุตสำหรับผู้เล่น ZEPETO

### เมธอด

### Create

`static Create(playerActions: PlayerActions) → ZepetoPlayerControl`

สร้างอินสแตนซ์ `ZepetoPlayerControl`

| พารามิเตอร์   | ประเภท          | คำอธิบาย                                                    |
| ------------- | --------------- | ----------------------------------------------------------- |
| playerActions | `PlayerActions` | ชุดของ input action ที่จะเชื่อมโยงกับ `ZepetoPlayerControl` |

**ค่าที่คืนกลับ:** [ZepetoPlayerControl](./#zepetoplayercontrol) — อินสแตนซ์ใหม่ของ `ZepetoPlayerControl`
อินสแตนซ์จะถูกแนบกับเกมอ็อบเจกต์ใหม่และพร้อมจัดการ input action ของผู้เล่น

## ZepetoCameraControl

`class`

จัดการการควบคุมกล้องในสภาพแวดล้อม ZEPETO รวมถึงการจัดการอินพุตสำหรับการเคลื่อนกล้องและการซูม

### เมธอด

### Create

`static Create(cameraActions: CameraActions) → ZepetoCameraControl`

สร้างอินสแตนซ์ `ZepetoCameraControl`

| พารามิเตอร์   | ประเภท          | คำอธิบาย                                                                                                                       |
| ------------- | --------------- | ------------------------------------------------------------------------------------------------------------------------------ |
| cameraActions | `CameraActions` | ชุดของ camera action ที่จะเชื่อมโยงกับ `ZepetoCameraControl` โดยแอ็กชันเหล่านี้กำหนดว่ากล้องจะตอบสนองต่ออินพุตของผู้ใช้อย่างไร |

**ค่าที่คืนกลับ:** [ZepetoCameraControl](./#zepetocameracontrol) — อินสแตนซ์ใหม่ของ `ZepetoCameraControl`
อินสแตนซ์จะถูกแนบกับเกมอ็อบเจกต์ใหม่และพร้อมจัดการ input action ของกล้อง

## CharacterState

`enum`

แทนสถานะของตัวละคร ZEPETO

| ชื่อ     | ค่า | คำอธิบาย                                                                           |
| -------- | --- | ---------------------------------------------------------------------------------- |
| Invalid  | 0   | ยังไม่ถูกเริ่มต้นหรือไม่ถูกต้อง                                                    |
| Idle     | 1   | ตัวละครไม่ได้เคลื่อนที่หรือทำการกระทำใด ๆ                                          |
| Walk     | 2   | ตัวละครกำลังเคลื่อนที่อย่างช้า ๆ                                                   |
| Run      | 3   | ตัวละครกำลังเคลื่อนที่อย่างรวดเร็ว                                                 |
| JumpIdle | 4   | ตัวละครกำลังกระโดดอยู่กับที่                                                       |
| JumpMove | 5   | ตัวละครกำลังกระโดดไปในทิศทางหนึ่ง โดยผสมการกระโดดแนวตั้งเข้ากับการเคลื่อนที่แนวนอน |
| Teleport | 20  | ตัวละครกำลังย้ายจากตำแหน่งหนึ่งไปยังอีกตำแหน่งหนึ่งโดยไม่ผ่านพื้นที่ระหว่างกลาง    |
| Gesture  | 30  | ตัวละครกำลังแสดงท่าทาง                                                             |
| Move     | 102 | สถานะการเคลื่อนที่ทั่วไป                                                           |
| MoveTurn | 103 | ตัวละครกำลังเปลี่ยนทิศทางการเคลื่อนที่                                             |
| Jump     | 104 | สถานะการกระโดดทั่วไป                                                               |
| Stamp    | 106 | ตัวละครกำลังกระทืบเท้า                                                             |
| Falling  | 108 | ตัวละครกำลังตกอย่างอิสระ                                                           |
| Landing  | 109 | ตัวละครกำลังกลับลงสู่พื้นหลังจากตกลงมา                                             |

## CharacterMoveState

`enum`

แทนสถานะการเคลื่อนที่โดยละเอียดของตัวละคร ZEPETO

| ชื่อ     | ค่า | คำอธิบาย               |
| -------- | --- | ---------------------- |
| None     | -1  | None.                  |
| MoveWalk | 0   | เคลื่อนที่อย่างช้า ๆ   |
| MoveRun  | 1   | เคลื่อนที่อย่างรวดเร็ว |

## CharacterJumpState

`enum`

แทนสถานะการกระโดดโดยละเอียดของตัวละคร ZEPETO

| ชื่อ       | ค่า | คำอธิบาย                                                               |
| ---------- | --- | ---------------------------------------------------------------------- |
| None       | -1  | None.                                                                  |
| JumpIdle   | 0   | กระโดดอยู่กับที่                                                       |
| JumpMove   | 1   | กระโดดไปในทิศทางหนึ่ง โดยผสมการกระโดดแนวตั้งเข้ากับการเคลื่อนที่แนวนอน |
| JumpDash   | 2   | กระโดดอย่างรวดเร็ว                                                     |
| JumpDouble | 3   | การกระโดดครั้งที่สองขณะที่กำลังกระโดดอยู่แล้ว                          |

## CharacterLandingState

`enum`

แทนสถานะการลงพื้นโดยละเอียดของตัวละคร ZEPETO

| ชื่อ          | ค่า | คำอธิบาย                        |
| ------------- | --- | ------------------------------- |
| None          | -1  | None.                           |
| LandingSlight | 0   | การลงพื้นที่มีแรงกระแทกเล็กน้อย |
| LandingDeep   | 1   | การลงพื้นที่มีแรงกระแทกมาก      |
| LandingRoll   | 2   | การลงพื้นพร้อมม้วนตัว           |

## KnowSockets

`enum`

กำหนดชุดของจุดยึดที่รู้จัก ซึ่งเรียกว่า socket บนตัวละคร

| ชื่อ        | ค่า | คำอธิบาย                 |
| ----------- | --- | ------------------------ |
| HEAD\_UPPER | 0   | แทนส่วนบนของศีรษะตัวละคร |

## MotionState

`class`

คลาสสำหรับจัดการสถานะและการตั้งค่าโมชันของตัวละคร

### พร็อพเพอร์ตี้

| ชื่อ                | ประเภท                                            | คำอธิบาย                                                                |
| ------------------- | ------------------------------------------------- | ----------------------------------------------------------------------- |
| useDoubleJump       | `boolean`                                         | กำหนดว่าตัวละครสามารถกระโดดสองชั้นได้หรือไม่                            |
| doubleJumpPower     | `number`                                          | แรงเพิ่มเติมที่ใช้ระหว่างการกระโดดสองชั้น                               |
| useLanding          | `boolean`                                         | กำหนดว่าจะใช้โมชันการลงพื้นหรือไม่                                      |
| useLandingRoll      | `boolean`                                         | กำหนดว่าตัวละครจะม้วนตัวเมื่อลงพื้นหรือไม่                              |
| landingRollSpeed    | `number`                                          | รับหรือกำหนดความเร็วการม้วนตัวเมื่อลงพื้นของตัวละคร                     |
| useMoveTurn         | `boolean`                                         | กำหนดว่าจะเล่นโมชันสำหรับการเปลี่ยนทิศทางการเคลื่อนที่ของตัวละครหรือไม่ |
| gravity             | `number`                                          | แรงโน้มถ่วงที่ใช้กับตัวละคร                                             |
| currentJumpState    | [CharacterJumpState](./#characterjumpstate)       | ดึงสถานะการกระโดดปัจจุบันของตัวละคร                                     |
| currentLandingState | [CharacterLandingState](./#characterlandingstate) | ดึงสถานะการลงพื้นปัจจุบันของตัวละคร                                     |
| currentMoveState    | [CharacterMoveState](./#charactermovestate)       | ดึงสถานะการเคลื่อนที่ปัจจุบันของตัวละคร                                 |

## CharacterStateMachine

`class` · extends [StateMachine\<CharacterState>](./#statemachine)

คลาสที่รับผิดชอบการซิงโครไนซ์ animator กับสถานะตัวละครของตัวละคร ZEPETO

### พร็อพเพอร์ตี้

| ชื่อ                     | ประเภท    | คำอธิบาย                                                                                                                                              |
| ------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
| constraintStateAnimation | `boolean` | กำหนดว่าจะซิงโครไนซ์ animator กับสถานะปัจจุบันของตัวละคร ZEPETO หรือไม่ หากตั้งค่าเป็น `true` สถานะของ animator จะไม่ถูกอัปเดตตามสถานะตัวละครปัจจุบัน |

### เมธอด

### SyncStateAnimation

`SyncStateAnimation() → void`

ซิงโครไนซ์ animator กับสถานะปัจจุบันของตัวละคร ZEPETO

### ChangeStateAnimation

`ChangeStateAnimation(state: CharacterState) → void`

เล่นแอนิเมชันที่เชื่อมโยงกับสถานะตัวละครที่ให้มาบน animator

| พารามิเตอร์ | ประเภท                              | คำอธิบาย                             |
| ----------- | ----------------------------------- | ------------------------------------ |
| state       | [CharacterState](./#characterstate) | สถานะตัวละครที่แทนแอนิเมชันที่จะเล่น |

## StateMachine

`class`

`StateMachine` manages the `States`, `Transitions`, and `Events`.
การอัปเดตสถานะตามเงื่อนไขที่กำหนดและเวลาที่ผ่านไป ทำให้สามารถกำหนดและควบคุมสถานะที่หลากหลายของอ็อบเจกต์ได้

### พร็อพเพอร์ตี้

| ชื่อ            | ประเภท                                          | คำอธิบาย                                                                                                                        |
| --------------- | ----------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- |
| OnChangedState  | `Action<TEnum, TEnum>`                          | อีเวนต์ที่ถูกทริกเกอร์เมื่อสถานะกล้องเปลี่ยนแปลง listener ที่ลงทะเบียนไว้จะได้รับพารามิเตอร์สองตัว: - สถานะใหม่ - สถานะก่อนหน้า |
| Events          | [TransitionBase\<TEnum>\[\]](./#transitionbase) | ให้อาร์เรย์ของอีเวนต์ทั้งหมดที่กำหนดไว้ใน state machine                                                                         |
| Current         | [State\<TEnum>](./#state)                       | ดึง state ปัจจุบัน                                                                                                              |
| Prev            | [State\<TEnum>](./#state)                       | ดึง state ก่อนหน้า                                                                                                              |
| IsRunning       | `boolean`                                       | ระบุว่า state machine กำลังประมวลผล state และการเปลี่ยนผ่านอยู่หรือไม่                                                          |
| stateCount      | `number`                                        | ดึงจำนวน state ที่กำหนดไว้ใน state machine                                                                                      |
| transitionCount | `number`                                        | ดึงจำนวนการเปลี่ยนผ่านที่กำหนดไว้ใน state machine                                                                               |

### เมธอด

### FindState

`FindState(state: TEnum, success: Action<State<TEnum>>, failed: Action) → void`

ค้นหา state ภายใน state machine และเรียก callback เมื่อสำเร็จ

| พารามิเตอร์ | ประเภท                 | คำอธิบาย                                         |
| ----------- | ---------------------- | ------------------------------------------------ |
| state       | `TEnum`                | state ที่จะค้นหาภายใน state machine              |
| success     | `Action<State<TEnum>>` | ฟังก์ชัน callback สำหรับจัดการ `State` ที่พบ     |
| failed      | `Action`               | ฟังก์ชัน callback สำหรับจัดการกรณีที่ไม่พบ state |

### FindTransitions

`FindTransitions(from: TEnum, success: Action<Transition<TEnum>[]>, failed: Action) → void`

ค้นหาการเปลี่ยนผ่านภายใน state machine และเรียก callback เมื่อสำเร็จ

| พารามิเตอร์ | ประเภท                        | คำอธิบาย                                                     |
| ----------- | ----------------------------- | ------------------------------------------------------------ |
| from        | `TEnum`                       | state ที่การเปลี่ยนผ่านเริ่มต้นจาก                           |
| success     | `Action<Transition<TEnum>[]>` | ฟังก์ชัน callback สำหรับจัดการอาร์เรย์ของ `Transition` ที่พบ |
| failed      | `Action`                      | ฟังก์ชัน callback สำหรับจัดการกรณีที่ไม่พบการเปลี่ยนผ่าน     |

### FindTransition

`FindTransition(from: TEnum, to: TEnum, success: Action<Transition<TEnum>>, failed: Action) → void`

ค้นหาการเปลี่ยนผ่านหนึ่งรายการภายใน state machine และเรียก callback เมื่อสำเร็จ

| พารามิเตอร์ | ประเภท                      | คำอธิบาย                                                     |
| ----------- | --------------------------- | ------------------------------------------------------------ |
| from        | `TEnum`                     | state ที่การเปลี่ยนผ่านเริ่มต้นจาก                           |
| to          | `TEnum`                     | state ที่จะเปลี่ยนผ่านไป                                     |
| success     | `Action<Transition<TEnum>>` | ฟังก์ชัน callback สำหรับจัดการ `Transition` ที่พบ            |
| failed      | `Action`                    | ฟังก์ชัน callback สำหรับจัดการกรณีที่ไม่พบการเปลี่ยนผ่านนั้น |

### Start

`Start(state: TEnum) → void`

เริ่มการประมวลผลของ state machine

| พารามิเตอร์ | ประเภท  | คำอธิบาย                                   |
| ----------- | ------- | ------------------------------------------ |
| state       | `TEnum` | state ที่ state machine จะเริ่มการประมวลผล |

### Update

`Update(deltaTime: number) → void`

อัปเดต state และการเปลี่ยนผ่านปัจจุบันของ state machine

| พารามิเตอร์ | ประเภท   | คำอธิบาย                                                       |
| ----------- | -------- | -------------------------------------------------------------- |
| deltaTime   | `number` | เวลาที่ผ่านไปเป็นวินาทีนับตั้งแต่การเรียก `Update` ครั้งล่าสุด |

### Stop

`Stop() → void`

หยุดการประมวลผลของ state machine

### EnterState

`EnterState(state: TEnum) → void`

เปลี่ยน state machine ไปยัง state ที่ระบุ

| พารามิเตอร์ | ประเภท  | คำอธิบาย                                |
| ----------- | ------- | --------------------------------------- |
| state       | `TEnum` | state ที่ state machine จะเปลี่ยนผ่านไป |

### LeaveState

`LeaveState(nextState: TEnum) → void`

state machine ออกจาก state ปัจจุบัน

| พารามิเตอร์ | ประเภท  | คำอธิบาย                                                  |
| ----------- | ------- | --------------------------------------------------------- |
| nextState   | `TEnum` | state ถัดไปที่จะถูกจัดการโดย `OnLeave` ของ state ปัจจุบัน |

## StateStatus

`enum`

แทนสถานะที่เป็นไปได้ของ state ภายใน state machine ซึ่งบ่งบอกช่วงปัจจุบันของวงจรชีวิตของ state นั้น

| ชื่อ   | ค่า | คำอธิบาย                                               |
| ------ | --- | ------------------------------------------------------ |
| Wait   | 0   | state ไม่ทำงานและกำลังรอการเข้าสู่สถานะ                |
| Enter  | 1   | state กำลังอยู่ในขั้นตอนการเข้าสู่สถานะ                |
| Update | 2   | state ทำงานอยู่และตรรกะของมันกำลังถูกประมวลผล          |
| End    | 3   | state ทำงานในช่วงที่ใช้งานเสร็จสิ้นแล้วและพร้อมสิ้นสุด |
| Leave  | 4   | state กำลังอยู่ในขั้นตอนการออกจากสถานะ                 |

## CustomMotionData

`class`

แทนการตั้งค่าที่กำหนดเองสำหรับโมชันของตัวละคร

### พร็อพเพอร์ตี้

| ชื่อ                          | ประเภท    | คำอธิบาย                                                                                  |
| ----------------------------- | --------- | ----------------------------------------------------------------------------------------- |
| useDoubleJump                 | `boolean` | กำหนดว่าตัวละครสามารถกระโดดสองชั้นได้หรือไม่                                              |
| doubleJumpPower               | `number`  | แรงเพิ่มเติมที่ใช้ระหว่างการกระโดดสองชั้น                                                 |
| useLanding                    | `boolean` | กำหนดว่าจะใช้โมชันการลงพื้นหรือไม่                                                        |
| useLandingRoll                | `boolean` | กำหนดว่าตัวละครจะม้วนตัวเมื่อลงพื้นหรือไม่                                                |
| landingRollSpeed              | `number`  | ความเร็วในการเล่นโมชันม้วนตัวเมื่อลงพื้น                                                  |
| useMoveTurn                   | `boolean` | กำหนดว่าจะเล่นโมชันสำหรับการเปลี่ยนทิศทางการเคลื่อนที่ของตัวละครหรือไม่                   |
| gravity                       | `number`  | แรงโน้มถ่วงที่ใช้กับตัวละคร                                                               |
| walkThreshold                 | `number`  | ค่าอินพุตต่ำสุดที่ต้องใช้เพื่อกระตุ้นการเร่งความเร็วของโมชันการเดิน                       |
| runThreshold                  | `number`  | ค่าอินพุตต่ำสุดที่ต้องใช้เพื่อเปลี่ยนโมชันจากการเดินเป็นการวิ่ง                           |
| fallingTimeThreshold          | `number`  | ระยะเวลาการตกขั้นต่ำที่ใช้พิจารณาว่าตัวละครเข้าสู่สถานะกำลังตกแล้วหรือไม่                 |
| fallingSpeedThreshold         | `number`  | ความเร็วการตกขั้นต่ำที่ใช้พิจารณาว่าตัวละครเข้าสู่สถานะกำลังตกแล้วหรือไม่                 |
| landingTimeThreshold          | `number`  | ระยะเวลาขั้นต่ำที่แตะพื้นเพื่อใช้พิจารณาว่าตัวละครลงพื้นแล้วหรือไม่                       |
| landingSpeedThreshold         | `number`  | ความเร็วการตกขั้นต่ำที่ใช้พิจารณาว่าตัวละครสามารถทำการกระทำเพิ่มเติมเมื่อลงพื้นได้หรือไม่ |
| landingImpactSpeedThreshold   | `number`  | ความเร็วการตกขั้นต่ำที่ใช้พิจารณาว่าตัวละครได้รับแรงกระแทกมากขึ้นเมื่อลงพื้นหรือไม่       |
| landingRollSpeedThreshold     | `number`  | ความเร็วการตกสูงสุดที่ต้องใช้เพื่อกระตุ้นการม้วนตัวเมื่อลงพื้น                            |
| moveTurnAngleThreshold        | `number`  | มุมการหันขั้นต่ำที่ต้องใช้เพื่อกระตุ้นโมชันการหันตัว                                      |
| moveTurnSpeedThreshold        | `number`  | ความเร็วการเคลื่อนที่ขั้นต่ำที่ต้องใช้เพื่อกระตุ้นโมชันการหันตัว                          |
| moveTurnTimeThreshold         | `number`  | ระยะเวลาของโมชันการหันตัว                                                                 |
| jumpDashSpeedThreshold        | `number`  | ความเร็วการกระโดดขั้นต่ำที่ต้องใช้เพื่อกระตุ้นการพุ่งตัว                                  |
| walkClipBaseSpeed             | `number`  | ความเร็วพื้นฐานของโมชันการเดิน                                                            |
| stampClipNormalizedTime       | `number`  | ระยะเวลาของโมชันการกระทืบเท้า                                                             |
| landingClipNormalizedTime     | `number`  | ระยะเวลาของโมชันการลงพื้น                                                                 |
| landingRollClipNormalizedTime | `number`  | ระยะเวลาของโมชันม้วนตัวเมื่อลงพื้น                                                        |
| moveTurnClipNormalizedTime    | `number`  | ระยะเวลาของโมชันการหันตัว                                                                 |

## CharacterShadow

`class`

คลาสที่รับผิดชอบการจัดการเงาของตัวละคร ZEPETO

### พร็อพเพอร์ตี้

| ชื่อ              | ประเภท      | คำอธิบาย                                         |
| ----------------- | ----------- | ------------------------------------------------ |
| target            | `Transform` | แทนอ็อบเจกต์ที่ใช้เป็นข้อมูลอ้างอิงของ transform |
| autoSyncTransform | `boolean`   | กำหนดว่าจะซิงโครไนซ์ตำแหน่งเงากับเป้าหมายหรือไม่ |

## CameraState

`enum`

แทนสถานะของ `ZepetoCamera`

| ชื่อ   | ค่า | คำอธิบาย                  |
| ------ | --- | ------------------------- |
| Idle   | 0   | กล้องไม่ได้ติดตามเป้าหมาย |
| Follow | 1   | กล้องกำลังติดตามเป้าหมาย  |

## ZepetoScreenStick

`class` · extends [ZepetoScreenControl](./#zepetoscreencontrol)

คลาสที่ออกแบบมาเพื่อจัดการการโต้ตอบด้วยสติ๊กในสภาพแวดล้อม ZEPETO

### อีเวนต์

| ชื่อ               | ประเภท                | คำอธิบาย                                 |
| ------------------ | --------------------- | ---------------------------------------- |
| OnPointerDownEvent | `UnityEvent`          | อีเวนต์ที่ถูกทริกเกอร์เมื่อกดสติ๊ก       |
| OnDragEvent        | `UnityEvent<Vector2>` | อีเวนต์ที่ถูกทริกเกอร์เมื่อกำลังลากสติ๊ก |
| OnPointerUpEvent   | `UnityEvent`          | อีเวนต์ที่ถูกทริกเกอร์เมื่อปล่อยสติ๊ก    |

### เมธอด

### OnDrag

`OnDrag(eventData: PointerEventData) → void`

จัดการพฤติกรรมการลาก โดยคำนวณส่วนต่างของตำแหน่งและจำกัดให้อยู่ในช่วงการเคลื่อนที่ที่กำหนด
ทริกเกอร์ `OnDragEvent` พร้อมค่าตำแหน่งที่ผ่านการนอร์มัลไลซ์แล้ว
จะโยน `ArgumentNullException`

| พารามิเตอร์ | ประเภท             | คำอธิบาย                            |
| ----------- | ------------------ | ----------------------------------- |
| eventData   | `PointerEventData` | ข้อมูลที่เกี่ยวข้องกับอีเวนต์การลาก |

## ZepetoScreenControl

`class`

คลาสนามธรรมที่ออกแบบมาสำหรับสร้างตัวควบคุม UI ในสภาพแวดล้อม ZEPETO

### เมธอด

### OnPointerDown

`OnPointerDown(eventData: PointerEventData) → void`

จัดการอีเวนต์เมื่อผู้ใช้กดตัวควบคุม UI

| พารามิเตอร์ | ประเภท             | คำอธิบาย                                     |
| ----------- | ------------------ | -------------------------------------------- |
| eventData   | `PointerEventData` | ข้อมูลที่เกี่ยวข้องกับอีเวนต์การกดพอยน์เตอร์ |

### OnPointerUp

`OnPointerUp(eventData: PointerEventData) → void`

จัดการอีเวนต์เมื่อผู้ใช้ปล่อยตัวควบคุม UI

| พารามิเตอร์ | ประเภท             | คำอธิบาย                                        |
| ----------- | ------------------ | ----------------------------------------------- |
| eventData   | `PointerEventData` | ข้อมูลที่เกี่ยวข้องกับอีเวนต์การปล่อยพอยน์เตอร์ |

## ZepetoScreenButton

`class` · extends [ZepetoScreenControl](./#zepetoscreencontrol)

คลาสที่ออกแบบมาเพื่อจัดการการโต้ตอบด้วยปุ่มในสภาพแวดล้อม ZEPETO

### อีเวนต์

| ชื่อ             | ประเภท       | คำอธิบาย                             |
| ---------------- | ------------ | ------------------------------------ |
| OnPointDownEvent | `UnityEvent` | อีเวนต์ที่ถูกทริกเกอร์เมื่อกดปุ่ม    |
| OnPointUpEvent   | `UnityEvent` | อีเวนต์ที่ถูกทริกเกอร์เมื่อปล่อยปุ่ม |

## ZepetoScreenTouchpad

`class` · extends [ZepetoScreenControl](./#zepetoscreencontrol)

คลาสที่ออกแบบมาเพื่อจัดการการโต้ตอบด้วยทัชแพดในสภาพแวดล้อม ZEPETO

### พร็อพเพอร์ตี้

| ชื่อ                          | ประเภท           | คำอธิบาย                                                                 |
| ----------------------------- | ---------------- | ------------------------------------------------------------------------ |
| canvasGroupTouchPadBackground | `CanvasGroup`    | คอมโพเนนต์ canvas group ที่ใช้จัดการความทึบและการโต้ตอบของพื้นหลังทัชแพด |
| touchPadBackgroundCurve       | `AnimationCurve` | เส้นโค้งแอนิเมชันสำหรับเอฟเฟกต์การค่อย ๆ ปรากฏและจางหายของพื้นหลังทัชแพด |
| touchHandle                   | `RectTransform`  | คอมโพเนนต์ `RectTransform` ที่แทน touch handle                           |
| touchHandleAnimator           | `Animator`       | คอมโพเนนต์ animator ที่ใช้ทำแอนิเมชันให้กับ touch handle                 |
| touchHandleOrigin             | `RectTransform`  | `RectTransform` สำหรับตำแหน่งเดิมของ touch handle                        |
| touchHandleOriginAnimator     | `Animator`       | คอมโพเนนต์ animator สำหรับจุดกำเนิดของ touch handle                      |

### อีเวนต์

| ชื่อ               | ประเภท                | คำอธิบาย                                    |
| ------------------ | --------------------- | ------------------------------------------- |
| OnPointerDownEvent | `UnityEvent`          | อีเวนต์ที่ถูกทริกเกอร์เมื่อกดทัชแพด         |
| OnDragEvent        | `UnityEvent<Vector2>` | อีเวนต์ที่ถูกทริกเกอร์เมื่อกำลังลากบนทัชแพด |
| OnPointerUpEvent   | `UnityEvent`          | อีเวนต์ที่ถูกทริกเกอร์เมื่อปล่อยทัชแพด      |

### เมธอด

### OnPointerClick

`OnPointerClick(eventData: PointerEventData) → void`

จัดการอีเวนต์การคลิกบนทัชแพด โดยจะโยน `ArgumentNullException`

| พารามิเตอร์ | ประเภท             | คำอธิบาย                            |
| ----------- | ------------------ | ----------------------------------- |
| eventData   | `PointerEventData` | ข้อมูลที่เกี่ยวข้องกับอีเวนต์การลาก |

### OnDrag

`OnDrag(eventData: PointerEventData) → void`

จัดการพฤติกรรมการลาก โดยคำนวณส่วนต่างของตำแหน่งและจำกัดให้อยู่ในช่วงการเคลื่อนที่ที่กำหนด
ทริกเกอร์ `OnDragEvent` พร้อมค่าตำแหน่งที่ผ่านการนอร์มัลไลซ์แล้ว
จะโยน `ArgumentNullException`

| พารามิเตอร์ | ประเภท             | คำอธิบาย                            |
| ----------- | ------------------ | ----------------------------------- |
| eventData   | `PointerEventData` | ข้อมูลที่เกี่ยวข้องกับอีเวนต์การลาก |

## UIZepetoPlayerControl

`class`

คลาสที่ให้การควบคุมตัวละครของ local player ผ่าน UI

### เมธอด

### StartMoving

`StartMoving() → void`

กำหนดแฟล็กการเคลื่อนที่ของตัวละคร local player เป็น `true`

### Move

`Move(delta: Vector2) → void`

กำหนดทิศทางการเคลื่อนที่ของตัวละคร ZEPETO ของ local player

| พารามิเตอร์ | ประเภท    |
| ----------- | --------- |
| delta       | `Vector2` |

### StopMoving

`StopMoving() → void`

หยุดตัวละคร ZEPETO ของ local player

### Jump

`Jump() → void`

ทำให้ตัวละคร ZEPETO ของ local player กระโดด

### DoubleJump

`DoubleJump() → void`

ทำให้ตัวละคร ZEPETO ของ local player กระโดดสองชั้น

### Update

`Update() → void`

อัปเดตทิศทางการเคลื่อนที่ของตัวละคร ZEPETO ของ local player

## InputHelper

`class`

คลาสอรรถประโยชน์ที่ออกแบบมาเพื่อช่วยในการจัดการอินพุต

### เมธอด

### IsPointerOverUIObjectCurrentPosition

`static IsPointerOverUIObjectCurrentPosition() → boolean`

ตรวจสอบว่าพอยน์เตอร์อยู่เหนืออ็อบเจกต์ UI ในขณะนี้หรือไม่

**ค่าที่คืนกลับ:** `boolean` — คืนค่า `true` หากพอยน์เตอร์อยู่เหนืออ็อบเจกต์ UI

### IsPointerOverUIObject

`static IsPointerOverUIObject(position: Vector2) → boolean`

ตรวจสอบว่าตำแหน่งที่ระบุบนหน้าจออยู่เหนือองค์ประกอบ UI หรือไม่

| พารามิเตอร์ | ประเภท    | คำอธิบาย        |
| ----------- | --------- | --------------- |
| position    | `Vector2` | ตำแหน่งบนหน้าจอ |

**ค่าที่คืนกลับ:** `boolean` — คืนค่า `true` หากตำแหน่งนั้นอยู่เหนืออ็อบเจกต์ UI

## EventReceiver

`class`

คลาสที่รับผิดชอบการจัดการอีเวนต์ที่เกี่ยวข้องกับตัวละครหรืออีเวนต์ทั่วไปภายใน ZEPETO World

### อีเวนต์

| ชื่อ                             | ประเภท                              | คำอธิบาย                                                        |
| -------------------------------- | ----------------------------------- | --------------------------------------------------------------- |
| OnCharacterClick (static)        | `UnityEvent<string, ZepetoContext>` | อีเวนต์ที่ถูกทริกเกอร์เมื่อคลิกที่ตัวละคร                       |
| OnCharacterProfileClick (static) | `UnityEvent<string, ZepetoContext>` | อีเวนต์ที่ถูกทริกเกอร์เมื่อคลิกที่โปรไฟล์ของตัวละคร             |
| OnClick (static)                 | `UnityEvent<number>`                | อีเวนต์การคลิกอเนกประสงค์ที่ใช้ได้กับองค์ประกอบเชิงโต้ตอบต่าง ๆ |

## TransitionBase

`class`

คลาสพื้นฐานสำหรับกำหนดการเปลี่ยนผ่านระหว่าง state ใน state machine

### พร็อพเพอร์ตี้

| ชื่อ      | ประเภท                        | คำอธิบาย                                                                                       |
| --------- | ----------------------------- | ---------------------------------------------------------------------------------------------- |
| To        | `TEnum`                       | state ที่จะเปลี่ยนผ่านไป                                                                       |
| Duration  | `number`                      | ระยะเวลาที่การเปลี่ยนผ่านควรใช้ตั้งแต่เริ่มจนจบ (เป็นวินาที)                                   |
| Status    | [StateStatus](./#statestatus) | สถานะของการเปลี่ยนผ่าน                                                                         |
| IsRunning | `boolean`                     | ระบุว่าการเปลี่ยนผ่านอยู่ในสถานะ `StateStatus.Enter` หรือ `StateStatus.Update` ในขณะนี้หรือไม่ |

### เมธอด

### Check

`Check() → boolean`

ตรวจสอบว่าเงื่อนไขสำหรับการเรียกใช้การเปลี่ยนผ่านครบถ้วนหรือไม่

**ค่าที่คืนกลับ:** `boolean` — `true` หากเงื่อนไขของการเปลี่ยนผ่านครบถ้วน

## State

`class`

แทน state หนึ่งภายใน state machine

### พร็อพเพอร์ตี้

| ชื่อ          | ประเภท                        | คำอธิบาย                                      |
| ------------- | ----------------------------- | --------------------------------------------- |
| OnUpdateState | `Action<TEnum>`               | ฟังก์ชัน callback สำหรับจัดการการอัปเดต state |
| stateType     | `TEnum`                       | ประเภทของ state                               |
| Status        | [StateStatus](./#statestatus) | สถานะของ state                                |

## Transition

`class` · extends [TransitionBase\<TEnum>](./#transitionbase)

คลาสเจเนอริกสำหรับกำหนดการเปลี่ยนผ่านระหว่าง state ใน state machine

### พร็อพเพอร์ตี้

| ชื่อ | ประเภท  | คำอธิบาย                           |
| ---- | ------- | ---------------------------------- |
| From | `TEnum` | state ที่การเปลี่ยนผ่านเริ่มต้นจาก |

## ZepetoCharacter.LoadingStatus

`enum`

สถานะการโหลดของตัวละคร ZEPETO

| ชื่อ      | ค่า | คำอธิบาย                           |
| --------- | --- | ---------------------------------- |
| NotLoaded | 0   | ตัวละครยังไม่เริ่มกระบวนการโหลด    |
| Loading   | 1   | ตัวละครกำลังอยู่ในกระบวนการโหลด    |
| Loaded    | 2   | ตัวละครโหลดเสร็จสมบูรณ์แล้ว        |
| Error     | 3   | เกิดข้อผิดพลาดระหว่างกระบวนการโหลด |

## PlayerControlMode

`enum`

| ชื่อ     | ค่า |
| -------- | --- |
| Default  | 0   |
| WalkOnly | 1   |
| RunOnly  | 2   |
