Generate stubs for queries

src/CMakeLists.txt

@@ -1,4 +1,5 @@
 add_subdirectory(Game/AI/Action)
+add_subdirectory(Game/AI/Query)
 add_subdirectory(Game/DLC)
 
 add_subdirectory(KingSystem)

src/Game/AI/Query/CMakeLists.txt

@@ -0,0 +1,330 @@
+target_sources(uking PRIVATE
+  queryBranchByDyeColor.cpp
+  queryBranchByDyeColor.h
+  queryBranchByGameOver.cpp
+  queryBranchByGameOver.h
+  queryCanCreateMakeItemList.cpp
+  queryCanCreateMakeItemList.h
+  queryCanMarkMapPin.cpp
+  queryCanMarkMapPin.h
+  queryCheck100EnemyActiveTiming.cpp
+  queryCheck100EnemyActiveTiming.h
+  queryCheckActorAction13.cpp
+  queryCheckActorAction13.h
+  queryCheckActorAction14_2.cpp
+  queryCheckActorAction14_2.h
+  queryCheckActorAction.cpp
+  queryCheckActorAction.h
+  queryCheckAddPorchItem.cpp
+  queryCheckAddPorchItem.h
+  queryCheckAppPoint.cpp
+  queryCheckAppPoint.h
+  queryCheckAppShopSelect.cpp
+  queryCheckAppShopSelect.h
+  queryCheckAreaTransition.cpp
+  queryCheckAreaTransition.h
+  queryCheckBalladOfHeroActiveTiming.cpp
+  queryCheckBalladOfHeroActiveTiming.h
+  queryCheckContainerItem.cpp
+  queryCheckContainerItem.h
+  queryCheckCookResultStatus.cpp
+  queryCheckCookResultStatus.h
+  queryCheckCurrentMap.cpp
+  queryCheckCurrentMap.h
+  queryCheckCurseRRetryEverOnce.cpp
+  queryCheckCurseRRetryEverOnce.h
+  queryCheckDeadHorseResistered.cpp
+  queryCheckDeadHorseResistered.h
+  queryCheckDeadlyQuestEscapeTiming.cpp
+  queryCheckDeadlyQuestEscapeTiming.h
+  queryCheckDieCnt.cpp
+  queryCheckDieCnt.h
+  queryCheckDistanceForWarp.cpp
+  queryCheckDistanceForWarp.h
+  queryCheckDistanceFromPlayer.cpp
+  queryCheckDistanceFromPlayer.h
+  queryCheckDownloadItemNum.cpp
+  queryCheckDownloadItemNum.h
+  queryCheckDuringBloodyMoon.cpp
+  queryCheckDuringBloodyMoon.h
+  queryCheckDyeShopSelect.cpp
+  queryCheckDyeShopSelect.h
+  queryCheckE3Mode.cpp
+  queryCheckE3Mode.h
+  queryCheckEatActor.cpp
+  queryCheckEatActor.h
+  queryCheckElapsedTimeOfMiniGame.cpp
+  queryCheckElapsedTimeOfMiniGame.h
+  queryCheckEquipArmorSeriesType.cpp
+  queryCheckEquipArmorSeriesType.h
+  queryCheckEquipItemType.cpp
+  queryCheckEquipItemType.h
+  queryCheckEquipment.cpp
+  queryCheckEquipment.h
+  queryCheckEventCancel.cpp
+  queryCheckEventCancel.h
+  queryCheckExistActor.cpp
+  queryCheckExistActor.h
+  queryCheckExistArrow.cpp
+  queryCheckExistArrow.h
+  queryCheckExtraEnergyOfPlayer.cpp
+  queryCheckExtraEnergyOfPlayer.h
+  queryCheckExtraLifeOfPlayer.cpp
+  queryCheckExtraLifeOfPlayer.h
+  queryCheckFadeState.cpp
+  queryCheckFadeState.h
+  queryCheckFame.cpp
+  queryCheckFame.h
+  queryCheckFlag.cpp
+  queryCheckFlag.h
+  queryCheckGameDataFloat.cpp
+  queryCheckGameDataFloat.h
+  queryCheckGameDataInt.cpp
+  queryCheckGameDataInt.h
+  queryCheckGetDemoTypeFromArg.cpp
+  queryCheckGetDemoTypeFromArg.h
+  queryCheckGiveReward.cpp
+  queryCheckGiveReward.h
+  queryCheckHasManifactureArmor.cpp
+  queryCheckHasManifactureArmor.h
+  queryCheckHorseCustomizeSelect.cpp
+  queryCheckHorseCustomizeSelect.h
+  queryCheckHorseDeadCause.cpp
+  queryCheckHorseDeadCause.h
+  queryCheckHorseRegistered.cpp
+  queryCheckHorseRegistered.h
+  queryCheckHorseTakenOut.cpp
+  queryCheckHorseTakenOut.h
+  queryCheckIsOpenItemCategory.cpp
+  queryCheckIsOpenItemCategory.h
+  queryCheckItemShopDecide.cpp
+  queryCheckItemShopDecide.h
+  queryCheckItemShopPorchVacancy.cpp
+  queryCheckItemShopPorchVacancy.h
+  queryCheckItemShopSelectBuy.cpp
+  queryCheckItemShopSelectBuy.h
+  queryCheckItemShopSelect.cpp
+  queryCheckItemShopSelect.h
+  queryCheckJustBeforeEventCancel.cpp
+  queryCheckJustBeforeEventCancel.h
+  queryCheckLastDamageAttacker.cpp
+  queryCheckLastDamageAttacker.h
+  queryCheckManufactResult.cpp
+  queryCheckManufactResult.h
+  queryCheckMapArea.cpp
+  queryCheckMapArea.h
+  queryCheckMasterSwordState.cpp
+  queryCheckMasterSwordState.h
+  queryCheckMaterialValue.cpp
+  queryCheckMaterialValue.h
+  queryCheckMiniGameTime.cpp
+  queryCheckMiniGameTime.h
+  queryCheckMiniGameTimeOver.cpp
+  queryCheckMiniGameTimeOver.h
+  queryCheckNumOfBuyPicture.cpp
+  queryCheckNumOfBuyPicture.h
+  queryCheckOwnedHorseFamiliarity.cpp
+  queryCheckOwnedHorseFamiliarity.h
+  queryCheckPictureBookVacancy.cpp
+  queryCheckPictureBookVacancy.h
+  queryCheckPlacedItemSaled.cpp
+  queryCheckPlacedItemSaled.h
+  queryCheckPlayerDeadCause.cpp
+  queryCheckPlayerDeadCause.h
+  queryCheckPlayerEquip.cpp
+  queryCheckPlayerEquip.h
+  queryCheckPlayerFastFadeDead.cpp
+  queryCheckPlayerFastFadeDead.h
+  queryCheckPlayerHellType.cpp
+  queryCheckPlayerHellType.h
+  queryCheckPlayerPullSwordFailEnd.cpp
+  queryCheckPlayerPullSwordFailEnd.h
+  queryCheckPlayerRideHorse.cpp
+  queryCheckPlayerRideHorse.h
+  queryCheckPlayerRideSunazarashi.cpp
+  queryCheckPlayerRideSunazarashi.h
+  queryCheckPlayerState.cpp
+  queryCheckPlayerState.h
+  queryCheckPlayerTemperatureCondition.cpp
+  queryCheckPlayerTemperatureCondition.h
+  queryCheckPlayerWeaponFired.cpp
+  queryCheckPlayerWeaponFired.h
+  queryCheckPorchInItem.cpp
+  queryCheckPorchInItem.h
+  queryCheckProConUse.cpp
+  queryCheckProConUse.h
+  queryCheckRainRatio.cpp
+  queryCheckRainRatio.h
+  queryCheckRankOfEnemyAttackedNPC.cpp
+  queryCheckRankOfEnemyAttackedNPC.h
+  queryCheckReceiveTerrorLevel.cpp
+  queryCheckReceiveTerrorLevel.h
+  queryCheckResultOfNPCConflict.cpp
+  queryCheckResultOfNPCConflict.h
+  queryCheckRoad.cpp
+  queryCheckRoad.h
+  queryCheckRupee.cpp
+  queryCheckRupee.h
+  queryCheckSelectPicture.cpp
+  queryCheckSelectPicture.h
+  queryCheckSellResult.cpp
+  queryCheckSellResult.h
+  queryCheckShopSelectedItemName.cpp
+  queryCheckShopSelectedItemName.h
+  queryCheckSiteBossDamageAnm.cpp
+  queryCheckSiteBossDamageAnm.h
+  queryCheckStage.cpp
+  queryCheckStage.h
+  queryCheckStarter.cpp
+  queryCheckStarter.h
+  queryCheckTerrorLevel.cpp
+  queryCheckTerrorLevel.h
+  queryCheckTime.cpp
+  queryCheckTime.h
+  queryCheckTimeType.cpp
+  queryCheckTimeType.h
+  queryCheckTypeOfOwnedHorseForEvent.cpp
+  queryCheckTypeOfOwnedHorseForEvent.h
+  queryCheckTypeOfWildHorseAssociated.cpp
+  queryCheckTypeOfWildHorseAssociated.h
+  queryCheckVacancyItem.cpp
+  queryCheckVacancyItem.h
+  queryCheckWarpMist.cpp
+  queryCheckWarpMist.h
+  queryCheckWeaponVacancyItem.cpp
+  queryCheckWeaponVacancyItem.h
+  queryCheckWeather.cpp
+  queryCheckWeather.h
+  queryCompareGameDataFloat.cpp
+  queryCompareGameDataFloat.h
+  queryCompareGameDataInt.cpp
+  queryCompareGameDataInt.h
+  queryCompareGameDataTime.cpp
+  queryCompareGameDataTime.h
+  queryComparePlayerFireResistantLevel.cpp
+  queryComparePlayerFireResistantLevel.h
+  queryComparePlayerHeart.cpp
+  queryComparePlayerHeart.h
+  queryComparePlayerMaxHeart.cpp
+  queryComparePlayerMaxHeart.h
+  queryComparePlayerMaxStamina.cpp
+  queryComparePlayerMaxStamina.h
+  queryComparePlayerOriginalHeart.cpp
+  queryComparePlayerOriginalHeart.h
+  queryCountFlag4.cpp
+  queryCountFlag4.h
+  queryEnemyDieCheck.cpp
+  queryEnemyDieCheck.h
+  queryEnemyRestLifeRate.cpp
+  queryEnemyRestLifeRate.h
+  queryGeneralChoice2.cpp
+  queryGeneralChoice2.h
+  queryGeneralChoice3.cpp
+  queryGeneralChoice3.h
+  queryGeneralChoice4.cpp
+  queryGeneralChoice4.h
+  queryGeneralChoice8.cpp
+  queryGeneralChoice8.h
+  queryHasArmorAlreadyDyed.cpp
+  queryHasArmorAlreadyDyed.h
+  queryHasArmorDye.cpp
+  queryHasArmorDye.h
+  queryHasCookResultInPorch.cpp
+  queryHasCookResultInPorch.h
+  queryHasEnoughPayment.cpp
+  queryHasEnoughPayment.h
+  queryHasItemDye.cpp
+  queryHasItemDye.h
+  queryHasItemDyeSpecifiedColor.cpp
+  queryHasItemDyeSpecifiedColor.h
+  queryHasPorchArrow.cpp
+  queryHasPorchArrow.h
+  queryHasPorchItemByCategory.cpp
+  queryHasPorchItemByCategory.h
+  queryHasPorchItem.cpp
+  queryHasPorchItem.h
+  queryHasPouchItemByPouchCategory.cpp
+  queryHasPouchItemByPouchCategory.h
+  queryHasSetItem.cpp
+  queryHasSetItem.h
+  queryHasSpecificArmorSeries.cpp
+  queryHasSpecificArmorSeries.h
+  queryIsAppAlreadyExchanged.cpp
+  queryIsAppAlreadyExchanged.h
+  queryIsArriveAnchorForRain.cpp
+  queryIsArriveAnchorForRain.h
+  queryIsAwakened.cpp
+  queryIsAwakened.h
+  queryIsBloodyMoonTrig.cpp
+  queryIsBloodyMoonTrig.h
+  queryIsCurrentAocFieldStage.cpp
+  queryIsCurrentAocFieldStage.h
+  queryIsCurrentCDungeonStage.cpp
+  queryIsCurrentCDungeonStage.h
+  queryIsCurrentMainFieldDungeonStage.cpp
+  queryIsCurrentMainFieldDungeonStage.h
+  queryIsCurrentMainFieldStage.cpp
+  queryIsCurrentMainFieldStage.h
+  queryIsEquipedDyedArmor.cpp
+  queryIsEquipedDyedArmor.h
+  queryIsEquippedEnableDye.cpp
+  queryIsEquippedEnableDye.h
+  queryIsEquippedWithLowerBody.cpp
+  queryIsEquippedWithLowerBody.h
+  queryIsHorseFamiliarityPassedAlready.cpp
+  queryIsHorseFamiliarityPassedAlready.h
+  queryIsHorseNumMax.cpp
+  queryIsHorseNumMax.h
+  queryIsIgnitionByArrowFire.cpp
+  queryIsIgnitionByArrowFire.h
+  queryIsItemInStock.cpp
+  queryIsItemInStock.h
+  queryIsNeedEquipWeapon.cpp
+  queryIsNeedEquipWeapon.h
+  queryIsNoEquipArmorAnyTarget.cpp
+  queryIsNoEquipArmorAnyTarget.h
+  queryIsOffLinkTag.cpp
+  queryIsOffLinkTag.h
+  queryIsOnEnterDungeonFlag.cpp
+  queryIsOnEnterDungeonFlag.h
+  queryIsOnInstEventFlag.cpp
+  queryIsOnInstEventFlag.h
+  queryIsOwnedHorseAssociated.cpp
+  queryIsOwnedHorseAssociated.h
+  queryIsPlayerGrounded.cpp
+  queryIsPlayerGrounded.h
+  queryIsRest.cpp
+  queryIsRest.h
+  queryIsRideHorse.cpp
+  queryIsRideHorse.h
+  queryIsSoldOut.cpp
+  queryIsSoldOut.h
+  queryIsSuccessEndLastDemoAction.cpp
+  queryIsSuccessEndLastDemoAction.h
+  queryIsTerrorDisappeared.cpp
+  queryIsTerrorDisappeared.h
+  queryIsWaitRevival.cpp
+  queryIsWaitRevival.h
+  queryIsWeaponDrawn.cpp
+  queryIsWeaponDrawn.h
+  queryKeyInputCheck.cpp
+  queryKeyInputCheck.h
+  queryRandomChoice2.cpp
+  queryRandomChoice2.h
+  queryRandomChoice3.cpp
+  queryRandomChoice3.h
+  queryRandomChoice4.cpp
+  queryRandomChoice4.h
+  queryRandomChoice8.cpp
+  queryRandomChoice8.h
+  queryRandomChoiceExceptOnFlag.cpp
+  queryRandomChoiceExceptOnFlag.h
+  queryWhatCurrentItem.cpp
+  queryWhatCurrentItem.h
+  queryWhatDayOfTheWeek.cpp
+  queryWhatDayOfTheWeek.h
+  queryWhatDungeonType.cpp
+  queryWhatDungeonType.h
+  queryWhatMoonName.cpp
+  queryWhatMoonName.h
+)

