481 lines
26 KiB
C++
481 lines
26 KiB
C++
|
#pragma once
|
||
|
|
|
||
|
|
#include <optional>
|
||
|
|
|
||
|
|
#include <Unreal/FText.hpp>
|
||
|
|
#include <Unreal/NameTypes.hpp>
|
||
|
|
|
||
|
|
#include <Api/UnrealWrapper.hpp>
|
||
|
|
#include "PalIndividual.hpp"
|
||
|
|
#include "PalTypes.hpp"
|
||
|
|
|
||
|
|
namespace PalUIExtension::Api::Pal
|
||
|
|
{
|
||
|
|
|
||
|
|
class PalIndividualCharacterParameter : public UnrealWrapper
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
static auto ClassPath() -> const TCHAR* { return STR("/Script/Pal.PalIndividualCharacterParameter"); }
|
||
|
|
static auto DebugTag() -> const TCHAR* { return STR("PalIndividualCharacterParameter"); }
|
||
|
|
|
||
|
|
PalIndividualCharacterParameter() = default;
|
||
|
|
explicit PalIndividualCharacterParameter(UObject* Obj) : UnrealWrapper(Obj, ClassOf<PalIndividualCharacterParameter>(), DebugTag()) {}
|
||
|
|
|
||
|
|
// ---- identity ---------------------------------------------------
|
||
|
|
|
||
|
|
auto GetCharacterID() -> std::optional<FName> { return CallForReturn<FName>(STR("GetCharacterID")); }
|
||
|
|
auto GetUniqueNPCID() -> std::optional<FName> { return CallForReturn<FName>(STR("GetUniqueNPCID")); }
|
||
|
|
auto GetSkinName() -> std::optional<FName> { return CallForReturn<FName>(STR("GetSkinName")); }
|
||
|
|
|
||
|
|
auto GetGenderType() -> std::optional<EPalGenderType_>
|
||
|
|
{
|
||
|
|
return CallForReturn<EPalGenderType_>(STR("GetGenderType"));
|
||
|
|
}
|
||
|
|
auto GetTribeID() -> std::optional<EPalTribeID_>
|
||
|
|
{
|
||
|
|
return CallForReturn<EPalTribeID_>(STR("GetTribeID"));
|
||
|
|
}
|
||
|
|
auto IsRarePal() -> std::optional<bool> { return CallForReturn<bool>(STR("IsRarePal")); }
|
||
|
|
auto IsFavoritePal() -> std::optional<bool> { return CallForReturn<bool>(STR("IsFavoritePal")); }
|
||
|
|
auto GetFavoriteIndex() -> std::optional<int32> { return CallForReturn<int32>(STR("GetFavoriteIndex")); }
|
||
|
|
auto IsSkinApplied() -> std::optional<bool> { return CallForReturn<bool>(STR("IsSkinApplied")); }
|
||
|
|
auto GetSkinAppliedCharacterId() -> std::optional<FGuid_>
|
||
|
|
{
|
||
|
|
return CallForReturn<FGuid_>(STR("GetSkinAppliedCharacterId"));
|
||
|
|
}
|
||
|
|
|
||
|
|
auto GetPalId() -> std::optional<FPalInstanceID>
|
||
|
|
{
|
||
|
|
struct P { alignas(8) uint8 Frame[48]; } p{}; // FPalInstanceID
|
||
|
|
if (!Call(STR("GetPalId"), p)) return std::nullopt;
|
||
|
|
FPalInstanceID Out{};
|
||
|
|
std::memcpy(&Out, p.Frame, sizeof(Out));
|
||
|
|
return Out;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Nickname getters
|
||
|
|
|
||
|
|
auto GetNickname() -> std::optional<FString>
|
||
|
|
{
|
||
|
|
struct P { FString OutName; } p{};
|
||
|
|
if (!Call(STR("GetNickname"), p)) return std::nullopt;
|
||
|
|
return p.OutName;
|
||
|
|
}
|
||
|
|
auto GetNickNameWithOnlineID() -> std::optional<FString>
|
||
|
|
{
|
||
|
|
struct P { FString OutName; } p{};
|
||
|
|
if (!Call(STR("GetNickNameWithOnlineID"), p)) return std::nullopt;
|
||
|
|
return p.OutName;
|
||
|
|
}
|
||
|
|
auto GetNickNameByCheckBlockedUser() -> std::optional<FString>
|
||
|
|
{
|
||
|
|
struct P { FString OutName; } p{};
|
||
|
|
if (!Call(STR("GetNickNameByCheckBlockedUser"), p)) return std::nullopt;
|
||
|
|
return p.OutName;
|
||
|
|
}
|
||
|
|
|
||
|
|
// ---- level / experience ------------------------------------------
|
||
|
|
|
||
|
|
auto GetLevel() -> std::optional<int32> { return CallForReturn<int32>(STR("GetLevel")); }
|
||
|
|
auto IsLevelMax() -> std::optional<bool> { return CallForReturn<bool>(STR("IsLevelMax")); }
|
||
|
|
auto GetExp() -> std::optional<int64> { return CallForReturn<int64>(STR("GetExp")); }
|
||
|
|
auto GetRank() -> std::optional<int32> { return CallForReturn<int32>(STR("GetRank")); }
|
||
|
|
auto GetRankUpExp() -> std::optional<int32> { return CallForReturn<int32>(STR("GetRankUpExp")); }
|
||
|
|
auto GetPalSoulRank() -> std::optional<int32> { return CallForReturn<int32>(STR("GetPalSoulRank")); }
|
||
|
|
auto IsOverrideLevel() -> std::optional<bool> { return CallForReturn<bool>(STR("IsOverrideLevel")); }
|
||
|
|
auto GetOverrideLevel() -> std::optional<int32> { return CallForReturn<int32>(STR("GetOverrideLevel")); }
|
||
|
|
|
||
|
|
auto SetOverrideLevel(int32 OverrideLevel) -> bool
|
||
|
|
{
|
||
|
|
struct P { int32 OverrideLevel; } p{ OverrideLevel };
|
||
|
|
return Call(STR("SetOverrideLevel"), p);
|
||
|
|
}
|
||
|
|
|
||
|
|
// ---- HP / shield / death -----------------------------------------
|
||
|
|
|
||
|
|
auto GetHP() -> std::optional<FFixedPoint64_> { return CallForReturn<FFixedPoint64_>(STR("GetHP")); }
|
||
|
|
auto GetMaxHP_withBuff() -> std::optional<FFixedPoint64_> { return CallForReturn<FFixedPoint64_>(STR("GetMaxHP_withBuff")); }
|
||
|
|
auto GetMaxHP() -> std::optional<int32> { return CallForReturn<int32>(STR("GetMaxHP")); }
|
||
|
|
auto GetHPRank() -> std::optional<int32> { return CallForReturn<int32>(STR("GetHPRank")); }
|
||
|
|
|
||
|
|
auto GetShieldHP() -> std::optional<FFixedPoint64_> { return CallForReturn<FFixedPoint64_>(STR("GetShieldHP")); }
|
||
|
|
auto GetShieldMaxHP() -> std::optional<FFixedPoint64_> { return CallForReturn<FFixedPoint64_>(STR("GetShieldMaxHP")); }
|
||
|
|
|
||
|
|
auto GetCurrentPhaseHPLimit() -> std::optional<FFixedPoint64_>
|
||
|
|
{
|
||
|
|
struct P { FFixedPoint64_ OutPhaseHPLimit; bool ReturnValue; } p{ {}, false };
|
||
|
|
auto Result = CallForReturn(STR("GetCurrentPhaseHPLimit"), p, &P::ReturnValue);
|
||
|
|
if (!Result || !*Result) return std::nullopt;
|
||
|
|
return p.OutPhaseHPLimit;
|
||
|
|
}
|
||
|
|
auto IsPhaseHPLimitValid() -> std::optional<bool> { return CallForReturn<bool>(STR("IsPhaseHPLimitValid")); }
|
||
|
|
|
||
|
|
auto AddHP(FFixedPoint64_ PlusHP) -> bool
|
||
|
|
{
|
||
|
|
struct P { FFixedPoint64_ PlusHP; } p{ PlusHP };
|
||
|
|
return Call(STR("AddHP"), p);
|
||
|
|
}
|
||
|
|
auto FullRecoveryHP() -> bool { return CallVoid(STR("FullRecoveryHP")); }
|
||
|
|
auto IsHPFullRecovered() -> std::optional<bool> { return CallForReturn<bool>(STR("IsHPFullRecovered")); }
|
||
|
|
|
||
|
|
auto SetShieldHP(FFixedPoint64_ NextShieldHP) -> bool
|
||
|
|
{
|
||
|
|
struct P { FFixedPoint64_ NextSheildHP; } p{ NextShieldHP }; // engine spelling
|
||
|
|
return Call(STR("SetShieldHP"), p);
|
||
|
|
}
|
||
|
|
auto SetShieldMaxHP(FFixedPoint64_ NextShieldMaxHP) -> bool
|
||
|
|
{
|
||
|
|
struct P { FFixedPoint64_ NextSheildMaxHP; } p{ NextShieldMaxHP }; // engine spelling
|
||
|
|
return Call(STR("SetShieldMaxHP"), p);
|
||
|
|
}
|
||
|
|
auto DecreaseShieldHPByDamage(int32 Damage) -> bool
|
||
|
|
{
|
||
|
|
struct P { int32 Damage; } p{ Damage };
|
||
|
|
return Call(STR("DecreaseShieldHPByDamage"), p);
|
||
|
|
}
|
||
|
|
|
||
|
|
auto IsDead() -> std::optional<bool> { return CallForReturn<bool>(STR("IsDead")); }
|
||
|
|
auto GetPhysicalHealth() -> std::optional<EPalStatusPhysicalHealthType_>
|
||
|
|
{
|
||
|
|
return CallForReturn<EPalStatusPhysicalHealthType_>(STR("GetPhysicalHealth"));
|
||
|
|
}
|
||
|
|
auto SetPhysicalHealth(EPalStatusPhysicalHealthType_ PhysicalHealth) -> bool
|
||
|
|
{
|
||
|
|
struct P { EPalStatusPhysicalHealthType_ PhysicalHealth; } p{ PhysicalHealth };
|
||
|
|
return Call(STR("SetPhysicalHealth"), p);
|
||
|
|
}
|
||
|
|
auto IsRespawnReady() -> std::optional<bool> { return CallForReturn<bool>(STR("IsRespawnReady")); }
|
||
|
|
auto GetRespawnTime() -> std::optional<float> { return CallForReturn<float>(STR("GetRespawnTime")); }
|
||
|
|
|
||
|
|
// ---- combat stats -------------------------------------------------
|
||
|
|
|
||
|
|
auto GetMeleeAttack() -> std::optional<int32> { return CallForReturn<int32>(STR("GetMeleeAttack")); }
|
||
|
|
auto GetMeleeAttack_withBuff() -> std::optional<int32> { return CallForReturn<int32>(STR("GetMeleeAttack_withBuff")); }
|
||
|
|
auto GetShotAttack() -> std::optional<int32> { return CallForReturn<int32>(STR("GetShotAttack")); }
|
||
|
|
auto GetShotAttack_withBuff() -> std::optional<int32> { return CallForReturn<int32>(STR("GetShotAttack_withBuff")); }
|
||
|
|
auto GetDefense() -> std::optional<int32> { return CallForReturn<int32>(STR("GetDefense")); }
|
||
|
|
auto GetDefense_withBuff() -> std::optional<int32> { return CallForReturn<int32>(STR("GetDefense_withBuff")); }
|
||
|
|
auto GetAttackRank() -> std::optional<int32> { return CallForReturn<int32>(STR("GetAttackRank")); }
|
||
|
|
auto GetDefenceRank() -> std::optional<int32> { return CallForReturn<int32>(STR("GetDefenceRank")); }
|
||
|
|
|
||
|
|
auto HasMasteredWaza(EPalWazaID_ WazaID) -> std::optional<bool>
|
||
|
|
{
|
||
|
|
struct P { EPalWazaID_ WazaID; bool ReturnValue; } p{ WazaID, false };
|
||
|
|
return CallForReturn(STR("HasMasteredWaza"), p, &P::ReturnValue);
|
||
|
|
}
|
||
|
|
auto AddEquipWaza(EPalWazaID_ WazaID) -> bool
|
||
|
|
{
|
||
|
|
struct P { EPalWazaID_ WazaID; } p{ WazaID };
|
||
|
|
return Call(STR("AddEquipWaza"), p);
|
||
|
|
}
|
||
|
|
auto RemoveEquipWaza(EPalWazaID_ WazaID) -> bool
|
||
|
|
{
|
||
|
|
struct P { EPalWazaID_ WazaID; } p{ WazaID };
|
||
|
|
return Call(STR("RemoveEquipWaza"), p);
|
||
|
|
}
|
||
|
|
auto ClearEquipWaza() -> bool { return CallVoid(STR("ClearEquipWaza")); }
|
||
|
|
|
||
|
|
// ---- sanity / hunger / stomach ------------------------------------
|
||
|
|
|
||
|
|
auto GetSanityValue() -> std::optional<float> { return CallForReturn<float>(STR("GetSanityValue")); }
|
||
|
|
auto GetMaxSanityValue() -> std::optional<float> { return CallForReturn<float>(STR("GetMaxSanityValue")); }
|
||
|
|
auto GetSanityRate() -> std::optional<float> { return CallForReturn<float>(STR("GetSanityRate")); }
|
||
|
|
auto GetAffectSanityValue() -> std::optional<float> { return CallForReturn<float>(STR("GetAffectSanityValue")); }
|
||
|
|
|
||
|
|
auto GetHungerType() -> std::optional<EPalStatusHungerType_>
|
||
|
|
{
|
||
|
|
return CallForReturn<EPalStatusHungerType_>(STR("GetHungerType"));
|
||
|
|
}
|
||
|
|
auto GetFullStomach() -> std::optional<float> { return CallForReturn<float>(STR("GetFullStomach")); }
|
||
|
|
auto GetMaxFullStomach() -> std::optional<float> { return CallForReturn<float>(STR("GetMaxFullStomach")); }
|
||
|
|
auto GetFullStomachRate() -> std::optional<float> { return CallForReturn<float>(STR("GetFullStomachRate")); }
|
||
|
|
auto GetFullStomachDecreasingRate() -> std::optional<float> { return CallForReturn<float>(STR("GetFullStomachDecreasingRate")); }
|
||
|
|
auto IsFullStomachDecreaseStoppedByFood() -> std::optional<bool>
|
||
|
|
{
|
||
|
|
return CallForReturn<bool>(STR("IsFullStomachDecreaseStoppedByFood"));
|
||
|
|
}
|
||
|
|
|
||
|
|
auto SetFullStomach(float NextValue) -> bool
|
||
|
|
{
|
||
|
|
struct P { float NextValue; } p{ NextValue };
|
||
|
|
return Call(STR("SetFullStomach"), p);
|
||
|
|
}
|
||
|
|
auto SetDecreaseFullStomachRates(FName Name, float Rate) -> bool
|
||
|
|
{
|
||
|
|
struct P { FName Name; float Rate; } p{ Name, Rate };
|
||
|
|
return Call(STR("SetDecreaseFullStomachRates"), p);
|
||
|
|
}
|
||
|
|
auto RemoveDecreaseFullStomachRates(FName Name) -> bool
|
||
|
|
{
|
||
|
|
struct P { FName Name; } p{ Name };
|
||
|
|
return Call(STR("RemoveDecreaseFullStomachRates"), p);
|
||
|
|
}
|
||
|
|
|
||
|
|
auto GetEffectFoodName() -> std::optional<FName> { return CallForReturn<FName>(STR("GetEffectFoodName")); }
|
||
|
|
auto GetEffectFoodName_FullStomachKeep() -> std::optional<FName> { return CallForReturn<FName>(STR("GetEffectFoodName_FullStomachKeep")); }
|
||
|
|
auto GetEffectFoodTimeRate() -> std::optional<float> { return CallForReturn<float>(STR("GetEffectFoodTimeRate")); }
|
||
|
|
auto GetEffectFoodTimeRate_FullStomachKeep() -> std::optional<float> { return CallForReturn<float>(STR("GetEffectFoodTimeRate_FullStomachKeep")); }
|
||
|
|
auto GetFoodStatusRate(EPalFoodStatusEffectType_ EffectType) -> std::optional<float>
|
||
|
|
{
|
||
|
|
struct P { EPalFoodStatusEffectType_ EffectType; float ReturnValue; } p{ EffectType, 0.f };
|
||
|
|
return CallForReturn(STR("GetFoodStatusRate"), p, &P::ReturnValue);
|
||
|
|
}
|
||
|
|
|
||
|
|
// ---- friendship -----------------------------------------------------
|
||
|
|
|
||
|
|
auto GetFriendshipRank() -> std::optional<int32> { return CallForReturn<int32>(STR("GetFriendshipRank")); }
|
||
|
|
auto GetFriendshipPoint() -> std::optional<int32> { return CallForReturn<int32>(STR("GetFriendshipPoint")); }
|
||
|
|
auto AddFriendShip(int32 Value, bool bApplyPassiveSkill) -> bool
|
||
|
|
{
|
||
|
|
struct P { int32 Value; bool bApplyPassiveSkill; } p{ Value, bApplyPassiveSkill };
|
||
|
|
return Call(STR("AddFriendShip"), p);
|
||
|
|
}
|
||
|
|
|
||
|
|
// ---- status points --------------------------------------------------
|
||
|
|
|
||
|
|
auto GetUnusedStatusPoint() -> std::optional<int32> { return CallForReturn<int32>(STR("GetUnusedStatusPoint")); }
|
||
|
|
auto DecrementUnusedStatusPoint() -> bool { return CallVoid(STR("DecrementUnusedStatusPoint")); }
|
||
|
|
auto IsStatusPointAllMax() -> std::optional<bool> { return CallForReturn<bool>(STR("IsStatusPointAllMax")); }
|
||
|
|
|
||
|
|
auto GetStatusPoint(FName StatusName) -> std::optional<int32>
|
||
|
|
{
|
||
|
|
struct P { FName StatusName; int32 ReturnValue; } p{ StatusName, 0 };
|
||
|
|
return CallForReturn(STR("GetStatusPoint"), p, &P::ReturnValue);
|
||
|
|
}
|
||
|
|
auto GetTotalStatusPoint(FName StatusName) -> std::optional<int32>
|
||
|
|
{
|
||
|
|
struct P { FName StatusName; int32 ReturnValue; } p{ StatusName, 0 };
|
||
|
|
return CallForReturn(STR("GetTotalStatusPoint"), p, &P::ReturnValue);
|
||
|
|
}
|
||
|
|
auto GetExStatusPoint(FName StatusName) -> std::optional<int32>
|
||
|
|
{
|
||
|
|
struct P { FName StatusName; int32 ReturnValue; } p{ StatusName, 0 };
|
||
|
|
return CallForReturn(STR("GetExStatusPoint"), p, &P::ReturnValue);
|
||
|
|
}
|
||
|
|
auto SetStatusPoint(FName StatusName, int32 Point) -> bool
|
||
|
|
{
|
||
|
|
struct P { FName StatusName; int32 Point; } p{ StatusName, Point };
|
||
|
|
return Call(STR("SetStatusPoint"), p);
|
||
|
|
}
|
||
|
|
auto SetExStatusPoint(FName StatusName, int32 Point) -> bool
|
||
|
|
{
|
||
|
|
struct P { FName StatusName; int32 Point; } p{ StatusName, Point };
|
||
|
|
return Call(STR("SetExStatusPoint"), p);
|
||
|
|
}
|
||
|
|
// Two outputs (bool return + int32& out), same non-CallForReturn
|
||
|
|
// shape as CheckValidWorkSuitability in PalDetailWidget.hpp.
|
||
|
|
auto IsStatusPointAddable(FName StatusName) -> std::optional<int32>
|
||
|
|
{
|
||
|
|
struct P { FName StatusName; int32 AddablePoint; bool ReturnValue; } p{ StatusName, 0, false };
|
||
|
|
if (!Call(STR("IsStatusPointAddable"), p) || !p.ReturnValue) return std::nullopt;
|
||
|
|
return p.AddablePoint;
|
||
|
|
}
|
||
|
|
|
||
|
|
// ---- work suitability -------------------------------------------------
|
||
|
|
|
||
|
|
auto GetCurrentWorkSuitability() -> std::optional<EPalWorkSuitability_>
|
||
|
|
{
|
||
|
|
return CallForReturn<EPalWorkSuitability_>(STR("GetCurrentWorkSuitability"));
|
||
|
|
}
|
||
|
|
auto GetWorkSpeedRank() -> std::optional<int32> { return CallForReturn<int32>(STR("GetWorkSpeedRank")); }
|
||
|
|
auto GetCraftSpeed() -> std::optional<int32> { return CallForReturn<int32>(STR("GetCraftSpeed")); }
|
||
|
|
auto GetCraftSpeed_withBuff() -> std::optional<int32> { return CallForReturn<int32>(STR("GetCraftSpeed_withBuff")); }
|
||
|
|
auto GetCraftSpeedSickRate() -> std::optional<float> { return CallForReturn<float>(STR("GetCraftSpeedSickRate")); }
|
||
|
|
auto GetBaseCampCraftSpeedBuffRate() -> std::optional<float> { return CallForReturn<float>(STR("GetBaseCampCraftSpeedBuffRate")); }
|
||
|
|
auto GetWorkerSick() -> std::optional<EPalBaseCampWorkerSickType_>
|
||
|
|
{
|
||
|
|
return CallForReturn<EPalBaseCampWorkerSickType_>(STR("GetWorkerSick"));
|
||
|
|
}
|
||
|
|
auto GetBaseCampWorkerEventType() -> std::optional<EPalBaseCampWorkerEventType_>
|
||
|
|
{
|
||
|
|
return CallForReturn<EPalBaseCampWorkerEventType_>(STR("GetBaseCampWorkerEventType"));
|
||
|
|
}
|
||
|
|
|
||
|
|
auto HasWorkSuitability(EPalWorkSuitability_ Suitability) -> std::optional<bool>
|
||
|
|
{
|
||
|
|
struct P { EPalWorkSuitability_ InWorkSuitability; bool ReturnValue; } p{ Suitability, false };
|
||
|
|
return CallForReturn(STR("HasWorkSuitability"), p, &P::ReturnValue);
|
||
|
|
}
|
||
|
|
auto HasWorkSuitabilityRank(EPalWorkSuitability_ Suitability, int32 Rank) -> std::optional<bool>
|
||
|
|
{
|
||
|
|
struct P { EPalWorkSuitability_ InWorkSuitability; int32 SuitabilityRank; bool ReturnValue; }
|
||
|
|
p{ Suitability, Rank, false };
|
||
|
|
return CallForReturn(STR("HasWorkSuitabilityRank"), p, &P::ReturnValue);
|
||
|
|
}
|
||
|
|
auto GetWorkSuitabilityRank(EPalWorkSuitability_ Suitability) -> std::optional<int32>
|
||
|
|
{
|
||
|
|
struct P { EPalWorkSuitability_ InWorkSuitability; int32 ReturnValue; } p{ Suitability, 0 };
|
||
|
|
return CallForReturn(STR("GetWorkSuitabilityRank"), p, &P::ReturnValue);
|
||
|
|
}
|
||
|
|
auto GetWorkSuitabilityRankWithCharacterRank(EPalWorkSuitability_ Suitability) -> std::optional<int32>
|
||
|
|
{
|
||
|
|
struct P { EPalWorkSuitability_ WorkSuitability; int32 ReturnValue; } p{ Suitability, 0 };
|
||
|
|
return CallForReturn(STR("GetWorkSuitabilityRankWithCharacterRank"), p, &P::ReturnValue);
|
||
|
|
}
|
||
|
|
auto GetRankBasedWorkSuitabilityBonus(EPalWorkSuitability_ Suitability) -> std::optional<int32>
|
||
|
|
{
|
||
|
|
struct P { EPalWorkSuitability_ WorkSuitability; int32 ReturnValue; } p{ Suitability, 0 };
|
||
|
|
return CallForReturn(STR("GetRankBasedWorkSuitabilityBonus"), p, &P::ReturnValue);
|
||
|
|
}
|
||
|
|
auto GetCraftSpeedByWorkSuitability(EPalWorkSuitability_ Suitability) -> std::optional<int32>
|
||
|
|
{
|
||
|
|
struct P { EPalWorkSuitability_ WorkSuitability; int32 ReturnValue; } p{ Suitability, 0 };
|
||
|
|
return CallForReturn(STR("GetCraftSpeedByWorkSuitability"), p, &P::ReturnValue);
|
||
|
|
}
|
||
|
|
auto GetCraftSpeedBuffRate(EPalWorkSuitability_ Suitability) -> std::optional<float>
|
||
|
|
{
|
||
|
|
struct P { EPalWorkSuitability_ WorkSuitability; float ReturnValue; } p{ Suitability, 0.f };
|
||
|
|
return CallForReturn(STR("GetCraftSpeedBuffRate"), p, &P::ReturnValue);
|
||
|
|
}
|
||
|
|
auto GetCraftSpeed_withBuff_WorkSuitability(EPalWorkSuitability_ Suitability) -> std::optional<int32>
|
||
|
|
{
|
||
|
|
struct P { EPalWorkSuitability_ Suitability; int32 ReturnValue; } p{ Suitability, 0 };
|
||
|
|
return CallForReturn(STR("GetCraftSpeed_withBuff_WorkSuitability"), p, &P::ReturnValue);
|
||
|
|
}
|
||
|
|
auto SetWorkSuitabilityAddRank(EPalWorkSuitability_ Suitability, int32 AddRank) -> bool
|
||
|
|
{
|
||
|
|
struct P { EPalWorkSuitability_ WorkSuitability; int32 addRank; } p{ Suitability, AddRank };
|
||
|
|
return Call(STR("SetWorkSuitabilityAddRank"), p);
|
||
|
|
}
|
||
|
|
|
||
|
|
// ---- passive skills ---------------------------------------------------
|
||
|
|
//
|
||
|
|
// GetPassiveSkillList (TArray<FName>) is NOT wrapped -- see class
|
||
|
|
// comment. Add/Remove take scalar FName params, no such problem.
|
||
|
|
auto AddPassiveSkill(FName AddSkill, FName OverrideSkill) -> bool
|
||
|
|
{
|
||
|
|
struct P { FName AddSkill; FName OverrideSkill; } p{ AddSkill, OverrideSkill };
|
||
|
|
return Call(STR("AddPassiveSkill"), p);
|
||
|
|
}
|
||
|
|
auto RemovePassiveSkill(FName SkillId) -> bool
|
||
|
|
{
|
||
|
|
struct P { FName SkillId; } p{ SkillId };
|
||
|
|
return Call(STR("RemovePassiveSkill"), p);
|
||
|
|
}
|
||
|
|
auto GetPassiveRateBySkillEffect(EPalPassiveSkillEffectType_ EffectType) -> std::optional<float>
|
||
|
|
{
|
||
|
|
struct P { EPalPassiveSkillEffectType_ EffectType; float ReturnValue; } p{ EffectType, 0.f };
|
||
|
|
return CallForReturn(STR("GetPassiveRateBySkillEffect"), p, &P::ReturnValue);
|
||
|
|
}
|
||
|
|
auto GetPassiveRateByEquipment(EPalPassiveSkillEffectType_ EffectType) -> std::optional<float>
|
||
|
|
{
|
||
|
|
struct P { EPalPassiveSkillEffectType_ EffectType; float ReturnValue; } p{ EffectType, 0.f };
|
||
|
|
return CallForReturn(STR("GetPassiveRateByEquipment"), p, &P::ReturnValue);
|
||
|
|
}
|
||
|
|
|
||
|
|
// ---- classification / misc flags ---------------------------------------
|
||
|
|
|
||
|
|
auto GetSizeType() -> std::optional<EPalSizeType_> { return CallForReturn<EPalSizeType_>(STR("GetSizeType")); }
|
||
|
|
auto GetGroupType() -> std::optional<EPalGroupType_> { return CallForReturn<EPalGroupType_>(STR("GetGroupType")); }
|
||
|
|
auto GetGroupId() -> std::optional<FGuid_> { return CallForReturn<FGuid_>(STR("GetGroupId")); }
|
||
|
|
auto GetBaseCampId() -> std::optional<FGuid_> { return CallForReturn<FGuid_>(STR("GetBaseCampId")); }
|
||
|
|
auto GetArenaRank() -> std::optional<EPalArenaRank_> { return CallForReturn<EPalArenaRank_>(STR("GetArenaRank")); }
|
||
|
|
auto GetArenaRankPoint() -> std::optional<int32> { return CallForReturn<int32>(STR("GetArenaRankPoint")); }
|
||
|
|
auto IsInArena() -> std::optional<bool> { return CallForReturn<bool>(STR("IsInArena")); }
|
||
|
|
auto IsInRaidArea() -> std::optional<bool> { return CallForReturn<bool>(STR("IsInRaidArea")); }
|
||
|
|
auto IsUncapturable() -> std::optional<bool> { return CallForReturn<bool>(STR("IsUncapturable")); }
|
||
|
|
auto IsForceCapturable() -> std::optional<bool> { return CallForReturn<bool>(STR("IsForceCapturable")); }
|
||
|
|
auto IsAwakening() -> std::optional<bool> { return CallForReturn<bool>(STR("IsAwakening")); }
|
||
|
|
auto IsPartBroken() -> std::optional<bool> { return CallForReturn<bool>(STR("IsPartBroken")); }
|
||
|
|
auto IsParts() -> std::optional<bool> { return CallForReturn<bool>(STR("IsParts")); }
|
||
|
|
auto GetParentParameterObject() -> UObject*
|
||
|
|
{
|
||
|
|
struct P { UObject* ReturnValue; } p{ nullptr };
|
||
|
|
auto Result = CallForReturn(STR("GetParentParameter"), p, &P::ReturnValue);
|
||
|
|
return (Result && *Result) ? *Result : nullptr;
|
||
|
|
}
|
||
|
|
auto IsAssignedToExpedition() -> std::optional<bool> { return CallForReturn<bool>(STR("IsAssignedToExpedition")); }
|
||
|
|
auto IsAssignedToExpeditionIn(FGuid_ MapObjectId) -> std::optional<bool>
|
||
|
|
{
|
||
|
|
struct P { FGuid_ MapObjectConcreteInstanceId; bool ReturnValue; } p{ MapObjectId, false };
|
||
|
|
return CallForReturn(STR("IsAssignedToExpeditionIn"), p, &P::ReturnValue);
|
||
|
|
}
|
||
|
|
auto IsExcludedFromTeamMission() -> std::optional<bool> { return CallForReturn<bool>(STR("IsExcludedFromTeamMission")); }
|
||
|
|
auto CanTargetFromAI() -> std::optional<bool> { return CallForReturn<bool>(STR("CanTargetFromAI")); }
|
||
|
|
auto HasGenusCategory(EPalGenusCategoryType_ Category) -> std::optional<bool>
|
||
|
|
{
|
||
|
|
struct P { EPalGenusCategoryType_ Category; bool ReturnValue; } p{ Category, false };
|
||
|
|
return CallForReturn(STR("HasGenusCategory"), p, &P::ReturnValue);
|
||
|
|
}
|
||
|
|
auto CanAddTalentByItem(FName ItemName) -> std::optional<bool>
|
||
|
|
{
|
||
|
|
struct P { FName ItemName; bool ReturnValue; } p{ ItemName, false };
|
||
|
|
return CallForReturn(STR("CanAddTalentByItem"), p, &P::ReturnValue);
|
||
|
|
}
|
||
|
|
auto GetNPCWeaponType() -> std::optional<EPalWeaponType_> { return CallForReturn<EPalWeaponType_>(STR("GetNPCWeaponType")); }
|
||
|
|
auto GetEquipItemContainerId() -> std::optional<FPalContainerId_>
|
||
|
|
{
|
||
|
|
return CallForReturn<FPalContainerId_>(STR("GetEquipItemContainerId"));
|
||
|
|
}
|
||
|
|
|
||
|
|
auto SetUncapturable(bool bInUncapturable) -> bool
|
||
|
|
{
|
||
|
|
struct P { bool bInUncapturable; } p{ bInUncapturable };
|
||
|
|
return Call(STR("SetUncapturable"), p);
|
||
|
|
}
|
||
|
|
auto SetForceCapturable(bool bInForceCapturable) -> bool
|
||
|
|
{
|
||
|
|
struct P { bool bInForceCapturable; } p{ bInForceCapturable };
|
||
|
|
return Call(STR("SetForceCapturable"), p);
|
||
|
|
}
|
||
|
|
auto SetInArena(bool InArena) -> bool
|
||
|
|
{
|
||
|
|
struct P { bool InArena; } p{ InArena };
|
||
|
|
return Call(STR("SetInArena"), p);
|
||
|
|
}
|
||
|
|
auto SetInRaidArea(bool InRaidArea) -> bool
|
||
|
|
{
|
||
|
|
struct P { bool InRaidArea; } p{ InRaidArea };
|
||
|
|
return Call(STR("SetInRaidArea"), p);
|
||
|
|
}
|
||
|
|
auto SetCanTargetFromAI(bool bInCanTargetFromAI) -> bool
|
||
|
|
{
|
||
|
|
struct P { bool bInCanTargetFromAI; } p{ bInCanTargetFromAI };
|
||
|
|
return Call(STR("SetCanTargetFromAI"), p);
|
||
|
|
}
|
||
|
|
auto SetSkinName(FName InSkinName) -> bool
|
||
|
|
{
|
||
|
|
struct P { FName InSkinName; } p{ InSkinName };
|
||
|
|
return Call(STR("SetSkinName"), p);
|
||
|
|
}
|
||
|
|
auto SetSkinAppliedCharacterId(FGuid_ InCharacterId) -> bool
|
||
|
|
{
|
||
|
|
struct P { FGuid_ InCharacterId; } p{ InCharacterId };
|
||
|
|
return Call(STR("SetSkinAppliedCharacterId"), p);
|
||
|
|
}
|
||
|
|
auto SetSecurityPoliceTargetPlayerId(FGuid_ PlayerId) -> bool
|
||
|
|
{
|
||
|
|
struct P { FGuid_ PlayerId; } p{ PlayerId };
|
||
|
|
return Call(STR("SetSecurityPoliceTargetPlayerId"), p);
|
||
|
|
}
|
||
|
|
auto SetInvaderData(EPalInvaderType_ InvaderType, FGuid_ InBaseCampId) -> bool
|
||
|
|
{
|
||
|
|
struct P { EPalInvaderType_ InvaderType; FGuid_ InBaseCampId; } p{ InvaderType, InBaseCampId };
|
||
|
|
return Call(STR("SetInvaderData"), p);
|
||
|
|
}
|
||
|
|
auto SetDisableNaturalUpdate(FName Key, bool Disable) -> bool
|
||
|
|
{
|
||
|
|
struct P { FName Key; bool Disable; } p{ Key, Disable };
|
||
|
|
return Call(STR("SetDisableNaturalUpdate"), p);
|
||
|
|
}
|
||
|
|
auto SetDisableNaturalHealing(FName Key, bool Disable) -> bool
|
||
|
|
{
|
||
|
|
struct P { FName Key; bool Disable; } p{ Key, Disable };
|
||
|
|
return Call(STR("SetDisableNaturalHealing"), p);
|
||
|
|
}
|
||
|
|
auto NaturalUpdateSaveParameter(EPalCharacterNaturalUpdateType_ Type) -> bool
|
||
|
|
{
|
||
|
|
struct P { EPalCharacterNaturalUpdateType_ Type; } p{ Type };
|
||
|
|
return Call(STR("NaturalUpdateSaveParameter"), p);
|
||
|
|
}
|
||
|
|
auto SetForcePartBreak() -> bool { return CallVoid(STR("SetForcePartBreak")); }
|
||
|
|
|
||
|
|
// ---- medical bed / misc actions -----------------------------------
|
||
|
|
|
||
|
|
auto StartRecuperatingInMedicalBed() -> bool { return CallVoid(STR("StartRecuperatingInMedicalBed")); }
|
||
|
|
auto RecuperateInMedicalBed() -> bool { return CallVoid(STR("RecuperateInMedicalBed")); }
|
||
|
|
auto EndRecuperatingInMedicalBed() -> bool { return CallVoid(STR("EndRecuperatingInMedicalBed")); }
|
||
|
|
auto StartRemainderOfLifeTimer() -> bool { return CallVoid(STR("StartRemainderOfLifeTimer")); }
|
||
|
|
};
|
||
|
|
}
|