mLua · Nemotron-CC 리프레이즈 (CPT)

[task] | extract_knowledge [title] | 3. 인벤토리 데이터 저장 및 불러오기 [category] | Guides [rephrased] | # 인벤토리 데이터 구조 및 초기화 이벤트 정의 인벤토리 시스템을 구현하기 위해 개별 아이템의 상태와 전체 인벤토리의 초기화 상태를 표현하는 데이터 구조(`StructType`)와 이벤트(`EventType`)를 정의해야 합니다. 본 절에서는 `ItemStack` 구조체와 `SimpleInventoryInitializedEvent` 이벤트의 생성 및 API 사용법을 다룹니다. ## 1. 개념 설명 * **ItemStack (StructType)**: 인벤토리의 한 슬롯에 저장되는 아이템의 정보를 담는 데이터 구조입니다. 아 [original] | DataStorage에서 불러온 데이터로 인벤토리를 초기화할 수 있도록 컴포넌트를 만들어 봅시다. SimpleInventory 컴포넌트, SimpleInventoryInitializedEvent, ItemStack을 활용해 인벤토리 데이터를 저장하고, 불러올 수 있도록 만들어봅시다. # ItemStack 만들기 1. **Workspace - MyDesk - Create Scripts - Create StructType**을 눌러 **ItemStack**을 생성합니다. 2. **SlotIndex, ItemId, Count** [chunk_id] | Guides:1113:0

[task] | wikipedia [title] | 3. 인벤토리 데이터 저장 및 불러오기 [category] | Guides [rephrased] | ### 인벤토리 데이터 저장 및 불러오기 인벤토리 데이터를 외부 저장소(DataStorage)에 영구적으로 보존하기 위해 직렬화(Serialization) 과정이 필요합니다. 이 과정은 게임 내 메소(Meso)와 아이템 스택(Item Stack) 정보를 구조화된 형태로 변환하여 저장하는 것을 목표로 합니다. **1. 직렬화 함수 구현** 먼저, 인벤토리 상태를 문자열(string) 형태로 변환하는 `Serialize()` 메서드를 추가해야 합니다. 이 함수는 현재 엔티티의 메소량과 모든 아이템 스택 데이터를 하나의 테이블로 묶 [original] | 11. 새로운 string 타입의 `Serialize()` 함수를 추가합니다. 메소와 아이템 데이터를 DataStorage에 저장할 수 있도록 아래와 같이 작성합니다. 메소와 아이템을 하나의 테이블에 담고 Json 포맷으로 변환합니다. ```lua string Serialize () { local dataTable = {} local itemStacks = {} dataTable.Meso = self.Meso [chunk_id] | Guides:1113:3

[task] | extract_knowledge [title] | 003_InGame [category] | Guides [rephrased] | # 슈피겔만 게임 리메이크: 인게임 구멍 막기 로직 (02_InstanceRoom 003_InGame) 본 절에서는 슈피겔만 게임 리메이크 프로젝트에서 특정 구멍(Entity)의 게이지를 관리하고, 플레이어의 상호작용을 통해 구멍이 막히는(`Clear`) 상태를 제어하는 로직을 다룹니다. 이 컴포넌트는 서버에서 게이지 증감 타이머를 제어하고, 클라이언트 및 서버 간 상태 동기화를 처리합니다. ## 1. 개념 설명 구멍 막기 시스템은 다음 세 가지 핵심 상태로 구성됩니다. 1. **게이지(Gage) 관리**: `targetG [original] | | 동기화 | 타입 | 이름 | 설명 | | --- | --- | --- | --- | | None | boolean | Clear |해당 구멍이 막아졌는지 확인합니다. targetGage가 100이되면 값을 true로 변경합니다. | | None | SyncTable<Entity, boolean> | playerInteraction | 현재 몇 명의 플레이어가 상호작용 중인지 확인합니다. | | None | number | targetGage | 해당 구멍의 게이지입니다. 100이 되면 구멍이 막힌 것으로 간주합니다. | | No [chunk_id] | Guides:1110:1

[task] | wikipedia [title] | 3. 인벤토리 데이터 저장 및 불러오기 [category] | Guides [rephrased] | # 인벤토리 데이터 저장 및 불러오기 메이플스토리 월드의 `SimpleInventory` 컴포넌트를 활용하여 인벤토리 데이터를 서버에서 클라이언트로 동기화하고, 플레이어 퇴장 시 데이터베이스에 저장하는 과정은 다음과 같은 단계로 구성됩니다. ### 1. 서버에서 초기화 이벤트 전송 서버 공간에서 실행되는 `SendInitializedEvent()` 메서드를 통해 현재 인벤토리 상태(메소 및 아이템 스택)를 클라이언트로 전달합니다. 이 메서드는 `SimpleInventoryInitializedEvent`를 생성하여 `Meso`와 [original] | ```lua [server only] void SendInitializedEvent () { local event = SimpleInventoryInitializedEvent() event.Meso = self.Meso event.ItemStacks = self.ItemStacks self.Entity:SendEvent(event) } ``` 7. `SimpleInventory` 컴포넌트에서 `SendInitializedEventToCli [chunk_id] | Guides:1113:2