src/Game/AI/Query/queryBranchByDyeColor.cpp

@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryBranchByDyeColor.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+BranchByDyeColor::BranchByDyeColor(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+BranchByDyeColor::~BranchByDyeColor() = default;
+
+// FIXME: implement
+int BranchByDyeColor::doQuery() {
+    return -1;
+}
+
+void BranchByDyeColor::loadParams(const evfl::QueryArg& arg) {}
+
+void BranchByDyeColor::loadParams() {}
+
+}  // namespace uking::query

src/Game/AI/Query/queryBranchByDyeColor.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class BranchByDyeColor : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(BranchByDyeColor, Query)
+public:
+    explicit BranchByDyeColor(const InitArg& arg);
+    ~BranchByDyeColor() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query

src/Game/AI/Query/queryBranchByGameOver.cpp

@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryBranchByGameOver.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+BranchByGameOver::BranchByGameOver(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+BranchByGameOver::~BranchByGameOver() = default;
+
+// FIXME: implement
+int BranchByGameOver::doQuery() {
+    return -1;
+}
+
+void BranchByGameOver::loadParams(const evfl::QueryArg& arg) {}
+
+void BranchByGameOver::loadParams() {}
+
+}  // namespace uking::query

src/Game/AI/Query/queryBranchByGameOver.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class BranchByGameOver : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(BranchByGameOver, Query)
+public:
+    explicit BranchByGameOver(const InitArg& arg);
+    ~BranchByGameOver() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query

