Implement CookingMgr class (#113)

* Added CookingMgr fields and started on ctor

* Implemented CookItem::copy

* Implemented CookingMgr dtor

* Marked CookingMgr createInstance as matching

* Implemented CookingMgr::getCookItem

* Added CookingMgr::cook decl

* Added CookingMgr method decls

* Replaced part of CookingMgr with sead::FixedObjArray

* Added line separators in cookManager.h

* Defined structs Ingredient and BoostArg in CookingMgr

* Defined structs CookArg and CookIngredient

* Renamed some fields of CookingMgr

* Added struct CookingMgr::CookingEffectEntry

* Started implementing CookingMgr::init

* Set more entries in init

* Set field _548

* Set field default values in init

* Loaded string values from config

* Set mCookingEffectEntries in init

* Added conditional mConfig allocation

* Added FixedTreeMap class to sead

* Used FixedTreeMap in CookingMgr

* Set CookingMgr constructor to default and marked it as matching

* Removed field _31C from CookingMgr

* Updated sead

* Cleared _548 before filling

* Used name hash for _548 keys

* Fixed path setup

* Changed type of _548 to sead::FixedTreeMap<u32, u32, 13>

* Set mNMSSR to correct values

* Fixed field init order

* Rearranged variables

* Swapped entry_hash comparisons

* Changed CRC32 names and index values

* Cast i to u64

* Renamed static crc32 variables

* Renamed _548 to mCookingEffectNameIdMap

* Marked static vars as const and used decimal numbers

* Used sead::SafeArray for mNMMR and mNMSSR

* Rearranged mNMMR and mNMSSR conditions

* Removed size check from mNMMR and mNMSSR conditions

* Removed size check from CEI conditions

* Renamed mRes2 to mResHandle

* Renamed cook args

* Moved crc32 statics into Constants struct

* Marked CookingMgr::init as matching

* Renamed Constants to Crc32Constants

* Added cookFail and cookFailForMissingConfig

* Added NumIngredientsMax, NumEffects, and NumEffectSlots constants

* Renamed getCookItem to setCookItem

* Renamed x to getCookItem

* Implemented getCookItem

* Made setCookItem take a const ref

* Decompiled cookCalcItemPrice

* Marked cookCalcItemPrice as const

* Fixed both cookFail and cookFailForMissingConfig

* Added CookItem::reset

* Added CookingMgr::resetCookItem

* Moved ctor and dtor below static variables

* Changed cookFailForMissingConfig arg to sead::SafeString

* Started on cookCalcBoost

* Moved CookItem into cookManager.h

* Moved Cooking into Game

* Moved CookingMgr to uking namespace

* Inlined CookItem::reset

* Renamed CookItem members

* Fixed CookItem mangled names in uking_functions.csv

* Added enum class CookEffectId

* Moved CookingMgr ctor below disposer impl

* Updated sead

* Started on cookHandleBoostSuccessInner

* Made changes to cookCalcBoost and cookHandleBoostSuccessInner

* Extracted cookHandleBoostMonsterExtractInner

* Removed found_monster_extract in cookCalcBoost

* Marked cookCalcBoost as matching

* Got cookHandleBoostMonsterExtractInner matching

* Made changes to cookHandleBoostSuccessInner

* Renamed discriminator to bonus in cookHandleBoostSuccessInner

* Added CookingMgr::cookCalcSpiceBoost

* Made changes to CookingMgr::cookCalcSpiceBoost

* Added CookingMgr::cookCalcPotencyBoost

* Mostly matched CookingMgr::cookCalcPotencyBoost

* Added CookingMgr::getCookEffectId

* Used getCookEffectId in cookCalcPotencyBoost

* Set access modifiers in CookingMgr

* Made cookCalcPotencyBoost const-correct

* Marked global init as mismatching

* Renamed CookingMgr functions in uking_functions.csv

* Added CookingMgr::prepareCookArg

* Added IngredientArray type

* Added cookWithItems

* Added CookingMgr::prepareCookArg

* Fixed getCookEffectId

* Fixed cookCalcPotencyBoost

* Made changes to prepareCookArg

* Got cookWithItems matching

* Marked vars const

* Removed commented-out destructor and UnkItem

* Renamed CookIngredient._58 to count

* Started on CookingMgr::cook

* Extracted cookAdjustItem

* Fixed ingredient setup

* Extracted actor_info_data

* Fixed some control flow for single ingredients

* Fixed more control flow for single ingredients

* Handled no effect and empty actor name

* Renamed Ingredient::_10 to used_in_recipe

* Fixed recipe control flow

* Matched cookAdjustItem

* Fixed InfoData instance uses

* Removed BAD_RECIPE label

* Rearranged to remove goto

* Added cookCalcRecipeBoost

* Extracted getCookEffectId

* Extracted isCookFailure and isMedicine

* Extracted getCookEffectIdFromTreeMap

* Extracted findIngredientByName and findIngredientByTag

* Marked nonmatching functions

* Added resetArgCookData

* Matched resetArgCookData and prepareCookArg

* Added fields and handleMessage to CookPotRoot

* Started on CookPotRoot::init_

* Added hasMonsterExtract

* Added to CookPotRoot::handleMessage_

* Removed Ingredient::_4 field

* Renamed CookItem::_224 to is_crit

* Renamed CookingEffectEntry members

* Renamed CookingMgr fields

* Changed comparison in cook

* Renamed actor_tag_iter to hash_iter and added num checks

* Got cookCalcSpiceBoost closer to matching

* Removed int_val init from cookCalcSpiceBoost

* Inlined actor_data

* Added `using namespace ksys::act`

* Moved int_val outside loop

* Marked cookCalcSpiceBoost as matching

* Rearranged cookHandleBoostSuccessInner

* Renamed cookCalcPotencyBoost to cookCalcIngredientsBoost

* Renamed stamina_recover to vitality_boost

* Renamed CookItem args to cook_item

* Renamed cookFailForMissingConfig arg

* Used IngredientArray in findIngredient functions

* Renamed crit functions

* Renamed getCookEffectId arg

* Renamed getCookEffectId to getCookEffectIdByName

* Added SetCookItemInDemo::oneShot_

* Matched SetCookItemInDemo::oneShot_

* Added comment about CookArg constructor and formatted

* Removed TODO from CookingMgr

* Marked WIP functions as non-matching

* Fixed formatting

* Matched sead::SafeArray<uking::CookIngredient, 5>::SafeArray

* Added BoostArg default member initializers

* Used auto for cooking_mgr in CookPotRoot::handleMessage_

* Used designated initializers for boost_arg and added whitespace

* Used angle brackets for sead import

* Removed [[maybe_unused]] from declaration

* Used safeDelete

* Inverted condition in CookingMgr::cookCalcCritBoost

* Added getCookingEffectEntry getter and moved CookingEffectEntry up

* Cleaned up CookingMgr::cookCalcSpiceBoost

* Used loops to init ingredient num members

* Converted CookingMgr fields to s32

* Cleaned up CookingMgr::cookCalcItemPrice

* Renamed CookItem::item_price to sell_price

* Used min and max in CookingMgr::cookCalcItemPrice

* Inlined count vars in CookingMgr::cookCalcItemPrice

* Removed explicit casts in CookingMgr::cookCalcItemPrice

* Cleaned up and reformatted CookingMgr::cookCalcIngredientsBoost

* Added casts back into CookingMgr::cookCalcItemPrice to silence warnings

src/Game/AI/AI/aiCookPotRoot.cpp

@@ -1,4 +1,11 @@
 #include "Game/AI/AI/aiCookPotRoot.h"
+#include "Game/DLC/aocHardModeManager.h"
+#include "Game/UI/uiPauseMenuDataMgr.h"
+#include "KingSystem/ActorSystem/Attention/actAttention.h"
+#include "KingSystem/ActorSystem/actActor.h"
+#include "KingSystem/Utils/Thread/Message.h"
+#include "KingSystem/World/worldEnvMgr.h"
+#include "KingSystem/World/worldManager.h"
 
 namespace uking::ai {
 
@@ -6,8 +13,20 @@ CookPotRoot::CookPotRoot(const InitArg& arg) : ksys::act::ai::Ai(arg) {}
 
 CookPotRoot::~CookPotRoot() = default;
 
+// NON_MATCHING
 bool CookPotRoot::init_(sead::Heap* heap) {
-    return ksys::act::ai::Ai::init_(heap);
+    auto* ingredients =
+        new (heap, std::nothrow) sead::FixedSafeString<64>[CookingMgr::NumIngredientsMax];
+    mCookIngredients.setBuffer(CookingMgr::NumIngredientsMax, ingredients);
+    if (!mCookIngredients.isBufferReady()) {
+        return false;
+    }
+    if (*mInitBurnState_m) {
+        // TODO
+    }
+    mActor->getChemicalStuff();
+    mProcLink.reset();
+    return true;
 }
 
 void CookPotRoot::enter_(ksys::act::ai::InlineParamPack* params) {
@@ -23,4 +42,68 @@ void CookPotRoot::loadParams_() {
     getAITreeVariable(&mCurrentCookResultHolder_a, "CurrentCookResultHolder");
 }
 
+// NON_MATCHING
+bool CookPotRoot::handleMessage_(const ksys::Message& message) {
+    if (message.getType().value == (u32)ksys::act::AttActionCode::Cook) {
+        // 着火: "ignition" or "on fire"
+        // This is checking if the pot is lit.
+        if (isCurrentChild("着火")) {
+            // TODO: sub_7100EDC4B8
+            // TODO: GameSceneSubsys12 class
+            // GameSceneSubsys12 handles carried items.
+            // This needs to check if the player is targeting the pot.
+            if (true /* TODO */) {
+                if (!_48 /* TODO */) {
+                    _48 = true;
+
+                    const int num_ingredients = 5;  // TODO
+                    auto* cooking_mgr = CookingMgr::instance();
+
+                    cooking_mgr->resetArgCookData(mCookArg, mCookIngredients, num_ingredients,
+                                                  mCookItem);
+
+                    CookingMgr::BoostArg boost_arg{.always_boost = false,
+                                                   .enable_random_boost = true};
+
+                    if (ksys::world::Manager::instance()->getEnvMgr()->isInBloodMoonTimeRange()) {
+                        boost_arg.always_boost = true;
+                    }
+
+                    if (cooking_mgr->cook(mCookArg, mCookItem, boost_arg)) {
+                        if (const auto* hard_mode_manager = aoc::HardModeManager::instance()) {
+                            if (hard_mode_manager->checkFlag(
+                                    aoc::HardModeManager::Flag::EnableHardMode)) {
+                                if (hard_mode_manager->isHardModeChangeOn(
+                                        aoc::HardModeManager::HardModeChange::NerfHpRestore)) {
+                                    hard_mode_manager->nerfHpRestore(&mCookItem.life_recover);
+                                }
+                            }
+                        }
+                        if (true /* TODO: callCookingDemo */) {
+                            ui::PauseMenuDataMgr::instance()->removeGrabbedItems();
+                            cooking_mgr->setCookItem(mCookItem);
+                            mHasFinishedCookItem = true;
+                            return true;
+                        }
+                        _48 = false;
+                        mHasFinishedCookItem = false;
+                        // TODO
+                    } else {
+                        _48 = false;
+                        mHasFinishedCookItem = false;
+                        // TODO
+                    }
+                }
+            }
+        }
+    }
+
+    if (message.getType().value != (u32)ksys::act::AttActionCode::KillTime) {
+        return false;
+    }
+
+    // TODO: callDemo007_1
+    return isCurrentChild("着火");
+}
+
 }  // namespace uking::ai

src/Game/AI/AI/aiCookPotRoot.h

@@ -1,6 +1,8 @@
 #pragma once
 
+#include "Game/Cooking/cookManager.h"
 #include "KingSystem/ActorSystem/actAiAi.h"
+#include "KingSystem/ActorSystem/actBaseProcLink.h"
 
 namespace uking::ai {
 
@@ -14,12 +16,34 @@ public:
     void enter_(ksys::act::ai::InlineParamPack* params) override;
     void leave_() override;
     void loadParams_() override;
+    bool handleMessage_(const ksys::Message& message) override;
 
 protected:
     // map_unit_param at offset 0x38
     const bool* mInitBurnState_m{};
     // aitree_variable at offset 0x40
     void* mCurrentCookResultHolder_a{};
+    bool _48;
+    bool mHasFinishedCookItem;
+    u8 _4A[6];
+    CookArg mCookArg;
+    sead::Buffer<sead::FixedSafeString<64>> mCookIngredients;
+    u8 _240;
+    u8 _241;
+    u8 _242[6];
+    // vtable
+    void* _248;
+    s64 _250;
+    s32 _258;
+    u8 _25C[4];
+    u8 _260[8];
+    u32 _268;
+    ksys::act::BaseProcLink mProcLink;
+    s32 _280;
+    // vtable
+    void* _288;
+    CookItem mCookItem;
 };
+KSYS_CHECK_SIZE_NX150(CookPotRoot, 0x4B8);
 
 }  // namespace uking::ai

src/Game/AI/Action/actionSetCookItemInDemo.cpp

@@ -1,4 +1,6 @@
 #include "Game/AI/Action/actionSetCookItemInDemo.h"
+#include "Game/Cooking/cookManager.h"
+#include "Game/UI/uiPauseMenuDataMgr.h"
 
 namespace uking::action {
 
@@ -10,6 +12,27 @@ bool SetCookItemInDemo::init_(sead::Heap* heap) {
     return ksys::act::ai::Action::init_(heap);
 }
 
+bool SetCookItemInDemo::oneShot_() {
+    CookItem cook_item{};
+
+    CookingMgr::BoostArg boost_arg{};
+
+    s32 adjusted_set_num = sead::Mathi::clampMin(*mSetNum_d, 1);
+
+    bool result = CookingMgr::instance()->cookWithItems(mPorchItemName01_d, mPorchItemName02_d,
+                                                        mPorchItemName03_d, mPorchItemName04_d,
+                                                        mPorchItemName05_d, cook_item, boost_arg);
+
+    if (!ui::PauseMenuDataMgr::instance() || !result)
+        return false;
+
+    for (int i = 0; i < adjusted_set_num; i++) {
+        ui::PauseMenuDataMgr::instance()->cookItemGet(cook_item);
+    }
+
+    return true;
+}
+
 void SetCookItemInDemo::loadParams_() {
     getDynamicParam(&mSetNum_d, "SetNum");
     getDynamicParam(&mPorchItemName01_d, "PorchItemName01");

src/Game/AI/Action/actionSetCookItemInDemo.h

@@ -11,6 +11,7 @@ public:
     ~SetCookItemInDemo() override;
 
     bool init_(sead::Heap* heap) override;
+    bool oneShot_() override;
     void loadParams_() override;
 
 protected:

src/Game/CMakeLists.txt

@@ -1,5 +1,6 @@
 add_subdirectory(Actor)
 add_subdirectory(AI)
+add_subdirectory(Cooking)
 add_subdirectory(Damage)
 add_subdirectory(DLC)
 add_subdirectory(UI)

src/Game/Cooking/CMakeLists.txt

@@ -1,6 +1,4 @@
 target_sources(uking PRIVATE
-  cookItem.cpp
-  cookItem.h
   cookManager.cpp
   cookManager.h
 )

src/Game/Cooking/cookManager.h

@@ -0,0 +1,181 @@
+#pragma once
+
+#include <container/seadBuffer.h>
+#include <container/seadSafeArray.h>
+#include <container/seadTreeMap.h>
+#include <heap/seadDisposer.h>
+#include "KingSystem/Resource/resHandle.h"
+#include "KingSystem/Utils/Byaml/Byaml.h"
+#include "KingSystem/Utils/Types.h"
+
+namespace uking {
+
+struct CookArg;
+struct CookIngredient;
+
+enum class CookEffectId : s32 {
+    None = -1,
+    LifeRecover = 1,
+    LifeMaxUp = 2,
+    ResistHot = 4,
+    ResistCold = 5,
+    ResistElectric = 6,
+    AttackUp = 10,
+    DefenseUp = 11,
+    Quietness = 12,
+    MovingSpeed = 13,
+    GutsRecover = 14,
+    ExGutsMaxUp = 15,
+    Fireproof = 16,
+};
+
+struct CookItem {
+    CookItem();
+
+    void reset();
+    void copy(CookItem& to) const;
+
+    sead::FixedSafeString<64> actor_name{""};
+    sead::SafeArray<sead::FixedSafeString<64>, 5> ingredients;
+    f32 life_recover{};
+    s32 effect_time{};
+    s32 sell_price{};
+    CookEffectId effect_id = CookEffectId::None;
+    /// Can refer to life bonus, stamina recover, or stamina bonus, depending on `effect_id`.
+    f32 vitality_boost{};
+    bool is_crit{};
+};
+KSYS_CHECK_SIZE_NX150(CookItem, 0x228);
+
+class CookingMgr {
+    SEAD_SINGLETON_DISPOSER(CookingMgr)
+public:
+    static constexpr s32 NumIngredientsMax = 5;
+    static constexpr s32 NumEffects = 13;
+    static constexpr s32 NumEffectSlots = 17;
+
+    struct Ingredient {
+        u32 name_hash{};
+        const CookIngredient* arg{};
+        bool used_in_recipe{};
+        al::ByamlIter actor_data{};
+    };
+
+    using IngredientArray = sead::SafeArray<Ingredient, NumIngredientsMax>;
+
+    struct BoostArg {
+        bool always_boost = false;
+        bool enable_random_boost = false;
+    };
+
+    CookingMgr();
+    ~CookingMgr();
+
+private:
+    struct CookingEffectEntry {
+        int boost_time = 0;
+        int max = 0;
+        int min = 0;
+        float multiplier = 1.0f;
+        int ssa = 1;
+    };
+
+    void cookFail(CookItem& cook_item);
+    void cookFailForMissingConfig(CookItem& cook_item, const sead::SafeString& actor_name);
+    void cookCalcCritBoost(const IngredientArray& ingredients, CookItem& cook_item,
+                           const BoostArg* boost_arg) const;
+    void cookHandleMonsterExtract(const IngredientArray& ingredients, CookItem& cook_item) const;
+    void cookHandleCrit(const IngredientArray& ingredients, CookItem& cook_item) const;
+    void cookCalcSpiceBoost(const IngredientArray& ingredients, CookItem& cook_item) const;
+    void cookCalcItemPrice(const IngredientArray& ingredients, CookItem& cook_item) const;
+    void cookCalcIngredientsBoost(const IngredientArray& ingredients, CookItem& cook_item) const;
+    void cookCalcRecipeBoost(const al::ByamlIter& recipe_iter, CookItem& cook_item) const;
+
+    void cookAdjustItem(CookItem& cook_item) const;
+
+    bool findIngredientByName(IngredientArray& ingredients, u32 name_hash,
+                              int num_ingredients) const;
+    bool findIngredientByTag(IngredientArray& ingredients, u32 tag_hash, int num_ingredients) const;
+
+    bool isCookFailure(const CookItem& cook_item) const;
+    bool isMedicine(const CookItem& cook_item) const;
+    bool hasMonsterExtract(const IngredientArray& ingredients) const;
+
+    CookingEffectEntry& getCookingEffectEntry(CookEffectId id) {
+        return mCookingEffectEntries[(int)id];
+    }
+    const CookingEffectEntry& getCookingEffectEntry(CookEffectId id) const {
+        return mCookingEffectEntries[(int)id];
+    }
+
+    CookEffectId getCookEffectId(u32 name_hash) const;
+    CookEffectId getCookEffectIdFromTreeMap(u32 name_hash) const;
+
+public:
+    CookEffectId getCookEffectIdByName(const sead::SafeString& effect_name) const;
+
+    void init(sead::Heap* heap);
+
+    bool cook(const CookArg& arg, CookItem& cook_item, const BoostArg& boost_arg);
+
+    void resetArgCookData(CookArg& arg,
+                          const sead::Buffer<sead::FixedSafeString<64>>& ingredient_names,
+                          int num_ingredients, CookItem& cook_item) const;
+
+    void
+    prepareCookArg(CookArg& arg,
+                   const sead::SafeArray<sead::FixedSafeString<64>, NumIngredientsMax>& item_names,
+                   int num_items, CookItem& cook_item) const;
+
+    bool cookWithItems(const sead::SafeString& item1, const sead::SafeString& item2,
+                       const sead::SafeString& item3, const sead::SafeString& item4,
+                       const sead::SafeString& item5, CookItem& cook_item,
+                       const CookingMgr::BoostArg& boost_arg);
+
+    void setCookItem(const CookItem& from);
+    void resetCookItem();
+    void getCookItem(CookItem& to) const;
+
+private:
+    al::ByamlIter* mConfig = nullptr;
+
+    ksys::res::Handle mResHandle;
+
+    sead::FixedSafeString<64> mFailActorName;
+    sead::FixedSafeString<64> mFairyTonicName;
+    sead::FixedSafeString<64> mMonsterExtractName;
+
+    u32 mFailActorNameHash = 0;
+    u32 mFairyTonicNameHash = 0;
+    u32 mMonsterExtractNameHash = 0;
+
+    f32 mLifeRecoverMultiplier = 1.0f;
+    f32 mFailActorLifeRecoverMultiplier = 1.0f;
+    s32 mFailActorLifeRecover = 4;
+    s32 mStoneFoodActorLifeRecover = 1;
+    s32 mCritEffectTime = 300;
+
+    sead::SafeArray<CookingEffectEntry, NumEffectSlots> mCookingEffectEntries;
+
+    sead::SafeArray<f32, NumIngredientsMax> mIngredientNumMultipliers;
+
+    sead::SafeArray<s32, NumIngredientsMax> mIngredientNumSuccessRates;
+
+    CookItem mCookItem;
+
+    sead::FixedTreeMap<u32, CookEffectId, NumEffects> mCookingEffectNameIdMap{};
+};
+KSYS_CHECK_SIZE_NX150(CookingMgr, 0x7D8);
+
+struct CookIngredient {
+    sead::FixedSafeString<64> name{""};
+    int count{};
+};
+KSYS_CHECK_SIZE_NX150(CookIngredient, 0x60);
+
+struct CookArg {
+    sead::SafeArray<CookIngredient, CookingMgr::NumIngredientsMax> ingredients;
+};
+KSYS_CHECK_SIZE_NX150(CookArg, 0x1E0);
+
+}  // namespace uking

src/Game/UI/uiPauseMenuDataMgr.cpp

@@ -5,6 +5,7 @@
 #include <math/seadMathCalcCommon.h>
 #include <prim/seadScopedLock.h>
 #include "Game/Actor/actWeapon.h"
+#include "Game/Cooking/cookManager.h"
 #include "Game/DLC/aocManager.h"
 #include "Game/UI/uiUtils.h"
 #include "Game/gameItemUtils.h"
@@ -17,7 +18,6 @@
 #include "KingSystem/ActorSystem/actInfoCommon.h"
 #include "KingSystem/ActorSystem/actInfoData.h"
 #include "KingSystem/ActorSystem/actPlayerInfo.h"
-#include "KingSystem/Cooking/cookItem.h"
 #include "KingSystem/GameData/gdtCommonFlagsUtils.h"
 #include "KingSystem/GameData/gdtSpecialFlags.h"
 #include "KingSystem/System/PlayReportMgr.h"
@@ -1017,30 +1017,30 @@ void PauseMenuDataMgr::saveToGameData(const sead::OffsetList<PouchItem>& list) c
     }
 }
 
-void PauseMenuDataMgr::cookItemGet(const ksys::CookItem& cook_item) {
+void PauseMenuDataMgr::cookItemGet(const uking::CookItem& cook_item) {
     const auto* info = ksys::act::InfoData::instance();
-    if (!info->hasTag(cook_item.name.cstr(), ksys::act::tags::CookResult))
+    if (!info->hasTag(cook_item.actor_name.cstr(), ksys::act::tags::CookResult))
         return;
 
     const auto lock = sead::makeScopedLock(mCritSection);
     auto& lists = mItemLists;
 
-    ksys::PlayReportMgr::instance()->reportDebug("PouchGet", cook_item.name);
-    const auto type = getType(cook_item.name);
-    addToPouch(cook_item.name, type, lists, 1, false);
+    ksys::PlayReportMgr::instance()->reportDebug("PouchGet", cook_item.actor_name);
+    const auto type = getType(cook_item.actor_name);
+    addToPouch(cook_item.actor_name, type, lists, 1, false);
     setCookDataOnLastAddedItem(cook_item);
     saveToGameData(lists.list1);
 }
 
-void PauseMenuDataMgr::setCookDataOnLastAddedItem(const ksys::CookItem& cook_item) {
+void PauseMenuDataMgr::setCookDataOnLastAddedItem(const uking::CookItem& cook_item) {
     if (!mLastAddedItem)
         return;
 
-    mLastAddedItem->getCookData().setStaminaRecoverY(cook_item.stamina_recover_y);
-    mLastAddedItem->getCookData().setStaminaRecoverX(cook_item.stamina_recover_x);
-    mLastAddedItem->getCookData().setCookEffect1(cook_item.cook_effect_1);
-    const int y = cook_item.cook_effect_0_y;
-    const int x = cook_item.cook_effect_0_x;
+    mLastAddedItem->getCookData().setStaminaRecoverY(cook_item.effect_time);
+    mLastAddedItem->getCookData().setStaminaRecoverX(cook_item.life_recover);
+    mLastAddedItem->getCookData().setCookEffect1(cook_item.sell_price);
+    const int y = cook_item.vitality_boost;
+    const CookEffectId x = cook_item.effect_id;
     mLastAddedItem->getCookData().setCookEffect0({float(x), float(y)});
     for (s32 i = 0; i < cook_item.ingredients.size(); ++i)
         mLastAddedItem->setIngredient(i, cook_item.ingredients[i]);

src/Game/UI/uiPauseMenuDataMgr.h

@@ -27,9 +27,9 @@ enum class WeaponModifier : u32;
 struct WeaponModifierInfo;
 }  // namespace uking::act
 
-namespace ksys {
+namespace uking {
 struct CookItem;
-}
+}  // namespace uking
 
 namespace uking::ui {
 
@@ -262,9 +262,9 @@ public:
     bool isWeaponSectionFull(const sead::SafeString& get_flag) const;
 
     void itemGet(const sead::SafeString& name, int value, const act::WeaponModifierInfo* modifier);
-    void cookItemGet(const ksys::CookItem& cook_item);
+    void cookItemGet(const uking::CookItem& cook_item);
 
-    void setCookDataOnLastAddedItem(const ksys::CookItem& cook_item);
+    void setCookDataOnLastAddedItem(const uking::CookItem& cook_item);
 
     void autoEquipLastAddedItem();
     const sead::SafeString& autoEquip(PouchItem* item, const sead::OffsetList<PouchItem>& list);

src/KingSystem/CMakeLists.txt

@@ -4,7 +4,6 @@ add_subdirectory(Resource)
 
 add_subdirectory(ActorSystem)
 add_subdirectory(Chemical)
-add_subdirectory(Cooking)
 add_subdirectory(Ecosystem)
 add_subdirectory(Effect)
 add_subdirectory(Event)

src/KingSystem/Cooking/cookItem.cpp

@@ -1,7 +0,0 @@
-#include "KingSystem/Cooking/cookItem.h"
-
-namespace ksys {
-
-CookItem::CookItem() = default;
-
-}  // namespace ksys

src/KingSystem/Cooking/cookItem.h

@@ -1,24 +0,0 @@
-#pragma once
-
-#include <basis/seadTypes.h>
-#include <container/seadSafeArray.h>
-#include <prim/seadSafeString.h>
-#include "KingSystem/Utils/Types.h"
-
-namespace ksys {
-
-struct CookItem {
-    CookItem();
-
-    sead::FixedSafeString<64> name{""};
-    sead::SafeArray<sead::FixedSafeString<64>, 5> ingredients;
-    f32 stamina_recover_x{};
-    s32 stamina_recover_y{};
-    s32 cook_effect_1{};
-    s32 cook_effect_0_x = -1;
-    f32 cook_effect_0_y{};
-    bool _224{};
-};
-KSYS_CHECK_SIZE_NX150(CookItem, 0x228);
-
-}  // namespace ksys

src/KingSystem/Cooking/cookManager.cpp

@@ -1 +0,0 @@
-#include "KingSystem/Cooking/cookManager.h"

src/KingSystem/Cooking/cookManager.h

@@ -1,15 +0,0 @@
-#pragma once
-
-#include <heap/seadDisposer.h>
-
-namespace ksys {
-
-// TODO
-class CookingMgr {
-    SEAD_SINGLETON_DISPOSER(CookingMgr)
-    CookingMgr();
-    // TODO: inline
-    ~CookingMgr();
-};
-
-}  // namespace ksys