[task] | distill [title] | 3. 인벤토리 데이터 저장 및 불러오기 [category] | Guides [rephrased] | ### 인벤토리 데이터 저장 및 불러오기 인벤토리 초기화 시 서버에서 클라이언트로 데이터를 동기화하고, 유저 퇴장 시 데이터 저장을 수행합니다. **초기화 이벤트 전송 (Server -> Client)** 서버는 `SimpleInventoryInitializedEvent`를 생성하여 로컬 플레이어에게만 전송합니다. ```lua [server only] void SendInitializedEvent() { local event = SimpleInventoryInitializedEvent() event.Meso = [original] | [server only] void SendInitializedEvent() { local event = SimpleInventoryInitializedEvent() event.Meso = self.Meso event.ItemStacks = self.ItemStacks self.Entity:SendEvent(event) -- 로컬 플레이어에게만 전달 self:SendInitializedEventToClient(event, self.Entity.PlayerComponent.UserId [chunk_id] | Guides:1113:5

[task] | wikipedia [title] | 3. 인벤토리 데이터 저장 및 불러오기 [category] | Guides [rephrased] | # 인벤토리 데이터 저장 및 불러오기 메이플스토리 월드(MapleStory Worlds)의 mLua 환경에서 플레이어의 인벤토리 데이터를 영구적으로 저장하고 불러오는 방법을 설명합니다. 이 과정은 `SimpleInventory` 컴포넌트를 생성하고, 데이터 스토리지(DataStorage) 및 HTTP 서비스를 활용해 데이터를 직렬화(serialize) 및 역직렬화(deserialize)하는 절차로 구성됩니다. ## 1. 컴포넌트 생성 및 배치 먼저 에디터의 **Workspace > MyDesk > Create Scripts > [original] | 1. **Workspace - MyDesk - Create Scripts - Create Component**에서 새로운 `SimpleInventory` 컴포넌트를 생성합니다. `SimpleInventory` 컴포넌트를 **DefaultPlayer**에 추가합니다. 2. **Meso, ItemStacks** 프로퍼티를 추가합니다. ```lua Property: [None] integer Meso = 10000 [None] table ItemStacks = {} ``` 3 [chunk_id] | Guides:1113:1