src/Game/AI/Query/queryCanCreateMakeItemList.cpp

@@ -0,0 +1,27 @@
+#include "Game/AI/Query/queryCanCreateMakeItemList.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CanCreateMakeItemList::CanCreateMakeItemList(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CanCreateMakeItemList::~CanCreateMakeItemList() = default;
+
+// FIXME: implement
+int CanCreateMakeItemList::doQuery() {
+    return -1;
+}
+
+void CanCreateMakeItemList::loadParams(const evfl::QueryArg& arg) {
+    loadInt(arg.param_accessor, "ShopType");
+    loadBool(arg.param_accessor, "IncludePorchMainMat");
+    loadBool(arg.param_accessor, "IncludePorchSubMat");
+}
+
+void CanCreateMakeItemList::loadParams() {
+    getDynamicParam(&mShopType, "ShopType");
+    getDynamicParam(&mIncludePorchMainMat, "IncludePorchMainMat");
+    getDynamicParam(&mIncludePorchSubMat, "IncludePorchSubMat");
+}
+
+}  // namespace uking::query

src/Game/AI/Query/queryCanCreateMakeItemList.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CanCreateMakeItemList : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CanCreateMakeItemList, Query)
+public:
+    explicit CanCreateMakeItemList(const InitArg& arg);
+    ~CanCreateMakeItemList() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    int* mShopType{};
+    bool* mIncludePorchMainMat{};
+    bool* mIncludePorchSubMat{};
+};
+
+}  // namespace uking::query

src/Game/AI/Query/queryCanMarkMapPin.cpp

@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryCanMarkMapPin.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CanMarkMapPin::CanMarkMapPin(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CanMarkMapPin::~CanMarkMapPin() = default;
+
+// FIXME: implement
+int CanMarkMapPin::doQuery() {
+    return -1;
+}
+
+void CanMarkMapPin::loadParams(const evfl::QueryArg& arg) {}
+
+void CanMarkMapPin::loadParams() {}
+
+}  // namespace uking::query

src/Game/AI/Query/queryCanMarkMapPin.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CanMarkMapPin : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CanMarkMapPin, Query)
+public:
+    explicit CanMarkMapPin(const InitArg& arg);
+    ~CanMarkMapPin() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheck100EnemyActiveTiming.cpp

@@ -0,0 +1,20 @@
+#include "Game/AI/Query/queryCheck100EnemyActiveTiming.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+Check100EnemyActiveTiming::Check100EnemyActiveTiming(const InitArg& arg)
+    : ksys::act::ai::Query(arg) {}
+
+Check100EnemyActiveTiming::~Check100EnemyActiveTiming() = default;
+
+// FIXME: implement
+int Check100EnemyActiveTiming::doQuery() {
+    return -1;
+}
+
+void Check100EnemyActiveTiming::loadParams(const evfl::QueryArg& arg) {}
+
+void Check100EnemyActiveTiming::loadParams() {}
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheck100EnemyActiveTiming.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class Check100EnemyActiveTiming : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(Check100EnemyActiveTiming, Query)
+public:
+    explicit Check100EnemyActiveTiming(const InitArg& arg);
+    ~Check100EnemyActiveTiming() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckActorAction.cpp

@@ -0,0 +1,23 @@
+#include "Game/AI/Query/queryCheckActorAction.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckActorAction::CheckActorAction(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckActorAction::~CheckActorAction() = default;
+
+// FIXME: implement
+int CheckActorAction::doQuery() {
+    return -1;
+}
+
+void CheckActorAction::loadParams(const evfl::QueryArg& arg) {
+    loadString(arg.param_accessor, "ActionName");
+}
+
+void CheckActorAction::loadParams() {
+    getDynamicParam(&mActionName, "ActionName");
+}
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckActorAction.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckActorAction : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckActorAction, Query)
+public:
+    explicit CheckActorAction(const InitArg& arg);
+    ~CheckActorAction() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    sead::SafeString mActionName{};
+};
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckActorAction13.cpp

@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryCheckActorAction13.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckActorAction13::CheckActorAction13(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckActorAction13::~CheckActorAction13() = default;
+
+// FIXME: implement
+int CheckActorAction13::doQuery() {
+    return -1;
+}
+
+void CheckActorAction13::loadParams(const evfl::QueryArg& arg) {}
+
+void CheckActorAction13::loadParams() {}
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckActorAction13.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckActorAction13 : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckActorAction13, Query)
+public:
+    explicit CheckActorAction13(const InitArg& arg);
+    ~CheckActorAction13() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckActorAction14_2.cpp

@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryCheckActorAction14_2.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckActorAction14_2::CheckActorAction14_2(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckActorAction14_2::~CheckActorAction14_2() = default;
+
+// FIXME: implement
+int CheckActorAction14_2::doQuery() {
+    return -1;
+}
+
+void CheckActorAction14_2::loadParams(const evfl::QueryArg& arg) {}
+
+void CheckActorAction14_2::loadParams() {}
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckActorAction14_2.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckActorAction14_2 : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckActorAction14_2, Query)
+public:
+    explicit CheckActorAction14_2(const InitArg& arg);
+    ~CheckActorAction14_2() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckAddPorchItem.cpp

