Generate stubs for queries

332 files changed, 7086 insertions, 18 deletions

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 4be82264..db44144c 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1,4 +1,5 @@
 add_subdirectory(Game/AI/Action)
+add_subdirectory(Game/AI/Query)
 add_subdirectory(Game/DLC)
 
 add_subdirectory(KingSystem)
diff --git a/src/Game/AI/Query/CMakeLists.txt b/src/Game/AI/Query/CMakeLists.txt
new file mode 100644
index 00000000..1eb2ea5d
--- /dev/null
+++ b/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
+)
diff --git a/src/Game/AI/Query/queryBranchByDyeColor.cpp b/src/Game/AI/Query/queryBranchByDyeColor.cpp
new file mode 100644
index 00000000..9b0abecc
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryBranchByDyeColor.h b/src/Game/AI/Query/queryBranchByDyeColor.h
new file mode 100644
index 00000000..40ef59c3
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryBranchByGameOver.cpp b/src/Game/AI/Query/queryBranchByGameOver.cpp
new file mode 100644
index 00000000..8ca4f1f4
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryBranchByGameOver.h b/src/Game/AI/Query/queryBranchByGameOver.h
new file mode 100644
index 00000000..7a120053
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCanCreateMakeItemList.cpp b/src/Game/AI/Query/queryCanCreateMakeItemList.cpp
new file mode 100644
index 00000000..f98cbc34
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCanCreateMakeItemList.h b/src/Game/AI/Query/queryCanCreateMakeItemList.h
new file mode 100644
index 00000000..02301cc8
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCanMarkMapPin.cpp b/src/Game/AI/Query/queryCanMarkMapPin.cpp
new file mode 100644
index 00000000..536a45c3
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCanMarkMapPin.h b/src/Game/AI/Query/queryCanMarkMapPin.h
new file mode 100644
index 00000000..215a1db7
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheck100EnemyActiveTiming.cpp b/src/Game/AI/Query/queryCheck100EnemyActiveTiming.cpp
new file mode 100644
index 00000000..5ce18a6c
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheck100EnemyActiveTiming.h b/src/Game/AI/Query/queryCheck100EnemyActiveTiming.h
new file mode 100644
index 00000000..f0d62139
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckActorAction.cpp b/src/Game/AI/Query/queryCheckActorAction.cpp
new file mode 100644
index 00000000..038467c3
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckActorAction.h b/src/Game/AI/Query/queryCheckActorAction.h
new file mode 100644
index 00000000..602d54ac
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckActorAction13.cpp b/src/Game/AI/Query/queryCheckActorAction13.cpp
new file mode 100644
index 00000000..1a34a5dd
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckActorAction13.h b/src/Game/AI/Query/queryCheckActorAction13.h
new file mode 100644
index 00000000..ffd3939a
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckActorAction14_2.cpp b/src/Game/AI/Query/queryCheckActorAction14_2.cpp
new file mode 100644
index 00000000..428606df
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckActorAction14_2.h b/src/Game/AI/Query/queryCheckActorAction14_2.h
new file mode 100644
index 00000000..d98bd0ef
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckAddPorchItem.cpp b/src/Game/AI/Query/queryCheckAddPorchItem.cpp
new file mode 100644
index 00000000..a76f739b
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckAddPorchItem.h b/src/Game/AI/Query/queryCheckAddPorchItem.h
new file mode 100644
index 00000000..ef97a2de
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckAppPoint.cpp b/src/Game/AI/Query/queryCheckAppPoint.cpp
new file mode 100644
index 00000000..013480d8
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckAppPoint.h b/src/Game/AI/Query/queryCheckAppPoint.h
new file mode 100644
index 00000000..a6b2bb17
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckAppShopSelect.cpp b/src/Game/AI/Query/queryCheckAppShopSelect.cpp
new file mode 100644
index 00000000..3fff3d10
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckAppShopSelect.h b/src/Game/AI/Query/queryCheckAppShopSelect.h
new file mode 100644
index 00000000..72e0c00d
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckAreaTransition.cpp b/src/Game/AI/Query/queryCheckAreaTransition.cpp
new file mode 100644
index 00000000..a2a15714
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckAreaTransition.h b/src/Game/AI/Query/queryCheckAreaTransition.h
new file mode 100644
index 00000000..27b15ffa
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckBalladOfHeroActiveTiming.cpp b/src/Game/AI/Query/queryCheckBalladOfHeroActiveTiming.cpp
new file mode 100644
index 00000000..36bd9351
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckBalladOfHeroActiveTiming.h b/src/Game/AI/Query/queryCheckBalladOfHeroActiveTiming.h
new file mode 100644
index 00000000..6408d9b6
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckContainerItem.cpp b/src/Game/AI/Query/queryCheckContainerItem.cpp
new file mode 100644
index 00000000..48015944
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckContainerItem.h b/src/Game/AI/Query/queryCheckContainerItem.h
new file mode 100644
index 00000000..4c673521
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckCookResultStatus.cpp b/src/Game/AI/Query/queryCheckCookResultStatus.cpp
new file mode 100644
index 00000000..d7a5d864
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckCookResultStatus.h b/src/Game/AI/Query/queryCheckCookResultStatus.h
new file mode 100644
index 00000000..d9933d79
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckCurrentMap.cpp b/src/Game/AI/Query/queryCheckCurrentMap.cpp
new file mode 100644
index 00000000..727133ec
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckCurrentMap.h b/src/Game/AI/Query/queryCheckCurrentMap.h
new file mode 100644
index 00000000..65e81dbd
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckCurseRRetryEverOnce.cpp b/src/Game/AI/Query/queryCheckCurseRRetryEverOnce.cpp
new file mode 100644
index 00000000..a7cdd3c8
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckCurseRRetryEverOnce.h b/src/Game/AI/Query/queryCheckCurseRRetryEverOnce.h
new file mode 100644
index 00000000..8356bb3b
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckDeadHorseResistered.cpp b/src/Game/AI/Query/queryCheckDeadHorseResistered.cpp
new file mode 100644
index 00000000..754b40e9
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckDeadHorseResistered.h b/src/Game/AI/Query/queryCheckDeadHorseResistered.h
new file mode 100644
index 00000000..94c6018a
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckDeadlyQuestEscapeTiming.cpp b/src/Game/AI/Query/queryCheckDeadlyQuestEscapeTiming.cpp
new file mode 100644
index 00000000..ae625e7b
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckDeadlyQuestEscapeTiming.h b/src/Game/AI/Query/queryCheckDeadlyQuestEscapeTiming.h
new file mode 100644
index 00000000..90fa7cf3
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckDieCnt.cpp b/src/Game/AI/Query/queryCheckDieCnt.cpp
new file mode 100644
index 00000000..82444bd4
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckDieCnt.h b/src/Game/AI/Query/queryCheckDieCnt.h
new file mode 100644
index 00000000..f2be2e73
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckDistanceForWarp.cpp b/src/Game/AI/Query/queryCheckDistanceForWarp.cpp
new file mode 100644
index 00000000..c8716246
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckDistanceForWarp.h b/src/Game/AI/Query/queryCheckDistanceForWarp.h
new file mode 100644
index 00000000..11f06709
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckDistanceFromPlayer.cpp b/src/Game/AI/Query/queryCheckDistanceFromPlayer.cpp
new file mode 100644
index 00000000..f7213a6e
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckDistanceFromPlayer.h b/src/Game/AI/Query/queryCheckDistanceFromPlayer.h
new file mode 100644
index 00000000..644e1e4d
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckDownloadItemNum.cpp b/src/Game/AI/Query/queryCheckDownloadItemNum.cpp
new file mode 100644
index 00000000..ae0fc93b
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckDownloadItemNum.h b/src/Game/AI/Query/queryCheckDownloadItemNum.h
new file mode 100644
index 00000000..0f713e6a
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckDuringBloodyMoon.cpp b/src/Game/AI/Query/queryCheckDuringBloodyMoon.cpp
new file mode 100644
index 00000000..6ae4f5f0
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckDuringBloodyMoon.h b/src/Game/AI/Query/queryCheckDuringBloodyMoon.h
new file mode 100644
index 00000000..f9613afb
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckDyeShopSelect.cpp b/src/Game/AI/Query/queryCheckDyeShopSelect.cpp
new file mode 100644
index 00000000..4410b2fb
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckDyeShopSelect.h b/src/Game/AI/Query/queryCheckDyeShopSelect.h
new file mode 100644
index 00000000..543cfcf8
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckE3Mode.cpp b/src/Game/AI/Query/queryCheckE3Mode.cpp
new file mode 100644
index 00000000..695e137f
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckE3Mode.h b/src/Game/AI/Query/queryCheckE3Mode.h
new file mode 100644
index 00000000..6a6d666c
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckEatActor.cpp b/src/Game/AI/Query/queryCheckEatActor.cpp
new file mode 100644
index 00000000..123708d0
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckEatActor.h b/src/Game/AI/Query/queryCheckEatActor.h
new file mode 100644
index 00000000..44294fe1
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckElapsedTimeOfMiniGame.cpp b/src/Game/AI/Query/queryCheckElapsedTimeOfMiniGame.cpp
new file mode 100644
index 00000000..d240a1f9
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckElapsedTimeOfMiniGame.h b/src/Game/AI/Query/queryCheckElapsedTimeOfMiniGame.h
new file mode 100644
index 00000000..9b022dd7
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckEquipArmorSeriesType.cpp b/src/Game/AI/Query/queryCheckEquipArmorSeriesType.cpp
new file mode 100644
index 00000000..bedc3eb1
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckEquipArmorSeriesType.h b/src/Game/AI/Query/queryCheckEquipArmorSeriesType.h
new file mode 100644
index 00000000..d438e59e
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckEquipItemType.cpp b/src/Game/AI/Query/queryCheckEquipItemType.cpp
new file mode 100644
index 00000000..591f580e
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckEquipItemType.h b/src/Game/AI/Query/queryCheckEquipItemType.h
new file mode 100644
index 00000000..b28a1478
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckEquipment.cpp b/src/Game/AI/Query/queryCheckEquipment.cpp
new file mode 100644
index 00000000..ebcf7d55
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckEquipment.h b/src/Game/AI/Query/queryCheckEquipment.h
new file mode 100644
index 00000000..c2bba39c
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckEventCancel.cpp b/src/Game/AI/Query/queryCheckEventCancel.cpp
new file mode 100644
index 00000000..792e101c
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckEventCancel.h b/src/Game/AI/Query/queryCheckEventCancel.h
new file mode 100644
index 00000000..382e1d6b
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckExistActor.cpp b/src/Game/AI/Query/queryCheckExistActor.cpp
new file mode 100644
index 00000000..2a95b817
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckExistActor.h b/src/Game/AI/Query/queryCheckExistActor.h
new file mode 100644
index 00000000..d464dacd
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckExistArrow.cpp b/src/Game/AI/Query/queryCheckExistArrow.cpp
new file mode 100644
index 00000000..4dbf9c01
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckExistArrow.h b/src/Game/AI/Query/queryCheckExistArrow.h
new file mode 100644
index 00000000..98aabf4d
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckExtraEnergyOfPlayer.cpp b/src/Game/AI/Query/queryCheckExtraEnergyOfPlayer.cpp
new file mode 100644
index 00000000..38d7f879
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckExtraEnergyOfPlayer.h b/src/Game/AI/Query/queryCheckExtraEnergyOfPlayer.h
new file mode 100644
index 00000000..06ccb0a3
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckExtraLifeOfPlayer.cpp b/src/Game/AI/Query/queryCheckExtraLifeOfPlayer.cpp
new file mode 100644
index 00000000..26d65359
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckExtraLifeOfPlayer.h b/src/Game/AI/Query/queryCheckExtraLifeOfPlayer.h
new file mode 100644
index 00000000..c2685843
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckFadeState.cpp b/src/Game/AI/Query/queryCheckFadeState.cpp
new file mode 100644
index 00000000..5092b2c7
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckFadeState.h b/src/Game/AI/Query/queryCheckFadeState.h
new file mode 100644
index 00000000..5980bb78
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckFame.cpp b/src/Game/AI/Query/queryCheckFame.cpp
new file mode 100644
index 00000000..c2bcc898
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckFame.h b/src/Game/AI/Query/queryCheckFame.h
new file mode 100644
index 00000000..da2630a5
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckFlag.cpp b/src/Game/AI/Query/queryCheckFlag.cpp
new file mode 100644
index 00000000..17f28b79
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckFlag.h b/src/Game/AI/Query/queryCheckFlag.h
new file mode 100644
index 00000000..ae1b4531
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckGameDataFloat.cpp b/src/Game/AI/Query/queryCheckGameDataFloat.cpp
new file mode 100644
index 00000000..7fbd3c47
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckGameDataFloat.h b/src/Game/AI/Query/queryCheckGameDataFloat.h
new file mode 100644
index 00000000..94a6381d
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckGameDataInt.cpp b/src/Game/AI/Query/queryCheckGameDataInt.cpp
new file mode 100644
index 00000000..e7b4c8f5
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckGameDataInt.h b/src/Game/AI/Query/queryCheckGameDataInt.h
new file mode 100644
index 00000000..4ac3126e
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckGetDemoTypeFromArg.cpp b/src/Game/AI/Query/queryCheckGetDemoTypeFromArg.cpp
new file mode 100644
index 00000000..ad81da26
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckGetDemoTypeFromArg.h b/src/Game/AI/Query/queryCheckGetDemoTypeFromArg.h
new file mode 100644
index 00000000..ce863424
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckGiveReward.cpp b/src/Game/AI/Query/queryCheckGiveReward.cpp
new file mode 100644
index 00000000..e73d1fc1
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckGiveReward.h b/src/Game/AI/Query/queryCheckGiveReward.h
new file mode 100644
index 00000000..f25d017e
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckHasManifactureArmor.cpp b/src/Game/AI/Query/queryCheckHasManifactureArmor.cpp
new file mode 100644
index 00000000..8aaa3f39
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckHasManifactureArmor.h b/src/Game/AI/Query/queryCheckHasManifactureArmor.h
new file mode 100644
index 00000000..613473cb
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckHorseCustomizeSelect.cpp b/src/Game/AI/Query/queryCheckHorseCustomizeSelect.cpp
new file mode 100644
index 00000000..6dd4d199
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckHorseCustomizeSelect.h b/src/Game/AI/Query/queryCheckHorseCustomizeSelect.h
new file mode 100644
index 00000000..a0d7b567
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckHorseDeadCause.cpp b/src/Game/AI/Query/queryCheckHorseDeadCause.cpp
new file mode 100644
index 00000000..e83365fa
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckHorseDeadCause.h b/src/Game/AI/Query/queryCheckHorseDeadCause.h
new file mode 100644
index 00000000..592ad33c
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckHorseRegistered.cpp b/src/Game/AI/Query/queryCheckHorseRegistered.cpp
new file mode 100644
index 00000000..fe631e10
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckHorseRegistered.h b/src/Game/AI/Query/queryCheckHorseRegistered.h
new file mode 100644
index 00000000..a72316b7
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckHorseTakenOut.cpp b/src/Game/AI/Query/queryCheckHorseTakenOut.cpp
new file mode 100644
index 00000000..e0d23506
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckHorseTakenOut.h b/src/Game/AI/Query/queryCheckHorseTakenOut.h
new file mode 100644
index 00000000..4f310280
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckIsOpenItemCategory.cpp b/src/Game/AI/Query/queryCheckIsOpenItemCategory.cpp
new file mode 100644
index 00000000..714e561c
--- /dev/null
+++ b/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
diff --git a/src/Game/AI/Query/queryCheckIsOpenItemCategory.h b/src/Game/AI/Query/queryCheckIsOpenItemCategory.h
new file mode 100644
index 00000000..d007d026
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckIsOpenItemCategory.h
@@ -0,0 +1,21 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckIsOpenItemCategory : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckIsOpenItemCategory, Query)
+public:
+    explicit CheckIsOpenItemCategory(const InitArg& arg);
+    ~CheckIsOpenItemCategory() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    int* mCategory{};
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckItemShopDecide.cpp b/src/Game/AI/Query/queryCheckItemShopDecide.cpp
new file mode 100644
index 00000000..6dc5e008
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckItemShopDecide.cpp
@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryCheckItemShopDecide.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckItemShopDecide::CheckItemShopDecide(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckItemShopDecide::~CheckItemShopDecide() = default;
+
+// FIXME: implement
+int CheckItemShopDecide::doQuery() {
+    return -1;
+}
+
+void CheckItemShopDecide::loadParams(const evfl::QueryArg& arg) {}
+
+void CheckItemShopDecide::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckItemShopDecide.h b/src/Game/AI/Query/queryCheckItemShopDecide.h
new file mode 100644
index 00000000..82dfd75e
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckItemShopDecide.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckItemShopDecide : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckItemShopDecide, Query)
+public:
+    explicit CheckItemShopDecide(const InitArg& arg);
+    ~CheckItemShopDecide() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckItemShopPorchVacancy.cpp b/src/Game/AI/Query/queryCheckItemShopPorchVacancy.cpp
new file mode 100644
index 00000000..4e5739ed
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckItemShopPorchVacancy.cpp
@@ -0,0 +1,20 @@
+#include "Game/AI/Query/queryCheckItemShopPorchVacancy.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckItemShopPorchVacancy::CheckItemShopPorchVacancy(const InitArg& arg)
+    : ksys::act::ai::Query(arg) {}
+
+CheckItemShopPorchVacancy::~CheckItemShopPorchVacancy() = default;
+
+// FIXME: implement
+int CheckItemShopPorchVacancy::doQuery() {
+    return -1;
+}
+
+void CheckItemShopPorchVacancy::loadParams(const evfl::QueryArg& arg) {}
+
+void CheckItemShopPorchVacancy::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckItemShopPorchVacancy.h b/src/Game/AI/Query/queryCheckItemShopPorchVacancy.h
new file mode 100644
index 00000000..1759b8ec
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckItemShopPorchVacancy.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckItemShopPorchVacancy : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckItemShopPorchVacancy, Query)
+public:
+    explicit CheckItemShopPorchVacancy(const InitArg& arg);
+    ~CheckItemShopPorchVacancy() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckItemShopSelect.cpp b/src/Game/AI/Query/queryCheckItemShopSelect.cpp
new file mode 100644
index 00000000..7b207a96
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckItemShopSelect.cpp
@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryCheckItemShopSelect.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckItemShopSelect::CheckItemShopSelect(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckItemShopSelect::~CheckItemShopSelect() = default;
+
+// FIXME: implement
+int CheckItemShopSelect::doQuery() {
+    return -1;
+}
+
+void CheckItemShopSelect::loadParams(const evfl::QueryArg& arg) {}
+
+void CheckItemShopSelect::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckItemShopSelect.h b/src/Game/AI/Query/queryCheckItemShopSelect.h
new file mode 100644
index 00000000..d18901f7
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckItemShopSelect.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckItemShopSelect : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckItemShopSelect, Query)
+public:
+    explicit CheckItemShopSelect(const InitArg& arg);
+    ~CheckItemShopSelect() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckItemShopSelectBuy.cpp b/src/Game/AI/Query/queryCheckItemShopSelectBuy.cpp
new file mode 100644
index 00000000..1b792e4a
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckItemShopSelectBuy.cpp
@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryCheckItemShopSelectBuy.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckItemShopSelectBuy::CheckItemShopSelectBuy(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckItemShopSelectBuy::~CheckItemShopSelectBuy() = default;
+
+// FIXME: implement
+int CheckItemShopSelectBuy::doQuery() {
+    return -1;
+}
+
+void CheckItemShopSelectBuy::loadParams(const evfl::QueryArg& arg) {}
+
+void CheckItemShopSelectBuy::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckItemShopSelectBuy.h b/src/Game/AI/Query/queryCheckItemShopSelectBuy.h
new file mode 100644
index 00000000..c5c8a90a
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckItemShopSelectBuy.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckItemShopSelectBuy : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckItemShopSelectBuy, Query)
+public:
+    explicit CheckItemShopSelectBuy(const InitArg& arg);
+    ~CheckItemShopSelectBuy() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckJustBeforeEventCancel.cpp b/src/Game/AI/Query/queryCheckJustBeforeEventCancel.cpp
new file mode 100644
index 00000000..1fccc53a
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckJustBeforeEventCancel.cpp
@@ -0,0 +1,20 @@
+#include "Game/AI/Query/queryCheckJustBeforeEventCancel.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckJustBeforeEventCancel::CheckJustBeforeEventCancel(const InitArg& arg)
+    : ksys::act::ai::Query(arg) {}
+
+CheckJustBeforeEventCancel::~CheckJustBeforeEventCancel() = default;
+
+// FIXME: implement
+int CheckJustBeforeEventCancel::doQuery() {
+    return -1;
+}
+
+void CheckJustBeforeEventCancel::loadParams(const evfl::QueryArg& arg) {}
+
+void CheckJustBeforeEventCancel::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckJustBeforeEventCancel.h b/src/Game/AI/Query/queryCheckJustBeforeEventCancel.h
new file mode 100644
index 00000000..f339404c
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckJustBeforeEventCancel.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckJustBeforeEventCancel : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckJustBeforeEventCancel, Query)
+public:
+    explicit CheckJustBeforeEventCancel(const InitArg& arg);
+    ~CheckJustBeforeEventCancel() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckLastDamageAttacker.cpp b/src/Game/AI/Query/queryCheckLastDamageAttacker.cpp
new file mode 100644
index 00000000..662023a6
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckLastDamageAttacker.cpp
@@ -0,0 +1,23 @@
+#include "Game/AI/Query/queryCheckLastDamageAttacker.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckLastDamageAttacker::CheckLastDamageAttacker(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckLastDamageAttacker::~CheckLastDamageAttacker() = default;
+
+// FIXME: implement
+int CheckLastDamageAttacker::doQuery() {
+    return -1;
+}
+
+void CheckLastDamageAttacker::loadParams(const evfl::QueryArg& arg) {
+    loadString(arg.param_accessor, "Name");
+}
+
+void CheckLastDamageAttacker::loadParams() {
+    getDynamicParam(&mName, "Name");
+}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckLastDamageAttacker.h b/src/Game/AI/Query/queryCheckLastDamageAttacker.h
new file mode 100644
index 00000000..1a47a38f
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckLastDamageAttacker.h
@@ -0,0 +1,21 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckLastDamageAttacker : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckLastDamageAttacker, Query)
+public:
+    explicit CheckLastDamageAttacker(const InitArg& arg);
+    ~CheckLastDamageAttacker() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    sead::SafeString mName{};
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckManufactResult.cpp b/src/Game/AI/Query/queryCheckManufactResult.cpp
new file mode 100644
index 00000000..7658d17a
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckManufactResult.cpp
@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryCheckManufactResult.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckManufactResult::CheckManufactResult(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckManufactResult::~CheckManufactResult() = default;
+
+// FIXME: implement
+int CheckManufactResult::doQuery() {
+    return -1;
+}
+
+void CheckManufactResult::loadParams(const evfl::QueryArg& arg) {}
+
+void CheckManufactResult::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckManufactResult.h b/src/Game/AI/Query/queryCheckManufactResult.h
new file mode 100644
index 00000000..02aea5af
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckManufactResult.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckManufactResult : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckManufactResult, Query)
+public:
+    explicit CheckManufactResult(const InitArg& arg);
+    ~CheckManufactResult() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckMapArea.cpp b/src/Game/AI/Query/queryCheckMapArea.cpp
new file mode 100644
index 00000000..1606c304
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckMapArea.cpp
@@ -0,0 +1,23 @@
+#include "Game/AI/Query/queryCheckMapArea.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckMapArea::CheckMapArea(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckMapArea::~CheckMapArea() = default;
+
+// FIXME: implement
+int CheckMapArea::doQuery() {
+    return -1;
+}
+
+void CheckMapArea::loadParams(const evfl::QueryArg& arg) {
+    loadString(arg.param_accessor, "MapAreaName");
+}
+
+void CheckMapArea::loadParams() {
+    getDynamicParam(&mMapAreaName, "MapAreaName");
+}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckMapArea.h b/src/Game/AI/Query/queryCheckMapArea.h
new file mode 100644
index 00000000..01882404
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckMapArea.h
@@ -0,0 +1,21 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckMapArea : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckMapArea, Query)
+public:
+    explicit CheckMapArea(const InitArg& arg);
+    ~CheckMapArea() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    sead::SafeString mMapAreaName{};
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckMasterSwordState.cpp b/src/Game/AI/Query/queryCheckMasterSwordState.cpp
new file mode 100644
index 00000000..6cf8fd47
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckMasterSwordState.cpp
@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryCheckMasterSwordState.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckMasterSwordState::CheckMasterSwordState(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckMasterSwordState::~CheckMasterSwordState() = default;
+
+// FIXME: implement
+int CheckMasterSwordState::doQuery() {
+    return -1;
+}
+
+void CheckMasterSwordState::loadParams(const evfl::QueryArg& arg) {}
+
+void CheckMasterSwordState::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckMasterSwordState.h b/src/Game/AI/Query/queryCheckMasterSwordState.h
new file mode 100644
index 00000000..382e8985
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckMasterSwordState.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckMasterSwordState : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckMasterSwordState, Query)
+public:
+    explicit CheckMasterSwordState(const InitArg& arg);
+    ~CheckMasterSwordState() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckMaterialValue.cpp b/src/Game/AI/Query/queryCheckMaterialValue.cpp
new file mode 100644
index 00000000..adfc0b45
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckMaterialValue.cpp
@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryCheckMaterialValue.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckMaterialValue::CheckMaterialValue(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckMaterialValue::~CheckMaterialValue() = default;
+
+// FIXME: implement
+int CheckMaterialValue::doQuery() {
+    return -1;
+}
+
+void CheckMaterialValue::loadParams(const evfl::QueryArg& arg) {}
+
+void CheckMaterialValue::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckMaterialValue.h b/src/Game/AI/Query/queryCheckMaterialValue.h
new file mode 100644
index 00000000..a3073468
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckMaterialValue.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckMaterialValue : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckMaterialValue, Query)
+public:
+    explicit CheckMaterialValue(const InitArg& arg);
+    ~CheckMaterialValue() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckMiniGameTime.cpp b/src/Game/AI/Query/queryCheckMiniGameTime.cpp
new file mode 100644
index 00000000..d441219c
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckMiniGameTime.cpp
@@ -0,0 +1,27 @@
+#include "Game/AI/Query/queryCheckMiniGameTime.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckMiniGameTime::CheckMiniGameTime(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckMiniGameTime::~CheckMiniGameTime() = default;
+
+// FIXME: implement
+int CheckMiniGameTime::doQuery() {
+    return -1;
+}
+
+void CheckMiniGameTime::loadParams(const evfl::QueryArg& arg) {
+    loadInt(arg.param_accessor, "Minute");
+    loadInt(arg.param_accessor, "Second");
+    loadInt(arg.param_accessor, "ConditionType");
+}
+
+void CheckMiniGameTime::loadParams() {
+    getDynamicParam(&mMinute, "Minute");
+    getDynamicParam(&mSecond, "Second");
+    getDynamicParam(&mConditionType, "ConditionType");
+}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckMiniGameTime.h b/src/Game/AI/Query/queryCheckMiniGameTime.h
new file mode 100644
index 00000000..5a4675a5
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckMiniGameTime.h
@@ -0,0 +1,23 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckMiniGameTime : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckMiniGameTime, Query)
+public:
+    explicit CheckMiniGameTime(const InitArg& arg);
+    ~CheckMiniGameTime() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    int* mMinute{};
+    int* mSecond{};
+    int* mConditionType{};
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckMiniGameTimeOver.cpp b/src/Game/AI/Query/queryCheckMiniGameTimeOver.cpp
new file mode 100644
index 00000000..80ae396e
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckMiniGameTimeOver.cpp
@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryCheckMiniGameTimeOver.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckMiniGameTimeOver::CheckMiniGameTimeOver(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckMiniGameTimeOver::~CheckMiniGameTimeOver() = default;
+
+// FIXME: implement
+int CheckMiniGameTimeOver::doQuery() {
+    return -1;
+}
+
+void CheckMiniGameTimeOver::loadParams(const evfl::QueryArg& arg) {}
+
+void CheckMiniGameTimeOver::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckMiniGameTimeOver.h b/src/Game/AI/Query/queryCheckMiniGameTimeOver.h
new file mode 100644
index 00000000..9a491ecf
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckMiniGameTimeOver.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckMiniGameTimeOver : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckMiniGameTimeOver, Query)
+public:
+    explicit CheckMiniGameTimeOver(const InitArg& arg);
+    ~CheckMiniGameTimeOver() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckNumOfBuyPicture.cpp b/src/Game/AI/Query/queryCheckNumOfBuyPicture.cpp
new file mode 100644
index 00000000..8c6e2192
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckNumOfBuyPicture.cpp
@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryCheckNumOfBuyPicture.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckNumOfBuyPicture::CheckNumOfBuyPicture(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckNumOfBuyPicture::~CheckNumOfBuyPicture() = default;
+
+// FIXME: implement
+int CheckNumOfBuyPicture::doQuery() {
+    return -1;
+}
+
+void CheckNumOfBuyPicture::loadParams(const evfl::QueryArg& arg) {}
+
+void CheckNumOfBuyPicture::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckNumOfBuyPicture.h b/src/Game/AI/Query/queryCheckNumOfBuyPicture.h
new file mode 100644
index 00000000..effdf55c
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckNumOfBuyPicture.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckNumOfBuyPicture : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckNumOfBuyPicture, Query)
+public:
+    explicit CheckNumOfBuyPicture(const InitArg& arg);
+    ~CheckNumOfBuyPicture() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckOwnedHorseFamiliarity.cpp b/src/Game/AI/Query/queryCheckOwnedHorseFamiliarity.cpp
new file mode 100644
index 00000000..c543f162
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckOwnedHorseFamiliarity.cpp
@@ -0,0 +1,20 @@
+#include "Game/AI/Query/queryCheckOwnedHorseFamiliarity.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckOwnedHorseFamiliarity::CheckOwnedHorseFamiliarity(const InitArg& arg)
+    : ksys::act::ai::Query(arg) {}
+
+CheckOwnedHorseFamiliarity::~CheckOwnedHorseFamiliarity() = default;
+
+// FIXME: implement
+int CheckOwnedHorseFamiliarity::doQuery() {
+    return -1;
+}
+
+void CheckOwnedHorseFamiliarity::loadParams(const evfl::QueryArg& arg) {}
+
+void CheckOwnedHorseFamiliarity::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckOwnedHorseFamiliarity.h b/src/Game/AI/Query/queryCheckOwnedHorseFamiliarity.h
new file mode 100644
index 00000000..1cad8207
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckOwnedHorseFamiliarity.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckOwnedHorseFamiliarity : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckOwnedHorseFamiliarity, Query)
+public:
+    explicit CheckOwnedHorseFamiliarity(const InitArg& arg);
+    ~CheckOwnedHorseFamiliarity() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckPictureBookVacancy.cpp b/src/Game/AI/Query/queryCheckPictureBookVacancy.cpp
new file mode 100644
index 00000000..1c269445
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckPictureBookVacancy.cpp
@@ -0,0 +1,25 @@
+#include "Game/AI/Query/queryCheckPictureBookVacancy.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckPictureBookVacancy::CheckPictureBookVacancy(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckPictureBookVacancy::~CheckPictureBookVacancy() = default;
+
+// FIXME: implement
+int CheckPictureBookVacancy::doQuery() {
+    return -1;
+}
+
+void CheckPictureBookVacancy::loadParams(const evfl::QueryArg& arg) {
+    loadInt(arg.param_accessor, "VacancyNum");
+    loadString(arg.param_accessor, "Category");
+}
+
+void CheckPictureBookVacancy::loadParams() {
+    getDynamicParam(&mVacancyNum, "VacancyNum");
+    getDynamicParam(&mCategory, "Category");
+}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckPictureBookVacancy.h b/src/Game/AI/Query/queryCheckPictureBookVacancy.h
new file mode 100644
index 00000000..02f5b71b
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckPictureBookVacancy.h
@@ -0,0 +1,22 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckPictureBookVacancy : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckPictureBookVacancy, Query)
+public:
+    explicit CheckPictureBookVacancy(const InitArg& arg);
+    ~CheckPictureBookVacancy() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    int* mVacancyNum{};
+    sead::SafeString mCategory{};
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckPlacedItemSaled.cpp b/src/Game/AI/Query/queryCheckPlacedItemSaled.cpp
new file mode 100644
index 00000000..1221020a
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckPlacedItemSaled.cpp
@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryCheckPlacedItemSaled.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckPlacedItemSaled::CheckPlacedItemSaled(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckPlacedItemSaled::~CheckPlacedItemSaled() = default;
+
+// FIXME: implement
+int CheckPlacedItemSaled::doQuery() {
+    return -1;
+}
+
+void CheckPlacedItemSaled::loadParams(const evfl::QueryArg& arg) {}
+
+void CheckPlacedItemSaled::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckPlacedItemSaled.h b/src/Game/AI/Query/queryCheckPlacedItemSaled.h
new file mode 100644
index 00000000..f508fc9c
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckPlacedItemSaled.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckPlacedItemSaled : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckPlacedItemSaled, Query)
+public:
+    explicit CheckPlacedItemSaled(const InitArg& arg);
+    ~CheckPlacedItemSaled() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckPlayerDeadCause.cpp b/src/Game/AI/Query/queryCheckPlayerDeadCause.cpp
new file mode 100644
index 00000000..be4c8848
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckPlayerDeadCause.cpp
@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryCheckPlayerDeadCause.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckPlayerDeadCause::CheckPlayerDeadCause(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckPlayerDeadCause::~CheckPlayerDeadCause() = default;
+
+// FIXME: implement
+int CheckPlayerDeadCause::doQuery() {
+    return -1;
+}
+
+void CheckPlayerDeadCause::loadParams(const evfl::QueryArg& arg) {}
+
+void CheckPlayerDeadCause::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckPlayerDeadCause.h b/src/Game/AI/Query/queryCheckPlayerDeadCause.h
new file mode 100644
index 00000000..dea9231c
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckPlayerDeadCause.h
@@ -0,0 +1,22 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckPlayerDeadCause : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckPlayerDeadCause, Query)
+public:
+    explicit CheckPlayerDeadCause(const InitArg& arg);
+    ~CheckPlayerDeadCause() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    // Unused
+    void* _20{};
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckPlayerEquip.cpp b/src/Game/AI/Query/queryCheckPlayerEquip.cpp
new file mode 100644
index 00000000..465b4a12
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckPlayerEquip.cpp
@@ -0,0 +1,23 @@
+#include "Game/AI/Query/queryCheckPlayerEquip.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckPlayerEquip::CheckPlayerEquip(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckPlayerEquip::~CheckPlayerEquip() = default;
+
+// FIXME: implement
+int CheckPlayerEquip::doQuery() {
+    return -1;
+}
+
+void CheckPlayerEquip::loadParams(const evfl::QueryArg& arg) {
+    loadInt(arg.param_accessor, "PlayerEquipType");
+}
+
+void CheckPlayerEquip::loadParams() {
+    getDynamicParam(&mPlayerEquipType, "PlayerEquipType");
+}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckPlayerEquip.h b/src/Game/AI/Query/queryCheckPlayerEquip.h
new file mode 100644
index 00000000..04b7a4e1
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckPlayerEquip.h
@@ -0,0 +1,21 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckPlayerEquip : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckPlayerEquip, Query)
+public:
+    explicit CheckPlayerEquip(const InitArg& arg);
+    ~CheckPlayerEquip() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    int* mPlayerEquipType{};
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckPlayerFastFadeDead.cpp b/src/Game/AI/Query/queryCheckPlayerFastFadeDead.cpp
new file mode 100644
index 00000000..e4e52a5c
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckPlayerFastFadeDead.cpp
@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryCheckPlayerFastFadeDead.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckPlayerFastFadeDead::CheckPlayerFastFadeDead(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckPlayerFastFadeDead::~CheckPlayerFastFadeDead() = default;
+
+// FIXME: implement
+int CheckPlayerFastFadeDead::doQuery() {
+    return -1;
+}
+
+void CheckPlayerFastFadeDead::loadParams(const evfl::QueryArg& arg) {}
+
+void CheckPlayerFastFadeDead::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckPlayerFastFadeDead.h b/src/Game/AI/Query/queryCheckPlayerFastFadeDead.h
new file mode 100644
index 00000000..0cc6b596
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckPlayerFastFadeDead.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckPlayerFastFadeDead : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckPlayerFastFadeDead, Query)
+public:
+    explicit CheckPlayerFastFadeDead(const InitArg& arg);
+    ~CheckPlayerFastFadeDead() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckPlayerHellType.cpp b/src/Game/AI/Query/queryCheckPlayerHellType.cpp
new file mode 100644
index 00000000..df6cd555
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckPlayerHellType.cpp
@@ -0,0 +1,23 @@
+#include "Game/AI/Query/queryCheckPlayerHellType.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckPlayerHellType::CheckPlayerHellType(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckPlayerHellType::~CheckPlayerHellType() = default;
+
+// FIXME: implement
+int CheckPlayerHellType::doQuery() {
+    return -1;
+}
+
+void CheckPlayerHellType::loadParams(const evfl::QueryArg& arg) {
+    loadInt(arg.param_accessor, "PlayerHellType");
+}
+
+void CheckPlayerHellType::loadParams() {
+    getDynamicParam(&mPlayerHellType, "PlayerHellType");
+}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckPlayerHellType.h b/src/Game/AI/Query/queryCheckPlayerHellType.h
new file mode 100644
index 00000000..dce728ac
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckPlayerHellType.h
@@ -0,0 +1,21 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckPlayerHellType : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckPlayerHellType, Query)
+public:
+    explicit CheckPlayerHellType(const InitArg& arg);
+    ~CheckPlayerHellType() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    int* mPlayerHellType{};
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckPlayerPullSwordFailEnd.cpp b/src/Game/AI/Query/queryCheckPlayerPullSwordFailEnd.cpp
new file mode 100644
index 00000000..267f5881
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckPlayerPullSwordFailEnd.cpp
@@ -0,0 +1,20 @@
+#include "Game/AI/Query/queryCheckPlayerPullSwordFailEnd.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckPlayerPullSwordFailEnd::CheckPlayerPullSwordFailEnd(const InitArg& arg)
+    : ksys::act::ai::Query(arg) {}
+
+CheckPlayerPullSwordFailEnd::~CheckPlayerPullSwordFailEnd() = default;
+
+// FIXME: implement
+int CheckPlayerPullSwordFailEnd::doQuery() {
+    return -1;
+}
+
+void CheckPlayerPullSwordFailEnd::loadParams(const evfl::QueryArg& arg) {}
+
+void CheckPlayerPullSwordFailEnd::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckPlayerPullSwordFailEnd.h b/src/Game/AI/Query/queryCheckPlayerPullSwordFailEnd.h
new file mode 100644
index 00000000..e1a60ce3
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckPlayerPullSwordFailEnd.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckPlayerPullSwordFailEnd : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckPlayerPullSwordFailEnd, Query)
+public:
+    explicit CheckPlayerPullSwordFailEnd(const InitArg& arg);
+    ~CheckPlayerPullSwordFailEnd() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckPlayerRideHorse.cpp b/src/Game/AI/Query/queryCheckPlayerRideHorse.cpp
new file mode 100644
index 00000000..c8a324cc
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckPlayerRideHorse.cpp
@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryCheckPlayerRideHorse.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckPlayerRideHorse::CheckPlayerRideHorse(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckPlayerRideHorse::~CheckPlayerRideHorse() = default;
+
+// FIXME: implement
+int CheckPlayerRideHorse::doQuery() {
+    return -1;
+}
+
+void CheckPlayerRideHorse::loadParams(const evfl::QueryArg& arg) {}
+
+void CheckPlayerRideHorse::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckPlayerRideHorse.h b/src/Game/AI/Query/queryCheckPlayerRideHorse.h
new file mode 100644
index 00000000..24419e85
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckPlayerRideHorse.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckPlayerRideHorse : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckPlayerRideHorse, Query)
+public:
+    explicit CheckPlayerRideHorse(const InitArg& arg);
+    ~CheckPlayerRideHorse() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckPlayerRideSunazarashi.cpp b/src/Game/AI/Query/queryCheckPlayerRideSunazarashi.cpp
new file mode 100644
index 00000000..536fea7f
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckPlayerRideSunazarashi.cpp
@@ -0,0 +1,26 @@
+#include "Game/AI/Query/queryCheckPlayerRideSunazarashi.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckPlayerRideSunazarashi::CheckPlayerRideSunazarashi(const InitArg& arg)
+    : ksys::act::ai::Query(arg) {}
+
+CheckPlayerRideSunazarashi::~CheckPlayerRideSunazarashi() = default;
+
+// FIXME: implement
+int CheckPlayerRideSunazarashi::doQuery() {
+    return -1;
+}
+
+void CheckPlayerRideSunazarashi::loadParams(const evfl::QueryArg& arg) {
+    loadInt(arg.param_accessor, "SunazarashiType");
+    loadString(arg.param_accessor, "SunazarashiName");
+}
+
+void CheckPlayerRideSunazarashi::loadParams() {
+    getDynamicParam(&mSunazarashiType, "SunazarashiType");
+    getDynamicParam(&mSunazarashiName, "SunazarashiName");
+}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckPlayerRideSunazarashi.h b/src/Game/AI/Query/queryCheckPlayerRideSunazarashi.h
new file mode 100644
index 00000000..fc16d2b4
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckPlayerRideSunazarashi.h
@@ -0,0 +1,22 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckPlayerRideSunazarashi : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckPlayerRideSunazarashi, Query)
+public:
+    explicit CheckPlayerRideSunazarashi(const InitArg& arg);
+    ~CheckPlayerRideSunazarashi() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    int* mSunazarashiType{};
+    sead::SafeString mSunazarashiName{};
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckPlayerState.cpp b/src/Game/AI/Query/queryCheckPlayerState.cpp
new file mode 100644
index 00000000..84e546f9
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckPlayerState.cpp
@@ -0,0 +1,23 @@
+#include "Game/AI/Query/queryCheckPlayerState.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckPlayerState::CheckPlayerState(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckPlayerState::~CheckPlayerState() = default;
+
+// FIXME: implement
+int CheckPlayerState::doQuery() {
+    return -1;
+}
+
+void CheckPlayerState::loadParams(const evfl::QueryArg& arg) {
+    loadInt(arg.param_accessor, "PlayerState");
+}
+
+void CheckPlayerState::loadParams() {
+    getDynamicParam(&mPlayerState, "PlayerState");
+}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckPlayerState.h b/src/Game/AI/Query/queryCheckPlayerState.h
new file mode 100644
index 00000000..d241a2e1
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckPlayerState.h
@@ -0,0 +1,21 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckPlayerState : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckPlayerState, Query)
+public:
+    explicit CheckPlayerState(const InitArg& arg);
+    ~CheckPlayerState() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    int* mPlayerState{};
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckPlayerTemperatureCondition.cpp b/src/Game/AI/Query/queryCheckPlayerTemperatureCondition.cpp
new file mode 100644
index 00000000..555c6b06
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckPlayerTemperatureCondition.cpp
@@ -0,0 +1,20 @@
+#include "Game/AI/Query/queryCheckPlayerTemperatureCondition.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckPlayerTemperatureCondition::CheckPlayerTemperatureCondition(const InitArg& arg)
+    : ksys::act::ai::Query(arg) {}
+
+CheckPlayerTemperatureCondition::~CheckPlayerTemperatureCondition() = default;
+
+// FIXME: implement
+int CheckPlayerTemperatureCondition::doQuery() {
+    return -1;
+}
+
+void CheckPlayerTemperatureCondition::loadParams(const evfl::QueryArg& arg) {}
+
+void CheckPlayerTemperatureCondition::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckPlayerTemperatureCondition.h b/src/Game/AI/Query/queryCheckPlayerTemperatureCondition.h
new file mode 100644
index 00000000..df69aff2
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckPlayerTemperatureCondition.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckPlayerTemperatureCondition : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckPlayerTemperatureCondition, Query)
+public:
+    explicit CheckPlayerTemperatureCondition(const InitArg& arg);
+    ~CheckPlayerTemperatureCondition() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckPlayerWeaponFired.cpp b/src/Game/AI/Query/queryCheckPlayerWeaponFired.cpp
new file mode 100644
index 00000000..e3f69feb
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckPlayerWeaponFired.cpp
@@ -0,0 +1,23 @@
+#include "Game/AI/Query/queryCheckPlayerWeaponFired.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckPlayerWeaponFired::CheckPlayerWeaponFired(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckPlayerWeaponFired::~CheckPlayerWeaponFired() = default;
+
+// FIXME: implement
+int CheckPlayerWeaponFired::doQuery() {
+    return -1;
+}
+
+void CheckPlayerWeaponFired::loadParams(const evfl::QueryArg& arg) {
+    loadInt(arg.param_accessor, "CheckFireType");
+}
+
+void CheckPlayerWeaponFired::loadParams() {
+    getDynamicParam(&mCheckFireType, "CheckFireType");
+}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckPlayerWeaponFired.h b/src/Game/AI/Query/queryCheckPlayerWeaponFired.h
new file mode 100644
index 00000000..81d66920
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckPlayerWeaponFired.h
@@ -0,0 +1,21 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckPlayerWeaponFired : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckPlayerWeaponFired, Query)
+public:
+    explicit CheckPlayerWeaponFired(const InitArg& arg);
+    ~CheckPlayerWeaponFired() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    int* mCheckFireType{};
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckPorchInItem.cpp b/src/Game/AI/Query/queryCheckPorchInItem.cpp
new file mode 100644
index 00000000..9c20d400
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckPorchInItem.cpp
@@ -0,0 +1,23 @@
+#include "Game/AI/Query/queryCheckPorchInItem.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckPorchInItem::CheckPorchInItem(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckPorchInItem::~CheckPorchInItem() = default;
+
+// FIXME: implement
+int CheckPorchInItem::doQuery() {
+    return -1;
+}
+
+void CheckPorchInItem::loadParams(const evfl::QueryArg& arg) {
+    loadString(arg.param_accessor, "PorchItemName");
+}
+
+void CheckPorchInItem::loadParams() {
+    getDynamicParam(&mPorchItemName, "PorchItemName");
+}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckPorchInItem.h b/src/Game/AI/Query/queryCheckPorchInItem.h
new file mode 100644
index 00000000..bce6c683
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckPorchInItem.h
@@ -0,0 +1,21 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckPorchInItem : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckPorchInItem, Query)
+public:
+    explicit CheckPorchInItem(const InitArg& arg);
+    ~CheckPorchInItem() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    sead::SafeString mPorchItemName{};
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckProConUse.cpp b/src/Game/AI/Query/queryCheckProConUse.cpp
new file mode 100644
index 00000000..6d16e107
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckProConUse.cpp
@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryCheckProConUse.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckProConUse::CheckProConUse(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckProConUse::~CheckProConUse() = default;
+
+// FIXME: implement
+int CheckProConUse::doQuery() {
+    return -1;
+}
+
+void CheckProConUse::loadParams(const evfl::QueryArg& arg) {}
+
+void CheckProConUse::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckProConUse.h b/src/Game/AI/Query/queryCheckProConUse.h
new file mode 100644
index 00000000..54fd8ce7
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckProConUse.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckProConUse : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckProConUse, Query)
+public:
+    explicit CheckProConUse(const InitArg& arg);
+    ~CheckProConUse() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckRainRatio.cpp b/src/Game/AI/Query/queryCheckRainRatio.cpp
new file mode 100644
index 00000000..0f7d5eb4
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckRainRatio.cpp
@@ -0,0 +1,23 @@
+#include "Game/AI/Query/queryCheckRainRatio.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckRainRatio::CheckRainRatio(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckRainRatio::~CheckRainRatio() = default;
+
+// FIXME: implement
+int CheckRainRatio::doQuery() {
+    return -1;
+}
+
+void CheckRainRatio::loadParams(const evfl::QueryArg& arg) {
+    loadFloat(arg.param_accessor, "RainRatio");
+}
+
+void CheckRainRatio::loadParams() {
+    getDynamicParam(&mRainRatio, "RainRatio");
+}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckRainRatio.h b/src/Game/AI/Query/queryCheckRainRatio.h
new file mode 100644
index 00000000..1a6928db
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckRainRatio.h
@@ -0,0 +1,21 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckRainRatio : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckRainRatio, Query)
+public:
+    explicit CheckRainRatio(const InitArg& arg);
+    ~CheckRainRatio() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    float* mRainRatio{};
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckRankOfEnemyAttackedNPC.cpp b/src/Game/AI/Query/queryCheckRankOfEnemyAttackedNPC.cpp
new file mode 100644
index 00000000..b9823f39
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckRankOfEnemyAttackedNPC.cpp
@@ -0,0 +1,20 @@
+#include "Game/AI/Query/queryCheckRankOfEnemyAttackedNPC.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckRankOfEnemyAttackedNPC::CheckRankOfEnemyAttackedNPC(const InitArg& arg)
+    : ksys::act::ai::Query(arg) {}
+
+CheckRankOfEnemyAttackedNPC::~CheckRankOfEnemyAttackedNPC() = default;
+
+// FIXME: implement
+int CheckRankOfEnemyAttackedNPC::doQuery() {
+    return -1;
+}
+
+void CheckRankOfEnemyAttackedNPC::loadParams(const evfl::QueryArg& arg) {}
+
+void CheckRankOfEnemyAttackedNPC::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckRankOfEnemyAttackedNPC.h b/src/Game/AI/Query/queryCheckRankOfEnemyAttackedNPC.h
new file mode 100644
index 00000000..ddaabfe8
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckRankOfEnemyAttackedNPC.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckRankOfEnemyAttackedNPC : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckRankOfEnemyAttackedNPC, Query)
+public:
+    explicit CheckRankOfEnemyAttackedNPC(const InitArg& arg);
+    ~CheckRankOfEnemyAttackedNPC() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckReceiveTerrorLevel.cpp b/src/Game/AI/Query/queryCheckReceiveTerrorLevel.cpp
new file mode 100644
index 00000000..3d22e447
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckReceiveTerrorLevel.cpp
@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryCheckReceiveTerrorLevel.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckReceiveTerrorLevel::CheckReceiveTerrorLevel(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckReceiveTerrorLevel::~CheckReceiveTerrorLevel() = default;
+
+// FIXME: implement
+int CheckReceiveTerrorLevel::doQuery() {
+    return -1;
+}
+
+void CheckReceiveTerrorLevel::loadParams(const evfl::QueryArg& arg) {}
+
+void CheckReceiveTerrorLevel::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckReceiveTerrorLevel.h b/src/Game/AI/Query/queryCheckReceiveTerrorLevel.h
new file mode 100644
index 00000000..244d525e
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckReceiveTerrorLevel.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckReceiveTerrorLevel : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckReceiveTerrorLevel, Query)
+public:
+    explicit CheckReceiveTerrorLevel(const InitArg& arg);
+    ~CheckReceiveTerrorLevel() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckResultOfNPCConflict.cpp b/src/Game/AI/Query/queryCheckResultOfNPCConflict.cpp
new file mode 100644
index 00000000..ab0b78ee
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckResultOfNPCConflict.cpp
@@ -0,0 +1,20 @@
+#include "Game/AI/Query/queryCheckResultOfNPCConflict.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckResultOfNPCConflict::CheckResultOfNPCConflict(const InitArg& arg)
+    : ksys::act::ai::Query(arg) {}
+
+CheckResultOfNPCConflict::~CheckResultOfNPCConflict() = default;
+
+// FIXME: implement
+int CheckResultOfNPCConflict::doQuery() {
+    return -1;
+}
+
+void CheckResultOfNPCConflict::loadParams(const evfl::QueryArg& arg) {}
+
+void CheckResultOfNPCConflict::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckResultOfNPCConflict.h b/src/Game/AI/Query/queryCheckResultOfNPCConflict.h
new file mode 100644
index 00000000..d01ae87c
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckResultOfNPCConflict.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckResultOfNPCConflict : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckResultOfNPCConflict, Query)
+public:
+    explicit CheckResultOfNPCConflict(const InitArg& arg);
+    ~CheckResultOfNPCConflict() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckRoad.cpp b/src/Game/AI/Query/queryCheckRoad.cpp
new file mode 100644
index 00000000..b5792da2
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckRoad.cpp
@@ -0,0 +1,23 @@
+#include "Game/AI/Query/queryCheckRoad.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckRoad::CheckRoad(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckRoad::~CheckRoad() = default;
+
+// FIXME: implement
+int CheckRoad::doQuery() {
+    return -1;
+}
+
+void CheckRoad::loadParams(const evfl::QueryArg& arg) {
+    loadString(arg.param_accessor, "RoadId");
+}
+
+void CheckRoad::loadParams() {
+    getDynamicParam(&mRoadId, "RoadId");
+}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckRoad.h b/src/Game/AI/Query/queryCheckRoad.h
new file mode 100644
index 00000000..aef6e59e
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckRoad.h
@@ -0,0 +1,21 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckRoad : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckRoad, Query)
+public:
+    explicit CheckRoad(const InitArg& arg);
+    ~CheckRoad() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    sead::SafeString mRoadId{};
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckRupee.cpp b/src/Game/AI/Query/queryCheckRupee.cpp
new file mode 100644
index 00000000..69992c63
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckRupee.cpp
@@ -0,0 +1,23 @@
+#include "Game/AI/Query/queryCheckRupee.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckRupee::CheckRupee(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckRupee::~CheckRupee() = default;
+
+// FIXME: implement
+int CheckRupee::doQuery() {
+    return -1;
+}
+
+void CheckRupee::loadParams(const evfl::QueryArg& arg) {
+    loadInt(arg.param_accessor, "Value");
+}
+
+void CheckRupee::loadParams() {
+    getDynamicParam(&mValue, "Value");
+}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckRupee.h b/src/Game/AI/Query/queryCheckRupee.h
new file mode 100644
index 00000000..6b124f05
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckRupee.h
@@ -0,0 +1,21 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckRupee : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckRupee, Query)
+public:
+    explicit CheckRupee(const InitArg& arg);
+    ~CheckRupee() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    int* mValue{};
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckSelectPicture.cpp b/src/Game/AI/Query/queryCheckSelectPicture.cpp
new file mode 100644
index 00000000..f649cfd5
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckSelectPicture.cpp
@@ -0,0 +1,23 @@
+#include "Game/AI/Query/queryCheckSelectPicture.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckSelectPicture::CheckSelectPicture(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckSelectPicture::~CheckSelectPicture() = default;
+
+// FIXME: implement
+int CheckSelectPicture::doQuery() {
+    return -1;
+}
+
+void CheckSelectPicture::loadParams(const evfl::QueryArg& arg) {
+    loadString(arg.param_accessor, "ActorName");
+}
+
+void CheckSelectPicture::loadParams() {
+    getDynamicParam(&mActorName, "ActorName");
+}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckSelectPicture.h b/src/Game/AI/Query/queryCheckSelectPicture.h
new file mode 100644
index 00000000..e05f9090
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckSelectPicture.h
@@ -0,0 +1,21 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckSelectPicture : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckSelectPicture, Query)
+public:
+    explicit CheckSelectPicture(const InitArg& arg);
+    ~CheckSelectPicture() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    sead::SafeString mActorName{};
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckSellResult.cpp b/src/Game/AI/Query/queryCheckSellResult.cpp
new file mode 100644
index 00000000..9efc6d01
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckSellResult.cpp
@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryCheckSellResult.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckSellResult::CheckSellResult(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckSellResult::~CheckSellResult() = default;
+
+// FIXME: implement
+int CheckSellResult::doQuery() {
+    return -1;
+}
+
+void CheckSellResult::loadParams(const evfl::QueryArg& arg) {}
+
+void CheckSellResult::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckSellResult.h b/src/Game/AI/Query/queryCheckSellResult.h
new file mode 100644
index 00000000..2dfe3c63
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckSellResult.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckSellResult : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckSellResult, Query)
+public:
+    explicit CheckSellResult(const InitArg& arg);
+    ~CheckSellResult() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckShopSelectedItemName.cpp b/src/Game/AI/Query/queryCheckShopSelectedItemName.cpp
new file mode 100644
index 00000000..592f0a6b
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckShopSelectedItemName.cpp
@@ -0,0 +1,24 @@
+#include "Game/AI/Query/queryCheckShopSelectedItemName.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckShopSelectedItemName::CheckShopSelectedItemName(const InitArg& arg)
+    : ksys::act::ai::Query(arg) {}
+
+CheckShopSelectedItemName::~CheckShopSelectedItemName() = default;
+
+// FIXME: implement
+int CheckShopSelectedItemName::doQuery() {
+    return -1;
+}
+
+void CheckShopSelectedItemName::loadParams(const evfl::QueryArg& arg) {
+    loadString(arg.param_accessor, "PorchItemName");
+}
+
+void CheckShopSelectedItemName::loadParams() {
+    getDynamicParam(&mPorchItemName, "PorchItemName");
+}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckShopSelectedItemName.h b/src/Game/AI/Query/queryCheckShopSelectedItemName.h
new file mode 100644
index 00000000..6bb2b303
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckShopSelectedItemName.h
@@ -0,0 +1,21 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckShopSelectedItemName : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckShopSelectedItemName, Query)
+public:
+    explicit CheckShopSelectedItemName(const InitArg& arg);
+    ~CheckShopSelectedItemName() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    sead::SafeString mPorchItemName{};
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckSiteBossDamageAnm.cpp b/src/Game/AI/Query/queryCheckSiteBossDamageAnm.cpp
new file mode 100644
index 00000000..8ed5e118
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckSiteBossDamageAnm.cpp
@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryCheckSiteBossDamageAnm.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckSiteBossDamageAnm::CheckSiteBossDamageAnm(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckSiteBossDamageAnm::~CheckSiteBossDamageAnm() = default;
+
+// FIXME: implement
+int CheckSiteBossDamageAnm::doQuery() {
+    return -1;
+}
+
+void CheckSiteBossDamageAnm::loadParams(const evfl::QueryArg& arg) {}
+
+void CheckSiteBossDamageAnm::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckSiteBossDamageAnm.h b/src/Game/AI/Query/queryCheckSiteBossDamageAnm.h
new file mode 100644
index 00000000..43c9e167
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckSiteBossDamageAnm.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckSiteBossDamageAnm : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckSiteBossDamageAnm, Query)
+public:
+    explicit CheckSiteBossDamageAnm(const InitArg& arg);
+    ~CheckSiteBossDamageAnm() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckStage.cpp b/src/Game/AI/Query/queryCheckStage.cpp
new file mode 100644
index 00000000..7ec81077
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckStage.cpp
@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryCheckStage.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckStage::CheckStage(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckStage::~CheckStage() = default;
+
+// FIXME: implement
+int CheckStage::doQuery() {
+    return -1;
+}
+
+void CheckStage::loadParams(const evfl::QueryArg& arg) {}
+
+void CheckStage::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckStage.h b/src/Game/AI/Query/queryCheckStage.h
new file mode 100644
index 00000000..c450b373
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckStage.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckStage : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckStage, Query)
+public:
+    explicit CheckStage(const InitArg& arg);
+    ~CheckStage() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckStarter.cpp b/src/Game/AI/Query/queryCheckStarter.cpp
new file mode 100644
index 00000000..d52e6b23
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckStarter.cpp
@@ -0,0 +1,25 @@
+#include "Game/AI/Query/queryCheckStarter.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckStarter::CheckStarter(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckStarter::~CheckStarter() = default;
+
+// FIXME: implement
+int CheckStarter::doQuery() {
+    return -1;
+}
+
+void CheckStarter::loadParams(const evfl::QueryArg& arg) {
+    loadString(arg.param_accessor, "ActorName");
+    loadString(arg.param_accessor, "UniqueName");
+}
+
+void CheckStarter::loadParams() {
+    getDynamicParam(&mActorName, "ActorName");
+    getDynamicParam(&mUniqueName, "UniqueName");
+}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckStarter.h b/src/Game/AI/Query/queryCheckStarter.h
new file mode 100644
index 00000000..02c3bf9f
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckStarter.h
@@ -0,0 +1,22 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckStarter : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckStarter, Query)
+public:
+    explicit CheckStarter(const InitArg& arg);
+    ~CheckStarter() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    sead::SafeString mActorName{};
+    sead::SafeString mUniqueName{};
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckTerrorLevel.cpp b/src/Game/AI/Query/queryCheckTerrorLevel.cpp
new file mode 100644
index 00000000..b407340e
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckTerrorLevel.cpp
@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryCheckTerrorLevel.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckTerrorLevel::CheckTerrorLevel(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckTerrorLevel::~CheckTerrorLevel() = default;
+
+// FIXME: implement
+int CheckTerrorLevel::doQuery() {
+    return -1;
+}
+
+void CheckTerrorLevel::loadParams(const evfl::QueryArg& arg) {}
+
+void CheckTerrorLevel::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckTerrorLevel.h b/src/Game/AI/Query/queryCheckTerrorLevel.h
new file mode 100644
index 00000000..4a2cf97b
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckTerrorLevel.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckTerrorLevel : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckTerrorLevel, Query)
+public:
+    explicit CheckTerrorLevel(const InitArg& arg);
+    ~CheckTerrorLevel() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckTime.cpp b/src/Game/AI/Query/queryCheckTime.cpp
new file mode 100644
index 00000000..7bf98deb
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckTime.cpp
@@ -0,0 +1,27 @@
+#include "Game/AI/Query/queryCheckTime.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckTime::CheckTime(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckTime::~CheckTime() = default;
+
+// FIXME: implement
+int CheckTime::doQuery() {
+    return -1;
+}
+
+void CheckTime::loadParams(const evfl::QueryArg& arg) {
+    loadInt(arg.param_accessor, "Hour");
+    loadInt(arg.param_accessor, "Minute");
+    loadString(arg.param_accessor, "ConditionType");
+}
+
+void CheckTime::loadParams() {
+    getDynamicParam(&mHour, "Hour");
+    getDynamicParam(&mMinute, "Minute");
+    getDynamicParam(&mConditionType, "ConditionType");
+}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckTime.h b/src/Game/AI/Query/queryCheckTime.h
new file mode 100644
index 00000000..62fdd1a8
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckTime.h
@@ -0,0 +1,23 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckTime : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckTime, Query)
+public:
+    explicit CheckTime(const InitArg& arg);
+    ~CheckTime() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    int* mHour{};
+    int* mMinute{};
+    sead::SafeString mConditionType{};
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckTimeType.cpp b/src/Game/AI/Query/queryCheckTimeType.cpp
new file mode 100644
index 00000000..cffb331c
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckTimeType.cpp
@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryCheckTimeType.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckTimeType::CheckTimeType(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckTimeType::~CheckTimeType() = default;
+
+// FIXME: implement
+int CheckTimeType::doQuery() {
+    return -1;
+}
+
+void CheckTimeType::loadParams(const evfl::QueryArg& arg) {}
+
+void CheckTimeType::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckTimeType.h b/src/Game/AI/Query/queryCheckTimeType.h
new file mode 100644
index 00000000..8c4e7792
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckTimeType.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckTimeType : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckTimeType, Query)
+public:
+    explicit CheckTimeType(const InitArg& arg);
+    ~CheckTimeType() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckTypeOfOwnedHorseForEvent.cpp b/src/Game/AI/Query/queryCheckTypeOfOwnedHorseForEvent.cpp
new file mode 100644
index 00000000..6e733bb3
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckTypeOfOwnedHorseForEvent.cpp
@@ -0,0 +1,20 @@
+#include "Game/AI/Query/queryCheckTypeOfOwnedHorseForEvent.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckTypeOfOwnedHorseForEvent::CheckTypeOfOwnedHorseForEvent(const InitArg& arg)
+    : ksys::act::ai::Query(arg) {}
+
+CheckTypeOfOwnedHorseForEvent::~CheckTypeOfOwnedHorseForEvent() = default;
+
+// FIXME: implement
+int CheckTypeOfOwnedHorseForEvent::doQuery() {
+    return -1;
+}
+
+void CheckTypeOfOwnedHorseForEvent::loadParams(const evfl::QueryArg& arg) {}
+
+void CheckTypeOfOwnedHorseForEvent::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckTypeOfOwnedHorseForEvent.h b/src/Game/AI/Query/queryCheckTypeOfOwnedHorseForEvent.h
new file mode 100644
index 00000000..cf363a8a
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckTypeOfOwnedHorseForEvent.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckTypeOfOwnedHorseForEvent : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckTypeOfOwnedHorseForEvent, Query)
+public:
+    explicit CheckTypeOfOwnedHorseForEvent(const InitArg& arg);
+    ~CheckTypeOfOwnedHorseForEvent() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckTypeOfWildHorseAssociated.cpp b/src/Game/AI/Query/queryCheckTypeOfWildHorseAssociated.cpp
new file mode 100644
index 00000000..75e33f56
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckTypeOfWildHorseAssociated.cpp
@@ -0,0 +1,20 @@
+#include "Game/AI/Query/queryCheckTypeOfWildHorseAssociated.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckTypeOfWildHorseAssociated::CheckTypeOfWildHorseAssociated(const InitArg& arg)
+    : ksys::act::ai::Query(arg) {}
+
+CheckTypeOfWildHorseAssociated::~CheckTypeOfWildHorseAssociated() = default;
+
+// FIXME: implement
+int CheckTypeOfWildHorseAssociated::doQuery() {
+    return -1;
+}
+
+void CheckTypeOfWildHorseAssociated::loadParams(const evfl::QueryArg& arg) {}
+
+void CheckTypeOfWildHorseAssociated::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckTypeOfWildHorseAssociated.h b/src/Game/AI/Query/queryCheckTypeOfWildHorseAssociated.h
new file mode 100644
index 00000000..cfff783c
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckTypeOfWildHorseAssociated.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckTypeOfWildHorseAssociated : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckTypeOfWildHorseAssociated, Query)
+public:
+    explicit CheckTypeOfWildHorseAssociated(const InitArg& arg);
+    ~CheckTypeOfWildHorseAssociated() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckVacancyItem.cpp b/src/Game/AI/Query/queryCheckVacancyItem.cpp
new file mode 100644
index 00000000..f487a3a2
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckVacancyItem.cpp
@@ -0,0 +1,23 @@
+#include "Game/AI/Query/queryCheckVacancyItem.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckVacancyItem::CheckVacancyItem(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckVacancyItem::~CheckVacancyItem() = default;
+
+// FIXME: implement
+int CheckVacancyItem::doQuery() {
+    return -1;
+}
+
+void CheckVacancyItem::loadParams(const evfl::QueryArg& arg) {
+    loadInt(arg.param_accessor, "Count");
+}
+
+void CheckVacancyItem::loadParams() {
+    getDynamicParam(&mCount, "Count");
+}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckVacancyItem.h b/src/Game/AI/Query/queryCheckVacancyItem.h
new file mode 100644
index 00000000..14304101
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckVacancyItem.h
@@ -0,0 +1,21 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckVacancyItem : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckVacancyItem, Query)
+public:
+    explicit CheckVacancyItem(const InitArg& arg);
+    ~CheckVacancyItem() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    int* mCount{};
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckWarpMist.cpp b/src/Game/AI/Query/queryCheckWarpMist.cpp
new file mode 100644
index 00000000..cb5e2448
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckWarpMist.cpp
@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryCheckWarpMist.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckWarpMist::CheckWarpMist(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckWarpMist::~CheckWarpMist() = default;
+
+// FIXME: implement
+int CheckWarpMist::doQuery() {
+    return -1;
+}
+
+void CheckWarpMist::loadParams(const evfl::QueryArg& arg) {}
+
+void CheckWarpMist::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckWarpMist.h b/src/Game/AI/Query/queryCheckWarpMist.h
new file mode 100644
index 00000000..5173a76f
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckWarpMist.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckWarpMist : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckWarpMist, Query)
+public:
+    explicit CheckWarpMist(const InitArg& arg);
+    ~CheckWarpMist() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckWeaponVacancyItem.cpp b/src/Game/AI/Query/queryCheckWeaponVacancyItem.cpp
new file mode 100644
index 00000000..75a324d4
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckWeaponVacancyItem.cpp
@@ -0,0 +1,23 @@
+#include "Game/AI/Query/queryCheckWeaponVacancyItem.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckWeaponVacancyItem::CheckWeaponVacancyItem(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckWeaponVacancyItem::~CheckWeaponVacancyItem() = default;
+
+// FIXME: implement
+int CheckWeaponVacancyItem::doQuery() {
+    return -1;
+}
+
+void CheckWeaponVacancyItem::loadParams(const evfl::QueryArg& arg) {
+    loadInt(arg.param_accessor, "Count");
+}
+
+void CheckWeaponVacancyItem::loadParams() {
+    getDynamicParam(&mCount, "Count");
+}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckWeaponVacancyItem.h b/src/Game/AI/Query/queryCheckWeaponVacancyItem.h
new file mode 100644
index 00000000..0100e2b3
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckWeaponVacancyItem.h
@@ -0,0 +1,21 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckWeaponVacancyItem : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckWeaponVacancyItem, Query)
+public:
+    explicit CheckWeaponVacancyItem(const InitArg& arg);
+    ~CheckWeaponVacancyItem() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    int* mCount{};
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckWeather.cpp b/src/Game/AI/Query/queryCheckWeather.cpp
new file mode 100644
index 00000000..21fb1bba
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckWeather.cpp
@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryCheckWeather.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CheckWeather::CheckWeather(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CheckWeather::~CheckWeather() = default;
+
+// FIXME: implement
+int CheckWeather::doQuery() {
+    return -1;
+}
+
+void CheckWeather::loadParams(const evfl::QueryArg& arg) {}
+
+void CheckWeather::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCheckWeather.h b/src/Game/AI/Query/queryCheckWeather.h
new file mode 100644
index 00000000..2ec0e64c
--- /dev/null
+++ b/src/Game/AI/Query/queryCheckWeather.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CheckWeather : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CheckWeather, Query)
+public:
+    explicit CheckWeather(const InitArg& arg);
+    ~CheckWeather() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCompareGameDataFloat.cpp b/src/Game/AI/Query/queryCompareGameDataFloat.cpp
new file mode 100644
index 00000000..2cf01e62
--- /dev/null
+++ b/src/Game/AI/Query/queryCompareGameDataFloat.cpp
@@ -0,0 +1,27 @@
+#include "Game/AI/Query/queryCompareGameDataFloat.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CompareGameDataFloat::CompareGameDataFloat(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CompareGameDataFloat::~CompareGameDataFloat() = default;
+
+// FIXME: implement
+int CompareGameDataFloat::doQuery() {
+    return -1;
+}
+
+void CompareGameDataFloat::loadParams(const evfl::QueryArg& arg) {
+    loadString(arg.param_accessor, "GameDataFloatName_A");
+    loadString(arg.param_accessor, "GameDataFloatName_B");
+    loadString(arg.param_accessor, "Operator");
+}
+
+void CompareGameDataFloat::loadParams() {
+    getDynamicParam(&mGameDataFloatName_A, "GameDataFloatName_A");
+    getDynamicParam(&mGameDataFloatName_B, "GameDataFloatName_B");
+    getDynamicParam(&mOperator, "Operator");
+}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCompareGameDataFloat.h b/src/Game/AI/Query/queryCompareGameDataFloat.h
new file mode 100644
index 00000000..35f7ed46
--- /dev/null
+++ b/src/Game/AI/Query/queryCompareGameDataFloat.h
@@ -0,0 +1,23 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CompareGameDataFloat : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CompareGameDataFloat, Query)
+public:
+    explicit CompareGameDataFloat(const InitArg& arg);
+    ~CompareGameDataFloat() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    sead::SafeString mGameDataFloatName_A{};
+    sead::SafeString mGameDataFloatName_B{};
+    sead::SafeString mOperator{};
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCompareGameDataInt.cpp b/src/Game/AI/Query/queryCompareGameDataInt.cpp
new file mode 100644
index 00000000..ed30a99e
--- /dev/null
+++ b/src/Game/AI/Query/queryCompareGameDataInt.cpp
@@ -0,0 +1,27 @@
+#include "Game/AI/Query/queryCompareGameDataInt.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CompareGameDataInt::CompareGameDataInt(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CompareGameDataInt::~CompareGameDataInt() = default;
+
+// FIXME: implement
+int CompareGameDataInt::doQuery() {
+    return -1;
+}
+
+void CompareGameDataInt::loadParams(const evfl::QueryArg& arg) {
+    loadString(arg.param_accessor, "GameDataIntName_A");
+    loadString(arg.param_accessor, "GameDataIntName_B");
+    loadString(arg.param_accessor, "Operator");
+}
+
+void CompareGameDataInt::loadParams() {
+    getDynamicParam(&mGameDataIntName_A, "GameDataIntName_A");
+    getDynamicParam(&mGameDataIntName_B, "GameDataIntName_B");
+    getDynamicParam(&mOperator, "Operator");
+}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCompareGameDataInt.h b/src/Game/AI/Query/queryCompareGameDataInt.h
new file mode 100644
index 00000000..b0a70a03
--- /dev/null
+++ b/src/Game/AI/Query/queryCompareGameDataInt.h
@@ -0,0 +1,23 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CompareGameDataInt : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CompareGameDataInt, Query)
+public:
+    explicit CompareGameDataInt(const InitArg& arg);
+    ~CompareGameDataInt() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    sead::SafeString mGameDataIntName_A{};
+    sead::SafeString mGameDataIntName_B{};
+    sead::SafeString mOperator{};
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCompareGameDataTime.cpp b/src/Game/AI/Query/queryCompareGameDataTime.cpp
new file mode 100644
index 00000000..257ab9d4
--- /dev/null
+++ b/src/Game/AI/Query/queryCompareGameDataTime.cpp
@@ -0,0 +1,33 @@
+#include "Game/AI/Query/queryCompareGameDataTime.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CompareGameDataTime::CompareGameDataTime(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CompareGameDataTime::~CompareGameDataTime() = default;
+
+// FIXME: implement
+int CompareGameDataTime::doQuery() {
+    return -1;
+}
+
+void CompareGameDataTime::loadParams(const evfl::QueryArg& arg) {
+    loadString(arg.param_accessor, "GameDataIntMinA");
+    loadString(arg.param_accessor, "GameDataIntSecA");
+    loadString(arg.param_accessor, "GameDataIntMilliA");
+    loadString(arg.param_accessor, "GameDataIntMinB");
+    loadString(arg.param_accessor, "GameDataIntSecB");
+    loadString(arg.param_accessor, "GameDataIntMilliB");
+}
+
+void CompareGameDataTime::loadParams() {
+    getDynamicParam(&mGameDataIntMinA, "GameDataIntMinA");
+    getDynamicParam(&mGameDataIntSecA, "GameDataIntSecA");
+    getDynamicParam(&mGameDataIntMilliA, "GameDataIntMilliA");
+    getDynamicParam(&mGameDataIntMinB, "GameDataIntMinB");
+    getDynamicParam(&mGameDataIntSecB, "GameDataIntSecB");
+    getDynamicParam(&mGameDataIntMilliB, "GameDataIntMilliB");
+}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCompareGameDataTime.h b/src/Game/AI/Query/queryCompareGameDataTime.h
new file mode 100644
index 00000000..49ce949e
--- /dev/null
+++ b/src/Game/AI/Query/queryCompareGameDataTime.h
@@ -0,0 +1,26 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CompareGameDataTime : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CompareGameDataTime, Query)
+public:
+    explicit CompareGameDataTime(const InitArg& arg);
+    ~CompareGameDataTime() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    sead::SafeString mGameDataIntMinA{};
+    sead::SafeString mGameDataIntSecA{};
+    sead::SafeString mGameDataIntMilliA{};
+    sead::SafeString mGameDataIntMinB{};
+    sead::SafeString mGameDataIntSecB{};
+    sead::SafeString mGameDataIntMilliB{};
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryComparePlayerFireResistantLevel.cpp b/src/Game/AI/Query/queryComparePlayerFireResistantLevel.cpp
new file mode 100644
index 00000000..0a2a1c82
--- /dev/null
+++ b/src/Game/AI/Query/queryComparePlayerFireResistantLevel.cpp
@@ -0,0 +1,20 @@
+#include "Game/AI/Query/queryComparePlayerFireResistantLevel.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+ComparePlayerFireResistantLevel::ComparePlayerFireResistantLevel(const InitArg& arg)
+    : ksys::act::ai::Query(arg) {}
+
+ComparePlayerFireResistantLevel::~ComparePlayerFireResistantLevel() = default;
+
+// FIXME: implement
+int ComparePlayerFireResistantLevel::doQuery() {
+    return -1;
+}
+
+void ComparePlayerFireResistantLevel::loadParams(const evfl::QueryArg& arg) {}
+
+void ComparePlayerFireResistantLevel::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryComparePlayerFireResistantLevel.h b/src/Game/AI/Query/queryComparePlayerFireResistantLevel.h
new file mode 100644
index 00000000..de3cd9cf
--- /dev/null
+++ b/src/Game/AI/Query/queryComparePlayerFireResistantLevel.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class ComparePlayerFireResistantLevel : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(ComparePlayerFireResistantLevel, Query)
+public:
+    explicit ComparePlayerFireResistantLevel(const InitArg& arg);
+    ~ComparePlayerFireResistantLevel() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryComparePlayerHeart.cpp b/src/Game/AI/Query/queryComparePlayerHeart.cpp
new file mode 100644
index 00000000..17efbddf
--- /dev/null
+++ b/src/Game/AI/Query/queryComparePlayerHeart.cpp
@@ -0,0 +1,23 @@
+#include "Game/AI/Query/queryComparePlayerHeart.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+ComparePlayerHeart::ComparePlayerHeart(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+ComparePlayerHeart::~ComparePlayerHeart() = default;
+
+// FIXME: implement
+int ComparePlayerHeart::doQuery() {
+    return -1;
+}
+
+void ComparePlayerHeart::loadParams(const evfl::QueryArg& arg) {
+    loadInt(arg.param_accessor, "Threshold");
+}
+
+void ComparePlayerHeart::loadParams() {
+    getDynamicParam(&mThreshold, "Threshold");
+}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryComparePlayerHeart.h b/src/Game/AI/Query/queryComparePlayerHeart.h
new file mode 100644
index 00000000..183c5e26
--- /dev/null
+++ b/src/Game/AI/Query/queryComparePlayerHeart.h
@@ -0,0 +1,21 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class ComparePlayerHeart : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(ComparePlayerHeart, Query)
+public:
+    explicit ComparePlayerHeart(const InitArg& arg);
+    ~ComparePlayerHeart() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    int* mThreshold{};
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryComparePlayerMaxHeart.cpp b/src/Game/AI/Query/queryComparePlayerMaxHeart.cpp
new file mode 100644
index 00000000..c36dc2a6
--- /dev/null
+++ b/src/Game/AI/Query/queryComparePlayerMaxHeart.cpp
@@ -0,0 +1,23 @@
+#include "Game/AI/Query/queryComparePlayerMaxHeart.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+ComparePlayerMaxHeart::ComparePlayerMaxHeart(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+ComparePlayerMaxHeart::~ComparePlayerMaxHeart() = default;
+
+// FIXME: implement
+int ComparePlayerMaxHeart::doQuery() {
+    return -1;
+}
+
+void ComparePlayerMaxHeart::loadParams(const evfl::QueryArg& arg) {
+    loadInt(arg.param_accessor, "Threshold");
+}
+
+void ComparePlayerMaxHeart::loadParams() {
+    getDynamicParam(&mThreshold, "Threshold");
+}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryComparePlayerMaxHeart.h b/src/Game/AI/Query/queryComparePlayerMaxHeart.h
new file mode 100644
index 00000000..9e526e68
--- /dev/null
+++ b/src/Game/AI/Query/queryComparePlayerMaxHeart.h
@@ -0,0 +1,21 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class ComparePlayerMaxHeart : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(ComparePlayerMaxHeart, Query)
+public:
+    explicit ComparePlayerMaxHeart(const InitArg& arg);
+    ~ComparePlayerMaxHeart() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    int* mThreshold{};
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryComparePlayerMaxStamina.cpp b/src/Game/AI/Query/queryComparePlayerMaxStamina.cpp
new file mode 100644
index 00000000..f87c6485
--- /dev/null
+++ b/src/Game/AI/Query/queryComparePlayerMaxStamina.cpp
@@ -0,0 +1,23 @@
+#include "Game/AI/Query/queryComparePlayerMaxStamina.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+ComparePlayerMaxStamina::ComparePlayerMaxStamina(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+ComparePlayerMaxStamina::~ComparePlayerMaxStamina() = default;
+
+// FIXME: implement
+int ComparePlayerMaxStamina::doQuery() {
+    return -1;
+}
+
+void ComparePlayerMaxStamina::loadParams(const evfl::QueryArg& arg) {
+    loadInt(arg.param_accessor, "Threshold");
+}
+
+void ComparePlayerMaxStamina::loadParams() {
+    getDynamicParam(&mThreshold, "Threshold");
+}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryComparePlayerMaxStamina.h b/src/Game/AI/Query/queryComparePlayerMaxStamina.h
new file mode 100644
index 00000000..2da24366
--- /dev/null
+++ b/src/Game/AI/Query/queryComparePlayerMaxStamina.h
@@ -0,0 +1,21 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class ComparePlayerMaxStamina : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(ComparePlayerMaxStamina, Query)
+public:
+    explicit ComparePlayerMaxStamina(const InitArg& arg);
+    ~ComparePlayerMaxStamina() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    int* mThreshold{};
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryComparePlayerOriginalHeart.cpp b/src/Game/AI/Query/queryComparePlayerOriginalHeart.cpp
new file mode 100644
index 00000000..4006ef81
--- /dev/null
+++ b/src/Game/AI/Query/queryComparePlayerOriginalHeart.cpp
@@ -0,0 +1,24 @@
+#include "Game/AI/Query/queryComparePlayerOriginalHeart.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+ComparePlayerOriginalHeart::ComparePlayerOriginalHeart(const InitArg& arg)
+    : ksys::act::ai::Query(arg) {}
+
+ComparePlayerOriginalHeart::~ComparePlayerOriginalHeart() = default;
+
+// FIXME: implement
+int ComparePlayerOriginalHeart::doQuery() {
+    return -1;
+}
+
+void ComparePlayerOriginalHeart::loadParams(const evfl::QueryArg& arg) {
+    loadInt(arg.param_accessor, "Threshold");
+}
+
+void ComparePlayerOriginalHeart::loadParams() {
+    getDynamicParam(&mThreshold, "Threshold");
+}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryComparePlayerOriginalHeart.h b/src/Game/AI/Query/queryComparePlayerOriginalHeart.h
new file mode 100644
index 00000000..45f49263
--- /dev/null
+++ b/src/Game/AI/Query/queryComparePlayerOriginalHeart.h
@@ -0,0 +1,21 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class ComparePlayerOriginalHeart : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(ComparePlayerOriginalHeart, Query)
+public:
+    explicit ComparePlayerOriginalHeart(const InitArg& arg);
+    ~ComparePlayerOriginalHeart() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    int* mThreshold{};
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCountFlag4.cpp b/src/Game/AI/Query/queryCountFlag4.cpp
new file mode 100644
index 00000000..13395cdd
--- /dev/null
+++ b/src/Game/AI/Query/queryCountFlag4.cpp
@@ -0,0 +1,31 @@
+#include "Game/AI/Query/queryCountFlag4.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+CountFlag4::CountFlag4(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+CountFlag4::~CountFlag4() = default;
+
+// FIXME: implement
+int CountFlag4::doQuery() {
+    return -1;
+}
+
+void CountFlag4::loadParams(const evfl::QueryArg& arg) {
+    loadString(arg.param_accessor, "GameDataFlagNo0");
+    loadString(arg.param_accessor, "GameDataFlagNo1");
+    loadString(arg.param_accessor, "GameDataFlagNo2");
+    loadString(arg.param_accessor, "GameDataFlagNo3");
+    loadString(arg.param_accessor, "GameDataFlagNo4");
+}
+
+void CountFlag4::loadParams() {
+    getDynamicParam(&mGameDataFlagNo0, "GameDataFlagNo0");
+    getDynamicParam(&mGameDataFlagNo1, "GameDataFlagNo1");
+    getDynamicParam(&mGameDataFlagNo2, "GameDataFlagNo2");
+    getDynamicParam(&mGameDataFlagNo3, "GameDataFlagNo3");
+    getDynamicParam(&mGameDataFlagNo4, "GameDataFlagNo4");
+}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryCountFlag4.h b/src/Game/AI/Query/queryCountFlag4.h
new file mode 100644
index 00000000..b8006039
--- /dev/null
+++ b/src/Game/AI/Query/queryCountFlag4.h
@@ -0,0 +1,25 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class CountFlag4 : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(CountFlag4, Query)
+public:
+    explicit CountFlag4(const InitArg& arg);
+    ~CountFlag4() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    sead::SafeString mGameDataFlagNo0{};
+    sead::SafeString mGameDataFlagNo1{};
+    sead::SafeString mGameDataFlagNo2{};
+    sead::SafeString mGameDataFlagNo3{};
+    sead::SafeString mGameDataFlagNo4{};
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryEnemyDieCheck.cpp b/src/Game/AI/Query/queryEnemyDieCheck.cpp
new file mode 100644
index 00000000..0984d092
--- /dev/null
+++ b/src/Game/AI/Query/queryEnemyDieCheck.cpp
@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryEnemyDieCheck.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+EnemyDieCheck::EnemyDieCheck(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+EnemyDieCheck::~EnemyDieCheck() = default;
+
+// FIXME: implement
+int EnemyDieCheck::doQuery() {
+    return -1;
+}
+
+void EnemyDieCheck::loadParams(const evfl::QueryArg& arg) {}
+
+void EnemyDieCheck::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryEnemyDieCheck.h b/src/Game/AI/Query/queryEnemyDieCheck.h
new file mode 100644
index 00000000..e1a3411c
--- /dev/null
+++ b/src/Game/AI/Query/queryEnemyDieCheck.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class EnemyDieCheck : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(EnemyDieCheck, Query)
+public:
+    explicit EnemyDieCheck(const InitArg& arg);
+    ~EnemyDieCheck() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryEnemyRestLifeRate.cpp b/src/Game/AI/Query/queryEnemyRestLifeRate.cpp
new file mode 100644
index 00000000..4d1598d0
--- /dev/null
+++ b/src/Game/AI/Query/queryEnemyRestLifeRate.cpp
@@ -0,0 +1,23 @@
+#include "Game/AI/Query/queryEnemyRestLifeRate.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+EnemyRestLifeRate::EnemyRestLifeRate(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+EnemyRestLifeRate::~EnemyRestLifeRate() = default;
+
+// FIXME: implement
+int EnemyRestLifeRate::doQuery() {
+    return -1;
+}
+
+void EnemyRestLifeRate::loadParams(const evfl::QueryArg& arg) {
+    loadFloat(arg.param_accessor, "CheckRate");
+}
+
+void EnemyRestLifeRate::loadParams() {
+    getDynamicParam(&mCheckRate, "CheckRate");
+}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryEnemyRestLifeRate.h b/src/Game/AI/Query/queryEnemyRestLifeRate.h
new file mode 100644
index 00000000..0073285e
--- /dev/null
+++ b/src/Game/AI/Query/queryEnemyRestLifeRate.h
@@ -0,0 +1,21 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class EnemyRestLifeRate : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(EnemyRestLifeRate, Query)
+public:
+    explicit EnemyRestLifeRate(const InitArg& arg);
+    ~EnemyRestLifeRate() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    float* mCheckRate{};
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryGeneralChoice2.cpp b/src/Game/AI/Query/queryGeneralChoice2.cpp
new file mode 100644
index 00000000..405fe269
--- /dev/null
+++ b/src/Game/AI/Query/queryGeneralChoice2.cpp
@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryGeneralChoice2.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+GeneralChoice2::GeneralChoice2(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+GeneralChoice2::~GeneralChoice2() = default;
+
+// FIXME: implement
+int GeneralChoice2::doQuery() {
+    return -1;
+}
+
+void GeneralChoice2::loadParams(const evfl::QueryArg& arg) {}
+
+void GeneralChoice2::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryGeneralChoice2.h b/src/Game/AI/Query/queryGeneralChoice2.h
new file mode 100644
index 00000000..cdecbdf4
--- /dev/null
+++ b/src/Game/AI/Query/queryGeneralChoice2.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class GeneralChoice2 : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(GeneralChoice2, Query)
+public:
+    explicit GeneralChoice2(const InitArg& arg);
+    ~GeneralChoice2() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryGeneralChoice3.cpp b/src/Game/AI/Query/queryGeneralChoice3.cpp
new file mode 100644
index 00000000..d0c429ac
--- /dev/null
+++ b/src/Game/AI/Query/queryGeneralChoice3.cpp
@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryGeneralChoice3.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+GeneralChoice3::GeneralChoice3(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+GeneralChoice3::~GeneralChoice3() = default;
+
+// FIXME: implement
+int GeneralChoice3::doQuery() {
+    return -1;
+}
+
+void GeneralChoice3::loadParams(const evfl::QueryArg& arg) {}
+
+void GeneralChoice3::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryGeneralChoice3.h b/src/Game/AI/Query/queryGeneralChoice3.h
new file mode 100644
index 00000000..58ce35c7
--- /dev/null
+++ b/src/Game/AI/Query/queryGeneralChoice3.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class GeneralChoice3 : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(GeneralChoice3, Query)
+public:
+    explicit GeneralChoice3(const InitArg& arg);
+    ~GeneralChoice3() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryGeneralChoice4.cpp b/src/Game/AI/Query/queryGeneralChoice4.cpp
new file mode 100644
index 00000000..0b30f647
--- /dev/null
+++ b/src/Game/AI/Query/queryGeneralChoice4.cpp
@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryGeneralChoice4.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+GeneralChoice4::GeneralChoice4(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+GeneralChoice4::~GeneralChoice4() = default;
+
+// FIXME: implement
+int GeneralChoice4::doQuery() {
+    return -1;
+}
+
+void GeneralChoice4::loadParams(const evfl::QueryArg& arg) {}
+
+void GeneralChoice4::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryGeneralChoice4.h b/src/Game/AI/Query/queryGeneralChoice4.h
new file mode 100644
index 00000000..c46b420b
--- /dev/null
+++ b/src/Game/AI/Query/queryGeneralChoice4.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class GeneralChoice4 : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(GeneralChoice4, Query)
+public:
+    explicit GeneralChoice4(const InitArg& arg);
+    ~GeneralChoice4() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryGeneralChoice8.cpp b/src/Game/AI/Query/queryGeneralChoice8.cpp
new file mode 100644
index 00000000..8aa55819
--- /dev/null
+++ b/src/Game/AI/Query/queryGeneralChoice8.cpp
@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryGeneralChoice8.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+GeneralChoice8::GeneralChoice8(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+GeneralChoice8::~GeneralChoice8() = default;
+
+// FIXME: implement
+int GeneralChoice8::doQuery() {
+    return -1;
+}
+
+void GeneralChoice8::loadParams(const evfl::QueryArg& arg) {}
+
+void GeneralChoice8::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryGeneralChoice8.h b/src/Game/AI/Query/queryGeneralChoice8.h
new file mode 100644
index 00000000..89d9050c
--- /dev/null
+++ b/src/Game/AI/Query/queryGeneralChoice8.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class GeneralChoice8 : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(GeneralChoice8, Query)
+public:
+    explicit GeneralChoice8(const InitArg& arg);
+    ~GeneralChoice8() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryHasArmorAlreadyDyed.cpp b/src/Game/AI/Query/queryHasArmorAlreadyDyed.cpp
new file mode 100644
index 00000000..0bd17686
--- /dev/null
+++ b/src/Game/AI/Query/queryHasArmorAlreadyDyed.cpp
@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryHasArmorAlreadyDyed.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+HasArmorAlreadyDyed::HasArmorAlreadyDyed(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+HasArmorAlreadyDyed::~HasArmorAlreadyDyed() = default;
+
+// FIXME: implement
+int HasArmorAlreadyDyed::doQuery() {
+    return -1;
+}
+
+void HasArmorAlreadyDyed::loadParams(const evfl::QueryArg& arg) {}
+
+void HasArmorAlreadyDyed::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryHasArmorAlreadyDyed.h b/src/Game/AI/Query/queryHasArmorAlreadyDyed.h
new file mode 100644
index 00000000..1affc38e
--- /dev/null
+++ b/src/Game/AI/Query/queryHasArmorAlreadyDyed.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class HasArmorAlreadyDyed : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(HasArmorAlreadyDyed, Query)
+public:
+    explicit HasArmorAlreadyDyed(const InitArg& arg);
+    ~HasArmorAlreadyDyed() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryHasArmorDye.cpp b/src/Game/AI/Query/queryHasArmorDye.cpp
new file mode 100644
index 00000000..8bc2e197
--- /dev/null
+++ b/src/Game/AI/Query/queryHasArmorDye.cpp
@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryHasArmorDye.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+HasArmorDye::HasArmorDye(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+HasArmorDye::~HasArmorDye() = default;
+
+// FIXME: implement
+int HasArmorDye::doQuery() {
+    return -1;
+}
+
+void HasArmorDye::loadParams(const evfl::QueryArg& arg) {}
+
+void HasArmorDye::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryHasArmorDye.h b/src/Game/AI/Query/queryHasArmorDye.h
new file mode 100644
index 00000000..4afa96f0
--- /dev/null
+++ b/src/Game/AI/Query/queryHasArmorDye.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class HasArmorDye : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(HasArmorDye, Query)
+public:
+    explicit HasArmorDye(const InitArg& arg);
+    ~HasArmorDye() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryHasCookResultInPorch.cpp b/src/Game/AI/Query/queryHasCookResultInPorch.cpp
new file mode 100644
index 00000000..ad9b643d
--- /dev/null
+++ b/src/Game/AI/Query/queryHasCookResultInPorch.cpp
@@ -0,0 +1,27 @@
+#include "Game/AI/Query/queryHasCookResultInPorch.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+HasCookResultInPorch::HasCookResultInPorch(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+HasCookResultInPorch::~HasCookResultInPorch() = default;
+
+// FIXME: implement
+int HasCookResultInPorch::doQuery() {
+    return -1;
+}
+
+void HasCookResultInPorch::loadParams(const evfl::QueryArg& arg) {
+    loadInt(arg.param_accessor, "Count");
+    loadString(arg.param_accessor, "PorchItemName");
+    loadString(arg.param_accessor, "CookEffectType");
+}
+
+void HasCookResultInPorch::loadParams() {
+    getDynamicParam(&mCount, "Count");
+    getDynamicParam(&mPorchItemName, "PorchItemName");
+    getDynamicParam(&mCookEffectType, "CookEffectType");
+}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryHasCookResultInPorch.h b/src/Game/AI/Query/queryHasCookResultInPorch.h
new file mode 100644
index 00000000..592eeb91
--- /dev/null
+++ b/src/Game/AI/Query/queryHasCookResultInPorch.h
@@ -0,0 +1,23 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class HasCookResultInPorch : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(HasCookResultInPorch, Query)
+public:
+    explicit HasCookResultInPorch(const InitArg& arg);
+    ~HasCookResultInPorch() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    int* mCount{};
+    sead::SafeString mPorchItemName{};
+    sead::SafeString mCookEffectType{};
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryHasEnoughPayment.cpp b/src/Game/AI/Query/queryHasEnoughPayment.cpp
new file mode 100644
index 00000000..17632459
--- /dev/null
+++ b/src/Game/AI/Query/queryHasEnoughPayment.cpp
@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryHasEnoughPayment.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+HasEnoughPayment::HasEnoughPayment(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+HasEnoughPayment::~HasEnoughPayment() = default;
+
+// FIXME: implement
+int HasEnoughPayment::doQuery() {
+    return -1;
+}
+
+void HasEnoughPayment::loadParams(const evfl::QueryArg& arg) {}
+
+void HasEnoughPayment::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryHasEnoughPayment.h b/src/Game/AI/Query/queryHasEnoughPayment.h
new file mode 100644
index 00000000..7ca5e822
--- /dev/null
+++ b/src/Game/AI/Query/queryHasEnoughPayment.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class HasEnoughPayment : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(HasEnoughPayment, Query)
+public:
+    explicit HasEnoughPayment(const InitArg& arg);
+    ~HasEnoughPayment() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryHasItemDye.cpp b/src/Game/AI/Query/queryHasItemDye.cpp
new file mode 100644
index 00000000..34c2baa2
--- /dev/null
+++ b/src/Game/AI/Query/queryHasItemDye.cpp
@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryHasItemDye.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+HasItemDye::HasItemDye(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+HasItemDye::~HasItemDye() = default;
+
+// FIXME: implement
+int HasItemDye::doQuery() {
+    return -1;
+}
+
+void HasItemDye::loadParams(const evfl::QueryArg& arg) {}
+
+void HasItemDye::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryHasItemDye.h b/src/Game/AI/Query/queryHasItemDye.h
new file mode 100644
index 00000000..ec5f4c31
--- /dev/null
+++ b/src/Game/AI/Query/queryHasItemDye.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class HasItemDye : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(HasItemDye, Query)
+public:
+    explicit HasItemDye(const InitArg& arg);
+    ~HasItemDye() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryHasItemDyeSpecifiedColor.cpp b/src/Game/AI/Query/queryHasItemDyeSpecifiedColor.cpp
new file mode 100644
index 00000000..29bfde14
--- /dev/null
+++ b/src/Game/AI/Query/queryHasItemDyeSpecifiedColor.cpp
@@ -0,0 +1,20 @@
+#include "Game/AI/Query/queryHasItemDyeSpecifiedColor.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+HasItemDyeSpecifiedColor::HasItemDyeSpecifiedColor(const InitArg& arg)
+    : ksys::act::ai::Query(arg) {}
+
+HasItemDyeSpecifiedColor::~HasItemDyeSpecifiedColor() = default;
+
+// FIXME: implement
+int HasItemDyeSpecifiedColor::doQuery() {
+    return -1;
+}
+
+void HasItemDyeSpecifiedColor::loadParams(const evfl::QueryArg& arg) {}
+
+void HasItemDyeSpecifiedColor::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryHasItemDyeSpecifiedColor.h b/src/Game/AI/Query/queryHasItemDyeSpecifiedColor.h
new file mode 100644
index 00000000..9ff202ce
--- /dev/null
+++ b/src/Game/AI/Query/queryHasItemDyeSpecifiedColor.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class HasItemDyeSpecifiedColor : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(HasItemDyeSpecifiedColor, Query)
+public:
+    explicit HasItemDyeSpecifiedColor(const InitArg& arg);
+    ~HasItemDyeSpecifiedColor() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryHasPorchArrow.cpp b/src/Game/AI/Query/queryHasPorchArrow.cpp
new file mode 100644
index 00000000..16517eb3
--- /dev/null
+++ b/src/Game/AI/Query/queryHasPorchArrow.cpp
@@ -0,0 +1,23 @@
+#include "Game/AI/Query/queryHasPorchArrow.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+HasPorchArrow::HasPorchArrow(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+HasPorchArrow::~HasPorchArrow() = default;
+
+// FIXME: implement
+int HasPorchArrow::doQuery() {
+    return -1;
+}
+
+void HasPorchArrow::loadParams(const evfl::QueryArg& arg) {
+    loadInt(arg.param_accessor, "CheckNum");
+}
+
+void HasPorchArrow::loadParams() {
+    getDynamicParam(&mCheckNum, "CheckNum");
+}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryHasPorchArrow.h b/src/Game/AI/Query/queryHasPorchArrow.h
new file mode 100644
index 00000000..354ba28b
--- /dev/null
+++ b/src/Game/AI/Query/queryHasPorchArrow.h
@@ -0,0 +1,21 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class HasPorchArrow : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(HasPorchArrow, Query)
+public:
+    explicit HasPorchArrow(const InitArg& arg);
+    ~HasPorchArrow() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    int* mCheckNum{};
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryHasPorchItem.cpp b/src/Game/AI/Query/queryHasPorchItem.cpp
new file mode 100644
index 00000000..fee38fd2
--- /dev/null
+++ b/src/Game/AI/Query/queryHasPorchItem.cpp
@@ -0,0 +1,25 @@
+#include "Game/AI/Query/queryHasPorchItem.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+HasPorchItem::HasPorchItem(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+HasPorchItem::~HasPorchItem() = default;
+
+// FIXME: implement
+int HasPorchItem::doQuery() {
+    return -1;
+}
+
+void HasPorchItem::loadParams(const evfl::QueryArg& arg) {
+    loadInt(arg.param_accessor, "Count");
+    loadString(arg.param_accessor, "PorchItemName");
+}
+
+void HasPorchItem::loadParams() {
+    getDynamicParam(&mCount, "Count");
+    getDynamicParam(&mPorchItemName, "PorchItemName");
+}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryHasPorchItem.h b/src/Game/AI/Query/queryHasPorchItem.h
new file mode 100644
index 00000000..ed0e0a63
--- /dev/null
+++ b/src/Game/AI/Query/queryHasPorchItem.h
@@ -0,0 +1,22 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class HasPorchItem : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(HasPorchItem, Query)
+public:
+    explicit HasPorchItem(const InitArg& arg);
+    ~HasPorchItem() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    int* mCount{};
+    sead::SafeString mPorchItemName{};
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryHasPorchItemByCategory.cpp b/src/Game/AI/Query/queryHasPorchItemByCategory.cpp
new file mode 100644
index 00000000..ce984ece
--- /dev/null
+++ b/src/Game/AI/Query/queryHasPorchItemByCategory.cpp
@@ -0,0 +1,25 @@
+#include "Game/AI/Query/queryHasPorchItemByCategory.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+HasPorchItemByCategory::HasPorchItemByCategory(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+HasPorchItemByCategory::~HasPorchItemByCategory() = default;
+
+// FIXME: implement
+int HasPorchItemByCategory::doQuery() {
+    return -1;
+}
+
+void HasPorchItemByCategory::loadParams(const evfl::QueryArg& arg) {
+    loadInt(arg.param_accessor, "Category");
+    loadInt(arg.param_accessor, "Count");
+}
+
+void HasPorchItemByCategory::loadParams() {
+    getDynamicParam(&mCategory, "Category");
+    getDynamicParam(&mCount, "Count");
+}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryHasPorchItemByCategory.h b/src/Game/AI/Query/queryHasPorchItemByCategory.h
new file mode 100644
index 00000000..e13223b1
--- /dev/null
+++ b/src/Game/AI/Query/queryHasPorchItemByCategory.h
@@ -0,0 +1,22 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class HasPorchItemByCategory : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(HasPorchItemByCategory, Query)
+public:
+    explicit HasPorchItemByCategory(const InitArg& arg);
+    ~HasPorchItemByCategory() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    int* mCategory{};
+    int* mCount{};
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryHasPouchItemByPouchCategory.cpp b/src/Game/AI/Query/queryHasPouchItemByPouchCategory.cpp
new file mode 100644
index 00000000..ae0d193d
--- /dev/null
+++ b/src/Game/AI/Query/queryHasPouchItemByPouchCategory.cpp
@@ -0,0 +1,26 @@
+#include "Game/AI/Query/queryHasPouchItemByPouchCategory.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+HasPouchItemByPouchCategory::HasPouchItemByPouchCategory(const InitArg& arg)
+    : ksys::act::ai::Query(arg) {}
+
+HasPouchItemByPouchCategory::~HasPouchItemByPouchCategory() = default;
+
+// FIXME: implement
+int HasPouchItemByPouchCategory::doQuery() {
+    return -1;
+}
+
+void HasPouchItemByPouchCategory::loadParams(const evfl::QueryArg& arg) {
+    loadInt(arg.param_accessor, "Category");
+    loadInt(arg.param_accessor, "Count");
+}
+
+void HasPouchItemByPouchCategory::loadParams() {
+    getDynamicParam(&mCategory, "Category");
+    getDynamicParam(&mCount, "Count");
+}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryHasPouchItemByPouchCategory.h b/src/Game/AI/Query/queryHasPouchItemByPouchCategory.h
new file mode 100644
index 00000000..1a2a77de
--- /dev/null
+++ b/src/Game/AI/Query/queryHasPouchItemByPouchCategory.h
@@ -0,0 +1,22 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class HasPouchItemByPouchCategory : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(HasPouchItemByPouchCategory, Query)
+public:
+    explicit HasPouchItemByPouchCategory(const InitArg& arg);
+    ~HasPouchItemByPouchCategory() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    int* mCategory{};
+    int* mCount{};
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryHasSetItem.cpp b/src/Game/AI/Query/queryHasSetItem.cpp
new file mode 100644
index 00000000..090b61d5
--- /dev/null
+++ b/src/Game/AI/Query/queryHasSetItem.cpp
@@ -0,0 +1,25 @@
+#include "Game/AI/Query/queryHasSetItem.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+HasSetItem::HasSetItem(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+HasSetItem::~HasSetItem() = default;
+
+// FIXME: implement
+int HasSetItem::doQuery() {
+    return -1;
+}
+
+void HasSetItem::loadParams(const evfl::QueryArg& arg) {
+    loadInt(arg.param_accessor, "Count");
+    loadString(arg.param_accessor, "ItemName");
+}
+
+void HasSetItem::loadParams() {
+    getDynamicParam(&mCount, "Count");
+    getDynamicParam(&mItemName, "ItemName");
+}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryHasSetItem.h b/src/Game/AI/Query/queryHasSetItem.h
new file mode 100644
index 00000000..0df95680
--- /dev/null
+++ b/src/Game/AI/Query/queryHasSetItem.h
@@ -0,0 +1,22 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class HasSetItem : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(HasSetItem, Query)
+public:
+    explicit HasSetItem(const InitArg& arg);
+    ~HasSetItem() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    int* mCount{};
+    sead::SafeString mItemName{};
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryHasSpecificArmorSeries.cpp b/src/Game/AI/Query/queryHasSpecificArmorSeries.cpp
new file mode 100644
index 00000000..5ba9f00d
--- /dev/null
+++ b/src/Game/AI/Query/queryHasSpecificArmorSeries.cpp
@@ -0,0 +1,23 @@
+#include "Game/AI/Query/queryHasSpecificArmorSeries.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+HasSpecificArmorSeries::HasSpecificArmorSeries(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+HasSpecificArmorSeries::~HasSpecificArmorSeries() = default;
+
+// FIXME: implement
+int HasSpecificArmorSeries::doQuery() {
+    return -1;
+}
+
+void HasSpecificArmorSeries::loadParams(const evfl::QueryArg& arg) {
+    loadInt(arg.param_accessor, "SeriesType");
+}
+
+void HasSpecificArmorSeries::loadParams() {
+    getDynamicParam(&mSeriesType, "SeriesType");
+}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryHasSpecificArmorSeries.h b/src/Game/AI/Query/queryHasSpecificArmorSeries.h
new file mode 100644
index 00000000..8243324e
--- /dev/null
+++ b/src/Game/AI/Query/queryHasSpecificArmorSeries.h
@@ -0,0 +1,21 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class HasSpecificArmorSeries : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(HasSpecificArmorSeries, Query)
+public:
+    explicit HasSpecificArmorSeries(const InitArg& arg);
+    ~HasSpecificArmorSeries() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    int* mSeriesType{};
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryIsAppAlreadyExchanged.cpp b/src/Game/AI/Query/queryIsAppAlreadyExchanged.cpp
new file mode 100644
index 00000000..2753d7ca
--- /dev/null
+++ b/src/Game/AI/Query/queryIsAppAlreadyExchanged.cpp
@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryIsAppAlreadyExchanged.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+IsAppAlreadyExchanged::IsAppAlreadyExchanged(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+IsAppAlreadyExchanged::~IsAppAlreadyExchanged() = default;
+
+// FIXME: implement
+int IsAppAlreadyExchanged::doQuery() {
+    return -1;
+}
+
+void IsAppAlreadyExchanged::loadParams(const evfl::QueryArg& arg) {}
+
+void IsAppAlreadyExchanged::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryIsAppAlreadyExchanged.h b/src/Game/AI/Query/queryIsAppAlreadyExchanged.h
new file mode 100644
index 00000000..f849fbc0
--- /dev/null
+++ b/src/Game/AI/Query/queryIsAppAlreadyExchanged.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class IsAppAlreadyExchanged : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(IsAppAlreadyExchanged, Query)
+public:
+    explicit IsAppAlreadyExchanged(const InitArg& arg);
+    ~IsAppAlreadyExchanged() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryIsArriveAnchorForRain.cpp b/src/Game/AI/Query/queryIsArriveAnchorForRain.cpp
new file mode 100644
index 00000000..cb3a9540
--- /dev/null
+++ b/src/Game/AI/Query/queryIsArriveAnchorForRain.cpp
@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryIsArriveAnchorForRain.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+IsArriveAnchorForRain::IsArriveAnchorForRain(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+IsArriveAnchorForRain::~IsArriveAnchorForRain() = default;
+
+// FIXME: implement
+int IsArriveAnchorForRain::doQuery() {
+    return -1;
+}
+
+void IsArriveAnchorForRain::loadParams(const evfl::QueryArg& arg) {}
+
+void IsArriveAnchorForRain::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryIsArriveAnchorForRain.h b/src/Game/AI/Query/queryIsArriveAnchorForRain.h
new file mode 100644
index 00000000..3415a49f
--- /dev/null
+++ b/src/Game/AI/Query/queryIsArriveAnchorForRain.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class IsArriveAnchorForRain : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(IsArriveAnchorForRain, Query)
+public:
+    explicit IsArriveAnchorForRain(const InitArg& arg);
+    ~IsArriveAnchorForRain() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryIsAwakened.cpp b/src/Game/AI/Query/queryIsAwakened.cpp
new file mode 100644
index 00000000..9aa11055
--- /dev/null
+++ b/src/Game/AI/Query/queryIsAwakened.cpp
@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryIsAwakened.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+IsAwakened::IsAwakened(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+IsAwakened::~IsAwakened() = default;
+
+// FIXME: implement
+int IsAwakened::doQuery() {
+    return -1;
+}
+
+void IsAwakened::loadParams(const evfl::QueryArg& arg) {}
+
+void IsAwakened::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryIsAwakened.h b/src/Game/AI/Query/queryIsAwakened.h
new file mode 100644
index 00000000..fef2167b
--- /dev/null
+++ b/src/Game/AI/Query/queryIsAwakened.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class IsAwakened : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(IsAwakened, Query)
+public:
+    explicit IsAwakened(const InitArg& arg);
+    ~IsAwakened() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryIsBloodyMoonTrig.cpp b/src/Game/AI/Query/queryIsBloodyMoonTrig.cpp
new file mode 100644
index 00000000..5798ff07
--- /dev/null
+++ b/src/Game/AI/Query/queryIsBloodyMoonTrig.cpp
@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryIsBloodyMoonTrig.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+IsBloodyMoonTrig::IsBloodyMoonTrig(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+IsBloodyMoonTrig::~IsBloodyMoonTrig() = default;
+
+// FIXME: implement
+int IsBloodyMoonTrig::doQuery() {
+    return -1;
+}
+
+void IsBloodyMoonTrig::loadParams(const evfl::QueryArg& arg) {}
+
+void IsBloodyMoonTrig::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryIsBloodyMoonTrig.h b/src/Game/AI/Query/queryIsBloodyMoonTrig.h
new file mode 100644
index 00000000..b0748fdb
--- /dev/null
+++ b/src/Game/AI/Query/queryIsBloodyMoonTrig.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class IsBloodyMoonTrig : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(IsBloodyMoonTrig, Query)
+public:
+    explicit IsBloodyMoonTrig(const InitArg& arg);
+    ~IsBloodyMoonTrig() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryIsCurrentAocFieldStage.cpp b/src/Game/AI/Query/queryIsCurrentAocFieldStage.cpp
new file mode 100644
index 00000000..f2a0e2a6
--- /dev/null
+++ b/src/Game/AI/Query/queryIsCurrentAocFieldStage.cpp
@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryIsCurrentAocFieldStage.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+IsCurrentAocFieldStage::IsCurrentAocFieldStage(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+IsCurrentAocFieldStage::~IsCurrentAocFieldStage() = default;
+
+// FIXME: implement
+int IsCurrentAocFieldStage::doQuery() {
+    return -1;
+}
+
+void IsCurrentAocFieldStage::loadParams(const evfl::QueryArg& arg) {}
+
+void IsCurrentAocFieldStage::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryIsCurrentAocFieldStage.h b/src/Game/AI/Query/queryIsCurrentAocFieldStage.h
new file mode 100644
index 00000000..110e39d3
--- /dev/null
+++ b/src/Game/AI/Query/queryIsCurrentAocFieldStage.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class IsCurrentAocFieldStage : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(IsCurrentAocFieldStage, Query)
+public:
+    explicit IsCurrentAocFieldStage(const InitArg& arg);
+    ~IsCurrentAocFieldStage() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryIsCurrentCDungeonStage.cpp b/src/Game/AI/Query/queryIsCurrentCDungeonStage.cpp
new file mode 100644
index 00000000..4ba07d6b
--- /dev/null
+++ b/src/Game/AI/Query/queryIsCurrentCDungeonStage.cpp
@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryIsCurrentCDungeonStage.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+IsCurrentCDungeonStage::IsCurrentCDungeonStage(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+IsCurrentCDungeonStage::~IsCurrentCDungeonStage() = default;
+
+// FIXME: implement
+int IsCurrentCDungeonStage::doQuery() {
+    return -1;
+}
+
+void IsCurrentCDungeonStage::loadParams(const evfl::QueryArg& arg) {}
+
+void IsCurrentCDungeonStage::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryIsCurrentCDungeonStage.h b/src/Game/AI/Query/queryIsCurrentCDungeonStage.h
new file mode 100644
index 00000000..0ac01f4e
--- /dev/null
+++ b/src/Game/AI/Query/queryIsCurrentCDungeonStage.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class IsCurrentCDungeonStage : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(IsCurrentCDungeonStage, Query)
+public:
+    explicit IsCurrentCDungeonStage(const InitArg& arg);
+    ~IsCurrentCDungeonStage() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryIsCurrentMainFieldDungeonStage.cpp b/src/Game/AI/Query/queryIsCurrentMainFieldDungeonStage.cpp
new file mode 100644
index 00000000..412fef96
--- /dev/null
+++ b/src/Game/AI/Query/queryIsCurrentMainFieldDungeonStage.cpp
@@ -0,0 +1,20 @@
+#include "Game/AI/Query/queryIsCurrentMainFieldDungeonStage.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+IsCurrentMainFieldDungeonStage::IsCurrentMainFieldDungeonStage(const InitArg& arg)
+    : ksys::act::ai::Query(arg) {}
+
+IsCurrentMainFieldDungeonStage::~IsCurrentMainFieldDungeonStage() = default;
+
+// FIXME: implement
+int IsCurrentMainFieldDungeonStage::doQuery() {
+    return -1;
+}
+
+void IsCurrentMainFieldDungeonStage::loadParams(const evfl::QueryArg& arg) {}
+
+void IsCurrentMainFieldDungeonStage::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryIsCurrentMainFieldDungeonStage.h b/src/Game/AI/Query/queryIsCurrentMainFieldDungeonStage.h
new file mode 100644
index 00000000..4910dbf5
--- /dev/null
+++ b/src/Game/AI/Query/queryIsCurrentMainFieldDungeonStage.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class IsCurrentMainFieldDungeonStage : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(IsCurrentMainFieldDungeonStage, Query)
+public:
+    explicit IsCurrentMainFieldDungeonStage(const InitArg& arg);
+    ~IsCurrentMainFieldDungeonStage() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryIsCurrentMainFieldStage.cpp b/src/Game/AI/Query/queryIsCurrentMainFieldStage.cpp
new file mode 100644
index 00000000..4ecb1f0b
--- /dev/null
+++ b/src/Game/AI/Query/queryIsCurrentMainFieldStage.cpp
@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryIsCurrentMainFieldStage.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+IsCurrentMainFieldStage::IsCurrentMainFieldStage(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+IsCurrentMainFieldStage::~IsCurrentMainFieldStage() = default;
+
+// FIXME: implement
+int IsCurrentMainFieldStage::doQuery() {
+    return -1;
+}
+
+void IsCurrentMainFieldStage::loadParams(const evfl::QueryArg& arg) {}
+
+void IsCurrentMainFieldStage::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryIsCurrentMainFieldStage.h b/src/Game/AI/Query/queryIsCurrentMainFieldStage.h
new file mode 100644
index 00000000..96f12c91
--- /dev/null
+++ b/src/Game/AI/Query/queryIsCurrentMainFieldStage.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class IsCurrentMainFieldStage : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(IsCurrentMainFieldStage, Query)
+public:
+    explicit IsCurrentMainFieldStage(const InitArg& arg);
+    ~IsCurrentMainFieldStage() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryIsEquipedDyedArmor.cpp b/src/Game/AI/Query/queryIsEquipedDyedArmor.cpp
new file mode 100644
index 00000000..d87f573b
--- /dev/null
+++ b/src/Game/AI/Query/queryIsEquipedDyedArmor.cpp
@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryIsEquipedDyedArmor.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+IsEquipedDyedArmor::IsEquipedDyedArmor(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+IsEquipedDyedArmor::~IsEquipedDyedArmor() = default;
+
+// FIXME: implement
+int IsEquipedDyedArmor::doQuery() {
+    return -1;
+}
+
+void IsEquipedDyedArmor::loadParams(const evfl::QueryArg& arg) {}
+
+void IsEquipedDyedArmor::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryIsEquipedDyedArmor.h b/src/Game/AI/Query/queryIsEquipedDyedArmor.h
new file mode 100644
index 00000000..ba8c524f
--- /dev/null
+++ b/src/Game/AI/Query/queryIsEquipedDyedArmor.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class IsEquipedDyedArmor : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(IsEquipedDyedArmor, Query)
+public:
+    explicit IsEquipedDyedArmor(const InitArg& arg);
+    ~IsEquipedDyedArmor() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryIsEquippedEnableDye.cpp b/src/Game/AI/Query/queryIsEquippedEnableDye.cpp
new file mode 100644
index 00000000..965230f3
--- /dev/null
+++ b/src/Game/AI/Query/queryIsEquippedEnableDye.cpp
@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryIsEquippedEnableDye.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+IsEquippedEnableDye::IsEquippedEnableDye(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+IsEquippedEnableDye::~IsEquippedEnableDye() = default;
+
+// FIXME: implement
+int IsEquippedEnableDye::doQuery() {
+    return -1;
+}
+
+void IsEquippedEnableDye::loadParams(const evfl::QueryArg& arg) {}
+
+void IsEquippedEnableDye::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryIsEquippedEnableDye.h b/src/Game/AI/Query/queryIsEquippedEnableDye.h
new file mode 100644
index 00000000..bbb44787
--- /dev/null
+++ b/src/Game/AI/Query/queryIsEquippedEnableDye.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class IsEquippedEnableDye : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(IsEquippedEnableDye, Query)
+public:
+    explicit IsEquippedEnableDye(const InitArg& arg);
+    ~IsEquippedEnableDye() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryIsEquippedWithLowerBody.cpp b/src/Game/AI/Query/queryIsEquippedWithLowerBody.cpp
new file mode 100644
index 00000000..cee7e68c
--- /dev/null
+++ b/src/Game/AI/Query/queryIsEquippedWithLowerBody.cpp
@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryIsEquippedWithLowerBody.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+IsEquippedWithLowerBody::IsEquippedWithLowerBody(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+IsEquippedWithLowerBody::~IsEquippedWithLowerBody() = default;
+
+// FIXME: implement
+int IsEquippedWithLowerBody::doQuery() {
+    return -1;
+}
+
+void IsEquippedWithLowerBody::loadParams(const evfl::QueryArg& arg) {}
+
+void IsEquippedWithLowerBody::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryIsEquippedWithLowerBody.h b/src/Game/AI/Query/queryIsEquippedWithLowerBody.h
new file mode 100644
index 00000000..768845fd
--- /dev/null
+++ b/src/Game/AI/Query/queryIsEquippedWithLowerBody.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class IsEquippedWithLowerBody : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(IsEquippedWithLowerBody, Query)
+public:
+    explicit IsEquippedWithLowerBody(const InitArg& arg);
+    ~IsEquippedWithLowerBody() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryIsHorseFamiliarityPassedAlready.cpp b/src/Game/AI/Query/queryIsHorseFamiliarityPassedAlready.cpp
new file mode 100644
index 00000000..4ab9add0
--- /dev/null
+++ b/src/Game/AI/Query/queryIsHorseFamiliarityPassedAlready.cpp
@@ -0,0 +1,20 @@
+#include "Game/AI/Query/queryIsHorseFamiliarityPassedAlready.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+IsHorseFamiliarityPassedAlready::IsHorseFamiliarityPassedAlready(const InitArg& arg)
+    : ksys::act::ai::Query(arg) {}
+
+IsHorseFamiliarityPassedAlready::~IsHorseFamiliarityPassedAlready() = default;
+
+// FIXME: implement
+int IsHorseFamiliarityPassedAlready::doQuery() {
+    return -1;
+}
+
+void IsHorseFamiliarityPassedAlready::loadParams(const evfl::QueryArg& arg) {}
+
+void IsHorseFamiliarityPassedAlready::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryIsHorseFamiliarityPassedAlready.h b/src/Game/AI/Query/queryIsHorseFamiliarityPassedAlready.h
new file mode 100644
index 00000000..efab16ec
--- /dev/null
+++ b/src/Game/AI/Query/queryIsHorseFamiliarityPassedAlready.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class IsHorseFamiliarityPassedAlready : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(IsHorseFamiliarityPassedAlready, Query)
+public:
+    explicit IsHorseFamiliarityPassedAlready(const InitArg& arg);
+    ~IsHorseFamiliarityPassedAlready() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryIsHorseNumMax.cpp b/src/Game/AI/Query/queryIsHorseNumMax.cpp
new file mode 100644
index 00000000..c5bf450a
--- /dev/null
+++ b/src/Game/AI/Query/queryIsHorseNumMax.cpp
@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryIsHorseNumMax.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+IsHorseNumMax::IsHorseNumMax(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+IsHorseNumMax::~IsHorseNumMax() = default;
+
+// FIXME: implement
+int IsHorseNumMax::doQuery() {
+    return -1;
+}
+
+void IsHorseNumMax::loadParams(const evfl::QueryArg& arg) {}
+
+void IsHorseNumMax::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryIsHorseNumMax.h b/src/Game/AI/Query/queryIsHorseNumMax.h
new file mode 100644
index 00000000..7d8430fb
--- /dev/null
+++ b/src/Game/AI/Query/queryIsHorseNumMax.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class IsHorseNumMax : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(IsHorseNumMax, Query)
+public:
+    explicit IsHorseNumMax(const InitArg& arg);
+    ~IsHorseNumMax() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryIsIgnitionByArrowFire.cpp b/src/Game/AI/Query/queryIsIgnitionByArrowFire.cpp
new file mode 100644
index 00000000..ae4ffd3b
--- /dev/null
+++ b/src/Game/AI/Query/queryIsIgnitionByArrowFire.cpp
@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryIsIgnitionByArrowFire.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+IsIgnitionByArrowFire::IsIgnitionByArrowFire(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+IsIgnitionByArrowFire::~IsIgnitionByArrowFire() = default;
+
+// FIXME: implement
+int IsIgnitionByArrowFire::doQuery() {
+    return -1;
+}
+
+void IsIgnitionByArrowFire::loadParams(const evfl::QueryArg& arg) {}
+
+void IsIgnitionByArrowFire::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryIsIgnitionByArrowFire.h b/src/Game/AI/Query/queryIsIgnitionByArrowFire.h
new file mode 100644
index 00000000..9266aa7f
--- /dev/null
+++ b/src/Game/AI/Query/queryIsIgnitionByArrowFire.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class IsIgnitionByArrowFire : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(IsIgnitionByArrowFire, Query)
+public:
+    explicit IsIgnitionByArrowFire(const InitArg& arg);
+    ~IsIgnitionByArrowFire() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryIsItemInStock.cpp b/src/Game/AI/Query/queryIsItemInStock.cpp
new file mode 100644
index 00000000..aa33a5fe
--- /dev/null
+++ b/src/Game/AI/Query/queryIsItemInStock.cpp
@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryIsItemInStock.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+IsItemInStock::IsItemInStock(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+IsItemInStock::~IsItemInStock() = default;
+
+// FIXME: implement
+int IsItemInStock::doQuery() {
+    return -1;
+}
+
+void IsItemInStock::loadParams(const evfl::QueryArg& arg) {}
+
+void IsItemInStock::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryIsItemInStock.h b/src/Game/AI/Query/queryIsItemInStock.h
new file mode 100644
index 00000000..c853796e
--- /dev/null
+++ b/src/Game/AI/Query/queryIsItemInStock.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class IsItemInStock : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(IsItemInStock, Query)
+public:
+    explicit IsItemInStock(const InitArg& arg);
+    ~IsItemInStock() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryIsNeedEquipWeapon.cpp b/src/Game/AI/Query/queryIsNeedEquipWeapon.cpp
new file mode 100644
index 00000000..6c00660f
--- /dev/null
+++ b/src/Game/AI/Query/queryIsNeedEquipWeapon.cpp
@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryIsNeedEquipWeapon.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+IsNeedEquipWeapon::IsNeedEquipWeapon(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+IsNeedEquipWeapon::~IsNeedEquipWeapon() = default;
+
+// FIXME: implement
+int IsNeedEquipWeapon::doQuery() {
+    return -1;
+}
+
+void IsNeedEquipWeapon::loadParams(const evfl::QueryArg& arg) {}
+
+void IsNeedEquipWeapon::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryIsNeedEquipWeapon.h b/src/Game/AI/Query/queryIsNeedEquipWeapon.h
new file mode 100644
index 00000000..35fb304b
--- /dev/null
+++ b/src/Game/AI/Query/queryIsNeedEquipWeapon.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class IsNeedEquipWeapon : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(IsNeedEquipWeapon, Query)
+public:
+    explicit IsNeedEquipWeapon(const InitArg& arg);
+    ~IsNeedEquipWeapon() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryIsNoEquipArmorAnyTarget.cpp b/src/Game/AI/Query/queryIsNoEquipArmorAnyTarget.cpp
new file mode 100644
index 00000000..19ef62c3
--- /dev/null
+++ b/src/Game/AI/Query/queryIsNoEquipArmorAnyTarget.cpp
@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryIsNoEquipArmorAnyTarget.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+IsNoEquipArmorAnyTarget::IsNoEquipArmorAnyTarget(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+IsNoEquipArmorAnyTarget::~IsNoEquipArmorAnyTarget() = default;
+
+// FIXME: implement
+int IsNoEquipArmorAnyTarget::doQuery() {
+    return -1;
+}
+
+void IsNoEquipArmorAnyTarget::loadParams(const evfl::QueryArg& arg) {}
+
+void IsNoEquipArmorAnyTarget::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryIsNoEquipArmorAnyTarget.h b/src/Game/AI/Query/queryIsNoEquipArmorAnyTarget.h
new file mode 100644
index 00000000..6a2d7a5b
--- /dev/null
+++ b/src/Game/AI/Query/queryIsNoEquipArmorAnyTarget.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class IsNoEquipArmorAnyTarget : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(IsNoEquipArmorAnyTarget, Query)
+public:
+    explicit IsNoEquipArmorAnyTarget(const InitArg& arg);
+    ~IsNoEquipArmorAnyTarget() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryIsOffLinkTag.cpp b/src/Game/AI/Query/queryIsOffLinkTag.cpp
new file mode 100644
index 00000000..158434f2
--- /dev/null
+++ b/src/Game/AI/Query/queryIsOffLinkTag.cpp
@@ -0,0 +1,23 @@
+#include "Game/AI/Query/queryIsOffLinkTag.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+IsOffLinkTag::IsOffLinkTag(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+IsOffLinkTag::~IsOffLinkTag() = default;
+
+// FIXME: implement
+int IsOffLinkTag::doQuery() {
+    return -1;
+}
+
+void IsOffLinkTag::loadParams(const evfl::QueryArg& arg) {
+    loadInt(arg.param_accessor, "SignalType");
+}
+
+void IsOffLinkTag::loadParams() {
+    getDynamicParam(&mSignalType, "SignalType");
+}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryIsOffLinkTag.h b/src/Game/AI/Query/queryIsOffLinkTag.h
new file mode 100644
index 00000000..06a2d6c2
--- /dev/null
+++ b/src/Game/AI/Query/queryIsOffLinkTag.h
@@ -0,0 +1,21 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class IsOffLinkTag : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(IsOffLinkTag, Query)
+public:
+    explicit IsOffLinkTag(const InitArg& arg);
+    ~IsOffLinkTag() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    int* mSignalType{};
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryIsOnEnterDungeonFlag.cpp b/src/Game/AI/Query/queryIsOnEnterDungeonFlag.cpp
new file mode 100644
index 00000000..f12fefbd
--- /dev/null
+++ b/src/Game/AI/Query/queryIsOnEnterDungeonFlag.cpp
@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryIsOnEnterDungeonFlag.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+IsOnEnterDungeonFlag::IsOnEnterDungeonFlag(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+IsOnEnterDungeonFlag::~IsOnEnterDungeonFlag() = default;
+
+// FIXME: implement
+int IsOnEnterDungeonFlag::doQuery() {
+    return -1;
+}
+
+void IsOnEnterDungeonFlag::loadParams(const evfl::QueryArg& arg) {}
+
+void IsOnEnterDungeonFlag::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryIsOnEnterDungeonFlag.h b/src/Game/AI/Query/queryIsOnEnterDungeonFlag.h
new file mode 100644
index 00000000..b774b94d
--- /dev/null
+++ b/src/Game/AI/Query/queryIsOnEnterDungeonFlag.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class IsOnEnterDungeonFlag : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(IsOnEnterDungeonFlag, Query)
+public:
+    explicit IsOnEnterDungeonFlag(const InitArg& arg);
+    ~IsOnEnterDungeonFlag() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryIsOnInstEventFlag.cpp b/src/Game/AI/Query/queryIsOnInstEventFlag.cpp
new file mode 100644
index 00000000..716d43c9
--- /dev/null
+++ b/src/Game/AI/Query/queryIsOnInstEventFlag.cpp
@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryIsOnInstEventFlag.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+IsOnInstEventFlag::IsOnInstEventFlag(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+IsOnInstEventFlag::~IsOnInstEventFlag() = default;
+
+// FIXME: implement
+int IsOnInstEventFlag::doQuery() {
+    return -1;
+}
+
+void IsOnInstEventFlag::loadParams(const evfl::QueryArg& arg) {}
+
+void IsOnInstEventFlag::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryIsOnInstEventFlag.h b/src/Game/AI/Query/queryIsOnInstEventFlag.h
new file mode 100644
index 00000000..08c060a5
--- /dev/null
+++ b/src/Game/AI/Query/queryIsOnInstEventFlag.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class IsOnInstEventFlag : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(IsOnInstEventFlag, Query)
+public:
+    explicit IsOnInstEventFlag(const InitArg& arg);
+    ~IsOnInstEventFlag() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryIsOwnedHorseAssociated.cpp b/src/Game/AI/Query/queryIsOwnedHorseAssociated.cpp
new file mode 100644
index 00000000..208cbeec
--- /dev/null
+++ b/src/Game/AI/Query/queryIsOwnedHorseAssociated.cpp
@@ -0,0 +1,23 @@
+#include "Game/AI/Query/queryIsOwnedHorseAssociated.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+IsOwnedHorseAssociated::IsOwnedHorseAssociated(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+IsOwnedHorseAssociated::~IsOwnedHorseAssociated() = default;
+
+// FIXME: implement
+int IsOwnedHorseAssociated::doQuery() {
+    return -1;
+}
+
+void IsOwnedHorseAssociated::loadParams(const evfl::QueryArg& arg) {
+    loadBool(arg.param_accessor, "IsRidden");
+}
+
+void IsOwnedHorseAssociated::loadParams() {
+    getDynamicParam(&mIsRidden, "IsRidden");
+}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryIsOwnedHorseAssociated.h b/src/Game/AI/Query/queryIsOwnedHorseAssociated.h
new file mode 100644
index 00000000..6124dcde
--- /dev/null
+++ b/src/Game/AI/Query/queryIsOwnedHorseAssociated.h
@@ -0,0 +1,21 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class IsOwnedHorseAssociated : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(IsOwnedHorseAssociated, Query)
+public:
+    explicit IsOwnedHorseAssociated(const InitArg& arg);
+    ~IsOwnedHorseAssociated() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    bool* mIsRidden{};
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryIsPlayerGrounded.cpp b/src/Game/AI/Query/queryIsPlayerGrounded.cpp
new file mode 100644
index 00000000..4e28bca6
--- /dev/null
+++ b/src/Game/AI/Query/queryIsPlayerGrounded.cpp
@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryIsPlayerGrounded.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+IsPlayerGrounded::IsPlayerGrounded(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+IsPlayerGrounded::~IsPlayerGrounded() = default;
+
+// FIXME: implement
+int IsPlayerGrounded::doQuery() {
+    return -1;
+}
+
+void IsPlayerGrounded::loadParams(const evfl::QueryArg& arg) {}
+
+void IsPlayerGrounded::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryIsPlayerGrounded.h b/src/Game/AI/Query/queryIsPlayerGrounded.h
new file mode 100644
index 00000000..88ea18a8
--- /dev/null
+++ b/src/Game/AI/Query/queryIsPlayerGrounded.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class IsPlayerGrounded : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(IsPlayerGrounded, Query)
+public:
+    explicit IsPlayerGrounded(const InitArg& arg);
+    ~IsPlayerGrounded() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryIsRest.cpp b/src/Game/AI/Query/queryIsRest.cpp
new file mode 100644
index 00000000..fe219c12
--- /dev/null
+++ b/src/Game/AI/Query/queryIsRest.cpp
@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryIsRest.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+IsRest::IsRest(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+IsRest::~IsRest() = default;
+
+// FIXME: implement
+int IsRest::doQuery() {
+    return -1;
+}
+
+void IsRest::loadParams(const evfl::QueryArg& arg) {}
+
+void IsRest::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryIsRest.h b/src/Game/AI/Query/queryIsRest.h
new file mode 100644
index 00000000..099ab88f
--- /dev/null
+++ b/src/Game/AI/Query/queryIsRest.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class IsRest : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(IsRest, Query)
+public:
+    explicit IsRest(const InitArg& arg);
+    ~IsRest() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryIsRideHorse.cpp b/src/Game/AI/Query/queryIsRideHorse.cpp
new file mode 100644
index 00000000..0b1a2383
--- /dev/null
+++ b/src/Game/AI/Query/queryIsRideHorse.cpp
@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryIsRideHorse.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+IsRideHorse::IsRideHorse(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+IsRideHorse::~IsRideHorse() = default;
+
+// FIXME: implement
+int IsRideHorse::doQuery() {
+    return -1;
+}
+
+void IsRideHorse::loadParams(const evfl::QueryArg& arg) {}
+
+void IsRideHorse::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryIsRideHorse.h b/src/Game/AI/Query/queryIsRideHorse.h
new file mode 100644
index 00000000..4a9c9059
--- /dev/null
+++ b/src/Game/AI/Query/queryIsRideHorse.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class IsRideHorse : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(IsRideHorse, Query)
+public:
+    explicit IsRideHorse(const InitArg& arg);
+    ~IsRideHorse() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryIsSoldOut.cpp b/src/Game/AI/Query/queryIsSoldOut.cpp
new file mode 100644
index 00000000..86e19f66
--- /dev/null
+++ b/src/Game/AI/Query/queryIsSoldOut.cpp
@@ -0,0 +1,23 @@
+#include "Game/AI/Query/queryIsSoldOut.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+IsSoldOut::IsSoldOut(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+IsSoldOut::~IsSoldOut() = default;
+
+// FIXME: implement
+int IsSoldOut::doQuery() {
+    return -1;
+}
+
+void IsSoldOut::loadParams(const evfl::QueryArg& arg) {
+    loadString(arg.param_accessor, "TableName");
+}
+
+void IsSoldOut::loadParams() {
+    getDynamicParam(&mTableName, "TableName");
+}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryIsSoldOut.h b/src/Game/AI/Query/queryIsSoldOut.h
new file mode 100644
index 00000000..63939a42
--- /dev/null
+++ b/src/Game/AI/Query/queryIsSoldOut.h
@@ -0,0 +1,21 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class IsSoldOut : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(IsSoldOut, Query)
+public:
+    explicit IsSoldOut(const InitArg& arg);
+    ~IsSoldOut() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    sead::SafeString mTableName{};
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryIsSuccessEndLastDemoAction.cpp b/src/Game/AI/Query/queryIsSuccessEndLastDemoAction.cpp
new file mode 100644
index 00000000..d306a292
--- /dev/null
+++ b/src/Game/AI/Query/queryIsSuccessEndLastDemoAction.cpp
@@ -0,0 +1,20 @@
+#include "Game/AI/Query/queryIsSuccessEndLastDemoAction.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+IsSuccessEndLastDemoAction::IsSuccessEndLastDemoAction(const InitArg& arg)
+    : ksys::act::ai::Query(arg) {}
+
+IsSuccessEndLastDemoAction::~IsSuccessEndLastDemoAction() = default;
+
+// FIXME: implement
+int IsSuccessEndLastDemoAction::doQuery() {
+    return -1;
+}
+
+void IsSuccessEndLastDemoAction::loadParams(const evfl::QueryArg& arg) {}
+
+void IsSuccessEndLastDemoAction::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryIsSuccessEndLastDemoAction.h b/src/Game/AI/Query/queryIsSuccessEndLastDemoAction.h
new file mode 100644
index 00000000..46603329
--- /dev/null
+++ b/src/Game/AI/Query/queryIsSuccessEndLastDemoAction.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class IsSuccessEndLastDemoAction : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(IsSuccessEndLastDemoAction, Query)
+public:
+    explicit IsSuccessEndLastDemoAction(const InitArg& arg);
+    ~IsSuccessEndLastDemoAction() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryIsTerrorDisappeared.cpp b/src/Game/AI/Query/queryIsTerrorDisappeared.cpp
new file mode 100644
index 00000000..6e4bd832
--- /dev/null
+++ b/src/Game/AI/Query/queryIsTerrorDisappeared.cpp
@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryIsTerrorDisappeared.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+IsTerrorDisappeared::IsTerrorDisappeared(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+IsTerrorDisappeared::~IsTerrorDisappeared() = default;
+
+// FIXME: implement
+int IsTerrorDisappeared::doQuery() {
+    return -1;
+}
+
+void IsTerrorDisappeared::loadParams(const evfl::QueryArg& arg) {}
+
+void IsTerrorDisappeared::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryIsTerrorDisappeared.h b/src/Game/AI/Query/queryIsTerrorDisappeared.h
new file mode 100644
index 00000000..0e3b9806
--- /dev/null
+++ b/src/Game/AI/Query/queryIsTerrorDisappeared.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class IsTerrorDisappeared : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(IsTerrorDisappeared, Query)
+public:
+    explicit IsTerrorDisappeared(const InitArg& arg);
+    ~IsTerrorDisappeared() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryIsWaitRevival.cpp b/src/Game/AI/Query/queryIsWaitRevival.cpp
new file mode 100644
index 00000000..6be00757
--- /dev/null
+++ b/src/Game/AI/Query/queryIsWaitRevival.cpp
@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryIsWaitRevival.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+IsWaitRevival::IsWaitRevival(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+IsWaitRevival::~IsWaitRevival() = default;
+
+// FIXME: implement
+int IsWaitRevival::doQuery() {
+    return -1;
+}
+
+void IsWaitRevival::loadParams(const evfl::QueryArg& arg) {}
+
+void IsWaitRevival::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryIsWaitRevival.h b/src/Game/AI/Query/queryIsWaitRevival.h
new file mode 100644
index 00000000..ddcaf6b5
--- /dev/null
+++ b/src/Game/AI/Query/queryIsWaitRevival.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class IsWaitRevival : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(IsWaitRevival, Query)
+public:
+    explicit IsWaitRevival(const InitArg& arg);
+    ~IsWaitRevival() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryIsWeaponDrawn.cpp b/src/Game/AI/Query/queryIsWeaponDrawn.cpp
new file mode 100644
index 00000000..07ec45c9
--- /dev/null
+++ b/src/Game/AI/Query/queryIsWeaponDrawn.cpp
@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryIsWeaponDrawn.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+IsWeaponDrawn::IsWeaponDrawn(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+IsWeaponDrawn::~IsWeaponDrawn() = default;
+
+// FIXME: implement
+int IsWeaponDrawn::doQuery() {
+    return -1;
+}
+
+void IsWeaponDrawn::loadParams(const evfl::QueryArg& arg) {}
+
+void IsWeaponDrawn::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryIsWeaponDrawn.h b/src/Game/AI/Query/queryIsWeaponDrawn.h
new file mode 100644
index 00000000..e824f8cf
--- /dev/null
+++ b/src/Game/AI/Query/queryIsWeaponDrawn.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class IsWeaponDrawn : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(IsWeaponDrawn, Query)
+public:
+    explicit IsWeaponDrawn(const InitArg& arg);
+    ~IsWeaponDrawn() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryKeyInputCheck.cpp b/src/Game/AI/Query/queryKeyInputCheck.cpp
new file mode 100644
index 00000000..0b4b3296
--- /dev/null
+++ b/src/Game/AI/Query/queryKeyInputCheck.cpp
@@ -0,0 +1,23 @@
+#include "Game/AI/Query/queryKeyInputCheck.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+KeyInputCheck::KeyInputCheck(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+KeyInputCheck::~KeyInputCheck() = default;
+
+// FIXME: implement
+int KeyInputCheck::doQuery() {
+    return -1;
+}
+
+void KeyInputCheck::loadParams(const evfl::QueryArg& arg) {
+    loadInt(arg.param_accessor, "ValidInput");
+}
+
+void KeyInputCheck::loadParams() {
+    getDynamicParam(&mValidInput, "ValidInput");
+}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryKeyInputCheck.h b/src/Game/AI/Query/queryKeyInputCheck.h
new file mode 100644
index 00000000..14535fd0
--- /dev/null
+++ b/src/Game/AI/Query/queryKeyInputCheck.h
@@ -0,0 +1,23 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class KeyInputCheck : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(KeyInputCheck, Query)
+public:
+    explicit KeyInputCheck(const InitArg& arg);
+    ~KeyInputCheck() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    int* mValidInput{};
+    u32 _28{};
+    u32 _2c{};
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryRandomChoice2.cpp b/src/Game/AI/Query/queryRandomChoice2.cpp
new file mode 100644
index 00000000..cf6a17ed
--- /dev/null
+++ b/src/Game/AI/Query/queryRandomChoice2.cpp
@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryRandomChoice2.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+RandomChoice2::RandomChoice2(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+RandomChoice2::~RandomChoice2() = default;
+
+// FIXME: implement
+int RandomChoice2::doQuery() {
+    return -1;
+}
+
+void RandomChoice2::loadParams(const evfl::QueryArg& arg) {}
+
+void RandomChoice2::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryRandomChoice2.h b/src/Game/AI/Query/queryRandomChoice2.h
new file mode 100644
index 00000000..fe2ccbed
--- /dev/null
+++ b/src/Game/AI/Query/queryRandomChoice2.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class RandomChoice2 : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(RandomChoice2, Query)
+public:
+    explicit RandomChoice2(const InitArg& arg);
+    ~RandomChoice2() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryRandomChoice3.cpp b/src/Game/AI/Query/queryRandomChoice3.cpp
new file mode 100644
index 00000000..dbb27371
--- /dev/null
+++ b/src/Game/AI/Query/queryRandomChoice3.cpp
@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryRandomChoice3.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+RandomChoice3::RandomChoice3(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+RandomChoice3::~RandomChoice3() = default;
+
+// FIXME: implement
+int RandomChoice3::doQuery() {
+    return -1;
+}
+
+void RandomChoice3::loadParams(const evfl::QueryArg& arg) {}
+
+void RandomChoice3::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryRandomChoice3.h b/src/Game/AI/Query/queryRandomChoice3.h
new file mode 100644
index 00000000..c39b1d57
--- /dev/null
+++ b/src/Game/AI/Query/queryRandomChoice3.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class RandomChoice3 : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(RandomChoice3, Query)
+public:
+    explicit RandomChoice3(const InitArg& arg);
+    ~RandomChoice3() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryRandomChoice4.cpp b/src/Game/AI/Query/queryRandomChoice4.cpp
new file mode 100644
index 00000000..e54de105
--- /dev/null
+++ b/src/Game/AI/Query/queryRandomChoice4.cpp
@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryRandomChoice4.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+RandomChoice4::RandomChoice4(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+RandomChoice4::~RandomChoice4() = default;
+
+// FIXME: implement
+int RandomChoice4::doQuery() {
+    return -1;
+}
+
+void RandomChoice4::loadParams(const evfl::QueryArg& arg) {}
+
+void RandomChoice4::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryRandomChoice4.h b/src/Game/AI/Query/queryRandomChoice4.h
new file mode 100644
index 00000000..a0b1b4be
--- /dev/null
+++ b/src/Game/AI/Query/queryRandomChoice4.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class RandomChoice4 : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(RandomChoice4, Query)
+public:
+    explicit RandomChoice4(const InitArg& arg);
+    ~RandomChoice4() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryRandomChoice8.cpp b/src/Game/AI/Query/queryRandomChoice8.cpp
new file mode 100644
index 00000000..b5b210c2
--- /dev/null
+++ b/src/Game/AI/Query/queryRandomChoice8.cpp
@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryRandomChoice8.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+RandomChoice8::RandomChoice8(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+RandomChoice8::~RandomChoice8() = default;
+
+// FIXME: implement
+int RandomChoice8::doQuery() {
+    return -1;
+}
+
+void RandomChoice8::loadParams(const evfl::QueryArg& arg) {}
+
+void RandomChoice8::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryRandomChoice8.h b/src/Game/AI/Query/queryRandomChoice8.h
new file mode 100644
index 00000000..14d923a1
--- /dev/null
+++ b/src/Game/AI/Query/queryRandomChoice8.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class RandomChoice8 : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(RandomChoice8, Query)
+public:
+    explicit RandomChoice8(const InitArg& arg);
+    ~RandomChoice8() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryRandomChoiceExceptOnFlag.cpp b/src/Game/AI/Query/queryRandomChoiceExceptOnFlag.cpp
new file mode 100644
index 00000000..923985be
--- /dev/null
+++ b/src/Game/AI/Query/queryRandomChoiceExceptOnFlag.cpp
@@ -0,0 +1,42 @@
+#include "Game/AI/Query/queryRandomChoiceExceptOnFlag.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+RandomChoiceExceptOnFlag::RandomChoiceExceptOnFlag(const InitArg& arg)
+    : ksys::act::ai::Query(arg) {}
+
+RandomChoiceExceptOnFlag::~RandomChoiceExceptOnFlag() = default;
+
+// FIXME: implement
+int RandomChoiceExceptOnFlag::doQuery() {
+    return -1;
+}
+
+void RandomChoiceExceptOnFlag::loadParams(const evfl::QueryArg& arg) {
+    loadString(arg.param_accessor, "CheckFlag0");
+    loadString(arg.param_accessor, "CheckFlag1");
+    loadString(arg.param_accessor, "CheckFlag2");
+    loadString(arg.param_accessor, "CheckFlag3");
+    loadString(arg.param_accessor, "CheckFlag4");
+    loadString(arg.param_accessor, "CheckFlag5");
+    loadString(arg.param_accessor, "CheckFlag6");
+    loadString(arg.param_accessor, "CheckFlag7");
+    loadString(arg.param_accessor, "CheckFlag8");
+    loadString(arg.param_accessor, "CheckFlag9");
+}
+
+void RandomChoiceExceptOnFlag::loadParams() {
+    getDynamicParam(&mCheckFlag0, "CheckFlag0");
+    getDynamicParam(&mCheckFlag1, "CheckFlag1");
+    getDynamicParam(&mCheckFlag2, "CheckFlag2");
+    getDynamicParam(&mCheckFlag3, "CheckFlag3");
+    getDynamicParam(&mCheckFlag4, "CheckFlag4");
+    getDynamicParam(&mCheckFlag5, "CheckFlag5");
+    getDynamicParam(&mCheckFlag6, "CheckFlag6");
+    getDynamicParam(&mCheckFlag7, "CheckFlag7");
+    getDynamicParam(&mCheckFlag8, "CheckFlag8");
+    getDynamicParam(&mCheckFlag9, "CheckFlag9");
+}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryRandomChoiceExceptOnFlag.h b/src/Game/AI/Query/queryRandomChoiceExceptOnFlag.h
new file mode 100644
index 00000000..f010a57a
--- /dev/null
+++ b/src/Game/AI/Query/queryRandomChoiceExceptOnFlag.h
@@ -0,0 +1,30 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class RandomChoiceExceptOnFlag : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(RandomChoiceExceptOnFlag, Query)
+public:
+    explicit RandomChoiceExceptOnFlag(const InitArg& arg);
+    ~RandomChoiceExceptOnFlag() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+
+protected:
+    sead::SafeString mCheckFlag0{};
+    sead::SafeString mCheckFlag1{};
+    sead::SafeString mCheckFlag2{};
+    sead::SafeString mCheckFlag3{};
+    sead::SafeString mCheckFlag4{};
+    sead::SafeString mCheckFlag5{};
+    sead::SafeString mCheckFlag6{};
+    sead::SafeString mCheckFlag7{};
+    sead::SafeString mCheckFlag8{};
+    sead::SafeString mCheckFlag9{};
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryWhatCurrentItem.cpp b/src/Game/AI/Query/queryWhatCurrentItem.cpp
new file mode 100644
index 00000000..e1c9e052
--- /dev/null
+++ b/src/Game/AI/Query/queryWhatCurrentItem.cpp
@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryWhatCurrentItem.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+WhatCurrentItem::WhatCurrentItem(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+WhatCurrentItem::~WhatCurrentItem() = default;
+
+// FIXME: implement
+int WhatCurrentItem::doQuery() {
+    return -1;
+}
+
+void WhatCurrentItem::loadParams(const evfl::QueryArg& arg) {}
+
+void WhatCurrentItem::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryWhatCurrentItem.h b/src/Game/AI/Query/queryWhatCurrentItem.h
new file mode 100644
index 00000000..c4047098
--- /dev/null
+++ b/src/Game/AI/Query/queryWhatCurrentItem.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class WhatCurrentItem : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(WhatCurrentItem, Query)
+public:
+    explicit WhatCurrentItem(const InitArg& arg);
+    ~WhatCurrentItem() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryWhatDayOfTheWeek.cpp b/src/Game/AI/Query/queryWhatDayOfTheWeek.cpp
new file mode 100644
index 00000000..543e667e
--- /dev/null
+++ b/src/Game/AI/Query/queryWhatDayOfTheWeek.cpp
@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryWhatDayOfTheWeek.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+WhatDayOfTheWeek::WhatDayOfTheWeek(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+WhatDayOfTheWeek::~WhatDayOfTheWeek() = default;
+
+// FIXME: implement
+int WhatDayOfTheWeek::doQuery() {
+    return -1;
+}
+
+void WhatDayOfTheWeek::loadParams(const evfl::QueryArg& arg) {}
+
+void WhatDayOfTheWeek::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryWhatDayOfTheWeek.h b/src/Game/AI/Query/queryWhatDayOfTheWeek.h
new file mode 100644
index 00000000..378859d4
--- /dev/null
+++ b/src/Game/AI/Query/queryWhatDayOfTheWeek.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class WhatDayOfTheWeek : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(WhatDayOfTheWeek, Query)
+public:
+    explicit WhatDayOfTheWeek(const InitArg& arg);
+    ~WhatDayOfTheWeek() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryWhatDungeonType.cpp b/src/Game/AI/Query/queryWhatDungeonType.cpp
new file mode 100644
index 00000000..b6d2d7f8
--- /dev/null
+++ b/src/Game/AI/Query/queryWhatDungeonType.cpp
@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryWhatDungeonType.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+WhatDungeonType::WhatDungeonType(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+WhatDungeonType::~WhatDungeonType() = default;
+
+// FIXME: implement
+int WhatDungeonType::doQuery() {
+    return -1;
+}
+
+void WhatDungeonType::loadParams(const evfl::QueryArg& arg) {}
+
+void WhatDungeonType::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryWhatDungeonType.h b/src/Game/AI/Query/queryWhatDungeonType.h
new file mode 100644
index 00000000..29900e62
--- /dev/null
+++ b/src/Game/AI/Query/queryWhatDungeonType.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class WhatDungeonType : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(WhatDungeonType, Query)
+public:
+    explicit WhatDungeonType(const InitArg& arg);
+    ~WhatDungeonType() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryWhatMoonName.cpp b/src/Game/AI/Query/queryWhatMoonName.cpp
new file mode 100644
index 00000000..218ef705
--- /dev/null
+++ b/src/Game/AI/Query/queryWhatMoonName.cpp
@@ -0,0 +1,19 @@
+#include "Game/AI/Query/queryWhatMoonName.h"
+#include <evfl/query.h>
+
+namespace uking::query {
+
+WhatMoonName::WhatMoonName(const InitArg& arg) : ksys::act::ai::Query(arg) {}
+
+WhatMoonName::~WhatMoonName() = default;
+
+// FIXME: implement
+int WhatMoonName::doQuery() {
+    return -1;
+}
+
+void WhatMoonName::loadParams(const evfl::QueryArg& arg) {}
+
+void WhatMoonName::loadParams() {}
+
+}  // namespace uking::query
diff --git a/src/Game/AI/Query/queryWhatMoonName.h b/src/Game/AI/Query/queryWhatMoonName.h
new file mode 100644
index 00000000..3bbd2411
--- /dev/null
+++ b/src/Game/AI/Query/queryWhatMoonName.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "KingSystem/ActorSystem/actAiQuery.h"
+
+namespace uking::query {
+
+class WhatMoonName : public ksys::act::ai::Query {
+    SEAD_RTTI_OVERRIDE(WhatMoonName, Query)
+public:
+    explicit WhatMoonName(const InitArg& arg);
+    ~WhatMoonName() override;
+    int doQuery() override;
+
+    void loadParams() override;
+    void loadParams(const evfl::QueryArg& arg) override;
+};
+
+}  // namespace uking::query
diff --git a/src/KingSystem/ActorSystem/actAiQuery.cpp b/src/KingSystem/ActorSystem/actAiQuery.cpp
index 234866ca..5f2eb9bf 100644
--- a/src/KingSystem/ActorSystem/actAiQuery.cpp
+++ b/src/KingSystem/ActorSystem/actAiQuery.cpp
@@ -40,29 +40,29 @@ const char* Query::getName() const {
     return getAIProg()->getQueries()[mDefIdx].mClassName;
 }
 
-bool Query::getSInstParam(const f32** value, const sead::SafeString& param) const {
+bool Query::getStaticParam(const f32** value, const sead::SafeString& param) const {
     const auto& def = getAIProg()->getQueries()[mDefIdx];
     return getAIProg()->getSInstParam(value, def, param);
 }
 
-bool Query::getDInstParam(sead::SafeString* value, const sead::SafeString& param) const {
+bool Query::getDynamicParam(sead::SafeString* value, const sead::SafeString& param) const {
     if (mParamPack.getString(value, param))
         return true;
     *value = "";
     return false;
 }
 
-bool Query::getDInstParam(const s32** value, const sead::SafeString& param) const {
+bool Query::getDynamicParam(s32** value, const sead::SafeString& param) const {
     static s32 sDefault{};
-    return getDInstParam_<s32>(value, param, AIDefParamType::Int, &sDefault);
+    return getDynamicParamImpl<s32>(value, param, AIDefParamType::Int, &sDefault);
 }
 
-bool Query::getDInstParam(const f32** value, const sead::SafeString& param) const {
+bool Query::getDynamicParam(f32** value, const sead::SafeString& param) const {
     static f32 sDefault{};
-    return getDInstParam_<f32>(value, param, AIDefParamType::Float, &sDefault);
+    return getDynamicParamImpl<f32>(value, param, AIDefParamType::Float, &sDefault);
 }
 
-bool Query::getDInstParam(const bool** value, const sead::SafeString& param) const {
+bool Query::getDynamicParam(bool** value, const sead::SafeString& param) const {
     static bool sDefault{};
     auto ret = static_cast<bool*>(mParamPack.getAITreeVariablePointer(param, AIDefParamType::Bool));
     *value = ret ? ret : &sDefault;
diff --git a/src/KingSystem/ActorSystem/actAiQuery.h b/src/KingSystem/ActorSystem/actAiQuery.h
index e435777d..837c491f 100644
--- a/src/KingSystem/ActorSystem/actAiQuery.h
+++ b/src/KingSystem/ActorSystem/actAiQuery.h
@@ -37,17 +37,17 @@ public:
     bool init(sead::Heap* heap);
     const char* getName() const;
 
-    bool getSInstParam(const f32** value, const sead::SafeString& param) const;
+    bool getStaticParam(const f32** value, const sead::SafeString& param) const;
 
-    bool getDInstParam(sead::SafeString* value, const sead::SafeString& param) const;
-    bool getDInstParam(const s32** value, const sead::SafeString& param) const;
-    bool getDInstParam(const f32** value, const sead::SafeString& param) const;
-    bool getDInstParam(const bool** value, const sead::SafeString& param) const;
+    bool getDynamicParam(sead::SafeString* value, const sead::SafeString& param) const;
+    bool getDynamicParam(s32** value, const sead::SafeString& param) const;
+    bool getDynamicParam(f32** value, const sead::SafeString& param) const;
+    bool getDynamicParam(bool** value, const sead::SafeString& param) const;
 
-    bool loadString(evfl::ParamAccessor* accessor, const sead::SafeString& param);
-    bool loadInt(evfl::ParamAccessor* accessor, const sead::SafeString& param);
-    bool loadFloat(evfl::ParamAccessor* accessor, const sead::SafeString& param);
-    bool loadBool(evfl::ParamAccessor* accessor, const sead::SafeString& param);
+    bool loadString(const evfl::ParamAccessor& accessor, const sead::SafeString& param);
+    bool loadInt(const evfl::ParamAccessor& accessor, const sead::SafeString& param);
+    bool loadFloat(const evfl::ParamAccessor& accessor, const sead::SafeString& param);
+    bool loadBool(const evfl::ParamAccessor& accessor, const sead::SafeString& param);
 
     bool getAITreeVariable(sead::SafeString** value, const sead::SafeString& param) const;
     bool getAITreeVariable(void** value, const sead::SafeString& param) const;
@@ -66,8 +66,8 @@ protected:
     res::AIProgram* getAIProg() const;
 
     template <typename T>
-    bool getDInstParam_(const T** value, const sead::SafeString& param, AIDefParamType type,
-                        const T* default_value) const {
+    bool getDynamicParamImpl(T** value, const sead::SafeString& param, AIDefParamType type,
+                             T* default_value) const {
         *value = static_cast<T*>(mParamPack.getAITreeVariablePointer(param, type));
         if (*value)
             return true;