[task] | knowledge_list [title] | 3. 인벤토리 데이터 저장 및 불러오기 [category] | Guides [rephrased] | 1. `SendInitializedEvent` 메서드는 `[server only]` 실행 공간에서 동작하며, `SimpleInventoryInitializedEvent` 객체를 생성하여 `self.Meso`와 `self.ItemStacks` 프로퍼티 값을 해당 이벤트에 할당합니다. 2. `SendInitializedEvent` 메서드는 `self.Entity:SendEvent(event)`를 호출하여 이벤트를 보낸 후, `self:SendInitializedEventToClient(event, self.Entity.PlayerCom [original] | [server only] void SendInitializedEvent() { local event = SimpleInventoryInitializedEvent() event.Meso = self.Meso event.ItemStacks = self.ItemStacks self.Entity:SendEvent(event) -- 로컬 플레이어에게만 전달 self:SendInitializedEventToClient(event, self.Entity.PlayerComponent.UserId [chunk_id] | Guides:1113:5

[task] | diverse_qa [title] | 3. 인벤토리 데이터 저장 및 불러오기 [category] | Guides [rephrased] | 질문: `Serialize()` 함수의 반환 타입은 무엇이며, 어떤 포맷으로 데이터를 변환하나요? 답변: `Serialize()` 함수의 반환 타입은 `string`이며, 메소와 아이템 데이터를 하나의 테이블에 담고 Json 포맷으로 변환하여 반환합니다. 질문: `Serialize()` 함수 내부에서 `dataTable.Meso` 에는 어떤 값이 저장되나요? 답변: `dataTable.Meso` 에는 `self.Meso` 값이 저장됩니다. 질문: `Serialize()` 함수에서 아이템 스택 데이터를 처리할 때 어떤 메서드를 사 [original] | 11. 새로운 string 타입의 `Serialize()` 함수를 추가합니다. 메소와 아이템 데이터를 DataStorage에 저장할 수 있도록 아래와 같이 작성합니다. 메소와 아이템을 하나의 테이블에 담고 Json 포맷으로 변환합니다. ```lua string Serialize () { local dataTable = {} local itemStacks = {} dataTable.Meso = self.Meso [chunk_id] | Guides:1113:3

[task] | extract_knowledge [title] | 2. 아이템 데이터 만들기 [category] | Guides [rephrased] | # 아이템 데이터 관리 로직 구성 이 절에서는 `Data` 로직 컴포넌트를 통해 아이템 메타데이터를 중앙 관리 테이블(`ItemTableDataSet`)에서 읽어와 메모리에 로드하는 방법을 다룹니다. 이 구조는 상점과 인벤토리 시스템에서 아이템 정보에 대한 일관된 접근을 보장하기 위해 사용됩니다. ## 1. 개념 설명 메이플스토리 월드의 `Data` 로직은 게임의 실행 상태와 분리된 데이터 처리를 담당합니다. 아이템의 식별자(`Id`), 이름(`Name`), 아이콘 리소스 ID(`IconRUID`), 최대 적재 수량(`MaxS [original] | 1. **Workspace - MyDesk - Create Scripts - Create Logic**을 선택해 새로운 `Data` 로직을 생성합니다. 2. **ItemTable, ItemTableRowCount** 프로퍼티를 추가합니다. ```lua Property: [None] table ItemTable = {} [None] integer ItemTableRowCount = 0 ``` 3. **OnBeginPlay()** 함수를 추가하고, `ItemTableDataSet`의 [chunk_id] | Guides:1112:1

[task] | distill [title] | 3. 인벤토리 데이터 저장 및 불러오기 [category] | Guides [rephrased] | # 인벤토리 데이터 저장 및 불러오기 `DataStorageService`를 활용해 사용자별 인벤토리 데이터를 서버에 영속화하고 복원하는 로직입니다. ### 핵심 동작 규칙 1. **데이터 로드**: `OnBeginPlay` 시 `GetAndWait`로 동기화 대기 후 데이터 적용. 실패 시(`errorCode ~= 0`) 에러 로그 출력 후 반환. 2. **직렬화 (Serialize)**: `Meso`와 `ItemStacks`를 Table로 구성 후 `JSONEncode`로 문자열 변환. 3. **역직렬화 (Deserializ [original] | # 전체 스크립트 #### SimpleInventory ```lua Property: [None] integer Meso = 10000 [None] table ItemStacks = {} Method: [server only] void OnBeginPlay() { -- 데이터 스토리지에서 인벤토리 데이터를 불러옴 local userId = self.Entity.PlayerComponent.UserId local userDataStorage = _DataStorageService:GetUserDataSt [chunk_id] | Guides:1113:4

[task] | distill [title] | 4. 아이템을 인벤토리에 추가하기 [category] | Guides [rephrased] | # 인벤토리 시스템: 이벤트 정의 및 슬롯 규칙 상점 구매 시 아이템은 인벤토리에 추가됩니다. **슬롯당 최대 10개**까지 저장되며, 수량이 초과되면 다음 슬롯으로 분산 저장됩니다. * **예시**: 슬롯에 5개 보유 시 10개 추가 → 기존 슬롯 5개 채움, 나머지 5개는 신규 슬롯에 저장. ## 1. 이벤트 타입(Event Type) 정의 `Workspace > MyDesk > Create Scripts > Create EventType`에서 아래 이벤트를 생성하고 프로퍼티를 설정합니다. ### `SimpleInve [original] | 상점에서 상품을 구매하면, 인벤토리에 담길 수 있게 만들어 봅시다. 인벤토리 슬롯 하나에는 최대 10개의 아이템을 담을 수 있습니다. 최대 수량이 찬 뒤에 다음 슬롯에 아이템을 저장하게 됩니다. 예를 들어 빨간포션을 인벤토리에 이미 5개 가지고 있을 때, 10개를 추가로 구매하면 5개가 있던 슬롯에 먼저 5개를 저장하고, 나머지 5개를 새로운 슬롯에 저장합니다. # SimpleInventoryItemAddedEvent 만들기 1. **Workspace - MyDesk - Create Scripts - Create EventTyp [chunk_id] | Guides:1114:0

[task] | knowledge_list [title] | 4. 아이템을 인벤토리에 추가하기 [category] | Guides [rephrased] | ```lua -- 문서에 명시된 사실 기반 핵심 정보 추출 1. 인벤토리의 슬롯 1개당 최대 수용 가능 아이템 수량은 10개이며, 이 수량이 채워지면 남은 아이템은 다음 슬롯에 저장된다. 2. 인벤토리에 이미 특정 아이템이 5개 존재할 때 10개를 추가로 구매하면, 기존 슬롯에 남은 공간만큼 5개가 먼저 저장되고 나머지 5개가 새로운 슬롯에 저장되는 방식이다. 3. SimpleInventoryItemAddedEvent는 Workspace의 MyDesk에서 Create Scripts > Create EventType를 통해 생성하며 [original] | 상점에서 상품을 구매하면, 인벤토리에 담길 수 있게 만들어 봅시다. 인벤토리 슬롯 하나에는 최대 10개의 아이템을 담을 수 있습니다. 최대 수량이 찬 뒤에 다음 슬롯에 아이템을 저장하게 됩니다. 예를 들어 빨간포션을 인벤토리에 이미 5개 가지고 있을 때, 10개를 추가로 구매하면 5개가 있던 슬롯에 먼저 5개를 저장하고, 나머지 5개를 새로운 슬롯에 저장합니다. # SimpleInventoryItemAddedEvent 만들기 1. **Workspace - MyDesk - Create Scripts - Create EventTyp [chunk_id] | Guides:1114:0

[task] | diverse_qa [title] | 4. 아이템을 인벤토리에 추가하기 [category] | Guides [rephrased] | 질문: 인벤토리 슬롯 하나에 최대 몇 개의 아이템을 담을 수 있나요? 답변: 인벤토리 슬롯 하나에는 최대 10개의 아이템을 담을 수 있습니다. 질문: 특정 아이템이 이미 슬롯에 5개 있고 10개를 추가로 구매했을 때, 아이템은 어떻게 저장되나요? 답변: 기존에 5개 있던 슬롯에 먼저 5개를 저장하고, 나머지 5개를 새로운 슬롯에 저장합니다. 질문: `SimpleInventoryItemAddedEvent`와 `SimpleInventoryItemModifiedEvent`의 프로퍼티 구조는 동일합니까? 답변: 네, 두 이벤트 모두 ` [original] | 상점에서 상품을 구매하면, 인벤토리에 담길 수 있게 만들어 봅시다. 인벤토리 슬롯 하나에는 최대 10개의 아이템을 담을 수 있습니다. 최대 수량이 찬 뒤에 다음 슬롯에 아이템을 저장하게 됩니다. 예를 들어 빨간포션을 인벤토리에 이미 5개 가지고 있을 때, 10개를 추가로 구매하면 5개가 있던 슬롯에 먼저 5개를 저장하고, 나머지 5개를 새로운 슬롯에 저장합니다. # SimpleInventoryItemAddedEvent 만들기 1. **Workspace - MyDesk - Create Scripts - Create EventTyp [chunk_id] | Guides:1114:0

[task] | wikipedia [title] | 4. 아이템을 인벤토리에 추가하기 [category] | Guides [rephrased] | 상점 시스템을 통해 상품을 구매한 후, 해당 아이템을 인벤토리에 등록하는 로직을 구현하기 위한 절차입니다. 인벤토리 구조의 기본 규칙은 하나의 슬롯(Slot)당 최대 10개의 동일 아이템을 저장할 수 있다는 점입니다. 특정 슬롯의 최대 수량이 도달한 경우, 초과분은 자동으로 다음 슬롯에 할당됩니다. 예컨대, 특정 슬롯에 이미 5개의 '빨간포션'이 존재하는 상태에서 10개를 추가로 구매하면, 기존 슬롯의 남은 공간(5개)에 먼저 5개가 채워지고, 나머지 5개는 새로운 슬롯에 저장됩니다. 이러한 인벤토리 상태 변화를 클라이언트와 서버 [original] | 상점에서 상품을 구매하면, 인벤토리에 담길 수 있게 만들어 봅시다. 인벤토리 슬롯 하나에는 최대 10개의 아이템을 담을 수 있습니다. 최대 수량이 찬 뒤에 다음 슬롯에 아이템을 저장하게 됩니다. 예를 들어 빨간포션을 인벤토리에 이미 5개 가지고 있을 때, 10개를 추가로 구매하면 5개가 있던 슬롯에 먼저 5개를 저장하고, 나머지 5개를 새로운 슬롯에 저장합니다. # SimpleInventoryItemAddedEvent 만들기 1. **Workspace - MyDesk - Create Scripts - Create EventTyp [chunk_id] | Guides:1114:0

[task] | distill [title] | 4. 아이템을 인벤토리에 추가하기 [category] | Guides [rephrased] | `SimpleInventory` 컴포넌트에 아이템 추가 기능 구현 가이드입니다. **1. 프로퍼티 추가** `Capacity` 프로퍼티를 추가하여 인벤토리 최대 슬롯 수를 정의합니다. ```lua [None] integer Capacity = 16 ``` **2. `AddItem()` 메서드 추가** `integer` 타입의 `AddItem()` 메서드를 추가합니다. 매개변수는 `itemId`, `itemCount`입니다. * **동작 규칙**: * `itemId`에 해당하는 아이템을 `itemCount`만큼 [original] | `SimpleInventory` 컴포넌트 아이템을 인벤토리에 추가할 수 있도록 만들어 봅시다. 1. **Capacity** 프로퍼티를 추가합니다. ```lua [None] integer Capacity = 16 ``` 2. 새로운 integer 타입의 `AddItem()` 함수를 추가합니다. 매개변수 **itemId, itemCount**를 추가합니다. 인벤토리에 아이템을 추가할 수 있도록 작성합니다. `AddItem()` 함수는 아래와 같이 동작합니다 * **itemId**에 해당하는 아 [chunk_id] | Guides:1114:1

[task] | knowledge_list [title] | 3. 인벤토리 데이터 저장 및 불러오기 [category] | Guides [rephrased] | 1. `SimpleInventory` 컴포넌트의 `[None]` 속성 `Meso`는 초기값이 10000인 `integer` 타입 변수로, 서버와 클라이언트 동기화되지 않습니다. 2. `SimpleInventory` 컴포넌트의 `[None]` 속성 `ItemStacks`는 초기값이 빈 테이블({})인 `table` 타입 변수로, 서버와 클라이언트 동기화되지 않습니다. 3. `[server only]` 메서드 `OnBeginPlay`는 `self.Entity.PlayerComponent.UserId`를 통해 현재 플레이어의 `userI [original] | # 전체 스크립트 #### SimpleInventory ```lua Property: [None] integer Meso = 10000 [None] table ItemStacks = {} Method: [server only] void OnBeginPlay() { -- 데이터 스토리지에서 인벤토리 데이터를 불러옴 local userId = self.Entity.PlayerComponent.UserId local userDataStorage = _DataStorageService:GetUserDataSt [chunk_id] | Guides:1113:4

[task] | knowledge_list [title] | 4. 아이템을 인벤토리에 추가하기 [category] | Guides [rephrased] | 1. `SimpleInventory` 컴포넌트의 `[None]` 동기화 속성인 `Capacity`는 인벤토리의 총 슬롯 수를 정의하는 `integer` 타입으로 기본값 16을 가집니다. 2. `AddItem()` 메서드는 `integer` 타입의 `itemId`와 `itemCount` 매개변수를 받아 인벤토리에 아이템을 추가하며, 실행 공간 제약이 명시되지 않았습니다. 3. `AddItem()` 메서드는 `itemId`에 해당하는 아이템을 `itemCount`만큼 인벤토리에 담는 로직을 수행합니다. 4. `AddItem()` 메서드 [original] | `SimpleInventory` 컴포넌트 아이템을 인벤토리에 추가할 수 있도록 만들어 봅시다. 1. **Capacity** 프로퍼티를 추가합니다. ```lua [None] integer Capacity = 16 ``` 2. 새로운 integer 타입의 `AddItem()` 함수를 추가합니다. 매개변수 **itemId, itemCount**를 추가합니다. 인벤토리에 아이템을 추가할 수 있도록 작성합니다. `AddItem()` 함수는 아래와 같이 동작합니다 * **itemId**에 해당하는 아 [chunk_id] | Guides:1114:1

[task] | wikipedia [title] | 3. 인벤토리 데이터 저장 및 불러오기 [category] | Guides [rephrased] | **인벤토리 데이터 저장 및 불러오기** 서버 측 인벤토리 컴포넌트는 초기화 시 클라이언트에 데이터를 동기화하는 과정과, 사용자가 게임에서 나갈 때 데이터를 영구적으로 저장하는 과정으로 구성됩니다. 먼저 서버에서 `SendInitializedEvent` 메서드를 호출하면, `SimpleInventoryInitializedEvent` 객체가 생성됩니다. 이 이벤트 객체에 현재 서버가 보유한 메소(`Meso`)와 아이템 스택(`ItemStacks`) 데이터가 할당되며, 해당 이벤트는 `self.Entity:SendEvent(even [original] | [server only] void SendInitializedEvent() { local event = SimpleInventoryInitializedEvent() event.Meso = self.Meso event.ItemStacks = self.ItemStacks self.Entity:SendEvent(event) -- 로컬 플레이어에게만 전달 self:SendInitializedEventToClient(event, self.Entity.PlayerComponent.UserId [chunk_id] | Guides:1113:5

[task] | diverse_qa [title] | 3. 인벤토리 데이터 저장 및 불러오기 [category] | Guides [rephrased] | 질문: `SendInitializedEvent` 함수는 어떤 실행 공간에서 동작합니까? 답변: `SendInitializedEvent` 함수는 `[server only]` 실행 공간에서 동작합니다. 질문: `SendInitializedEvent` 함수 내에서 `event.Meso`와 `event.ItemStacks`에 어떤 값이 할당됩니까? 답변: `event.Meso`에는 `self.Meso` 값이, `event.ItemStacks`에는 `self.ItemStacks` 값이 할당됩니다. 질문: `SendInitializedEv [original] | [server only] void SendInitializedEvent() { local event = SimpleInventoryInitializedEvent() event.Meso = self.Meso event.ItemStacks = self.ItemStacks self.Entity:SendEvent(event) -- 로컬 플레이어에게만 전달 self:SendInitializedEventToClient(event, self.Entity.PlayerComponent.UserId [chunk_id] | Guides:1113:5

[task] | wikipedia [title] | 4. 아이템을 인벤토리에 추가하기 [category] | Guides [rephrased] | `SimpleInventory` 컴포넌트는 게임 내 인벤토리에 아이템을 관리하는 기능을 제공하며, 이 가이드에서는 해당 컴포넌트에 아이템을 추가하는 로직을 구현하는 과정을 다룹니다. 먼저, 인벤토리가 저장할 수 있는 최대 슬롯 수를 정의하기 위해 `Capacity` 프로퍼티를 추가합니다. 이 프로퍼티는 동기화(Sync)가 필요 없는 로컬 변수로 설정되며, 기본값은 16으로 지정됩니다. ```lua [None] integer Capacity = 16 ``` 다음으로, 인벤토리에 아이템을 실제로 추가하는 `AddItem()` 메서 [original] | `SimpleInventory` 컴포넌트 아이템을 인벤토리에 추가할 수 있도록 만들어 봅시다. 1. **Capacity** 프로퍼티를 추가합니다. ```lua [None] integer Capacity = 16 ``` 2. 새로운 integer 타입의 `AddItem()` 함수를 추가합니다. 매개변수 **itemId, itemCount**를 추가합니다. 인벤토리에 아이템을 추가할 수 있도록 작성합니다. `AddItem()` 함수는 아래와 같이 동작합니다 * **itemId**에 해당하는 아 [chunk_id] | Guides:1114:1

[task] | extract_knowledge [title] | 3. 인벤토리 데이터 저장 및 불러오기 [category] | Guides [rephrased] | # 인벤토리 데이터 직렬화 및 자동 저장 ## 개념 설명 인벤토리 시스템에서 플레이어의 자산(메소, 아이템 스택)은 서버 재시작이나 세션 종료 시에도 유지되어야 하므로 영속적 저장소(DataStorage)에 저장해야 합니다. `DataStorage`는 구조화된 데이터를 문자열 형태로 저장하므로, 메모리에 존재하는 인벤토리 객체들을 직렬화(Serialize)하는 과정이 필요합니다. 직렬화 시 메소(`Meso`)와 아이템 스택(`ItemStacks`)을 하나의 테이블로 묶은 후 JSON 형식의 문자열로 변환하여 저장합니다. 또한, [original] | 11. 새로운 string 타입의 `Serialize()` 함수를 추가합니다. 메소와 아이템 데이터를 DataStorage에 저장할 수 있도록 아래와 같이 작성합니다. 메소와 아이템을 하나의 테이블에 담고 Json 포맷으로 변환합니다. ```lua string Serialize () { local dataTable = {} local itemStacks = {} dataTable.Meso = self.Meso [chunk_id] | Guides:1113:3

[task] | diverse_qa [title] | 4. 아이템을 인벤토리에 추가하기 [category] | Guides [rephrased] | 질문: `SimpleInventory` 컴포넌트에 인벤토리의 용량을 나타내기 위해 어떤 프로퍼티를 추가해야 하나요? 답변: `integer` 타입의 `Capacity` 프로퍼티를 추가해야 합니다. 질문: `Capacity` 프로퍼티의 초기값은 얼마로 설정되었나요? 답변: `Capacity` 프로퍼티의 초기값은 16으로 설정되었습니다. 질문: 인벤토리에 아이템을 추가하기 위해 작성해야 하는 함수의 이름과 반환 타입은 무엇인가요? 답변: 함수 이름은 `AddItem()`이며, 반환 타입은 `integer`입니다. 질문: `AddI [original] | `SimpleInventory` 컴포넌트 아이템을 인벤토리에 추가할 수 있도록 만들어 봅시다. 1. **Capacity** 프로퍼티를 추가합니다. ```lua [None] integer Capacity = 16 ``` 2. 새로운 integer 타입의 `AddItem()` 함수를 추가합니다. 매개변수 **itemId, itemCount**를 추가합니다. 인벤토리에 아이템을 추가할 수 있도록 작성합니다. `AddItem()` 함수는 아래와 같이 동작합니다 * **itemId**에 해당하는 아 [chunk_id] | Guides:1114:1

[task] | distill [title] | 4. 아이템을 인벤토리에 추가하기 [category] | Guides [rephrased] | ## 4. 인벤토리 추가 이벤트 전송 `SendItemAddedEvent()` 메서드를 생성하여 서버에서 클라이언트로 아이템 추가 정보를 전달합니다. * **매개변수**: `stack` (타입: `ItemStack`) * **동작 규칙**: * `SimpleInventoryItemAddedEvent` 객체를 생성하고 `SlotIndex`, `ItemId`, `Count`를 `stack`에서 복사합니다. * `self.Entity:SendEvent(event)`로 이벤트를 브로드캐스트합니다. * [original] | 4. `SendItemAddedEvent()` 함수를 생성합니다. 매개변수 타입은 **StructType - ItemStack** 으로 설정하고, 매개변수 **stack**을 추가합니다. ```lua [server only] void SendItemAddedEvent (ItemStack stack) { local event = SimpleInventoryItemAddedEvent() event.SlotIndex = stack.SlotIndex event.Ite [chunk_id] | Guides:1114:3

[task] | extract_knowledge [title] | 3. 인벤토리 데이터 저장 및 불러오기 [category] | Guides [rephrased] | # 인벤토리 데이터 저장 및 불러오기 ## 1. 개념 설명 mLua 환경에서 플레이어의 인벤토리 상태(메소, 아이템 스택)를 영구적으로 유지하기 위해 `DataStorageService`를 활용합니다. 클라이언트나 서버 메모리에만 존재하는 데이터는 세션 종료 시 사라지므로, 서버 측에서 데이터를 직렬화(Serialize)하여 저장소에 기록하고, 세션 시작 시 역직렬화(Deserialize)하여 복원하는 구조가 필요합니다. 이 가이드에서는 `SimpleInventory` 컴포넌트를 예로 들어, `HttpService`의 JSON [original] | 1. **Workspace - MyDesk - Create Scripts - Create Component**에서 새로운 `SimpleInventory` 컴포넌트를 생성합니다. `SimpleInventory` 컴포넌트를 **DefaultPlayer**에 추가합니다. 2. **Meso, ItemStacks** 프로퍼티를 추가합니다. ```lua Property: [None] integer Meso = 10000 [None] table ItemStacks = {} ``` 3 [chunk_id] | Guides:1113:1

[task] | knowledge_list [title] | 4. 아이템을 인벤토리에 추가하기 [category] | Guides [rephrased] | 1. `SendItemAddedEvent()` 함수는 `[server only]` 실행 공간에서 정의되며, 매개변수로 `ItemStack` 타입의 `stack`을 수신합니다. 2. 함수 내부에서 `SimpleInventoryItemAddedEvent()` 객체를 생성하여, 매개변수 `stack`의 `SlotIndex`, `ItemId`, `Count` 값을 각각 이벤트 객체의 `SlotIndex`, `ItemId`, `ItemCount` 프로퍼티에 대입합니다. 3. 생성된 이벤트 객체를 `self.Entity:SendEvent(ev [original] | 4. `SendItemAddedEvent()` 함수를 생성합니다. 매개변수 타입은 **StructType - ItemStack** 으로 설정하고, 매개변수 **stack**을 추가합니다. ```lua [server only] void SendItemAddedEvent (ItemStack stack) { local event = SimpleInventoryItemAddedEvent() event.SlotIndex = stack.SlotIndex event.Ite [chunk_id] | Guides:1114:3

[task] | extract_knowledge [title] | 3. 인벤토리 데이터 저장 및 불러오기 [category] | Guides [rephrased] | # 인벤토리 데이터 저장 및 불러오기: 서버-클라이언트 동기화 본 절에서는 `SimpleInventory` 컴포넌트에서 서버의 인벤토리 상태(Meso, ItemStacks)를 클라이언트로 전달하고, 플레이어 퇴장 시 데이터를 저장하는 로직을 구현하는 방법을 다룹니다. ## 개념 설명 멀티플레이어 환경에서 인벤토리 상태는 서버에서 관리되며, 클라이언트는 이를 수신하여 UI나 시각적 요소를 업데이트해야 합니다. 1. **초기화 동기화**: 서버가 인벤토리 데이터를 로드하거나 초기화한 후, 해당 상태를 클라이언트로 전송합니다. 2 [original] | ```lua [server only] void SendInitializedEvent () { local event = SimpleInventoryInitializedEvent() event.Meso = self.Meso event.ItemStacks = self.ItemStacks self.Entity:SendEvent(event) } ``` 7. `SimpleInventory` 컴포넌트에서 `SendInitializedEventToCli [chunk_id] | Guides:1113:2

[task] | diverse_qa [title] | 3. 인벤토리 데이터 저장 및 불러오기 [category] | Guides [rephrased] | 질문: `SimpleInventory` 컴포넌트에서 `Meso` 프로퍼티의 초기값은 얼마입니까? 답변: `Meso` 프로퍼티의 초기값은 10000입니다. 질문: `OnBeginPlay` 메서드에서 사용자 인벤토리 데이터를 불러오기 위해 호출하는 서비스와 메서드는 무엇입니까? 답변: `_DataStorageService:GetUserDataStorage(userId)`를 호출하여 `userDataStorage` 객체를 얻고, 이 객체의 `GetAndWait("SimpleInventoryData")` 메서드를 호출하여 데이터를 불러옵 [original] | # 전체 스크립트 #### SimpleInventory ```lua Property: [None] integer Meso = 10000 [None] table ItemStacks = {} Method: [server only] void OnBeginPlay() { -- 데이터 스토리지에서 인벤토리 데이터를 불러옴 local userId = self.Entity.PlayerComponent.UserId local userDataStorage = _DataStorageService:GetUserDataSt [chunk_id] | Guides:1113:4

[task] | wikipedia [title] | 4. 아이템을 인벤토리에 추가하기 [category] | Guides [rephrased] | **4. `SendItemAddedEvent()` 함수를 인벤토리에 추가하기** 인벤토리 시스템에서 아이템이 추가되었음을 클라이언트에 알리기 위해 `SendItemAddedEvent()` 함수를 생성해야 합니다. 이 함수는 서버에서만 실행되며, 매개변수로 **StructType - ItemStack** 타입을 가지며, 해당 매개변수의 이름은 `stack`으로 설정됩니다. 함수 본문에서는 `SimpleInventoryItemAddedEvent` 객체를 생성하여 `stack` 변수에서 가져온 `SlotIndex`, `ItemId`, [original] | 4. `SendItemAddedEvent()` 함수를 생성합니다. 매개변수 타입은 **StructType - ItemStack** 으로 설정하고, 매개변수 **stack**을 추가합니다. ```lua [server only] void SendItemAddedEvent (ItemStack stack) { local event = SimpleInventoryItemAddedEvent() event.SlotIndex = stack.SlotIndex event.Ite [chunk_id] | Guides:1114:3

[task] | knowledge_list [title] | 4. 아이템을 인벤토리에 추가하기 [category] | Guides [rephrased] | 제시된 문서의 내용만을 바탕으로 추출한 핵심 사실 목록입니다. 1. `AddItem` 메서드는 `[server only]` 실행 공간에서 동작하며, 매개변수 `string itemId`와 `integer itemCount`를 받아 `integer` 타입으로 반환합니다. 2. `AddItem` 메서드는 `_Data.ItemTable`의 `itemId` 키를 통해 아이템 정보를 조회하며, 정보가 없거나 `itemCount`가 0 이하인 경우 `log_error`를 출력하고 함수를 종료합니다. 3. `AddItem` 메서드는 `item [original] | ```lua [server only] integer AddItem (string itemId, integer itemCount) { local itemInfo = _Data.ItemTable[itemId] if itemInfo == nil then log_error("[SimpleInventory] (AddItem) 아이템 Id 오류: " .. itemId) return end if item [chunk_id] | Guides:1114:2

[task] | extract_knowledge [title] | 4. 아이템을 인벤토리에 추가하기 [category] | Guides [rephrased] | # 4.1 아이템을 인벤토리에 추가하기 ## 개념 설명 `SimpleInventory` 컴포넌트는 아이템을 인벤토리에 저장하는 기능을 제공합니다. 인벤토리의 총 용량(`Capacity`)을 초과하지 않는 범위 내에서 아이템을 슬롯에 배치하며, 각 슬롯은 `MaxStackCount`를 초과할 수 없습니다. 아이템 추가 시에는 기존에 일부 채워진 슬롯을 우선적으로 채운 후, 남은 수량만큼 새 슬롯을 할당합니다. ## API 사용법 ### 1. 프로퍼티 정의 인벤토리의 최대 슬롯 수를 지정하기 위해 `Capacity` 프로퍼티를 정 [original] | `SimpleInventory` 컴포넌트 아이템을 인벤토리에 추가할 수 있도록 만들어 봅시다. 1. **Capacity** 프로퍼티를 추가합니다. ```lua [None] integer Capacity = 16 ``` 2. 새로운 integer 타입의 `AddItem()` 함수를 추가합니다. 매개변수 **itemId, itemCount**를 추가합니다. 인벤토리에 아이템을 추가할 수 있도록 작성합니다. `AddItem()` 함수는 아래와 같이 동작합니다 * **itemId**에 해당하는 아 [chunk_id] | Guides:1114:1