@@ -0,0 +1,25 @@
+#include "Game/AI/Query/queryCheckAddPorchItem.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckAddPorchItem::CheckAddPorchItem(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckAddPorchItem::~CheckAddPorchItem() = default;
+
+// FIXME: implement
+int CheckAddPorchItem::doQuery() {
+    return -1;
+}
+
+void CheckAddPorchItem::loadParams(const evfl::QueryArg& arg) {
+    loadInt(arg.param_accessor, "Count");
+    loadString(arg.param_accessor, "PorchItemName");
+}
+
+void CheckAddPorchItem::loadParams() {
+    getDynamicParam(&mCount, "Count");
+    getDynamicParam(&mPorchItemName, "PorchItemName");
+}
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckAddPorchItem.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckAddPorchItem : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckAddPorchItem, Query)
+public:
+    explicit CheckAddPorchItem(const InitArg& arg);
+    ~CheckAddPorchItem() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    int* mCount{};
+    sead::SafeString mPorchItemName{};
+};
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckAppPoint.cpp

@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryCheckAppPoint.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckAppPoint::CheckAppPoint(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckAppPoint::~CheckAppPoint() = default;
+
+// FIXME: implement
+int CheckAppPoint::doQuery() {
+    return -1;
+}
+
+void CheckAppPoint::loadParams(const evfl::QueryArg& arg) {}
+
+void CheckAppPoint::loadParams() {}
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckAppPoint.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckAppPoint : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckAppPoint, Query)
+public:
+    explicit CheckAppPoint(const InitArg& arg);
+    ~CheckAppPoint() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckAppShopSelect.cpp

@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryCheckAppShopSelect.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckAppShopSelect::CheckAppShopSelect(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckAppShopSelect::~CheckAppShopSelect() = default;
+
+// FIXME: implement
+int CheckAppShopSelect::doQuery() {
+    return -1;
+}
+
+void CheckAppShopSelect::loadParams(const evfl::QueryArg& arg) {}
+
+void CheckAppShopSelect::loadParams() {}
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckAppShopSelect.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckAppShopSelect : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckAppShopSelect, Query)
+public:
+    explicit CheckAppShopSelect(const InitArg& arg);
+    ~CheckAppShopSelect() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckAreaTransition.cpp

@@ -0,0 +1,26 @@
+#include "Game/AI/Query/queryCheckAreaTransition.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckAreaTransition::CheckAreaTransition(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckAreaTransition::~CheckAreaTransition() = default;
+
+// FIXME: implement
+int CheckAreaTransition::doQuery() {
+    return -1;
+}
+
+void CheckAreaTransition::loadParams(const evfl::QueryArg& arg) {
+    loadInt(arg.param_accessor, "CurrentAreaNo");
+    loadInt(arg.param_accessor, "PostAreaNo");
+}
+
+void CheckAreaTransition::loadParams() {
+    getStaticParam(&mCheckDistFront, "CheckDistFront");
+    getDynamicParam(&mCurrentAreaNo, "CurrentAreaNo");
+    getDynamicParam(&mPostAreaNo, "PostAreaNo");
+}
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckAreaTransition.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckAreaTransition : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckAreaTransition, Query)
+public:
+    explicit CheckAreaTransition(const InitArg& arg);
+    ~CheckAreaTransition() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    const float* mCheckDistFront{};
+    int* mCurrentAreaNo{};
+    int* mPostAreaNo{};
+};
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckBalladOfHeroActiveTiming.cpp

@@ -0,0 +1,20 @@
+#include "Game/AI/Query/queryCheckBalladOfHeroActiveTiming.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckBalladOfHeroActiveTiming::CheckBalladOfHeroActiveTiming(const InitArg& arg)
+    : ksys::act::ai::Query(arg) {}
+
+CheckBalladOfHeroActiveTiming::~CheckBalladOfHeroActiveTiming() = default;
+
+// FIXME: implement
+int CheckBalladOfHeroActiveTiming::doQuery() {
+    return -1;
+}
+
+void CheckBalladOfHeroActiveTiming::loadParams(const evfl::QueryArg& arg) {}
+
+void CheckBalladOfHeroActiveTiming::loadParams() {}
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckBalladOfHeroActiveTiming.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckBalladOfHeroActiveTiming : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckBalladOfHeroActiveTiming, Query)
+public:
+    explicit CheckBalladOfHeroActiveTiming(const InitArg& arg);
+    ~CheckBalladOfHeroActiveTiming() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckContainerItem.cpp

@@ -0,0 +1,23 @@
+#include "Game/AI/Query/queryCheckContainerItem.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckContainerItem::CheckContainerItem(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckContainerItem::~CheckContainerItem() = default;
+
+// FIXME: implement
+int CheckContainerItem::doQuery() {
+    return -1;
+}
+
+void CheckContainerItem::loadParams(const evfl::QueryArg& arg) {
+    loadString(arg.param_accessor, "PorchItemName");
+}
+
+void CheckContainerItem::loadParams() {
+    getDynamicParam(&mPorchItemName, "PorchItemName");
+}
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckContainerItem.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckContainerItem : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckContainerItem, Query)
+public:
+    explicit CheckContainerItem(const InitArg& arg);
+    ~CheckContainerItem() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    sead::SafeString mPorchItemName{};
+};
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckCookResultStatus.cpp

@@ -0,0 +1,24 @@
+#include "Game/AI/Query/queryCheckCookResultStatus.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckCookResultStatus::CheckCookResultStatus(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckCookResultStatus::~CheckCookResultStatus() = default;
+
+// FIXME: implement
+int CheckCookResultStatus::doQuery() {
+    return -1;
+}
+
+void CheckCookResultStatus::loadParams(const evfl::QueryArg& arg) {
+    loadInt(arg.param_accessor, "CheckType");
+}
+
+void CheckCookResultStatus::loadParams() {
+    getDynamicParam(&mCheckType, "CheckType");
+    getAITreeVariable(&mCurrentCookResultHolder, "CurrentCookResultHolder");
+}
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckCookResultStatus.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckCookResultStatus : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckCookResultStatus, Query)
+public:
+    explicit CheckCookResultStatus(const InitArg& arg);
+    ~CheckCookResultStatus() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    int* mCheckType{};
+    void* mCurrentCookResultHolder{};
+};
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckCurrentMap.cpp

@@ -0,0 +1,23 @@
+#include "Game/AI/Query/queryCheckCurrentMap.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckCurrentMap::CheckCurrentMap(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckCurrentMap::~CheckCurrentMap() = default;
+
+// FIXME: implement
+int CheckCurrentMap::doQuery() {
+    return -1;
+}
+
+void CheckCurrentMap::loadParams(const evfl::QueryArg& arg) {
+    loadString(arg.param_accessor, "MapName");
+}
+
+void CheckCurrentMap::loadParams() {
+    getDynamicParam(&mMapName, "MapName");
+}
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckCurrentMap.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckCurrentMap : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckCurrentMap, Query)
+public:
+    explicit CheckCurrentMap(const InitArg& arg);
+    ~CheckCurrentMap() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    sead::SafeString mMapName{};
+};
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckCurseRRetryEverOnce.cpp

@@ -0,0 +1,24 @@
+#include "Game/AI/Query/queryCheckCurseRRetryEverOnce.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckCurseRRetryEverOnce::CheckCurseRRetryEverOnce(const InitArg& arg)
+    : ksys::act::ai::Query(arg) {}
+
+CheckCurseRRetryEverOnce::~CheckCurseRRetryEverOnce() = default;
+
+// FIXME: implement
+int CheckCurseRRetryEverOnce::doQuery() {
+    return -1;
+}
+
+void CheckCurseRRetryEverOnce::loadParams(const evfl::QueryArg& arg) {
+    loadInt(arg.param_accessor, "CurseRType");
+}
+
+void CheckCurseRRetryEverOnce::loadParams() {
+    getDynamicParam(&mCurseRType, "CurseRType");
+}
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckCurseRRetryEverOnce.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckCurseRRetryEverOnce : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckCurseRRetryEverOnce, Query)
+public:
+    explicit CheckCurseRRetryEverOnce(const InitArg& arg);
+    ~CheckCurseRRetryEverOnce() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    int* mCurseRType{};
+};
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckDeadHorseResistered.cpp

@@ -0,0 +1,20 @@
+#include "Game/AI/Query/queryCheckDeadHorseResistered.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckDeadHorseResistered::CheckDeadHorseResistered(const InitArg& arg)
+    : ksys::act::ai::Query(arg) {}
+
+CheckDeadHorseResistered::~CheckDeadHorseResistered() = default;
+
+// FIXME: implement
+int CheckDeadHorseResistered::doQuery() {
+    return -1;
+}
+
+void CheckDeadHorseResistered::loadParams(const evfl::QueryArg& arg) {}
+
+void CheckDeadHorseResistered::loadParams() {}
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckDeadHorseResistered.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckDeadHorseResistered : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckDeadHorseResistered, Query)
+public:
+    explicit CheckDeadHorseResistered(const InitArg& arg);
+    ~CheckDeadHorseResistered() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckDeadlyQuestEscapeTiming.cpp

@@ -0,0 +1,20 @@
+#include "Game/AI/Query/queryCheckDeadlyQuestEscapeTiming.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckDeadlyQuestEscapeTiming::CheckDeadlyQuestEscapeTiming(const InitArg& arg)
+    : ksys::act::ai::Query(arg) {}
+
+CheckDeadlyQuestEscapeTiming::~CheckDeadlyQuestEscapeTiming() = default;
+
+// FIXME: implement
+int CheckDeadlyQuestEscapeTiming::doQuery() {
+    return -1;
+}
+
+void CheckDeadlyQuestEscapeTiming::loadParams(const evfl::QueryArg& arg) {}
+
+void CheckDeadlyQuestEscapeTiming::loadParams() {}
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckDeadlyQuestEscapeTiming.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckDeadlyQuestEscapeTiming : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckDeadlyQuestEscapeTiming, Query)
+public:
+    explicit CheckDeadlyQuestEscapeTiming(const InitArg& arg);
+    ~CheckDeadlyQuestEscapeTiming() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckDieCnt.cpp

@@ -0,0 +1,25 @@
+#include "Game/AI/Query/queryCheckDieCnt.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckDieCnt::CheckDieCnt(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckDieCnt::~CheckDieCnt() = default;
+
+// FIXME: implement
+int CheckDieCnt::doQuery() {
+    return -1;
+}
+
+void CheckDieCnt::loadParams(const evfl::QueryArg& arg) {
+    loadInt(arg.param_accessor, "Count");
+    loadString(arg.param_accessor, "ActorName");
+}
+
+void CheckDieCnt::loadParams() {
+    getDynamicParam(&mCount, "Count");
+    getDynamicParam(&mActorName, "ActorName");
+}
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckDieCnt.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckDieCnt : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckDieCnt, Query)
+public:
+    explicit CheckDieCnt(const InitArg& arg);
+    ~CheckDieCnt() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    int* mCount{};
+    sead::SafeString mActorName{};
+};
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckDistanceForWarp.cpp

@@ -0,0 +1,25 @@
+#include "Game/AI/Query/queryCheckDistanceForWarp.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckDistanceForWarp::CheckDistanceForWarp(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckDistanceForWarp::~CheckDistanceForWarp() = default;
+
+// FIXME: implement
+int CheckDistanceForWarp::doQuery() {
+    return -1;
+}
+
+void CheckDistanceForWarp::loadParams(const evfl::QueryArg& arg) {
+    loadString(arg.param_accessor, "WarpDestMapName");
+    loadString(arg.param_accessor, "WarpDestPosName");
+}
+
+void CheckDistanceForWarp::loadParams() {
+    getDynamicParam(&mWarpDestMapName, "WarpDestMapName");
+    getDynamicParam(&mWarpDestPosName, "WarpDestPosName");
+}
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckDistanceForWarp.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckDistanceForWarp : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckDistanceForWarp, Query)
+public:
+    explicit CheckDistanceForWarp(const InitArg& arg);
+    ~CheckDistanceForWarp() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    sead::SafeString mWarpDestMapName{};
+    sead::SafeString mWarpDestPosName{};
+};
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckDistanceFromPlayer.cpp

@@ -0,0 +1,23 @@
+#include "Game/AI/Query/queryCheckDistanceFromPlayer.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckDistanceFromPlayer::CheckDistanceFromPlayer(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckDistanceFromPlayer::~CheckDistanceFromPlayer() = default;
+
+// FIXME: implement
+int CheckDistanceFromPlayer::doQuery() {
+    return -1;
+}
+
+void CheckDistanceFromPlayer::loadParams(const evfl::QueryArg& arg) {
+    loadFloat(arg.param_accessor, "Border");
+}
+
+void CheckDistanceFromPlayer::loadParams() {
+    getDynamicParam(&mBorder, "Border");
+}
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckDistanceFromPlayer.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckDistanceFromPlayer : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckDistanceFromPlayer, Query)
+public:
+    explicit CheckDistanceFromPlayer(const InitArg& arg);
+    ~CheckDistanceFromPlayer() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    float* mBorder{};
+};
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckDownloadItemNum.cpp

@@ -0,0 +1,25 @@
+#include "Game/AI/Query/queryCheckDownloadItemNum.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckDownloadItemNum::CheckDownloadItemNum(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckDownloadItemNum::~CheckDownloadItemNum() = default;
+
+// FIXME: implement
+int CheckDownloadItemNum::doQuery() {
+    return -1;
+}
+
+void CheckDownloadItemNum::loadParams(const evfl::QueryArg& arg) {
+    loadInt(arg.param_accessor, "CheckNum");
+    loadBool(arg.param_accessor, "IsUnityCheckBomb");
+}
+
+void CheckDownloadItemNum::loadParams() {
+    getDynamicParam(&mCheckNum, "CheckNum");
+    getDynamicParam(&mIsUnityCheckBomb, "IsUnityCheckBomb");
+}
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckDownloadItemNum.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckDownloadItemNum : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckDownloadItemNum, Query)
+public:
+    explicit CheckDownloadItemNum(const InitArg& arg);
+    ~CheckDownloadItemNum() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    int* mCheckNum{};
+    bool* mIsUnityCheckBomb{};
+};
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckDuringBloodyMoon.cpp

@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryCheckDuringBloodyMoon.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckDuringBloodyMoon::CheckDuringBloodyMoon(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckDuringBloodyMoon::~CheckDuringBloodyMoon() = default;
+
+// FIXME: implement
+int CheckDuringBloodyMoon::doQuery() {
+    return -1;
+}
+
+void CheckDuringBloodyMoon::loadParams(const evfl::QueryArg& arg) {}
+
+void CheckDuringBloodyMoon::loadParams() {}
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckDuringBloodyMoon.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckDuringBloodyMoon : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckDuringBloodyMoon, Query)
+public:
+    explicit CheckDuringBloodyMoon(const InitArg& arg);
+    ~CheckDuringBloodyMoon() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckDyeShopSelect.cpp

@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryCheckDyeShopSelect.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckDyeShopSelect::CheckDyeShopSelect(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckDyeShopSelect::~CheckDyeShopSelect() = default;
+
+// FIXME: implement
+int CheckDyeShopSelect::doQuery() {
+    return -1;
+}
+
+void CheckDyeShopSelect::loadParams(const evfl::QueryArg& arg) {}
+
+void CheckDyeShopSelect::loadParams() {}
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckDyeShopSelect.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckDyeShopSelect : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckDyeShopSelect, Query)
+public:
+    explicit CheckDyeShopSelect(const InitArg& arg);
+    ~CheckDyeShopSelect() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckE3Mode.cpp

@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryCheckE3Mode.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckE3Mode::CheckE3Mode(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckE3Mode::~CheckE3Mode() = default;
+
+// FIXME: implement
+int CheckE3Mode::doQuery() {
+    return -1;
+}
+
+void CheckE3Mode::loadParams(const evfl::QueryArg& arg) {}
+
+void CheckE3Mode::loadParams() {}
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckE3Mode.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckE3Mode : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckE3Mode, Query)
+public:
+    explicit CheckE3Mode(const InitArg& arg);
+    ~CheckE3Mode() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckEatActor.cpp

@@ -0,0 +1,24 @@
+#include "Game/AI/Query/queryCheckEatActor.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckEatActor::CheckEatActor(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckEatActor::~CheckEatActor() = default;
+
+// FIXME: implement
+int CheckEatActor::doQuery() {
+    return -1;
+}
+
+void CheckEatActor::loadParams(const evfl::QueryArg& arg) {
+    loadString(arg.param_accessor, "ActorName");
+}
+
+void CheckEatActor::loadParams() {
+    getDynamicParam(&mActorName, "ActorName");
+    getAITreeVariable(&mPrevEatActorName, "PrevEatActorName");
+}
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckEatActor.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckEatActor : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckEatActor, Query)
+public:
+    explicit CheckEatActor(const InitArg& arg);
+    ~CheckEatActor() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    sead::SafeString mActorName{};
+    sead::SafeString* mPrevEatActorName{};
+};
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckElapsedTimeOfMiniGame.cpp

@@ -0,0 +1,24 @@
+#include "Game/AI/Query/queryCheckElapsedTimeOfMiniGame.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckElapsedTimeOfMiniGame::CheckElapsedTimeOfMiniGame(const InitArg& arg)
+    : ksys::act::ai::Query(arg) {}
+
+CheckElapsedTimeOfMiniGame::~CheckElapsedTimeOfMiniGame() = default;
+
+// FIXME: implement
+int CheckElapsedTimeOfMiniGame::doQuery() {
+    return -1;
+}
+
+void CheckElapsedTimeOfMiniGame::loadParams(const evfl::QueryArg& arg) {
+    loadInt(arg.param_accessor, "Threshold");
+}
+
+void CheckElapsedTimeOfMiniGame::loadParams() {
+    getDynamicParam(&mThreshold, "Threshold");
+}
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckElapsedTimeOfMiniGame.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckElapsedTimeOfMiniGame : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckElapsedTimeOfMiniGame, Query)
+public:
+    explicit CheckElapsedTimeOfMiniGame(const InitArg& arg);
+    ~CheckElapsedTimeOfMiniGame() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    int* mThreshold{};
+};
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckEquipArmorSeriesType.cpp

@@ -0,0 +1,30 @@
+#include "Game/AI/Query/queryCheckEquipArmorSeriesType.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckEquipArmorSeriesType::CheckEquipArmorSeriesType(const InitArg& arg)
+    : ksys::act::ai::Query(arg) {}
+
+CheckEquipArmorSeriesType::~CheckEquipArmorSeriesType() = default;
+
+// FIXME: implement
+int CheckEquipArmorSeriesType::doQuery() {
+    return -1;
+}
+
+void CheckEquipArmorSeriesType::loadParams(const evfl::QueryArg& arg) {
+    loadBool(arg.param_accessor, "CheckHead");
+    loadBool(arg.param_accessor, "CheckUpper");
+    loadBool(arg.param_accessor, "CheckLower");
+    loadString(arg.param_accessor, "CheckType");
+}
+
+void CheckEquipArmorSeriesType::loadParams() {
+    getDynamicParam(&mCheckHead, "CheckHead");
+    getDynamicParam(&mCheckUpper, "CheckUpper");
+    getDynamicParam(&mCheckLower, "CheckLower");
+    getDynamicParam(&mCheckType, "CheckType");
+}
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckEquipArmorSeriesType.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckEquipArmorSeriesType : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckEquipArmorSeriesType, Query)
+public:
+    explicit CheckEquipArmorSeriesType(const InitArg& arg);
+    ~CheckEquipArmorSeriesType() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    bool* mCheckHead{};
+    bool* mCheckUpper{};
+    bool* mCheckLower{};
+    sead::SafeString mCheckType{};
+};
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckEquipItemType.cpp

@@ -0,0 +1,23 @@
+#include "Game/AI/Query/queryCheckEquipItemType.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckEquipItemType::CheckEquipItemType(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckEquipItemType::~CheckEquipItemType() = default;
+
+// FIXME: implement
+int CheckEquipItemType::doQuery() {
+    return -1;
+}
+
+void CheckEquipItemType::loadParams(const evfl::QueryArg& arg) {
+    loadString(arg.param_accessor, "CheckTargetActorName");
+}
+
+void CheckEquipItemType::loadParams() {
+    getDynamicParam(&mCheckTargetActorName, "CheckTargetActorName");
+}
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckEquipItemType.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckEquipItemType : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckEquipItemType, Query)
+public:
+    explicit CheckEquipItemType(const InitArg& arg);
+    ~CheckEquipItemType() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    sead::SafeString mCheckTargetActorName{};
+};
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckEquipment.cpp

@@ -0,0 +1,23 @@
+#include "Game/AI/Query/queryCheckEquipment.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckEquipment::CheckEquipment(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckEquipment::~CheckEquipment() = default;
+
+// FIXME: implement
+int CheckEquipment::doQuery() {
+    return -1;
+}
+
+void CheckEquipment::loadParams(const evfl::QueryArg& arg) {
+    loadString(arg.param_accessor, "EquipItemName");
+}
+
+void CheckEquipment::loadParams() {
+    getDynamicParam(&mEquipItemName, "EquipItemName");
+}
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckEquipment.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckEquipment : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckEquipment, Query)
+public:
+    explicit CheckEquipment(const InitArg& arg);
+    ~CheckEquipment() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    sead::SafeString mEquipItemName{};
+};
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckEventCancel.cpp

@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryCheckEventCancel.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckEventCancel::CheckEventCancel(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckEventCancel::~CheckEventCancel() = default;
+
+// FIXME: implement
+int CheckEventCancel::doQuery() {
+    return -1;
+}
+
+void CheckEventCancel::loadParams(const evfl::QueryArg& arg) {}
+
+void CheckEventCancel::loadParams() {}
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckEventCancel.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckEventCancel : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckEventCancel, Query)
+public:
+    explicit CheckEventCancel(const InitArg& arg);
+    ~CheckEventCancel() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckExistActor.cpp

@@ -0,0 +1,27 @@
+#include "Game/AI/Query/queryCheckExistActor.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckExistActor::CheckExistActor(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckExistActor::~CheckExistActor() = default;
+
+// FIXME: implement
+int CheckExistActor::doQuery() {
+    return -1;
+}
+
+void CheckExistActor::loadParams(const evfl::QueryArg& arg) {
+    loadBool(arg.param_accessor, "IsCheckEquipStand");
+    loadBool(arg.param_accessor, "IsCheckLife");
+    loadString(arg.param_accessor, "ActorName");
+}
+
+void CheckExistActor::loadParams() {
+    getDynamicParam(&mIsCheckEquipStand, "IsCheckEquipStand");
+    getDynamicParam(&mIsCheckLife, "IsCheckLife");
+    getDynamicParam(&mActorName, "ActorName");
+}
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckExistActor.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckExistActor : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckExistActor, Query)
+public:
+    explicit CheckExistActor(const InitArg& arg);
+    ~CheckExistActor() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    bool* mIsCheckEquipStand{};
+    bool* mIsCheckLife{};
+    sead::SafeString mActorName{};
+};
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckExistArrow.cpp

@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryCheckExistArrow.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckExistArrow::CheckExistArrow(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckExistArrow::~CheckExistArrow() = default;
+
+// FIXME: implement
+int CheckExistArrow::doQuery() {
+    return -1;
+}
+
+void CheckExistArrow::loadParams(const evfl::QueryArg& arg) {}
+
+void CheckExistArrow::loadParams() {}
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckExistArrow.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckExistArrow : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckExistArrow, Query)
+public:
+    explicit CheckExistArrow(const InitArg& arg);
+    ~CheckExistArrow() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckExtraEnergyOfPlayer.cpp

@@ -0,0 +1,24 @@
+#include "Game/AI/Query/queryCheckExtraEnergyOfPlayer.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckExtraEnergyOfPlayer::CheckExtraEnergyOfPlayer(const InitArg& arg)
+    : ksys::act::ai::Query(arg) {}
+
+CheckExtraEnergyOfPlayer::~CheckExtraEnergyOfPlayer() = default;
+
+// FIXME: implement
+int CheckExtraEnergyOfPlayer::doQuery() {
+    return -1;
+}
+
+void CheckExtraEnergyOfPlayer::loadParams(const evfl::QueryArg& arg) {
+    loadInt(arg.param_accessor, "Threshold");
+}
+
+void CheckExtraEnergyOfPlayer::loadParams() {
+    getDynamicParam(&mThreshold, "Threshold");
+}
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckExtraEnergyOfPlayer.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckExtraEnergyOfPlayer : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckExtraEnergyOfPlayer, Query)
+public:
+    explicit CheckExtraEnergyOfPlayer(const InitArg& arg);
+    ~CheckExtraEnergyOfPlayer() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    int* mThreshold{};
+};
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckExtraLifeOfPlayer.cpp

@@ -0,0 +1,23 @@
+#include "Game/AI/Query/queryCheckExtraLifeOfPlayer.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckExtraLifeOfPlayer::CheckExtraLifeOfPlayer(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckExtraLifeOfPlayer::~CheckExtraLifeOfPlayer() = default;
+
+// FIXME: implement
+int CheckExtraLifeOfPlayer::doQuery() {
+    return -1;
+}
+
+void CheckExtraLifeOfPlayer::loadParams(const evfl::QueryArg& arg) {
+    loadInt(arg.param_accessor, "Threshold");
+}
+
+void CheckExtraLifeOfPlayer::loadParams() {
+    getDynamicParam(&mThreshold, "Threshold");
+}
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckExtraLifeOfPlayer.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckExtraLifeOfPlayer : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckExtraLifeOfPlayer, Query)
+public:
+    explicit CheckExtraLifeOfPlayer(const InitArg& arg);
+    ~CheckExtraLifeOfPlayer() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    int* mThreshold{};
+};
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckFadeState.cpp

@@ -0,0 +1,25 @@
+#include "Game/AI/Query/queryCheckFadeState.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckFadeState::CheckFadeState(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckFadeState::~CheckFadeState() = default;
+
+// FIXME: implement
+int CheckFadeState::doQuery() {
+    return -1;
+}
+
+void CheckFadeState::loadParams(const evfl::QueryArg& arg) {
+    loadInt(arg.param_accessor, "FadeType");
+    loadInt(arg.param_accessor, "State");
+}
+
+void CheckFadeState::loadParams() {
+    getDynamicParam(&mFadeType, "FadeType");
+    getDynamicParam(&mState, "State");
+}
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckFadeState.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckFadeState : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckFadeState, Query)
+public:
+    explicit CheckFadeState(const InitArg& arg);
+    ~CheckFadeState() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    int* mFadeType{};
+    int* mState{};
+};
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckFame.cpp

@@ -0,0 +1,23 @@
+#include "Game/AI/Query/queryCheckFame.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckFame::CheckFame(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckFame::~CheckFame() = default;
+
+// FIXME: implement
+int CheckFame::doQuery() {
+    return -1;
+}
+
+void CheckFame::loadParams(const evfl::QueryArg& arg) {
+    loadInt(arg.param_accessor, "Value");
+}
+
+void CheckFame::loadParams() {
+    getDynamicParam(&mValue, "Value");
+}
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckFame.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckFame : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckFame, Query)
+public:
+    explicit CheckFame(const InitArg& arg);
+    ~CheckFame() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    int* mValue{};
+};
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckFlag.cpp

@@ -0,0 +1,23 @@
+#include "Game/AI/Query/queryCheckFlag.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckFlag::CheckFlag(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckFlag::~CheckFlag() = default;
+
+// FIXME: implement
+int CheckFlag::doQuery() {
+    return -1;
+}
+
+void CheckFlag::loadParams(const evfl::QueryArg& arg) {
+    loadString(arg.param_accessor, "FlagName");
+}
+
+void CheckFlag::loadParams() {
+    getDynamicParam(&mFlagName, "FlagName");
+}
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckFlag.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckFlag : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckFlag, Query)
+public:
+    explicit CheckFlag(const InitArg& arg);
+    ~CheckFlag() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    sead::SafeString mFlagName{};
+};
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckGameDataFloat.cpp

@@ -0,0 +1,27 @@
+#include "Game/AI/Query/queryCheckGameDataFloat.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckGameDataFloat::CheckGameDataFloat(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckGameDataFloat::~CheckGameDataFloat() = default;
+
+// FIXME: implement
+int CheckGameDataFloat::doQuery() {
+    return -1;
+}
+
+void CheckGameDataFloat::loadParams(const evfl::QueryArg& arg) {
+    loadFloat(arg.param_accessor, "Value");
+    loadString(arg.param_accessor, "GameDataFloatName");
+    loadString(arg.param_accessor, "Operator");
+}
+
+void CheckGameDataFloat::loadParams() {
+    getDynamicParam(&mValue, "Value");
+    getDynamicParam(&mGameDataFloatName, "GameDataFloatName");
+    getDynamicParam(&mOperator, "Operator");
+}
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckGameDataFloat.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckGameDataFloat : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckGameDataFloat, Query)
+public:
+    explicit CheckGameDataFloat(const InitArg& arg);
+    ~CheckGameDataFloat() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    float* mValue{};
+    sead::SafeString mGameDataFloatName{};
+    sead::SafeString mOperator{};
+};
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckGameDataInt.cpp

@@ -0,0 +1,27 @@
+#include "Game/AI/Query/queryCheckGameDataInt.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckGameDataInt::CheckGameDataInt(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckGameDataInt::~CheckGameDataInt() = default;
+
+// FIXME: implement
+int CheckGameDataInt::doQuery() {
+    return -1;
+}
+
+void CheckGameDataInt::loadParams(const evfl::QueryArg& arg) {
+    loadInt(arg.param_accessor, "Value");
+    loadString(arg.param_accessor, "GameDataIntName");
+    loadString(arg.param_accessor, "Operator");
+}
+
+void CheckGameDataInt::loadParams() {
+    getDynamicParam(&mValue, "Value");
+    getDynamicParam(&mGameDataIntName, "GameDataIntName");
+    getDynamicParam(&mOperator, "Operator");
+}
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckGameDataInt.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckGameDataInt : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckGameDataInt, Query)
+public:
+    explicit CheckGameDataInt(const InitArg& arg);
+    ~CheckGameDataInt() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    int* mValue{};
+    sead::SafeString mGameDataIntName{};
+    sead::SafeString mOperator{};
+};
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckGetDemoTypeFromArg.cpp

@@ -0,0 +1,25 @@
+#include "Game/AI/Query/queryCheckGetDemoTypeFromArg.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckGetDemoTypeFromArg::CheckGetDemoTypeFromArg(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckGetDemoTypeFromArg::~CheckGetDemoTypeFromArg() = default;
+
+// FIXME: implement
+int CheckGetDemoTypeFromArg::doQuery() {
+    return -1;
+}
+
+void CheckGetDemoTypeFromArg::loadParams(const evfl::QueryArg& arg) {
+    loadBool(arg.param_accessor, "UseLastTryGetItemName");
+    loadString(arg.param_accessor, "CheckTargetActorName");
+}
+
+void CheckGetDemoTypeFromArg::loadParams() {
+    getDynamicParam(&mUseLastTryGetItemName, "UseLastTryGetItemName");
+    getDynamicParam(&mCheckTargetActorName, "CheckTargetActorName");
+}
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckGetDemoTypeFromArg.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckGetDemoTypeFromArg : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckGetDemoTypeFromArg, Query)
+public:
+    explicit CheckGetDemoTypeFromArg(const InitArg& arg);
+    ~CheckGetDemoTypeFromArg() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    bool* mUseLastTryGetItemName{};
+    sead::SafeString mCheckTargetActorName{};
+};
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckGiveReward.cpp

@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryCheckGiveReward.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckGiveReward::CheckGiveReward(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckGiveReward::~CheckGiveReward() = default;
+
+// FIXME: implement
+int CheckGiveReward::doQuery() {
+    return -1;
+}
+
+void CheckGiveReward::loadParams(const evfl::QueryArg& arg) {}
+
+void CheckGiveReward::loadParams() {}
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckGiveReward.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckGiveReward : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckGiveReward, Query)
+public:
+    explicit CheckGiveReward(const InitArg& arg);
+    ~CheckGiveReward() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckHasManifactureArmor.cpp

@@ -0,0 +1,20 @@
+#include "Game/AI/Query/queryCheckHasManifactureArmor.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckHasManifactureArmor::CheckHasManifactureArmor(const InitArg& arg)
+    : ksys::act::ai::Query(arg) {}
+
+CheckHasManifactureArmor::~CheckHasManifactureArmor() = default;
+
+// FIXME: implement
+int CheckHasManifactureArmor::doQuery() {
+    return -1;
+}
+
+void CheckHasManifactureArmor::loadParams(const evfl::QueryArg& arg) {}
+
+void CheckHasManifactureArmor::loadParams() {}
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckHasManifactureArmor.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckHasManifactureArmor : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckHasManifactureArmor, Query)
+public:
+    explicit CheckHasManifactureArmor(const InitArg& arg);
+    ~CheckHasManifactureArmor() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckHorseCustomizeSelect.cpp

@@ -0,0 +1,20 @@
+#include "Game/AI/Query/queryCheckHorseCustomizeSelect.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckHorseCustomizeSelect::CheckHorseCustomizeSelect(const InitArg& arg)
+    : ksys::act::ai::Query(arg) {}
+
+CheckHorseCustomizeSelect::~CheckHorseCustomizeSelect() = default;
+
+// FIXME: implement
+int CheckHorseCustomizeSelect::doQuery() {
+    return -1;
+}
+
+void CheckHorseCustomizeSelect::loadParams(const evfl::QueryArg& arg) {}
+
+void CheckHorseCustomizeSelect::loadParams() {}
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckHorseCustomizeSelect.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckHorseCustomizeSelect : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckHorseCustomizeSelect, Query)
+public:
+    explicit CheckHorseCustomizeSelect(const InitArg& arg);
+    ~CheckHorseCustomizeSelect() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckHorseDeadCause.cpp

@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryCheckHorseDeadCause.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckHorseDeadCause::CheckHorseDeadCause(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckHorseDeadCause::~CheckHorseDeadCause() = default;
+
+// FIXME: implement
+int CheckHorseDeadCause::doQuery() {
+    return -1;
+}
+
+void CheckHorseDeadCause::loadParams(const evfl::QueryArg& arg) {}
+
+void CheckHorseDeadCause::loadParams() {}
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckHorseDeadCause.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckHorseDeadCause : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckHorseDeadCause, Query)
+public:
+    explicit CheckHorseDeadCause(const InitArg& arg);
+    ~CheckHorseDeadCause() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckHorseRegistered.cpp

@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryCheckHorseRegistered.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckHorseRegistered::CheckHorseRegistered(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckHorseRegistered::~CheckHorseRegistered() = default;
+
+// FIXME: implement
+int CheckHorseRegistered::doQuery() {
+    return -1;
+}
+
+void CheckHorseRegistered::loadParams(const evfl::QueryArg& arg) {}
+
+void CheckHorseRegistered::loadParams() {}
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckHorseRegistered.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckHorseRegistered : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckHorseRegistered, Query)
+public:
+    explicit CheckHorseRegistered(const InitArg& arg);
+    ~CheckHorseRegistered() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckHorseTakenOut.cpp

@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryCheckHorseTakenOut.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckHorseTakenOut::CheckHorseTakenOut(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckHorseTakenOut::~CheckHorseTakenOut() = default;
+
+// FIXME: implement
+int CheckHorseTakenOut::doQuery() {
+    return -1;
+}
+
+void CheckHorseTakenOut::loadParams(const evfl::QueryArg& arg) {}
+
+void CheckHorseTakenOut::loadParams() {}
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckHorseTakenOut.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckHorseTakenOut : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckHorseTakenOut, Query)
+public:
+    explicit CheckHorseTakenOut(const InitArg& arg);
+    ~CheckHorseTakenOut() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query

src/Game/AI/Query/queryCheckIsOpenItemCategory.cpp

@@ -0,0 +1,23 @@
+#include "Game/AI/Query/queryCheckIsOpenItemCategory.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckIsOpenItemCategory::CheckIsOpenItemCategory(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckIsOpenItemCategory::~CheckIsOpenItemCategory() = default;
+
+// FIXME: implement
+int CheckIsOpenItemCategory::doQuery() {
+    return -1;
+}
+
+void CheckIsOpenItemCategory::loadParams(const evfl::QueryArg& arg) {
+    loadInt(arg.param_accessor, "Category");
+}
+
+void CheckIsOpenItemCategory::loadParams() {
+    getDynamicParam(&mCategory, "Category");
+}
+
+}  // namespace uking::query