Palworld Props

#ifndef UE4SS_SDK_Pal_HPP
#define UE4SS_SDK_Pal_HPP
#include "Pal_enums.hpp"
struct FActionDynamicParameter
{
class AActor* ActionTarget;
// 0x0000 (size: 0x8)
FTransform StartTransform;
// 0x0010 (size: 0x60)
FVector ActionVelocity;
// 0x0070 (size: 0x18)
int32 GeneralPurposeIndex;
// 0x0088 (size: 0x4)
FVector DummyTargetLocation;
// 0x0090 (size: 0x18)
FGuid ActionID;
// 0x00A8 (size: 0x10)
bool bIsAdjustTransform;
// 0x00B8 (size: 0x1)
FPalNetArchive Blackboard;
// 0x00C0 (size: 0x10)
int32 NetRandSeed;
// 0x00D0 (size: 0x4)
}; // Size: 0xE0
struct FActorArray
{
TArray<class AActor*> Actors;
// 0x0000 (size: 0x10)
}; // Size: 0x10
struct FBuildingSurfaceMaterialSet
{
class UMaterialInstance* Highlight;
// 0x0000 (size: 0x8)
class UMaterialInstance* Error;
// 0x0008 (size: 0x8)
class UMaterialInstance* Building;
// 0x0010 (size: 0x8)
class UMaterialInstance* BuildComplete;
// 0x0018 (size: 0x8)
class UMaterialInstance* Dismantle;
// 0x0020 (size: 0x8)
class UMaterialInstance* Damage;
// 0x0028 (size: 0x8)
class UCurveFloat* BuildCompleteAnimationCurve;
// 0x0030 (size: 0x8)
}; // Size: 0x38
struct FBulletHoleDecalInfo
{
TArray<class UMaterialInterface*> BulletHoleDecals;
// 0x0000 (size: 0x10)
FVector Decal_Size;
// 0x0010 (size: 0x18)
float Decal_Size_RandomMin;
// 0x0028 (size: 0x4)
float Decal_Size_RandomMax;
// 0x002C (size: 0x4)
}; // Size: 0x30
struct FCaptureResult
{
bool IsSuccess;
// 0x0000 (size: 0x1)
int32 TestSuccessCount;
// 0x0004 (size: 0x4)
EFailedCaptureType FailedCaptureType;
// 0x0008 (size: 0x1)
}; // Size: 0xC
struct FCharacterListForImportanceManager
{
TArray<class APalCharacter*> CharacterList;
// 0x0000 (size: 0x10)
}; // Size: 0x10
struct FCharacterParameterRepInfo : public FFastArraySerializerItem

{
FGuid RequestGUID;
// 0x000C (size: 0x10)
FPalInstanceID ID;
// 0x0020 (size: 0x30)
class UPalIndividualCharacterParameter* Parameter;
// 0x0050 (size: 0x8)
}; // Size: 0x58
struct FDelegateTickFunction : public FTickFunction

{
}; // Size: 0x38
struct FElementOfLayeredFlagContainer
{
int32 Priority;
// 0x0000 (size: 0x4)
FFlagContainer Container;
// 0x0008 (size: 0x50)
}; // Size: 0x58
struct FFastCharacterParameterRepInfoArray : public FFastArraySerializer

{
TArray<FCharacterParameterRepInfo> Items;
// 0x0108 (size: 0x10)
}; // Size: 0x148
struct FFastPalBaseCampRepInfoArray : public FFastArraySerializer

{
TArray<FPalBaseCampRepInfo> Items;
// 0x0108 (size: 0x10)
}; // Size: 0x148
struct FFastPalLocationRepInfoArray : public FFastArraySerializer

{
TArray<FPalLocationRepInfo> Items;
// 0x0108 (size: 0x10)
}; // Size: 0x148
struct FFixedPoint
{
int32 Value;
// 0x0000 (size: 0x4)
}; // Size: 0x4
struct FFixedPoint64
{
int64 Value;
// 0x0000 (size: 0x8)
}; // Size: 0x8
struct FFlagContainer
{
TMap<class FName, class bool> Flags;
// 0x0000 (size: 0x50)
}; // Size: 0x50
struct FFloatContainer
{
TArray<FFloatContainer_FloatPair> Values;
// 0x0000 (size: 0x10)
}; // Size: 0x10
struct FFloatContainer_FloatPair
{
FName Key;
// 0x0000 (size: 0x8)
float Value;
// 0x0008 (size: 0x4)
}; // Size: 0xC
struct FFloatCounter
{
float TriggerValue;
// 0x0000 (size: 0x4)
float CurrentStackValue;
// 0x0004 (size: 0x4)
}; // Size: 0x8
struct FFootIKSetting
{
bool bIsEnableIK;
// 0x0000 (size: 0x1)
FName RayCastBoneName;
// 0x0004 (size: 0x8)
float RayStartOffset;
// 0x000C (size: 0x4)
float RayEndOffset;
// 0x0010 (size: 0x4)
}; // Size: 0x14
struct FFootStampInfo
{
TMap<class EPalFootType, class UMaterialInterface*> FootstepDecalMap;
// 0x0000 (size: 0x50)
FVector FootstepDecal_Size;
// 0x0050 (size: 0x18)
FRotator FootstepDecal_InitialRotation;
// 0x0068 (size: 0x18)
}; // Size: 0x80
struct FFootStepEffectInfo
{
TMap<TEnumAsByte<EPhysicalSurface>, TSoftObjectPtr<UNiagaraSystem>>
PhysicalSurfaceToEffect; // 0x0000 (size: 0x50)
}; // Size: 0x50
struct FGameDateTime
{
int64 Ticks;
// 0x0000 (size: 0x8)
}; // Size: 0x8
struct FGeneralAnimationParameter
{
float MoveSpeed;
// 0x0000 (size: 0x4)
float MoveSpeedXY;
// 0x0004 (size: 0x4)
FVector Velocity;
// 0x0008 (size: 0x18)
FVector InputVelocity;
// 0x0020 (size: 0x18)
FVector ClimbingVelocity;
// 0x0038 (size: 0x18)
bool bIsInAir;
// 0x0050 (size: 0x1)
bool bIsSliding;
// 0x0051 (size: 0x1)
bool bIsSwimming;
// 0x0052 (size: 0x1)
float RangeForGround;
// 0x0054 (size: 0x4)
bool bIsNearGround;
// 0x0058 (size: 0x1)
TMap<class EPalGeneralAnimSequenceType, class UAnimSequence*>
GeneralAnimSequenceMap; // 0x0060 (size: 0x50)
TMap<class EPalGeneralBlendSpaceType, class UBlendSpace*> GeneralBlendSpaceMap;
// 0x00B0 (size: 0x50)
float FootIKRootOffset;
// 0x0100 (size: 0x4)
TMap<EPalFootType, float> FootIKOffset;
// 0x0108 (size: 0x50)
float MoveSpeedPlusByRotateYaw;
// 0x0158 (size: 0x4)
float YawSpeed;
// 0x015C (size: 0x4)
float AdditiveAnimationRate;
// 0x0160 (size: 0x4)
bool DisableUpperOverrideFlag;
// 0x0164 (size: 0x1)
bool bTransportingObject;
// 0x0165 (size: 0x1)
}; // Size: 0x168
struct FLayeredFlagContainer
{
TArray<FElementOfLayeredFlagContainer> ContainerList;
// 0x0000 (size: 0x10)
}; // Size: 0x10
struct FNetworkActorSpawnParameters
{
class AActor* NetworkOwner;
// 0x0000 (size: 0x8)
FName Name;
// 0x0008 (size: 0x8)
class AActor* Owner;
// 0x0010 (size: 0x8)
FVector SpawnLocation;
// 0x0018 (size: 0x18)
FRotator SpawnRotation;
// 0x0030 (size: 0x18)
FVector SpawnScale;
// 0x0048 (size: 0x18)
TSubclassOf<class AController> ControllerClass;
// 0x0060 (size: 0x8)
ESpawnActorCollisionHandlingMethod SpawnCollisionHandlingOverride;
// 0x0068 (size: 0x1)
bool bAlwaysRelevant;
// 0x0069 (size: 0x1)
}; // Size: 0x70
struct FPalAIActionBaseCampSleepActivelyParameter
{
float WalkAroundTime;
// 0x0000 (size: 0x4)
}; // Size: 0x4
struct FPalAIActionDynamicParameter
{
class AActor* GeneralActor1;
// 0x0000 (size: 0x8)
FVector GeneralVector1;
// 0x0008 (size: 0x18)
FVector GeneralVector2;
// 0x0020 (size: 0x18)
int32 GeneralIndex1;
// 0x0038 (size: 0x4)
bool GeneralBool1;
// 0x003C (size: 0x1)
int32 GeneralInteger1;
// 0x0040 (size: 0x4)
int32 GeneralInteger2;
// 0x0044 (size: 0x4)
EPalWazaID SelfDestructWaza;
// 0x0048 (size: 0x1)
}; // Size: 0x50
struct FPalAIMoveRequest : public FAIMoveRequest

{
}; // Size: 0x68
struct FPalAISensorSearchQuery
{
}; // Size: 0x18
struct FPalAmbientSoundAreaData
{
int32 AmbientPriority;
// 0x0000 (size: 0x4)
TArray<class UAkAudioEvent*> DayAmbientEvents;
// 0x0008 (size: 0x10)
TArray<class UAkAudioEvent*> NightAmbientEvents;
// 0x0018 (size: 0x10)
}; // Size: 0x28
struct FPalArrowSettings
{
FColor Color;
// 0x0000 (size: 0x4)
float Size;
// 0x0004 (size: 0x4)
float Thickness;
// 0x0008 (size: 0x4)
}; // Size: 0xC
struct FPalAsyncSaveProcess
{
EPalAsyncSaveProcessState State;
// 0x0000 (size: 0x1)
}; // Size: 0x18
struct FPalAsyncSaveProcessParallel
{
TMap<class FString, class FPalAsyncSaveProcess> ProcessMap;
// 0x0000 (size: 0x50)
}; // Size: 0x60
struct FPalAudioFadeParameter
{
EPalAudioFadeType FadeType;
// 0x0000 (size: 0x1)
float CurrentVolume;
// 0x0004 (size: 0x4)
}; // Size: 0x8
struct FPalAxisKeyConfigKeys : public FPalKeyConfigKeys

{
FName AxisName;
// 0x0030 (size: 0x8)
EPalKeyConfigAxisFilterType FilterType;
// 0x0038 (size: 0x1)
}; // Size: 0x40
struct FPalBPClassDataRow : public FTableRowBase

{
TSoftClassPtr<APalCharacter> BPClass;
// 0x0008 (size: 0x30)
}; // Size: 0x38
struct FPalBaseCampCreateParameter
{
}; // Size: 0x170
struct FPalBaseCampFacilityCountPair
{
EPalMapObjectWorkerAvailableFacilityType FacilityType;
// 0x0000 (size: 0x1)
int32 FacilityCount;
// 0x0004 (size: 0x4)
}; // Size: 0x8
struct FPalBaseCampFacilityUsageInfo
{
EPalBaseCampFacilityUsageState State;
// 0x0000 (size: 0x1)
FPalInstanceID ReservedIndividualId;
// 0x0008 (size: 0x30)
}; // Size: 0x38
struct FPalBaseCampFacilityUsageInfoSet
{
TMap<class FGuid, class FPalBaseCampFacilityUsageInfo> InfoMap;
// 0x0000 (size: 0x50)
}; // Size: 0x50
struct FPalBaseCampItemContainerInfo
{
FPalContainerId ContainerId;
// 0x0000 (size: 0x10)
EPalBaseCampItemContainerType Type;
// 0x0010 (size: 0x1)
}; // Size: 0x14
struct FPalBaseCampItemExistsInfo
{
FGuid MapObjectModelInstanceId;
// 0x0000 (size: 0x10)
int32 itemNum;
// 0x0010 (size: 0x4)
}; // Size: 0x14
struct FPalBaseCampLevelMasterData : public FTableRowBase

{
int32 Level;
// 0x0008 (size: 0x4)
int32 WorkerMaxNum;
// 0x000C (size: 0x4)
int32 BaseCampMaxNumInGuild;
// 0x0010 (size: 0x4)
}; // Size: 0x18
struct FPalBaseCampModuleResourceCollectWorkInfo
{
FGuid WorkId;
// 0x0000 (size: 0x10)
}; // Size: 0x10
struct FPalBaseCampModuleTransportItemCharacterInfo
{
TArray<FPalItemAndNum> ItemInfos;
// 0x0000 (size: 0x10)
FVector CharacterLocation;
// 0x0010 (size: 0x18)
}; // Size: 0x28
struct FPalBaseCampModuleTransportItemDepotParameter
{
FGuid OwnerMapObjectConcreteModelInstanceId;
// 0x0000 (size: 0x10)
FPalBoundsTransform DepotLocalBoundsTransform;
// 0x0010 (size: 0x80)
FPalBaseCampModuleTransportItemRequirement Requirement;
// 0x0090 (size: 0x48)
}; // Size: 0xE0
struct FPalBaseCampModuleTransportItemDirection
{
FGuid RequiredMapObjectConcreteModelInstanceId;
// 0x0000 (size: 0x10)
FGuid TransportTargetMapObjectConcreteModelInstanceId;
// 0x0010 (size: 0x10)
int32 MaxItemStackNum;
// 0x0020 (size: 0x4)
bool bRetunring;
// 0x0024 (size: 0x1)
}; // Size: 0x28
struct FPalBaseCampModuleTransportItemRequirement
{
EPalBaseCampModuleTransportItemTransportPriority Priority;
// 0x0000 (size: 0x1)
TArray<FPalStaticItemIdAndNum> ItemInfo;
// 0x0008 (size: 0x10)
TArray<EPalItemTypeA> itemTypeA;
// 0x0018 (size: 0x10)
TArray<EPalItemTypeB> ItemTypeB;
// 0x0028 (size: 0x10)
TArray<EPalBaseCampModuleTransportItemTransportableItemExtraType>
ItemExtraTypes; // 0x0038 (size: 0x10)
}; // Size: 0x48
struct FPalBaseCampModuleTransportItemStatus
{
FPalBaseCampModuleTransportItemRequirement Requirement;
// 0x0000 (size: 0x48)
bool bDepot;
// 0x0048 (size: 0x1)
FPalBoundsTransform DepotLocalBoundsTransform;
// 0x0050 (size: 0x80)
FGuid WorkId;
// 0x00D0 (size: 0x10)
TMap<class FPalInstanceID, class FPalBaseCampModuleTransportItemDirection>
DirectionMap; // 0x00E0 (size: 0x50)
TMap<FName, int32> NotSatisfiedRequirementItemInfoMap;
// 0x0130 (size: 0x50)
}; // Size: 0x180
struct FPalBaseCampModuleTransportItemTarget
{
bool bTargetRemoved;
// 0x0000 (size: 0x1)
TMap<class FPalInstanceID, class
FPalBaseCampModuleTransportItemTargetReservedInfo> ReservedInfoMap; // 0x0008
(size: 0x50)
bool bNotExistMovePath;
// 0x0058 (size: 0x1)
bool bEnableObtainAnywhere;
// 0x0059 (size: 0x1)
TMap<FName, int32> NotReservedItemInfoMap;
// 0x0060 (size: 0x50)
FGuid WorkId;
// 0x00B0 (size: 0x10)
}; // Size: 0xC0
struct FPalBaseCampModuleTransportItemTargetReservedInfo
{
TArray<FPalStaticItemIdAndNum> ItemInfos;
// 0x0000 (size: 0x10)
FGuid RequiredConcreteModelId;
// 0x0010 (size: 0x10)
}; // Size: 0x20
struct FPalBaseCampPassiveEffectMapObjectInfo
{
TArray<FGuid> ConcreteModelInstanceIds;
// 0x0000 (size: 0x10)
}; // Size: 0x10
struct FPalBaseCampPassiveEffectRepInfo : public FFastArraySerializerItem

{
class UPalBaseCampPassiveEffectBase* Effect;
// 0x0010 (size: 0x8)
}; // Size: 0x18
struct FPalBaseCampPassiveEffectWorkHardInfo
{
float WorkSpeedRate;
// 0x0000 (size: 0x4)
float MoveSpeedRate;
// 0x0004 (size: 0x4)
float AffectSanityRate;
// 0x0008 (size: 0x4)
float DecreaseFullStomachRate;
// 0x000C (size: 0x4)
}; // Size: 0x10
struct FPalBaseCampRepInfo : public FFastArraySerializerItem

{
FGuid ID;
// 0x000C (size: 0x10)
class UPalBaseCampModel* BaseCamp;
// 0x0020 (size: 0x8)
}; // Size: 0x28
struct FPalBaseCampSaveData : public FPalBinaryMemory

{
FPalBaseCampSaveData_WorkerDirector WorkerDirector;
// 0x0010 (size: 0x10)
FPalBaseCampSaveData_WorkCollection WorkCollection;
// 0x0020 (size: 0x10)
TMap<class EPalBaseCampModuleType, class FPalBaseCampSaveData_Module>
ModuleMap; // 0x0030 (size: 0x50)
}; // Size: 0x80
struct FPalBaseCampSaveData_Module : public FPalBinaryMemory

{
}; // Size: 0x10
struct FPalBaseCampSaveData_Module_PassiveEffect : public FPalBinaryMemory

{
}; // Size: 0x10
struct FPalBaseCampSaveData_WorkCollection : public FPalBinaryMemory

{
}; // Size: 0x10
struct FPalBaseCampSaveData_WorkerDirector : public FPalBinaryMemory

{
}; // Size: 0x10
struct FPalBaseCampSignificanceInfo
{
float DistanceInRangeFromPlayer;
// 0x0000 (size: 0x4)
float TickInterval;
// 0x0004 (size: 0x4)
}; // Size: 0x8
struct FPalBaseCampTaskCheckedData
{
int32 completedTaskNum;
// 0x0000 (size: 0x4)
TMap<FName, int32> buildObjectNumMap;
// 0x0008 (size: 0x50)
int32 workerNum;
// 0x0058 (size: 0x4)
}; // Size: 0x60
struct FPalBaseCampTaskDataSet
{
TArray<FPalBaseCampTaskData_BuildObject> requireBuildObjects;
// 0x0000 (size: 0x10)
FPalBaseCampTaskData_WorkerNum requirePalNum;
// 0x0010 (size: 0x14)
}; // Size: 0x28
struct FPalBaseCampTaskDataSet_TableRow : public FTableRowBase

{
int32 Level;
// 0x0008 (size: 0x4)
int32 workerNum;
// 0x000C (size: 0x4)
FName WorkerNum_IncompleteMsgID;
// 0x0010 (size: 0x8)
FName WorkerNum_CompleteMsgID;
// 0x0018 (size: 0x8)
FName BuildObject1;
// 0x0020 (size: 0x8)
int32 BuildObjectNum1;
// 0x0028 (size: 0x4)
FName BuildObject1_IncompleteMsgID;
// 0x002C (size: 0x8)
FName BuildObject1_CompleteMsgID;
// 0x0034 (size: 0x8)
FName BuildObject2;
// 0x003C (size: 0x8)
// 0x0044 (size: 0x4)
// 0x0048 (size: 0x8)
// 0x0050 (size: 0x8)
FName BuildObject3;
// 0x0058 (size: 0x8)
// 0x0060 (size: 0x4)
// 0x0064 (size: 0x8)
// 0x006C (size: 0x8)
}; // Size: 0x78
struct FPalBaseCampTaskData_BuildObject
{
FName incompleteMsgID;
// 0x0000 (size: 0x8)
FName completeMsgID;
// 0x0008 (size: 0x8)
FPalDataTableRowName_MapObjectData mapObjectRowName;
// 0x0010 (size: 0x8)
int32 requireNum;
// 0x0018 (size: 0x4)
}; // Size: 0x1C
struct FPalBaseCampTaskData_WorkerNum
{
FName incompleteMsgID;
// 0x0000 (size: 0x8)
FName completeMsgID;
// 0x0008 (size: 0x8)
int32 requireNum;
// 0x0010 (size: 0x4)
}; // Size: 0x14
struct FPalBaseCampWorkAssignRequest
{
}; // Size: 0x30
struct FPalBaseCampWorkCollectionStashInfo
{
FGameDateTime StashAtTime;
// 0x0000 (size: 0x8)
}; // Size: 0x8
struct FPalBaseCampWorkerEventMasterData : public FTableRowBase

{
FName Debug_DisplayName;
// 0x0008 (size: 0x8)
EPalBaseCampWorkerEventPriority Priority;
// 0x0010 (size: 0x1)
int32 TriggerSanity;
// 0x0014 (size: 0x4)
bool bAllowInterruptRecoverHungry;
// 0x0018 (size: 0x1)
bool bAllowInterruptSleep;
// 0x0019 (size: 0x1)
bool bAssignableWork;
// 0x001A (size: 0x1)
int32 TriggerSkipCount;
// 0x001C (size: 0x4)
EPalLogPriority logPriority;
// 0x0020 (size: 0x1)
EPalLogContentToneType LogTone;
// 0x0021 (size: 0x1)
bool Invalid;
// 0x0022 (size: 0x1)
}; // Size: 0x28
struct FPalBaseCampWorkerSickMasterData : public FTableRowBase

{
EPalBaseCampWorkerSickType SickType;
// 0x0008 (size: 0x1)
int32 EffectiveItemRank;
// 0x000C (size: 0x4)
EPalFacialEyeType Facial;
// 0x0010 (size: 0x1)
int32 WorkSpeed;
// 0x0014 (size: 0x4)
int32 MoveSpeed;
// 0x0018 (size: 0x4)
int32 SatietyDecrease;
// 0x001C (size: 0x4)
}; // Size: 0x20
struct FPalBaseCampWorkerTaskCheckResponse
{
}; // Size: 0x50
struct FPalBelongInfo
{
}; // Size: 0x8
struct FPalBinaryMemory
{
TArray<uint8> RawData;
// 0x0000 (size: 0x10)
}; // Size: 0x10
struct FPalBodyInstanceParameter
{
int32 InstanceBodyIndex;
// 0x0000 (size: 0x4)
int16 InstanceBoneIndex;
// 0x0004 (size: 0x2)
float LinearDamping;
// 0x0008 (size: 0x4)
float AngularDamping;
// 0x000C (size: 0x4)
}; // Size: 0x10
struct FPalBossBattleInstanceModelCreateParameter
{
TSoftClassPtr<APalCutsceneActor> IntroCutsceneActor;
// 0x0008 (size: 0x30)
class UDataLayerAsset* ReservedDataLayerAsset;
// 0x0038 (size: 0x8)
TSoftObjectPtr<UAkAudioEvent> BGMAudioEvent;
// 0x0040 (size: 0x30)
class APalBossTower* BossTower;
// 0x0070 (size: 0x8)
}; // Size: 0x1A0
struct FPalBossBattleLevelInstanceLoadOperator
{
}; // Size: 0x28
struct FPalBossBattleStaticInfo
{
TSoftClassPtr<APalCutsceneActor> IntroCutscene;
// 0x0000 (size: 0x30)
class UDataLayerAsset* DataLayerAsset;
// 0x0030 (size: 0x8)
FPalDataTableRowName_PalMonsterData PalID;
// 0x0038 (size: 0x8)
int32 Level;
// 0x0040 (size: 0x4)
// 0x0048 (size: 0x30)
}; // Size: 0x78
struct FPalBossSpawnerSaveData
{
TMap<class FName, class bool> RespawnDisableFlag;
// 0x0000 (size: 0x50)
}; // Size: 0x50
struct FPalBoundsTransform
{
FVector Location;
// 0x0000 (size: 0x18)
FQuat Rotation;
// 0x0020 (size: 0x20)
FBoxSphereBounds Bounds;
// 0x0040 (size: 0x38)
}; // Size: 0x80
struct FPalBuildInstallOtherOptions
{
}; // Size: 0x2
struct FPalBuildObjectData : public FTableRowBase

{
FName MapObjectId;
// 0x0008 (size: 0x8)
EPalBuildObjectTypeA TypeA;
// 0x0010 (size: 0x1)
int32 RedialIndex;
// 0x0014 (size: 0x4)
EPalBuildObjectTypeB TypeB;
// 0x0018 (size: 0x1)
int32 Rank;
// 0x001C (size: 0x4)
int32 BuildCapacity;
// 0x0020 (size: 0x4)
float RequiredBuildWorkAmount;
// 0x0024 (size: 0x4)
int32 AssetValue;
// 0x0028 (size: 0x4)
EPalEnergyType RequiredEnergyType;
// 0x002C (size: 0x1)
float ConsumeEnergySpeed;
// 0x0030 (size: 0x4)
FName Material1_Id;
// 0x0034 (size: 0x8)
int32 Material1_Count;
// 0x003C (size: 0x4)
FName Material2_Id;
// 0x0040 (size: 0x8)
// 0x0048 (size: 0x4)
FName Material3_Id;
// 0x004C (size: 0x8)
// 0x0054 (size: 0x4)
FName Material4_Id;
// 0x0058 (size: 0x8)
// 0x0060 (size: 0x4)
FName OverrideDescMsgID;
// 0x0064 (size: 0x8)
bool bInstallAtReticle;
// 0x006C (size: 0x1)
float InstallNeighborThreshold;
// 0x0070 (size: 0x4)
bool bIsInstallOnlyOnBase;
// 0x0074 (size: 0x1)
bool bIsInstallOnlyInDoor;
// 0x0075 (size: 0x1)
bool bIsInstallOnlyHubAround;
// 0x0076 (size: 0x1)
bool bInstallableNoObstacleFromCamera;
// 0x0077 (size: 0x1)
}; // Size: 0x78
struct FPalBuildObjectDataSetTypeB
{
EPalBuildObjectTypeB TypeB;
// 0x0000 (size: 0x1)
TArray<FPalBuildObjectData> DataArray;
// 0x0008 (size: 0x10)
}; // Size: 0x18
struct FPalBuildObjectIconData : public FTableRowBase

{
TSoftObjectPtr<UTexture2D> SoftIcon;
// 0x0008 (size: 0x30)
}; // Size: 0x38
struct FPalBuildObjectMaterialArray
{
TArray<class UMaterialInterface*> Materials;
// 0x0000 (size: 0x10)
}; // Size: 0x10
struct FPalBuildObjectMeshDefaultSetting
{
FName ProfileName;
// 0x0000 (size: 0x8)
}; // Size: 0x8
struct FPalBuildRequestDebugParameter
{
bool bNotConsumeMaterials;
// 0x0000 (size: 0x1)
}; // Size: 0x1
struct FPalCalcCharacterDamageInfo
{
float OtomoRate;
// 0x0000 (size: 0x4)
int32 DefenderLevel;
// 0x0004 (size: 0x4)
int32 DefenderDefence;
// 0x0008 (size: 0x4)
EPalElementType DefenderElementType1;
// 0x000C (size: 0x1)
EPalElementType DefenderElementType2;
// 0x000D (size: 0x1)
float ElementStatusMultiplay;
// 0x0010 (size: 0x4)
}; // Size: 0x14
struct FPalCameraDOFSetting
{
float DepthOfFieldFocalDistance;
// 0x0000 (size: 0x4)
float DepthOfFieldDepthBlurAmount;
// 0x0004 (size: 0x4)
float DepthOfFieldDepthBlurRadius;
// 0x0008 (size: 0x4)
float DepthOfFieldFstop;
// 0x000C (size: 0x4)
float FOV;
// 0x0010 (size: 0x4)
}; // Size: 0x14
struct FPalCaptureBallEffectSettingData
{
int32 CaptureAbsorbToBall_ParticleCount;
// 0x0000 (size: 0x4)
float CaptureAbsorbToBall_Scale;
// 0x0004 (size: 0x4)
}; // Size: 0x8
struct FPalCaptureBonusExpRaw : public FTableRowBase

{
int32 BonusExp;
// 0x0008 (size: 0x4)
}; // Size: 0x10
struct FPalCapturedCageInfoDatabaseRow : public FTableRowBase

{
FName FieldName;
// 0x0008 (size: 0x8)
FName PalID;
// 0x0010 (size: 0x8)
float Weight;
// 0x0018 (size: 0x4)
int32 MinLevel;
// 0x001C (size: 0x4)
int32 MaxLevel;
// 0x0020 (size: 0x4)
}; // Size: 0x28
struct FPalCellCoord
{
int64 X;
// 0x0000 (size: 0x8)
int64 Y;
// 0x0008 (size: 0x8)
int64 Z;
// 0x0010 (size: 0x8)
}; // Size: 0x18
struct FPalCharacterCompleteDelegateParameter
{
EPalCharacterCompleteDelegatePriority Priority;
// 0x0000 (size: 0x1)
FPalCharacterCompleteDelegateParameterCompleteDelegate CompleteDelegate;
// 0x0004 (size: 0x10)
void PalOnCharacterCompleteInitializeParameter(class APalCharacter*
InCharacter);
}; // Size: 0x14
struct FPalCharacterContainerSaveData : public FPalBinaryMemory

{
bool bReferenceSlot;
// 0x0010 (size: 0x1)
TArray<FPalCharacterSlotSaveData> Slots;
// 0x0018 (size: 0x10)
}; // Size: 0x28
struct FPalCharacterContainerSlotInfo
{
FPalInstanceID IndividualId;
// 0x0000 (size: 0x30)
FPalCharacterSlotId SlotID;
// 0x0030 (size: 0x14)
}; // Size: 0x48
struct FPalCharacterCreationColorPresetDataRow : public FTableRowBase

{
TArray<FLinearColor> Colors;
// 0x0008 (size: 0x10)
}; // Size: 0x18
struct FPalCharacterCreationEyeMaterialDataRow : public FTableRowBase

{
TSoftObjectPtr<UMaterialInstance> EyeMaterialInstance;
// 0x0008 (size: 0x30)
TSoftObjectPtr<UTexture2D> IconTexture;
// 0x0038 (size: 0x30)
FLinearColor ShiftUIDisplayEyeColor;
// 0x0068 (size: 0x10)
}; // Size: 0x78
struct FPalCharacterCreationMakeInfoPresetDataRow : public FTableRowBase

{
FPalPlayerDataCharacterMakeInfo PresetMakeInfo;
// 0x0008 (size: 0x94)
}; // Size: 0xA0
struct FPalCharacterCreationMeshPresetDataRow : public FTableRowBase

{
TSoftObjectPtr<USkeletalMesh> SkeletalMesh;
// 0x0008 (size: 0x30)
TSoftObjectPtr<USkeletalMesh> SkeletalMesh_MaleHead;
// 0x0038 (size: 0x30)
// 0x0068 (size: 0x30)
TSoftClassPtr<UAnimInstance> ABPAsset;
// 0x0098 (size: 0x30)
FLinearColor ShiftUIDisplayEyeColor;
// 0x00C8 (size: 0x10)
FLinearColor ShiftUIDisplayBodyColor;
// 0x00D8 (size: 0x10)
FLinearColor ShiftUIDisplayBrowColor;
// 0x00E8 (size: 0x10)
FLinearColor ShiftUIDisplayHairColor;
// 0x00F8 (size: 0x10)
}; // Size: 0x108
struct FPalCharacterCreationPresetDataRow : public FTableRowBase

{
FPalPlayerDataCharacterMakeInfo MakeInfo;
// 0x0008 (size: 0x94)
// 0x00A0 (size: 0x30)
}; // Size: 0xD0
struct FPalCharacterIconDataRow : public FTableRowBase

{
TSoftObjectPtr<UTexture2D> Icon;
// 0x0008 (size: 0x30)
}; // Size: 0x38
struct FPalCharacterList
{
TArray<class APalCharacter*> CharacterList;
// 0x0000 (size: 0x10)
}; // Size: 0x10
struct FPalCharacterParameterDatabaseRow : public FTableRowBase

{
FName OverrideNameTextID;
// 0x0008 (size: 0x8)
FName NamePrefixID;
// 0x0010 (size: 0x8)
FName OverridePartnerSkillTextID;
// 0x0018 (size: 0x8)
bool IsPal;
// 0x0020 (size: 0x1)
EPalTribeID Tribe;
// 0x0021 (size: 0x1)
FName BPClass;
// 0x0024 (size: 0x8)
int32 ZukanIndex;
// 0x002C (size: 0x4)
FString ZukanIndexSuffix;
// 0x0030 (size: 0x10)
EPalSizeType Size;
// 0x0040 (size: 0x1)
int32 Rarity;
// 0x0044 (size: 0x4)
EPalElementType ElementType1;
// 0x0048 (size: 0x1)
// 0x0049 (size: 0x1)
EPalGenusCategoryType GenusCategory;
// 0x004A (size: 0x1)
EPalOrganizationType Organization;
// 0x004B (size: 0x1)
EPalWeaponType weapon;
// 0x004C (size: 0x1)
bool WeaponEquip;
// 0x004D (size: 0x1)
int32 HP;
// 0x0050 (size: 0x4)
int32 MeleeAttack;
// 0x0054 (size: 0x4)
int32 ShotAttack;
// 0x0058 (size: 0x4)
int32 Defense;
// 0x005C (size: 0x4)
int32 Support;
// 0x0060 (size: 0x4)
int32 CraftSpeed;
// 0x0064 (size: 0x4)
float EnemyReceiveDamageRate;
// 0x0068 (size: 0x4)
float CaptureRateCorrect;
// 0x006C (size: 0x4)
float ExpRatio;
// 0x0070 (size: 0x4)
float Price;
// 0x0074 (size: 0x4)
FName AIResponse;
// 0x0078 (size: 0x8)
FName AISightResponse;
// 0x0080 (size: 0x8)
int32 SlowWalkSpeed;
// 0x0088 (size: 0x4)
int32 WalkSpeed;
// 0x008C (size: 0x4)
int32 RunSpeed;
// 0x0090 (size: 0x4)
int32 RideSprintSpeed;
// 0x0094 (size: 0x4)
int32 TransportSpeed;
// 0x0098 (size: 0x4)
bool IsBoss;
// 0x009C (size: 0x1)
bool IsTowerBoss;
// 0x009D (size: 0x1)
EPalBattleBGMType BattleBGM;
// 0x009E (size: 0x1)
bool IgnoreLeanBack;
// 0x009F (size: 0x1)
bool IgnoreBlowAway;
// 0x00A0 (size: 0x1)
int32 MaxFullStomach;
// 0x00A4 (size: 0x4)
float FullStomachDecreaseRate;
// 0x00A8 (size: 0x4)
int32 FoodAmount;
// 0x00AC (size: 0x4)
int32 ViewingDistance;
// 0x00B0 (size: 0x4)
int32 ViewingAngle;
// 0x00B4 (size: 0x4)
float HearingRate;
// 0x00B8 (size: 0x4)
bool NooseTrap;
// 0x00BC (size: 0x1)
bool Nocturnal;
// 0x00BD (size: 0x1)
int32 BiologicalGrade;
// 0x00C0 (size: 0x4)
bool Predator;
// 0x00C4 (size: 0x1)
bool Edible;
// 0x00C5 (size: 0x1)
int32 Stamina;
// 0x00C8 (size: 0x4)
int32 MaleProbability;
// 0x00CC (size: 0x4)
int32 CombiRank;
// 0x00D0 (size: 0x4)
int32 WorkSuitability_EmitFlame;
// 0x00D4 (size: 0x4)
int32 WorkSuitability_Watering;
// 0x00D8 (size: 0x4)
int32 WorkSuitability_Seeding;
// 0x00DC (size: 0x4)
int32 WorkSuitability_GenerateElectricity;
// 0x00E0 (size: 0x4)
int32 WorkSuitability_Handcraft;
// 0x00E4 (size: 0x4)
int32 WorkSuitability_Collection;
// 0x00E8 (size: 0x4)
int32 WorkSuitability_Deforest;
// 0x00EC (size: 0x4)
int32 WorkSuitability_Mining;
// 0x00F0 (size: 0x4)
int32 WorkSuitability_OilExtraction;
// 0x00F4 (size: 0x4)
int32 WorkSuitability_ProductMedicine;
// 0x00F8 (size: 0x4)
int32 WorkSuitability_Cool;
// 0x00FC (size: 0x4)
int32 WorkSuitability_Transport;
// 0x0100 (size: 0x4)
int32 WorkSuitability_MonsterFarm;
// 0x0104 (size: 0x4)
FName PassiveSkill1;
// 0x0108 (size: 0x8)
// 0x0110 (size: 0x8)
// 0x0118 (size: 0x8)
// 0x0120 (size: 0x8)
}; // Size: 0x128
struct FPalCharacterParameterStorageSaveData
{
TArray<FPalCharacterStoredParameterInfoSaveData> StoredParameterInfoSaveData;
// 0x0000 (size: 0x10)
}; // Size: 0x10
struct FPalCharacterParameter_Work
{
FGuid MapObjectInstanceIdApproachTo;
// 0x0000 (size: 0x10)
bool bApproachToAssignedLocation;
// 0x0010 (size: 0x1)
float RepairRequiredWorkAmount;
// 0x0014 (size: 0x4)
FFlagContainer NotWorkableFlag;
// 0x0028 (size: 0x50)
}; // Size: 0x78
struct FPalCharacterSlotId
{
// 0x0000 (size: 0x10)
int32 SlotIndex;
// 0x0010 (size: 0x4)
}; // Size: 0x14
struct FPalCharacterSlotSaveData : public FPalBinaryMemory

{
// 0x0010 (size: 0x30)
EPalTribeID PermissionTribeID;
// 0x0040 (size: 0x1)
}; // Size: 0x48
struct FPalCharacterSlotUpdateInfo
{
// 0x0000 (size: 0x10)
int32 SlotIndex;
// 0x0010 (size: 0x4)
FPalInstanceID InstanceId;
// 0x0018 (size: 0x30)
}; // Size: 0x48
struct FPalCharacterStoredParameterId
{
FGuid ID;
// 0x0000 (size: 0x10)
}; // Size: 0x10
struct FPalCharacterStoredParameterInfo
{
FPalIndividualCharacterSaveParameter SaveParameter;
// 0x0000 (size: 0x218)
FGameDateTime StoredAt;
// 0x0218 (size: 0x8)
FGuid LostPlayerUId;
// 0x0220 (size: 0x10)
}; // Size: 0x230
struct FPalCharacterStoredParameterInfoSaveData
{
FPalCharacterStoredParameterId ID;
// 0x0000 (size: 0x10)
FPalIndividualCharacterSaveParameterSaveData SaveParameter;
// 0x0010 (size: 0x10)
FGameDateTime StoredAt;
// 0x0020 (size: 0x8)
FGuid LostPlayerUId;
// 0x0028 (size: 0x10)
}; // Size: 0x38
struct FPalCharacterUpgradeMasterData : public FTableRowBase

{
int32 Rank;
// 0x0008 (size: 0x4)
FName RequiredStaticItemId;
// 0x000C (size: 0x8)
int32 RequiredItemNum;
// 0x0014 (size: 0x4)
int32 ResetRequiredMoney;
// 0x0018 (size: 0x4)
}; // Size: 0x20
struct FPalChatMessage
{
EPalChatCategory Category;
// 0x0000 (size: 0x1)
FString Sender;
// 0x0008 (size: 0x10)
FGuid SenderPlayerUId;
// 0x0018 (size: 0x10)
FString Message;
// 0x0028 (size: 0x10)
FGuid ReceiverPlayerUId;
// 0x0038 (size: 0x10)
}; // Size: 0x48
struct FPalCheckStuckInfo
{
}; // Size: 0x18
struct FPalCollectionRankDefineData
{
float DropNumRate;
// 0x0000 (size: 0x4)
}; // Size: 0x4
struct FPalCombiUniqueDatabaseRow : public FTableRowBase

{
EPalTribeID ParentTribeA;
// 0x0008 (size: 0x1)
EPalTribeID ParentTribeB;
// 0x0009 (size: 0x1)
FName ChildCharacterID;
// 0x000C (size: 0x8)
}; // Size: 0x18
struct FPalCommonQuestRewardData
{
int32 Exp;
// 0x0000 (size: 0x4)
int32 TechnologyPoint;
// 0x0004 (size: 0x4)
TMap<FPalDataTableRowName_ItemData, int32> Items;
// 0x0008 (size: 0x50)
}; // Size: 0x58
struct FPalCompletedQuestSaveData
{
FName QuestName;
// 0x0000 (size: 0x8)
}; // Size: 0x8
struct FPalContainerBelongInfo : public FPalBelongInfo

{
}; // Size: 0x8
struct FPalContainerCreateExtraParameter
{
bool bIsWatchAllPlayer;
// 0x0000 (size: 0x1)
bool bIsSyncEnable;
// 0x0001 (size: 0x1)
EPalContainerOperationRestrictType OperationRestrictType;
// 0x0002 (size: 0x1)
}; // Size: 0x3
struct FPalContainerId
{
FGuid ID;
// 0x0000 (size: 0x10)
}; // Size: 0x10
struct FPalContainerInfo
{
// 0x0008 (size: 0x10)
int32 SlotNum;
// 0x0018 (size: 0x4)
}; // Size: 0x20
struct FPalContainerInitializeParameter
{
FPalContainerId ID;
// 0x0000 (size: 0x10)
int32 SlotNum;
// 0x0010 (size: 0x4)
bool bReferenceSlot;
// 0x0014 (size: 0x1)
// 0x0015 (size: 0x1)
}; // Size: 0x18
struct FPalCoopSkillAssaultrifleModeCandidateLocation
{
FVector Location;
// 0x0000 (size: 0x18)
float Distance;
// 0x0018 (size: 0x4)
}; // Size: 0x20
struct FPalCoopSkillModuleAssignPassiveSkillNames
{
TArray<FPalDataTableRowName_PassiveSkillData> AssignSkillNames;
// 0x0000 (size: 0x10)
}; // Size: 0x10
struct FPalCoopSkillSearchEffectParameter
{
FVector Origin;
// 0x0000 (size: 0x18)
float RadiusFrom;
// 0x0018 (size: 0x4)
float RadiusTo;
// 0x001C (size: 0x4)
float ExtRadiusPerSec;
// 0x0020 (size: 0x4)
}; // Size: 0x28
struct FPalCoopSkillSearchResultParameter
{
EPalCoopSkillSearchType SearchType;
// 0x0000 (size: 0x1)
FVector Location;
// 0x0008 (size: 0x18)
FGuid InstanceId;
// 0x0020 (size: 0x10)
// 0x0030 (size: 0x30)
FGuid RequestPlayerUId;
// 0x0060 (size: 0x10)
}; // Size: 0x70
struct FPalCrimeInstanceCreateParameter
{
FName CrimeId;
// 0x0000 (size: 0x8)
FGuid TargetId;
// 0x0008 (size: 0x10)
}; // Size: 0x18
struct FPalCrimeMasterData : public FTableRowBase

{
FName CrimeNameTextId;
// 0x0008 (size: 0x8)
int32 BaseReward;
// 0x0010 (size: 0x4)
}; // Size: 0x18
struct FPalCrimeStateInfo
{
TMap<class FGuid, class FDateTime> CrimeStateFinishTimeMap;
// 0x0000 (size: 0x50)
TArray<FGuid> CrimeStateArray;
// 0x0050 (size: 0x10)
}; // Size: 0x60
struct FPalCustomMarkerSaveData
{
FVector IconLocation;
// 0x0000 (size: 0x18)
int32 IconType;
// 0x0018 (size: 0x4)
}; // Size: 0x20
struct FPalDamageInfo
{
int32 NativeDamageValue;
// 0x0000 (size: 0x4)
EPalWazaCategory Category;
// 0x0004 (size: 0x1)
bool IsBlowAttack;
// 0x0005 (size: 0x1)
bool IsLeanBack;
// 0x0006 (size: 0x1)
FVector BlowVelocity;
// 0x0008 (size: 0x18)
EPalBodyPartsType BodyPartsType;
// 0x0020 (size: 0x1)
int32 AttackerLevel;
// 0x0024 (size: 0x4)
EPalElementType AttackElementType;
// 0x0028 (size: 0x1)
FGuid AttackerGroupID;
// 0x002C (size: 0x10)
class AActor* Attacker;
// 0x0040 (size: 0x8)
class AActor* OverrideNetworkOwner;
// 0x0048 (size: 0x8)
EPalAttackType AttackType;
// 0x0050 (size: 0x1)
FVector HitLocation;
// 0x0058 (size: 0x18)
FName FoliageModelId;
// 0x0070 (size: 0x8)
TArray<FPalFoliageInstanceId> FoliageInstanceIds;
// 0x0078 (size: 0x10)
EPalAdditionalEffectType EffectType1;
// 0x0088 (size: 0x1)
int32 EffectValue1;
// 0x008C (size: 0x4)
float EffectValueEx1;
// 0x0090 (size: 0x4)
// 0x0094 (size: 0x1)
int32 EffectValue2;
// 0x0098 (size: 0x4)
// 0x009C (size: 0x4)
float SneakAttackRate;
// 0x00A0 (size: 0x4)
bool PlaySneakAttackEffect;
// 0x00A4 (size: 0x1)
float DamageRatePerCollision;
// 0x00A8 (size: 0x4)
TArray<FPalSpecialAttackRateInfo> SpecialAttackRateInfos;
// 0x00B0 (size: 0x10)
EPalDamageAnimationReactionType DamageReactionAnimationType;
// 0x00C0 (size: 0x1)
bool bAttackableToFriend;
// 0x00C1 (size: 0x1)
bool NoDamage;
// 0x00C2 (size: 0x1)
bool IgnoreShield;
// 0x00C3 (size: 0x1)
bool UIDamageTextOverride_DoubleRegist;
// 0x00C4 (size: 0x1)
EPalPlayerDamageCameraShakeCategory CameraShake;
// 0x00C5 (size: 0x1)
EPalSizeType ForceRagdollSize;
// 0x00C6 (size: 0x1)
bool bApplyNativeDamageValue;
// 0x00C7 (size: 0x1)
bool IgnorePlayerEquipItemDamage;
// 0x00C8 (size: 0x1)
}; // Size: 0xD0
struct FPalDamageRactionInfo
{
bool IsBlow;
// 0x0000 (size: 0x1)
// 0x0008 (size: 0x18)
bool IsLeanBackAnime;
// 0x0020 (size: 0x1)
bool IsStan;
// 0x0021 (size: 0x1)
// 0x0028 (size: 0x18)
}; // Size: 0x40
struct FPalDamageResult
{
int32 Damage;
// 0x0000 (size: 0x4)
// 0x0008 (size: 0x8)
class AActor* Defender;
// 0x0010 (size: 0x8)
// 0x0018 (size: 0x18)
// 0x0030 (size: 0x18)
// 0x0048 (size: 0x1)
bool IgnoreShield;
// 0x0049 (size: 0x1)
bool IsPlayedLeanBack;
// 0x004A (size: 0x1)
// 0x004B (size: 0x1)
bool IgnorePlayerEquipItemDamage;
// 0x004C (size: 0x1)
}; // Size: 0x50
struct FPalDataTableRowName_BaseCampWorkerEventData
{
FName Key;
// 0x0000 (size: 0x8)
}; // Size: 0x8
struct FPalDataTableRowName_CrimeMasterData
{
FName Key;
// 0x0000 (size: 0x8)
}; // Size: 0x8
struct FPalDataTableRowName_DungeonSpawnAreaData
{
FName Key;
// 0x0000 (size: 0x8)
}; // Size: 0x8
struct FPalDataTableRowName_FarmCropData
{
FName Key;
// 0x0000 (size: 0x8)
}; // Size: 0x8
struct FPalDataTableRowName_FieldLotteryNameData
{
FName Key;
// 0x0000 (size: 0x8)
}; // Size: 0x8
struct FPalDataTableRowName_GameProgressPreset
{
FName Key;
// 0x0000 (size: 0x8)
}; // Size: 0x8
struct FPalDataTableRowName_ItemData
{
FName Key;
// 0x0000 (size: 0x8)
}; // Size: 0x8
struct FPalDataTableRowName_ItemProductData
{
FName Key;
// 0x0000 (size: 0x8)
}; // Size: 0x8
struct FPalDataTableRowName_ItemShopCreateData
{
FName Key;
// 0x0000 (size: 0x8)
}; // Size: 0x8
struct FPalDataTableRowName_ItemShopLotteryData
{
FName Key;
// 0x0000 (size: 0x8)
}; // Size: 0x8
struct FPalDataTableRowName_MapObjectData
{
FName Key;
// 0x0000 (size: 0x8)
}; // Size: 0x8
struct FPalDataTableRowName_NPCUniqueData
{
FName Key;
// 0x0000 (size: 0x8)
}; // Size: 0x8
struct FPalDataTableRowName_NoteData
{
FName Key;
// 0x0000 (size: 0x8)
}; // Size: 0x8
struct FPalDataTableRowName_PalHumanData
{
FName Key;
// 0x0000 (size: 0x8)
}; // Size: 0x8
struct FPalDataTableRowName_PalMonsterData
{
FName Key;
// 0x0000 (size: 0x8)
}; // Size: 0x8
struct FPalDataTableRowName_PalShopCreateData
{
FName Key;
// 0x0000 (size: 0x8)
}; // Size: 0x8
struct FPalDataTableRowName_PassiveSkillData
{
FName Key;
// 0x0000 (size: 0x8)
}; // Size: 0x8
struct FPalDataTableRowName_RecipeTechnologyData
{
FName Key;
// 0x0000 (size: 0x8)
}; // Size: 0x8
struct FPalDataTableRowName_SoundID
{
FName Key;
// 0x0000 (size: 0x8)
}; // Size: 0x8
struct FPalDataTableRowName_UIInputAction
{
FName Key;
// 0x0000 (size: 0x8)
}; // Size: 0x8
struct FPalDeadInfo
{
int32 LastDamage;
// 0x0000 (size: 0x4)
class AActor* LastAttacker;
// 0x0008 (size: 0x8)
class AActor* SelfActor;
// 0x0010 (size: 0x8)
// 0x0018 (size: 0x18)
// 0x0030 (size: 0x18)
EPalWazaID SelfDestructWaza;
// 0x0048 (size: 0x1)
}; // Size: 0x50
struct FPalDeathPenaltyInfo
{
FGuid DeathPenaID;
// 0x0000 (size: 0x10)
FGuid DeathPlayerID;
// 0x0010 (size: 0x10)
FVector PlayerDeathLocation;
// 0x0020 (size: 0x18)
FVector DropItemLocation;
// 0x0038 (size: 0x18)
TArray<FPalItemAndNum> DropItemList;
// 0x0050 (size: 0x10)
}; // Size: 0x60
struct FPalDeathPenaltyList
{
TArray<FPalDeathPenaltyInfo> DeathPenaArray;
// 0x0000 (size: 0x10)
}; // Size: 0x10
struct FPalDebugAttachPassiveSkillInfo
{
TArray<FPalDataTableRowName_PassiveSkillData> skill;
// 0x0000 (size: 0x10)
}; // Size: 0x10
struct FPalDebugInfoSet
{
}; // Size: 0x30
struct FPalDebugItemCreateInfo
{
FPalDataTableRowName_ItemData itemRowName;
// 0x0000 (size: 0x8)
int32 itemNum;
// 0x0008 (size: 0x4)
}; // Size: 0xC
struct FPalDebugOtomoPalInfo
{
FPalDataTableRowName_PalMonsterData PalName;
// 0x0000 (size: 0x8)
int32 Level;
// 0x0008 (size: 0x4)
int32 Rank;
// 0x000C (size: 0x4)
TArray<EPalWazaID> WazaList;
// 0x0010 (size: 0x10)
TArray<FPalDataTableRowName_PassiveSkillData> PassiveSkill;
// 0x0020 (size: 0x10)
}; // Size: 0x30
struct FPalDebugPalCaptureInfo
{
// 0x0000 (size: 0x8)
int32 Num;
// 0x0008 (size: 0x4)
}; // Size: 0xC
struct FPalDeforestRankDefineData
{
float DamageRate;
// 0x0000 (size: 0x4)
EPalMapObjectMaterialSubType MaterialSubType;
// 0x0004 (size: 0x1)
}; // Size: 0x8
struct FPalDropCharacterExtraParameter
{
FGuid DropPlayerUId;
// 0x0000 (size: 0x10)
}; // Size: 0x10
struct FPalDropItemDatabaseRow : public FTableRowBase

{
FName CharacterID;
// 0x0008 (size: 0x8)
int32 Level;
// 0x0010 (size: 0x4)
FName ItemId1;
// 0x0014 (size: 0x8)
float Rate1;
// 0x001C (size: 0x4)
int32 min1;
// 0x0020 (size: 0x4)
int32 Max1;
// 0x0024 (size: 0x4)
FName ItemId2;
// 0x0028 (size: 0x8)
float Rate2;
// 0x0030 (size: 0x4)
int32 min2;
// 0x0034 (size: 0x4)
int32 Max2;
// 0x0038 (size: 0x4)
FName ItemId3;
// 0x003C (size: 0x8)
float Rate3;
// 0x0044 (size: 0x4)
int32 min3;
// 0x0048 (size: 0x4)
int32 Max3;
// 0x004C (size: 0x4)
FName ItemId4;
// 0x0050 (size: 0x8)
float Rate4;
// 0x0058 (size: 0x4)
int32 min4;
// 0x005C (size: 0x4)
int32 Max4;
// 0x0060 (size: 0x4)
FName ItemId5;
// 0x0064 (size: 0x8)
float Rate5;
// 0x006C (size: 0x4)
int32 min5;
// 0x0070 (size: 0x4)
int32 Max5;
// 0x0074 (size: 0x4)
}; // Size: 0x78
struct FPalDropItemInfo
{
}; // Size: 0x28
struct FPalDroppedPalProductDataForShop
{
FPalCharacterStoredParameterId StoredParameterId;
// 0x0000 (size: 0x10)
// 0x0010 (size: 0x218)
}; // Size: 0x228
struct FPalDungeonDataLayerAssetSet
{
TArray<class UDataLayerAsset*> DataLayers;
// 0x0000 (size: 0x10)
}; // Size: 0x10
struct FPalDungeonEnemySpawnerData : public FTableRowBase

{
FName SpawnAreaId;
// 0x0008 (size: 0x8)
EPalDungeonEnemySpawnerRankType RankType;
// 0x0010 (size: 0x1)
float WeightInSpawnAreaAndRank;
// 0x0014 (size: 0x4)
TSoftClassPtr<APalNPCSpawnerBase> SpawnerBlueprintSoftClass;
// 0x0018 (size: 0x30)
FName SpawnerName;
// 0x0048 (size: 0x8)
}; // Size: 0x50
struct FPalDungeonInfoParameter
{
FText DungeonName;
// 0x0000 (size: 0x18)
int32 Level;
// 0x0018 (size: 0x4)
float DisappearRemainSeconds;
// 0x001C (size: 0x4)
}; // Size: 0x28
struct FPalDungeonInstanceModelCreateParameter
{
// 0x0060 (size: 0x8)
}; // Size: 0x68
struct FPalDungeonItemSpawnerData : public FTableRowBase

{
FName SpawnAreaId;
// 0x0008 (size: 0x8)
EPalDungeonItemSpawnerType Type;
// 0x0010 (size: 0x1)
FName ItemFieldLotteryName;
// 0x0014 (size: 0x8)
}; // Size: 0x20
struct FPalDungeonLevelData : public FTableRowBase

{
FName SpawnAreaId;
// 0x0008 (size: 0x8)
float WeightInSpawnArea;
// 0x0010 (size: 0x4)
FName LevelName;
// 0x0014 (size: 0x8)
}; // Size: 0x20
struct FPalDungeonLevelInstanceLoadOperator
{
}; // Size: 0x28
struct FPalDungeonMarkerPointData
{
FGuid MarkerPointId;
// 0x0000 (size: 0x10)
TArray<FName> SpawnAreaIds;
// 0x0010 (size: 0x10)
FTransform Transform;
// 0x0020 (size: 0x60)
FPalDungeonMarkerPointSpawnParameter SpawnParameter;
// 0x0080 (size: 0x10)
TSubclassOf<class APalDungeonEntrance> EntranceClass;
// 0x0090 (size: 0x8)
FGuid ConnectedDungeonInstanceId;
// 0x00A0 (size: 0x10)
}; // Size: 0xB0
struct FPalDungeonMarkerPointDataSet
{
TArray<FPalDungeonMarkerPointData> MarkerPoints;
// 0x0000 (size: 0x10)
}; // Size: 0x10
struct FPalDungeonMarkerPointSpawnParameter
{
float RespawnInterval;
// 0x0000 (size: 0x4)
float DisappearInterval;
// 0x0004 (size: 0x4)
float RespawnProbability;
// 0x0008 (size: 0x4)
float DisappearIntervalAfterDefeatBoss;
// 0x000C (size: 0x4)
}; // Size: 0x10
struct FPalDungeonPointMarkerSaveData
{
// 0x0000 (size: 0x10)
FGameDateTime NextRespawnGameTime;
// 0x0010 (size: 0x8)
FGuid ConnectedDungeonInstanceId;
// 0x0018 (size: 0x10)
}; // Size: 0x28
struct FPalDungeonSaveData
{
FGuid InstanceId;
// 0x0000 (size: 0x10)
EPalDungeonType DungeonType;
// 0x0010 (size: 0x1)
// 0x0014 (size: 0x10)
FName DungeonSpawnAreaId;
// 0x0024 (size: 0x8)
FName DungeonLevelName;
// 0x002C (size: 0x8)
EPalDungeonInstanceBossState BossState;
// 0x0034 (size: 0x1)
FName EnemySpawnerDataBossRowName;
// 0x0038 (size: 0x8)
FGameDateTime DisappearTimeAt;
// 0x0040 (size: 0x8)
int32 ReservedDataLayerAssetIndex;
// 0x0048 (size: 0x4)
FPalStageInstanceId StageInstanceId;
// 0x004C (size: 0x14)
TArray<FPalMapObjectSaveData> MapObjectSaveData;
// 0x0060 (size: 0x10)
}; // Size: 0x70
struct FPalDungeonSpawnAreaData : public FTableRowBase

{
FName DungeonNameTextId;
// 0x0008 (size: 0x8)
FName PostfixTextId;
// 0x0010 (size: 0x8)
}; // Size: 0x18
struct FPalDynamicItemDataInfo
{
class UPalDynamicItemDataBase* ItemData;
// 0x0000 (size: 0x8)
}; // Size: 0x10
struct FPalDynamicItemDisposeReserveInfo
{
}; // Size: 0x20
struct FPalDynamicItemDisposeWaitNotifyInfo
{
TArray<FPalDynamicItemId> DynamicItemIds;
// 0x0000 (size: 0x10)
TArray<int32> WaitPlayerIds;
// 0x0010 (size: 0x10)
}; // Size: 0x20
struct FPalDynamicItemId
{
FGuid CreatedWorldId;
// 0x0000 (size: 0x10)
FGuid LocalIdInCreatedWorld;
// 0x0010 (size: 0x10)
}; // Size: 0x20
struct FPalDynamicItemIdArray
{
}; // Size: 0x10
struct FPalDynamicItemInfo
{
FPalItemSlotId SlotID;
// 0x0000 (size: 0x14)
class UPalDynamicItemDataBase* DynamicItemData;
// 0x0018 (size: 0x8)
}; // Size: 0x20
struct FPalDynamicItemSaveData : public FPalBinaryMemory

{
FPalDynamicItemId ID;
// 0x0010 (size: 0x20)
FName StaticItemId;
// 0x0030 (size: 0x8)
}; // Size: 0x38
struct FPalEachDamageRactionInfo
{
// 0x0000 (size: 0x8)
bool IsBlow;
// 0x0008 (size: 0x1)
bool IsLeanBackAnime;
// 0x0009 (size: 0x1)
bool IsStan;
// 0x000A (size: 0x1)
EPalWazaCategory WazaCategory;
// 0x000B (size: 0x1)
}; // Size: 0x10
struct FPalEditorItemActorClassTableRow : public FTableRowBase

{
FName ClassName;
// 0x0008 (size: 0x8)
TSoftClassPtr<AActor> actorClass;
// 0x0010 (size: 0x30)
}; // Size: 0x40
struct FPalEditorItemDynamicClassTableRow : public FTableRowBase

{
FName ClassName;
// 0x0008 (size: 0x8)
TSubclassOf<class UPalDynamicItemDataBase> DynamicClass;
// 0x0010 (size: 0x8)
}; // Size: 0x18
struct FPalEditorItemIconTableRow : public FTableRowBase

{
// 0x0008 (size: 0x30)
}; // Size: 0x38
struct FPalEditorItemStaticClassTableRow : public FTableRowBase

{
FName ClassName;
// 0x0008 (size: 0x8)
TSubclassOf<class UPalStaticItemDataBase> StaticClass;
// 0x0010 (size: 0x8)
}; // Size: 0x18
struct FPalEditorItemStaticMeshTableRow : public FTableRowBase

{
FName StaticMeshName;
// 0x0008 (size: 0x8)
TSoftObjectPtr<UStaticMesh> StaticMeshPath;
// 0x0010 (size: 0x30)
}; // Size: 0x40
struct FPalEggRankInfo
{
int32 PalRarity;
// 0x0000 (size: 0x4)
float EggScale;
// 0x0004 (size: 0x4)
float HatchingSpeedDivisionRate;
// 0x0008 (size: 0x4)
}; // Size: 0xC
struct FPalEnemyCampSaveData
{
TMap<class FName, class FPalEnemyCampStatus> EnemyCampStatusMap;
// 0x0000 (size: 0x50)
}; // Size: 0x50
struct FPalEnemyCampStatus
{
bool bIsSpawned;
// 0x0000 (size: 0x1)
bool bIsEnemyAllDead;
// 0x0001 (size: 0x1)
bool bIsClear;
// 0x0002 (size: 0x1)
bool bRewardReceived;
// 0x0003 (size: 0x1)
FName RewardPalId;
// 0x0004 (size: 0x8)
int32 RewardPalLevel;
// 0x000C (size: 0x4)
FDateTime ClearDate;
// 0x0010 (size: 0x8)
float ElapsedTime;
// 0x0018 (size: 0x4)
FDateTime LastCalcDate;
// 0x0020 (size: 0x8)
}; // Size: 0x28
struct FPalEquipWeaponInfo
{
// 0x0000 (size: 0x10)
class APalMonsterEquipWeaponBase* SpawnedWeapon;
// 0x0010 (size: 0x8)
}; // Size: 0x18
struct FPalExpDatabaseRaw : public FTableRowBase

{
int32 DropEXP;
// 0x0008 (size: 0x4)
int32 NextEXP;
// 0x000C (size: 0x4)
int32 PalNextEXP;
// 0x0010 (size: 0x4)
int32 TotalEXP;
// 0x0014 (size: 0x4)
int32 PalTotalEXP;
// 0x0018 (size: 0x4)
}; // Size: 0x20
struct FPalFarmCropGrowupProcessSet
{
EPalFarmCropState State;
// 0x0000 (size: 0x1)
FComponentReference TargetCompRef;
// 0x0008 (size: 0x28)
float ProcessRate;
// 0x0030 (size: 0x4)
}; // Size: 0x38
struct FPalFastBaseCampPassiveEffectRepInfoArray : public FFastArraySerializer

{
TArray<FPalBaseCampPassiveEffectRepInfo> Items;
// 0x0108 (size: 0x10)
}; // Size: 0x118
struct FPalFastGuildPlayerInfoRepInfoArray : public FFastArraySerializer

{
TArray<FPalGuildPlayerInfoRepInfo> Items;
// 0x0108 (size: 0x10)
}; // Size: 0x148
struct FPalFastMapObjectModelEffectRepInfoArray : public FFastArraySerializer

{
TArray<FPalMapObjectModelEffectRepInfo> Items;
// 0x0108 (size: 0x10)
}; // Size: 0x148
struct FPalFastMapObjectModuleRepInfoArray : public FFastArraySerializer

{
TArray<FPalMapObjectModuleRepInfo> Items;
// 0x0108 (size: 0x10)
}; // Size: 0x148
struct FPalFastStageModelRepInfoArray : public FFastArraySerializer

{
TArray<FPalStageModelRepInfo> Items;
// 0x0108 (size: 0x10)
}; // Size: 0x148
struct FPalFastWorkAssignRepInfoArray : public FFastArraySerializer

{
TArray<FPalWorkAssignRepInfo> Items;
// 0x0108 (size: 0x10)
}; // Size: 0x148
struct FPalFieldLotteryName : public FTableRowBase

{
float ItemSlot1_ProbabilityPercent;
// 0x0008 (size: 0x4)
// 0x000C (size: 0x4)
// 0x0010 (size: 0x4)
// 0x0014 (size: 0x4)
// 0x0018 (size: 0x4)
}; // Size: 0x20
struct FPalFoliageGridInstanceMap
{
TMap<class FPalFoliageInstanceId, class UPalFoliageInstance*> InstanceMap;
// 0x0000 (size: 0x50)
}; // Size: 0x50
struct FPalFoliageGridSaveData
{
TMap<class FName, class FPalFoliageSaveData> ModelMap;
// 0x0000 (size: 0x50)
}; // Size: 0x50
struct FPalFoliageInstallData
{
FVector Location;
// 0x0000 (size: 0x18)
FRotator Rotator;
// 0x0018 (size: 0x18)
FVector Scale3D;
// 0x0030 (size: 0x18)
}; // Size: 0x48
struct FPalFoliageInstallDataArray
{
TArray<FPalFoliageInstallData> InstallDataArray;
// 0x0000 (size: 0x10)
}; // Size: 0x10
struct FPalFoliageInstallDataSet
{
}; // Size: 0x50
struct FPalFoliageInstanceId
{
FGuid Guid;
// 0x0000 (size: 0x10)
}; // Size: 0x10
struct FPalFoliageInstanceInfo
{
}; // Size: 0x4
struct FPalFoliageInstanceRepInfo : public FFastArraySerializerItem
{
FName FoliageTypeId;
// 0x000C (size: 0x8)
FPalFoliageInstanceId InstanceId;
// 0x0014 (size: 0x10)
class UPalFoliageInstance* Instance;
// 0x0028 (size: 0x8)
}; // Size: 0x30
struct FPalFoliageInstanceRepInfoArray : public FFastArraySerializer

{
TArray<FPalFoliageInstanceRepInfo> Items;
// 0x0108 (size: 0x10)
}; // Size: 0x148
struct FPalFoliageInstanceSaveData : public FPalBinaryMemory

{
}; // Size: 0x10
struct FPalFoliageInstanceTransform
{
FVector Location;
// 0x0000 (size: 0x18)
FRotator Rotator;
// 0x0018 (size: 0x18)
float ScaleX;
// 0x0030 (size: 0x4)
}; // Size: 0x38
struct FPalFoliageMasterData : public FTableRowBase

{
FName ClassRefId;
// 0x0008 (size: 0x8)
}; // Size: 0x10
struct FPalFoliagePresetData
{
FPalDataTableRowName_MapObjectData FoliageMapObjectId;
// 0x0000 (size: 0x8)
int32 HP;
// 0x0008 (size: 0x4)
TArray<FPalMapObjectDropItemData> DamagedDropItems;
// 0x0010 (size: 0x10)
FPalDataTableRowName_ItemData DropItemId;
// 0x0020 (size: 0x8)
int32 DropItemNum;
// 0x0028 (size: 0x4)
int32 DropEXP;
// 0x002C (size: 0x4)
EPalMapObjectDestroyFXType DestroyFXType;
// 0x0030 (size: 0x1)
float DistanceFromPlayerNotRespawn;
// 0x0034 (size: 0x4)
int32 RespawnIntervalRealMinutes;
// 0x0038 (size: 0x4)
int32 RetryRespawnIntervalRealMinutes;
// 0x003C (size: 0x4)
}; // Size: 0x40
struct FPalFoliageSaveData : public FPalBinaryMemory

{
TMap<class FPalFoliageInstanceId, class FPalFoliageInstanceSaveData>
InstanceDataMap; // 0x0010 (size: 0x50)
}; // Size: 0x60
struct FPalFoliageTypeReference : public FTableRowBase

{
TSoftObjectPtr<UFoliageType> FoliageType;
// 0x0008 (size: 0x30)
FPalDataTableRowName_MapObjectData FoliageMapObjectId;
// 0x0038 (size: 0x8)
int32 HP;
// 0x0040 (size: 0x4)
FPalDataTableRowName_ItemData DropItemId;
// 0x0044 (size: 0x8)
int32 DropItemNum;
// 0x004C (size: 0x4)
// 0x0050 (size: 0x1)
}; // Size: 0x58
struct FPalFunnelCharacterManagementInfo
{
FPalInstanceID OwnerCharacterId;
// 0x0000 (size: 0x30)
class APalFunnelCharacter* FunnelCharacter;
// 0x0030 (size: 0x8)
}; // Size: 0x38
struct FPalFunnelSkillModuleCollectItemSearchInfo
{
FVector Location;
// 0x0000 (size: 0x18)
float Distance;
// 0x0018 (size: 0x4)
float ElapsedTime;
// 0x001C (size: 0x4)
}; // Size: 0x28
struct FPalGameProgressPresetDataTableRow : public FTableRowBase

{
int32 Level;
// 0x0008 (size: 0x4)
int32 HPLevel;
// 0x000C (size: 0x4)
int32 SPLevel;
// 0x0010 (size: 0x4)
int32 AttackLevel;
// 0x0014 (size: 0x4)
int32 WorkLevel;
// 0x0018 (size: 0x4)
int32 WeightLevel;
// 0x001C (size: 0x4)
int32 CaptureLevel;
// 0x0020 (size: 0x4)
TArray<FPalDebugOtomoPalInfo> OtomoPals;
// 0x0028 (size: 0x10)
TArray<FPalDebugOtomoPalInfo> CapturedPals;
// 0x0038 (size: 0x10)
TArray<FPalDebugItemCreateInfo> LoadoutItems;
// 0x0048 (size: 0x10)
TArray<FPalDebugItemCreateInfo> Items;
// 0x0058 (size: 0x10)
}; // Size: 0x68
struct FPalGameSystemInitSequenceSet
{
TArray<class UPalGameSystemInitSequenceBase*> InitSequences;
// 0x0000 (size: 0x10)
}; // Size: 0x10
struct FPalGameTimeSaveData
{
int64 GameDateTimeTicks;
// 0x0000 (size: 0x8)
int64 RealDateTimeTicks;
// 0x0008 (size: 0x8)
}; // Size: 0x10
struct FPalGaugeInterpolationCalculator
{
float CurrentValue;
// 0x0000 (size: 0x4)
float TargetValue;
// 0x0004 (size: 0x4)
bool bDirectionPositive;
// 0x0008 (size: 0x1)
}; // Size: 0xC
struct FPalGliderPalInfo
{
// 0x0000 (size: 0x8)
TArray<TSoftClassPtr<APalGliderObject>> GliderPalArray;
// 0x0008 (size: 0x10)
}; // Size: 0x18
struct FPalGotStatusPoint
{
FName StatusName;
// 0x0000 (size: 0x8)
int32 StatusPoint;
// 0x0008 (size: 0x4)
}; // Size: 0xC
struct FPalGroupCreateParameter
{
EPalGroupType Type;
// 0x0000 (size: 0x1)
EPalOrganizationType OrganizationType;
// 0x0001 (size: 0x1)
FString GroupName;
// 0x0008 (size: 0x10)
FGuid AdminPlayerUId;
// 0x0018 (size: 0x10)
}; // Size: 0x28
struct FPalGroupSaveData : public FPalBinaryMemory

{
EPalGroupType GroupType;
// 0x0010 (size: 0x1)
}; // Size: 0x18
struct FPalGroupUpdateInfo
{
FGuid EnterGroupId;
// 0x0000 (size: 0x10)
FGuid ExitGroupId;
// 0x0010 (size: 0x10)
TArray<FGuid> PlayerUIds;
// 0x0020 (size: 0x10)
TArray<FPalInstanceID> CharacterIndividualIds;
// 0x0030 (size: 0x10)
TArray<FGuid> MapObjectInstanceIds_BaseCampPoint;
// 0x0040 (size: 0x10)
TArray<FGuid> BaseCampIds;
// 0x0050 (size: 0x10)
}; // Size: 0x60
struct FPalGuildPalStorageInfo
{
}; // Size: 0x38
struct FPalGuildPlayerInfo
{
EPalGuildPlayerStatus Status;
// 0x0000 (size: 0x1)
FDateTime LastOnlineRealTime;
// 0x0008 (size: 0x8)
FString PlayerName;
// 0x0010 (size: 0x10)
}; // Size: 0x20
struct FPalGuildPlayerInfoRepInfo : public FFastArraySerializerItem

{
FGuid PlayerUId;
// 0x000C (size: 0x10)
FPalGuildPlayerInfo PlayerInfo;
// 0x0020 (size: 0x20)
}; // Size: 0x40
struct FPalHeatSourceInfo
{
int32 HeatLevel_DayTime;
// 0x0000 (size: 0x4)
int32 HeatLevel_NightTime;
// 0x0004 (size: 0x4)
}; // Size: 0x8
struct FPalHitCollisionSetupParameter
{
}; // Size: 0x20
struct FPalIncidentBroadcastParameter
{
EPalInvaderType InvaderType;
// 0x0000 (size: 0x1)
class UPalBaseCampModel* TargetBaseCamp;
// 0x0008 (size: 0x8)
FPalInvaderDatabaseRow ChosenInvaderData;
// 0x0010 (size: 0x70)
FGuid GroupGuid;
// 0x0080 (size: 0x10)
}; // Size: 0x90
struct FPalIncidentExecutionSettings
{
bool bCanExecuteMultiple;
// 0x0000 (size: 0x1)
}; // Size: 0x1
struct FPalIncidentIdParameter
{
FName IncidentId;
// 0x0000 (size: 0x8)
FName IncidentType;
// 0x0008 (size: 0x8)
FName Option;
// 0x0010 (size: 0x8)
TArray<FName> Args;
// 0x0018 (size: 0x10)
TArray<FName> Options;
// 0x0028 (size: 0x10)
}; // Size: 0x38
struct FPalIncidentInitializeParameter
{
}; // Size: 0x38
struct FPalIncidentNotifyParameter
{
FName IncidentId;
// 0x0000 (size: 0x8)
FName IncidentType;
// 0x0008 (size: 0x8)
class UObject* OccuredObject;
// 0x0010 (size: 0x8)
class UObject* OwnerObject;
// 0x0018 (size: 0x8)
class UPalIncidentBase* IncidentObject;
// 0x0020 (size: 0x8)
}; // Size: 0x28
struct FPalIncidentParameterDataTableRow : public FTableRowBase

{
FName Option;
// 0x0008 (size: 0x8)
}; // Size: 0x10
struct FPalIncidentSystemFunctionAccessor
{
}; // Size: 0xC0
struct FPalIndividualCharacterCacheParameter
{
FGuid GroupID;
// 0x0000 (size: 0x10)
bool bSleeping;
// 0x0010 (size: 0x1)
FGuid InvaderTargetBaseCampId;
// 0x0018 (size: 0x10)
// 0x0028 (size: 0x1)
}; // Size: 0x2C
struct FPalIndividualCharacterEquipItemContainerHandler
{
}; // Size: 0x8
struct FPalIndividualCharacterSaveParameter
{
FName CharacterID;
// 0x0000 (size: 0x8)
FName UniqueNPCID;
// 0x0008 (size: 0x8)
EPalGenderType Gender;
// 0x0010 (size: 0x1)
TSubclassOf<class APalCharacter> CharacterClass;
// 0x0018 (size: 0x8)
int32 Level;
// 0x0020 (size: 0x4)
int32 Rank;
// 0x0024 (size: 0x4)
int32 Rank_HP;
// 0x0028 (size: 0x4)
int32 Rank_Attack;
// 0x002C (size: 0x4)
int32 Rank_Defence;
// 0x0030 (size: 0x4)
int32 Rank_CraftSpeed;
// 0x0034 (size: 0x4)
int32 Exp;
// 0x0038 (size: 0x4)
FString NickName;
// 0x0040 (size: 0x10)
bool IsRarePal;
// 0x0050 (size: 0x1)
TArray<EPalWazaID> EquipWaza;
// 0x0058 (size: 0x10)
TArray<EPalWazaID> MasteredWaza;
// 0x0068 (size: 0x10)
FFixedPoint64 HP;
// 0x0078 (size: 0x8)
int32 Talent_HP;
// 0x0080 (size: 0x4)
int32 Talent_Melee;
// 0x0084 (size: 0x4)
int32 Talent_Shot;
// 0x0088 (size: 0x4)
int32 Talent_Defense;
// 0x008C (size: 0x4)
float FullStomach;
// 0x0090 (size: 0x4)
EPalStatusPhysicalHealthType PhysicalHealth;
// 0x0094 (size: 0x1)
EPalBaseCampWorkerSickType WorkerSick;
// 0x0095 (size: 0x1)
TArray<FName> PassiveSkillList;
// 0x0098 (size: 0x10)
int32 DyingTimer;
// 0x00A8 (size: 0x4)
FFixedPoint64 MP;
// 0x00B0 (size: 0x8)
bool IsPlayer;
// 0x00B8 (size: 0x1)
FDateTime OwnedTime;
// 0x00C0 (size: 0x8)
FGuid OwnerPlayerUId;
// 0x00C8 (size: 0x10)
TArray<FGuid> OldOwnerPlayerUIds;
// 0x00D8 (size: 0x10)
FFixedPoint64 MaxHP;
// 0x00E8 (size: 0x8)
int32 Support;
// 0x00F0 (size: 0x4)
int32 CraftSpeed;
// 0x00F4 (size: 0x4)
TArray<FPalWorkSuitabilityInfo> CraftSpeeds;
// 0x00F8 (size: 0x10)
FFixedPoint64 ShieldHP;
// 0x0108 (size: 0x8)
FFixedPoint64 ShieldMaxHP;
// 0x0110 (size: 0x8)
FFixedPoint64 MaxMP;
// 0x0118 (size: 0x8)
FFixedPoint64 MaxSP;
// 0x0120 (size: 0x8)
EPalStatusHungerType HungerType;
// 0x0128 (size: 0x1)
float SanityValue;
// 0x012C (size: 0x4)
EPalBaseCampWorkerEventType BaseCampWorkerEventType;
// 0x0130 (size: 0x1)
float BaseCampWorkerEventProgressTime;
// 0x0134 (size: 0x4)
FPalContainerId ItemContainerId;
// 0x0138 (size: 0x10)
FPalContainerId EquipItemContainerId;
// 0x0148 (size: 0x10)
// 0x0158 (size: 0x14)
float MaxFullStomach;
// 0x016C (size: 0x4)
float FullStomachDecreaseRate_Tribe;
// 0x0170 (size: 0x4)
int32 UnusedStatusPoint;
// 0x0174 (size: 0x4)
TArray<FPalGotStatusPoint> GotStatusPointList;
// 0x0178 (size: 0x10)
FFloatContainer DecreaseFullStomachRates;
// 0x0188 (size: 0x10)
FFloatContainer AffectSanityRates;
// 0x0198 (size: 0x10)
FFloatContainer CraftSpeedRates;
// 0x01A8 (size: 0x10)
FVector LastJumpedLocation;
// 0x01B8 (size: 0x18)
FName FoodWithStatusEffect;
// 0x01D0 (size: 0x8)
int32 Tiemr_FoodWithStatusEffect;
// 0x01D8 (size: 0x4)
EPalWorkSuitability CurrentWorkSuitability;
// 0x01DC (size: 0x1)
bool bAppliedDeathPenarty;
// 0x01DD (size: 0x1)
float PalReviveTimer;
// 0x01E0 (size: 0x4)
int32 VoiceID;
// 0x01E4 (size: 0x4)
FPalIndividualCharacterCacheParameter Dynamic;
// 0x01E8 (size: 0x2C)
}; // Size: 0x218
struct FPalIndividualCharacterSaveParameterSaveData : public FPalBinaryMemory

{
}; // Size: 0x10
struct FPalIndividualCharacterSlotResultInfo
{
}; // Size: 0x20
struct FPalIndividualCharacterSlotUpdateInfo
{
}; // Size: 0x68
struct FPalInsideBaseCampUI_DisplayItemInfo
{
bool isShowWhenNothingItem;
// 0x0000 (size: 0x1)
}; // Size: 0x1
struct FPalInstanceID
{
FGuid PlayerUId;
// 0x0000 (size: 0x10)
FGuid InstanceId;
// 0x0010 (size: 0x10)
FString DebugName;
// 0x0020 (size: 0x10)
}; // Size: 0x30
struct FPalInteractiveObjectActionBy
{
class AActor* InteractingActor;
// 0x0000 (size: 0x8)
int32 InteractId;
// 0x0008 (size: 0x4)
}; // Size: 0x10
struct FPalInteractiveObjectActionInfoData
{
EPalInteractiveObjectIndicatorType IndicatorType;
// 0x0000 (size: 0x1)
EPalInteractiveObjectButtonType buttonType;
// 0x0001 (size: 0x1)
float longPushTime;
// 0x0004 (size: 0x4)
bool bValid;
// 0x0008 (size: 0x1)
bool bLockRiding;
// 0x0009 (size: 0x1)
bool isInputComsume;
// 0x000A (size: 0x1)
}; // Size: 0xC
struct FPalInteractiveObjectActionInfoSet
{
FPalInteractiveObjectActionInfoData Interact1_Indicator;
// 0x0000 (size: 0xC)
// 0x000C (size: 0xC)
// 0x0018 (size: 0xC)
// 0x0024 (size: 0xC)
}; // Size: 0x30
struct FPalInvaderDatabaseRow : public FTableRowBase
{
FName GroupName;
// 0x0008 (size: 0x8)
EPalBiomeType BiomeID;
// 0x0010 (size: 0x1)
int32 InvadeGradeMin;
// 0x0014 (size: 0x4)
int32 InvadeGradeMax;
// 0x0018 (size: 0x4)
float Weight;
// 0x001C (size: 0x4)
FName CharactorID_A;
// 0x0020 (size: 0x8)
int32 LevelMin_A;
// 0x0028 (size: 0x4)
int32 LevelMax_A;
// 0x002C (size: 0x4)
int32 Number_A;
// 0x0030 (size: 0x4)
FName CharactorID_B;
// 0x0034 (size: 0x8)
int32 LevelMin_B;
// 0x003C (size: 0x4)
int32 LevelMax_B;
// 0x0040 (size: 0x4)
int32 Number_B;
// 0x0044 (size: 0x4)
FName CharactorID_C;
// 0x0048 (size: 0x8)
int32 LevelMin_C;
// 0x0050 (size: 0x4)
int32 LevelMax_C;
// 0x0054 (size: 0x4)
int32 Number_C;
// 0x0058 (size: 0x4)
FName CharactorID_D;
// 0x005C (size: 0x8)
int32 LevelMin_D;
// 0x0064 (size: 0x4)
int32 LevelMax_D;
// 0x0068 (size: 0x4)
int32 Number_D;
// 0x006C (size: 0x4)
}; // Size: 0x70
struct FPalInvaderSpawnCharacterParameter
{
FName CharacterID;
// 0x0000 (size: 0x8)
int32 Level;
// 0x0008 (size: 0x4)
}; // Size: 0xC
struct FPalInvaderStartPointInfo
{
FVector Location;
// 0x0000 (size: 0x18)
EPalBiomeType BiomeType;
// 0x0018 (size: 0x1)
}; // Size: 0x20
struct FPalItemAndNum
{
FPalItemId ItemId;
// 0x0000 (size: 0x28)
int32 Num;
// 0x0028 (size: 0x4)
}; // Size: 0x2C
struct FPalItemAndSlot
{
FPalItemId ItemId;
// 0x0000 (size: 0x28)
int32 Num;
// 0x0028 (size: 0x4)
// 0x002C (size: 0x14)
}; // Size: 0x40
struct FPalItemAndSlotUpdateContentSet
{
TArray<FPalItemAndSlot> UpdateContents;
// 0x0000 (size: 0x10)
TArray<FPalStaticItemIdAndDynamicItemDataSet> UpdateDynamicItems;
// 0x0010 (size: 0x10)
}; // Size: 0x20
struct FPalItemContainerBelongInfo : public FPalContainerBelongInfo

{
FGuid GroupID;
// 0x0008 (size: 0x10)
}; // Size: 0x18
struct FPalItemContainerCreateParameter
{
int32 SlotNum;
// 0x0000 (size: 0x4)
FPalItemPermission Permission;
// 0x0008 (size: 0x30)
FPalItemContainerBelongInfo BelongInfo;
// 0x0038 (size: 0x18)
TArray<FPalItemAndNum> InitialItems;
// 0x0050 (size: 0x10)
}; // Size: 0x60
struct FPalItemContainerInfo : public FPalContainerInfo

{
// 0x0020 (size: 0x18)
// 0x0038 (size: 0x30)
}; // Size: 0x68
struct FPalItemContainerSaveData : public FPalBinaryMemory

{
// 0x0010 (size: 0x18)
TArray<FPalItemSlotSaveData> Slots;
// 0x0028 (size: 0x10)
}; // Size: 0x38
struct FPalItemCreateParameter
{
FPalPassiveSkillAssignInfo PassiveSkillAssignInfo;
// 0x0000 (size: 0x18)
FName CharacterID;
// 0x0018 (size: 0x8)
}; // Size: 0x20
struct FPalItemData
{
class UPalStaticItemDataBase* StaticData;
// 0x0000 (size: 0x8)
class UPalDynamicItemDataBase* DynamicData;
// 0x0008 (size: 0x8)
}; // Size: 0x10
struct FPalItemFlowInSplineInfo
{
class AActor* ItemActor;
// 0x0000 (size: 0x8)
float ProgressTime;
// 0x0008 (size: 0x4)
}; // Size: 0x10
struct FPalItemId
{
FName StaticId;
// 0x0000 (size: 0x8)
FPalDynamicItemId DynamicId;
// 0x0008 (size: 0x20)
}; // Size: 0x28
struct FPalItemLotteryData : public FTableRowBase

{
FName FieldName;
// 0x0008 (size: 0x8)
int32 SlotNo;
// 0x0010 (size: 0x4)
float WeightInSlot;
// 0x0014 (size: 0x4)
FName StaticItemId;
// 0x0018 (size: 0x8)
int32 MinNum;
// 0x0020 (size: 0x4)
int32 MaxNum;
// 0x0024 (size: 0x4)
int32 NumUnit;
// 0x0028 (size: 0x4)
EPalMapObjectTreasureGradeType TreasureBoxGrade;
// 0x002C (size: 0x1)
}; // Size: 0x30
struct FPalItemOperationInfo_Move
{
FPalInstanceID ExecutorIndividualId;
// 0x0000 (size: 0x30)
TArray<FPalItemId> ItemIds;
// 0x0030 (size: 0x10)
TArray<FPalItemSlotId> FromSlotIds;
// 0x0040 (size: 0x10)
FPalContainerId ToContainerId;
// 0x0050 (size: 0x10)
TArray<FPalItemSlotId> ToSlotIds;
// 0x0060 (size: 0x10)
}; // Size: 0x70
struct FPalItemOperationOptions
{
}; // Size: 0x1
struct FPalItemPalEggDataHandle
{
TArray<FPalDataTableRowName_ItemData> ItemRowNameArray;
// 0x0000 (size: 0x10)
}; // Size: 0x10
struct FPalItemPermission
{
TArray<EPalItemTypeA> PermissionTypeA;
// 0x0000 (size: 0x10)
TArray<EPalItemTypeB> PermissionTypeB;
// 0x0010 (size: 0x10)
TArray<FName> PermissionItemStaticIds;
// 0x0020 (size: 0x10)
}; // Size: 0x30
struct FPalItemRecipe : public FTableRowBase

{
FName Product_Id;
// 0x0008 (size: 0x8)
int32 Product_Count;
// 0x0010 (size: 0x4)
float WorkAmount;
// 0x0014 (size: 0x4)
int32 WorkableAttribute;
// 0x0018 (size: 0x4)
FName UnlockItemID;
// 0x001C (size: 0x8)
FName Material1_Id;
// 0x0024 (size: 0x8)
// 0x002C (size: 0x4)
FName Material2_Id;
// 0x0030 (size: 0x8)
// 0x0038 (size: 0x4)
FName Material3_Id;
// 0x003C (size: 0x8)
// 0x0044 (size: 0x4)
FName Material4_Id;
// 0x0048 (size: 0x8)
// 0x0050 (size: 0x4)
FName Material5_Id;
// 0x0054 (size: 0x8)
// 0x005C (size: 0x4)
EPalEnergyType EnergyType;
// 0x0060 (size: 0x1)
int32 EnergyAmount;
// 0x0064 (size: 0x4)
int32 Editor_RowNameHash;
// 0x0068 (size: 0x4)
}; // Size: 0x70
struct FPalItemRecipeMaterialInfo
{
FName MaterialID;
// 0x0000 (size: 0x8)
int32 MaterialCount;
// 0x0008 (size: 0x4)
}; // Size: 0xC
struct FPalItemShopCreateDataRow : public FTableRowBase

{
TArray<FPalItemShopCreateDataStruct> productDataArray;
// 0x0008 (size: 0x10)
}; // Size: 0x18
struct FPalItemShopCreateDataStruct
{
FName StaticItemId;
// 0x0000 (size: 0x8)
float BuyRate;
// 0x0008 (size: 0x4)
float SellRate;
// 0x000C (size: 0x4)
int32 Stock;
// 0x0010 (size: 0x4)
}; // Size: 0x14
struct FPalItemShopCreateIntermediateDataRow : public FTableRowBase

{
FName GroupName;
// 0x0008 (size: 0x8)
FName StaticItemId;
// 0x0010 (size: 0x8)
float BuyRate;
// 0x0018 (size: 0x4)
float SellRate;
// 0x001C (size: 0x4)
int32 Stock;
// 0x0020 (size: 0x4)
}; // Size: 0x28
struct FPalItemShopLotteryDataRow : public FTableRowBase

{
TArray<FPalItemShopLotteryDataStruct> lotteryDataArray;
// 0x0008 (size: 0x10)
}; // Size: 0x18
struct FPalItemShopLotteryDataStruct
{
FName ShopGroupName;
// 0x0000 (size: 0x8)
int32 Weight;
// 0x0008 (size: 0x4)
}; // Size: 0xC
struct FPalItemShopLotteryIntermediateDataRow : public FTableRowBase

{
FName GroupName;
// 0x0008 (size: 0x8)
FName ShopGroupName;
// 0x0010 (size: 0x8)
int32 Weight;
// 0x0018 (size: 0x4)
}; // Size: 0x20
struct FPalItemSlotId
{
// 0x0000 (size: 0x10)
int32 SlotIndex;
// 0x0010 (size: 0x4)
}; // Size: 0x14
struct FPalItemSlotIdAndNum
{
// 0x0000 (size: 0x14)
int32 Num;
// 0x0014 (size: 0x4)
}; // Size: 0x18
struct FPalItemSlotSaveData : public FPalBinaryMemory

{
int32 SlotIndex;
// 0x0010 (size: 0x4)
FPalItemId ItemId;
// 0x0014 (size: 0x28)
int32 StackCount;
// 0x003C (size: 0x4)
}; // Size: 0x40
struct FPalKeyAction
{
FName ActionName;
// 0x0000 (size: 0x8)
EPalKeyConfigAxisFilterType FilterType;
// 0x0008 (size: 0x1)
}; // Size: 0xC
struct FPalKeyConfigKeys
{
FKey MainKey;
// 0x0000 (size: 0x18)
FKey SecondaryKey;
// 0x0018 (size: 0x18)
}; // Size: 0x30
struct FPalKeyConfigSettings
{
TMap<class FName, class FPalKeyConfigKeys> MouseAndKeyboardActionMappings;
// 0x0000 (size: 0x50)
TArray<FPalAxisKeyConfigKeys> MouseAndKeyboardAxisMappings;
// 0x0050 (size: 0x10)
TMap<class FName, class FPalKeyConfigKeys> GamePadActionMappings;
// 0x0060 (size: 0x50)
TArray<FPalAxisKeyConfigKeys> GamePadAxisMappings;
// 0x00B0 (size: 0x10)
}; // Size: 0xC0
struct FPalLoadoutSynchronalizedData
{
// 0x0000 (size: 0x30)
FPalItemId ItemId;
// 0x0030 (size: 0x28)
}; // Size: 0x58
struct FPalLocalSaveData
{
TMap<EPalTribeID, int32> Local_ActivateOtomoCount;
// 0x0000 (size: 0x50)
TMap<class EPalTribeID, class bool> Local_PalEncountFlag;
// 0x0050 (size: 0x50)
TMap<class FName, class bool> Local_NoteCheckedFlag;
// 0x00A0 (size: 0x50)
TMap<EPalPlayerInventoryType, int32> Local_LoadoutSelectedIndexMap;
// 0x00F0 (size: 0x50)
TMap<FName, int32> Local_NewUnlockedBuilds;
// 0x0140 (size: 0x50)
bool Local_IsBuildMenuChecked;
// 0x0190 (size: 0x1)
TMap<FName, int32> Local_NPCTalkCountMap;
// 0x0198 (size: 0x50)
TMap<class FName, class bool> Local_NewUnlockedTechs;
// 0x01E8 (size: 0x50)
TMap<class FName, class bool> Local_ShowedCutsceneFlag;
// 0x0238 (size: 0x50)
int32 Local_PlayTime;
// 0x0288 (size: 0x4)
TArray<uint8> worldMapMaskTexture;
// 0x0290 (size: 0x10)
TArray<FPalCustomMarkerSaveData> Local_CustomMarkerSaveData;
// 0x02A0 (size: 0x10)
TArray<FPalTutorialTriggerSaveData> Local_TutorialTriggerSaveData;
// 0x02B0 (size: 0x10)
TArray<FPalCompletedQuestSaveData> Local_CompletedTutorialQuestSaveData;
// 0x02C0 (size: 0x10)
TArray<FPalOrderedQuestSaveData> Local_OrderedTutorialQuestSaveData;
// 0x02D0 (size: 0x10)
}; // Size: 0x2E0
struct FPalLocalizedTextData : public FTableRowBase

{
FText TextData;
// 0x0008 (size: 0x18)
}; // Size: 0x20
struct FPalLocationRepInfo : public FFastArraySerializerItem

{
FGuid ID;
// 0x000C (size: 0x10)
class UPalLocationBase* Location;
// 0x0020 (size: 0x8)
}; // Size: 0x28
struct FPalLocationUIData
{
// 0x0000 (size: 0x30)
TSubclassOf<class UPalUICompassIconBase> compassIconWidget;
// 0x0030 (size: 0x8)
float displayLength;
// 0x0038 (size: 0x4)
}; // Size: 0x40
struct FPalLocationUIData_TableRow : public FTableRowBase

{
TMap<class EPalLocationType, class FPalLocationUIData> locationUIDataMap;
// 0x0008 (size: 0x50)
TMap<class FName, class TSoftObjectPtr<UTexture2D>> mapObjectIconMap;
// 0x0058 (size: 0x50)
}; // Size: 0xA8
struct FPalLogAdditionalData
{
TArray<TSoftObjectPtr<UTexture2D>> softTextures;
// 0x0000 (size: 0x10)
EPalLogContentToneType logToneType;
// 0x0010 (size: 0x1)
FName DefaultFontStyleName;
// 0x0014 (size: 0x8)
TSubclassOf<class UPalLogWidgetBase> overrideWidgetClass;
// 0x0020 (size: 0x8)
FPalStaticItemIdAndNum ItemIDAndNum;
// 0x0028 (size: 0xC)
}; // Size: 0x38
struct FPalLogDataSet
{
FText Text;
// 0x0000 (size: 0x18)
FPalLogAdditionalData AdditionalData;
// 0x0018 (size: 0x38)
}; // Size: 0x50
struct FPalLogInfo_DropPal
{
FString NickName;
// 0x0000 (size: 0x10)
FName CharacterID;
// 0x0010 (size: 0x8)
}; // Size: 0x18
struct FPalLogInfo_Skill
{
FText SkillName;
// 0x0000 (size: 0x18)
FText CharacterName;
// 0x0018 (size: 0x18)
FText Value;
// 0x0030 (size: 0x18)
}; // Size: 0x48
struct FPalLoggedinPlayerSaveDataRecordData
{
TMap<class FName, class bool> TowerBossDefeatFlag;
// 0x0000 (size: 0x50)
TMap<class FName, class bool> NormalBossDefeatFlag;
// 0x0050 (size: 0x50)
int32 BossDefeatCount;
// 0x00A0 (size: 0x4)
int32 TribeCaptureCount;
// 0x00A4 (size: 0x4)
TMap<FName, int32> PalCaptureCount;
// 0x00A8 (size: 0x50)
TMap<class FName, class bool> PaldeckUnlockFlag;
// 0x00F8 (size: 0x50)
int32 PalCaptureCountBonusCount_Tier1;
// 0x0148 (size: 0x4)
// 0x014C (size: 0x4)
// 0x0150 (size: 0x4)
TMap<class FName, class bool> RelicObtainForInstanceFlag;
// 0x0158 (size: 0x50)
int32 RelicPossessNum;
// 0x01A8 (size: 0x4)
TMap<class FName, class bool> NoteObtainForInstanceFlag;
// 0x01B0 (size: 0x50)
TMap<FName, int32> NPCTalkIdCount;
// 0x0200 (size: 0x50)
TMap<class FName, class bool> FastTravelPointUnlockFlag;
// 0x0250 (size: 0x50)
TArray<FGuid> BuildingObjectMapObjectInstanceIds;
// 0x02A0 (size: 0x10)
}; // Size: 0x2B0
struct FPalMakeDamageInfo
{
// 0x0000 (size: 0x8)
class AActor* Defender;
// 0x0008 (size: 0x8)
class USceneComponent* HitComponent;
// 0x0010 (size: 0x8)
int32 Power;
// 0x0018 (size: 0x4)
// 0x001C (size: 0x1)
EPalElementType Element;
// 0x001D (size: 0x1)
EPalAttackType AttackType;
// 0x001E (size: 0x1)
EPalWeaponType WeaponType;
// 0x001F (size: 0x1)
// 0x0020 (size: 0x18)
bool IsLeanBack;
// 0x0038 (size: 0x1)
bool IsBlow;
// 0x0039 (size: 0x1)
// 0x0040 (size: 0x18)
FHitResult HitInfo;
// 0x0058 (size: 0xE8)
// 0x0140 (size: 0x1)
int32 EffectValue1;
// 0x0144 (size: 0x4)
// 0x0148 (size: 0x4)
// 0x014C (size: 0x1)
int32 EffectValue2;
// 0x0150 (size: 0x4)
// 0x0154 (size: 0x4)
TArray<int32> HitFoliageIndex;
// 0x0158 (size: 0x10)
// 0x0168 (size: 0x4)
float DamageRatePerCollision;
// 0x016C (size: 0x4)
// 0x0170 (size: 0x10)
// 0x0180 (size: 0x1)
bool bAttackableToFriend;
// 0x0181 (size: 0x1)
bool NoDamage;
// 0x0182 (size: 0x1)
bool IgnoreShield;
// 0x0183 (size: 0x1)
bool UIDamageTextOverride_DoubleRegist;
// 0x0184 (size: 0x1)
// 0x0185 (size: 0x1)
// 0x0186 (size: 0x1)
class AActor* OverrideNetworkOwner;
// 0x0188 (size: 0x8)
}; // Size: 0x190
struct FPalMapObjectAppearanceData
{
FGameDateTime DateTime;
// 0x0000 (size: 0x8)
}; // Size: 0x8
struct FPalMapObjectAppearanceDataWithId
{
FGuid InstanceId;
// 0x0000 (size: 0x10)
FPalMapObjectAppearanceData AppearanceData;
// 0x0010 (size: 0x8)
}; // Size: 0x18
struct FPalMapObjectAssignData : public FTableRowBase

{
EPalGenusCategoryType GenusCategory;
// 0x0008 (size: 0x1)
EPalElementType ElementType;
// 0x0009 (size: 0x1)
EPalWorkSuitability WorkSuitability;
// 0x000A (size: 0x1)
int32 WorkSuitabilityRank;
// 0x000C (size: 0x4)
bool bPlayerWorkable;
// 0x0010 (size: 0x1)
EPalWorkType WorkType;
// 0x0011 (size: 0x1)
EPalActionType WorkActionType;
// 0x0012 (size: 0x1)
int32 WorkerMaxNum;
// 0x0014 (size: 0x4)
float AffectSanityValue;
// 0x0018 (size: 0x4)
}; // Size: 0x20
struct FPalMapObjectBelongInfo : public FPalBelongInfo

{
FGuid GroupID;
// 0x0008 (size: 0x10)
}; // Size: 0x18
struct FPalMapObjectBuildProcessSaveData : public FPalBinaryMemory

{
}; // Size: 0x10
struct FPalMapObjectConcreteModelCreateParameter
{
}; // Size: 0xA0
struct FPalMapObjectConcreteModelModuleSaveData : public FPalBinaryMemory

{
}; // Size: 0x10
struct FPalMapObjectConcreteModelSaveData : public FPalBinaryMemory

{
TMap<class EPalMapObjectConcreteModelModuleType, class
FPalMapObjectConcreteModelModuleSaveData> ModuleMap; // 0x0010 (size: 0x50)
}; // Size: 0x60
struct FPalMapObjectConnectorSaveData : public FPalBinaryMemory

{
}; // Size: 0x10
struct FPalMapObjectCreateParameter
{
}; // Size: 0x80
struct FPalMapObjectDisposeOptions
{
}; // Size: 0x10
struct FPalMapObjectDisposeReserveInfo
{
}; // Size: 0x20
struct FPalMapObjectDropItemData
{
FPalDataTableRowName_ItemData StaticItemId;
// 0x0000 (size: 0x8)
int32 Num;
// 0x0008 (size: 0x4)
}; // Size: 0xC
struct FPalMapObjectEffectSaveData : public FPalBinaryMemory

{
}; // Size: 0x10
struct FPalMapObjectFarmCropData : public FTableRowBase

{
FName CropBlueprintClassName;
// 0x0008 (size: 0x8)
TSoftClassPtr<APalMapObjectFarmCrop> CropClassPath;
// 0x0010 (size: 0x30)
FName CropItemId;
// 0x0040 (size: 0x8)
float GrowupTime;
// 0x0048 (size: 0x4)
int32 CropItemNum;
// 0x004C (size: 0x4)
float SeedingWorkAmount;
// 0x0050 (size: 0x4)
float WateringWorkAmount;
// 0x0054 (size: 0x4)
float HarvestWorkAmount;
// 0x0058 (size: 0x4)
FName MaterialItem1_Id;
// 0x005C (size: 0x8)
int32 MaterialItem1_Num;
// 0x0064 (size: 0x4)
FName MaterialItem2_Id;
// 0x0068 (size: 0x8)
int32 MaterialItem2_Num;
// 0x0070 (size: 0x4)
// 0x0074 (size: 0x4)
}; // Size: 0x78
struct FPalMapObjectFoliageDropItemData
{
// 0x0000 (size: 0x8)
int32 Num;
// 0x0008 (size: 0x4)
}; // Size: 0xC
struct FPalMapObjectFoliageInstallData : public FTableRowBase

{
FName FoliageTypeName;
// 0x0008 (size: 0x8)
FVector Location;
// 0x0010 (size: 0x18)
FRotator Rotator;
// 0x0028 (size: 0x18)
FVector Scale3D;
// 0x0040 (size: 0x18)
}; // Size: 0x58
struct FPalMapObjectFoliageInstanceAccessID
{
FName ModelId;
// 0x0000 (size: 0x8)
FPalFoliageInstanceId InstanceId;
// 0x0008 (size: 0x10)
}; // Size: 0x18
struct FPalMapObjectItemContainerCreateContainerParameter
{
}; // Size: 0x68
struct FPalMapObjectItemContainerModuleSlotIndexes
{
EPalMapObjectItemContainerSlotAttribute Attribute;
// 0x0000 (size: 0x1)
TArray<int32> Indexes;
// 0x0008 (size: 0x10)
}; // Size: 0x18
struct FPalMapObjectItemProductData : public FTableRowBase

{
FName Product_Id;
// 0x0008 (size: 0x8)
float RequiredWorkAmount;
// 0x0010 (size: 0x4)
float AutoWorkAmountBySec;
// 0x0014 (size: 0x4)
}; // Size: 0x18
struct FPalMapObjectManageAsyncTickFunction : public FTickFunction

{
}; // Size: 0x30
struct FPalMapObjectMasterData : public FTableRowBase

{
FName OverrideNameMsgID;
// 0x0008 (size: 0x8)
FName BlueprintClassName;
// 0x0010 (size: 0x8)
TSoftClassPtr<APalMapObject> BlueprintClassSoft;
// 0x0018 (size: 0x30)
EPalMapObjectMaterialType MaterialType;
// 0x0048 (size: 0x1)
// 0x0049 (size: 0x1)
int32 HP;
// 0x004C (size: 0x4)
int32 Defense;
// 0x0050 (size: 0x4)
bool bBelongToBaseCamp;
// 0x0054 (size: 0x1)
int32 DistributeExpAroundPlayer;
// 0x0058 (size: 0x4)
float DeteriorationDamage;
// 0x005C (size: 0x4)
float ExtinguishBurnWorkAmount;
// 0x0060 (size: 0x4)
bool bShowHPGauge;
// 0x0064 (size: 0x1)
bool bInDevelop;
// 0x0065 (size: 0x1)
// 0x0068 (size: 0x4)
}; // Size: 0x70
struct FPalMapObjectMeshVisibleData
{
FComponentReference MeshComponentRef;
// 0x0000 (size: 0x28)
float VisibleHpPercentageThreshold;
// 0x0028 (size: 0x4)
}; // Size: 0x30
struct FPalMapObjectModelConnectInfo
{
EPalMapObjectModelConnectIndex ConnectIndex;
// 0x0000 (size: 0x1)
TArray<FPalMapObjectModelConnectInfoItem> ConnectToInfos;
// 0x0008 (size: 0x10)
}; // Size: 0x18
struct FPalMapObjectModelConnectInfoItem
{
FGuid ConnectToModelInstanceId;
// 0x0000 (size: 0x10)
EPalMapObjectModelConnectIndex ConnectIndex;
// 0x0010 (size: 0x1)
}; // Size: 0x14
struct FPalMapObjectModelEffectRepInfo : public FFastArraySerializerItem

{
EPalStatusID StatusId;
// 0x000C (size: 0x1)
class UPalMapObjectModelEffectBase* Effect;
// 0x0010 (size: 0x8)
}; // Size: 0x18
struct FPalMapObjectModelInitializeExtraParameters
{
TArray<class UPalMapObjectModelInitializeExtraParameterBase*> Entries;
// 0x0000 (size: 0x10)
bool bIgnoredSave;
// 0x0010 (size: 0x1)
FGuid LevelObjectInstanceId;
// 0x0014 (size: 0x10)
}; // Size: 0x28
struct FPalMapObjectModelSaveData : public FPalBinaryMemory

{
FPalMapObjectBuildProcessSaveData BuildProcess;
// 0x0010 (size: 0x10)
FPalMapObjectConnectorSaveData Connector;
// 0x0020 (size: 0x10)
TMap<class EPalStatusID, class FPalMapObjectEffectSaveData> EffectMap;
// 0x0030 (size: 0x50)
}; // Size: 0x80
struct FPalMapObjectModelStaticData
{
FPalBoundsTransform WorkableBounds;
// 0x0000 (size: 0x80)
FBox MeshBoxBounds;
// 0x0080 (size: 0x38)
EPalMapObjectDamagableType DamagableType;
// 0x00B8 (size: 0x1)
FName BuildObjectId;
// 0x00BC (size: 0x8)
TSubclassOf<class APalMapObject> BlueprintClass;
// 0x00C8 (size: 0x8)
}; // Size: 0xD0
struct FPalMapObjectModuleRepInfo : public FFastArraySerializerItem

{
class UPalMapObjectConcreteModelModuleBase* Module;
// 0x0010 (size: 0x8)
}; // Size: 0x18
struct FPalMapObjectPasswordLockPlayerInfo
{
FGuid PlayerUId;
// 0x0000 (size: 0x10)
int32 TryFailedCount;
// 0x0010 (size: 0x4)
bool TrySuccessCache;
// 0x0014 (size: 0x1)
}; // Size: 0x18
struct FPalMapObjectPickupItemData
{
// 0x0000 (size: 0x8)
int32 Num;
// 0x0008 (size: 0x4)
}; // Size: 0xC
struct FPalMapObjectPickupItemPalEggData
{
FPalDataTableRowName_PalMonsterData PalMonsterId;
// 0x0000 (size: 0x8)
}; // Size: 0x8
struct FPalMapObjectPickupItemPalEggLotteryData
{
FPalMapObjectPickupItemPalEggData PalEggData;
// 0x0000 (size: 0x8)
float Weight;
// 0x0008 (size: 0x4)
}; // Size: 0xC
struct FPalMapObjectRepairInfo
{
FPalDataTableRowName_ItemData RepairKitItemName;
// 0x0000 (size: 0x8)
int32 RepairKitRequiredNum;
// 0x0008 (size: 0x4)
float RepairRequiredWorkAmount;
// 0x000C (size: 0x4)
}; // Size: 0x10
struct FPalMapObjectSaveData
{
FVector WorldLocation;
// 0x0000 (size: 0x18)
FQuat WorldRotation;
// 0x0020 (size: 0x20)
FVector WorldScale3D;
// 0x0040 (size: 0x18)
FName MapObjectId;
// 0x0058 (size: 0x8)
FGuid MapObjectInstanceId;
// 0x0060 (size: 0x10)
FGuid MapObjectConcreteModelInstanceId;
// 0x0070 (size: 0x10)
FPalMapObjectModelSaveData Model;
// 0x0080 (size: 0x80)
FPalMapObjectConcreteModelSaveData ConcreteModel;
// 0x0100 (size: 0x60)
}; // Size: 0x160
struct FPalMapObjectSpawnableCheckParameter
{
TArray<class AActor*> IgnoredOverlapCheckActors;
// 0x0078 (size: 0x10)
}; // Size: 0x90
struct FPalMapObjectSpawnerInStageSaveData
{
TMap<class FGuid, class FPalMapObjectSpawnerSaveData>
SpawnerDataMapByLevelObjectInstanceId; // 0x0000 (size: 0x50)
}; // Size: 0x50
struct FPalMapObjectSpawnerItemSaveData
{
int64 NextLotteryGameTime;
// 0x0000 (size: 0x8)
// 0x0008 (size: 0x10)
}; // Size: 0x18
struct FPalMapObjectSpawnerSaveData
{
TMap<int32, FPalMapObjectSpawnerItemSaveData> ItemMap;
// 0x0000 (size: 0x50)
}; // Size: 0x50
struct FPalMapObjectStaticData
{
FName DummyFoliageMapObjectId;
// 0x0000 (size: 0x8)
FName DropItemMapObjectId;
// 0x0008 (size: 0x8)
FName DropItem3DMapObjectId;
// 0x0010 (size: 0x8)
FName BuildObjectId_PalStorage;
// 0x0018 (size: 0x8)
FName MapObjectId_ItemChest;
// 0x0020 (size: 0x8)
FName MapObjectId_DeathPenalty;
// 0x0028 (size: 0x8)
FName MapObjectId_DroppedCharacter;
// 0x0030 (size: 0x8)
FName MapObjectId_TreasureBox_VisibleContent;
// 0x0038 (size: 0x8)
FName MapObjectId_SkillFruit_VisibleContent;
// 0x0040 (size: 0x8)
}; // Size: 0x48
struct FPalMapObjectStatusValue
{
int32 CurrentValue;
// 0x0000 (size: 0x4)
int32 MaxValue;
// 0x0004 (size: 0x4)
}; // Size: 0x8
struct FPalMapObjectVisualEffectAssets
{
TMap<class EPalMapObjectVisualEffectType, class TSoftObjectPtr<UNiagaraSystem>>
AssetMap; // 0x0000 (size: 0x50)
}; // Size: 0x50
struct FPalMapObjectVisualEffectInstanceSet
{
TArray<class UNiagaraComponent*> Instances;
// 0x0000 (size: 0x10)
}; // Size: 0x10
struct FPalMapObjectWorldDropItemInfo
{
FName StaticItemId;
// 0x0008 (size: 0x8)
FGameDateTime CreatedAt;
// 0x0010 (size: 0x8)
}; // Size: 0x18
struct FPalMapObjectWorldDropItemInfoSet
{
TArray<FPalMapObjectWorldDropItemInfo> Infos;
// 0x0000 (size: 0x10)
TArray<FPalMapObjectWorldDropItemInfo> InsertReservedInfoSet;
// 0x0010 (size: 0x10)
int32 MaxCount;
// 0x0020 (size: 0x4)
}; // Size: 0x28
struct FPalMiningRankDefineData
{
float DamageRate;
// 0x0000 (size: 0x4)
// 0x0004 (size: 0x1)
}; // Size: 0x8
struct FPalMonsterControllerBaseCampHungryParameter
{
float RecoverSatietyTo;
// 0x0000 (size: 0x4)
float RecoverSanityTo;
// 0x0004 (size: 0x4)
int32 EatMaxNum;
// 0x0008 (size: 0x4)
}; // Size: 0xC
struct FPalMonsterControllerBaseCampLogContent
{
EPalMonsterControllerBaseCampLogType Type;
// 0x0000 (size: 0x1)
FName TextId;
// 0x0004 (size: 0x8)
FName TargetObjectTextId;
// 0x000C (size: 0x8)
FPalInstanceID InstanceId;
// 0x0018 (size: 0x30)
}; // Size: 0x48
struct FPalMorphSetting
{
TMap<FName, float> WeightList;
// 0x0000 (size: 0x50)
}; // Size: 0x50
struct FPalNPCInteractConditionConstValueDataTableRow : public FTableRowBase

{
FName ValText;
// 0x0008 (size: 0x8)
}; // Size: 0x10
struct FPalNPCInteractionDataTableRow : public FTableRowBase

{
FName UniqueNPCID;
// 0x0008 (size: 0x8)
FName CharacterID;
// 0x0010 (size: 0x8)
EPalInteractiveObjectIndicatorType InteractionType;
// 0x0018 (size: 0x1)
FName Conditions;
// 0x001C (size: 0x8)
FName IncidentId;
// 0x0024 (size: 0x8)
FName IncidentArgs1;
// 0x002C (size: 0x8)
FName IncidentArgs2;
// 0x0034 (size: 0x8)
}; // Size: 0x40
struct FPalNPCMultiTalkRow : public FTableRowBase

{
TSubclassOf<class UPalNPCMultiTalkHandle> MultiTalkHandleClass;
// 0x0008 (size: 0x8)
}; // Size: 0x10
struct FPalNPCOneTalkRow : public FTableRowBase

{
class UDataTable* OneTalkData;
// 0x0008 (size: 0x8)
}; // Size: 0x10
struct FPalNPCSpawnInfo
{
TSubclassOf<class APalAIController> ControllerClass;
// 0x0000 (size: 0x8)
FName CharacterID;
// 0x0008 (size: 0x8)
int32 Level;
// 0x0010 (size: 0x4)
FVector Location;
// 0x0018 (size: 0x18)
float Yaw;
// 0x0030 (size: 0x4)
class UPalSquad* Squad;
// 0x0038 (size: 0x8)
}; // Size: 0x40
struct FPalNPCTalkData
{
EPalNPCTalkCommand TalkCommand;
// 0x0000 (size: 0x1)
TArray<FName> MessageIDList;
// 0x0008 (size: 0x10)
TArray<FName> ChoiceMessageIDList;
// 0x0018 (size: 0x10)
FName TalkerNameID;
// 0x0028 (size: 0x8)
FName CustomFuncName;
// 0x0030 (size: 0x8)
bool isCloseWhenCalledCustomFunc;
// 0x0038 (size: 0x1)
class UDataTable* CustomFuncParam;
// 0x0040 (size: 0x8)
TArray<FPalNPCTalkSelectedChoiceCommandData> SelectedChoiceCommandDataList;
// 0x0048 (size: 0x10)
}; // Size: 0x58
struct FPalNPCTalkDataTableRow : public FTableRowBase

{
TArray<FPalNPCTalkData> TalkData;
// 0x0008 (size: 0x10)
}; // Size: 0x18
struct FPalNPCTalkSelectedChoiceCommandData
{
EPalNPCTalkSelectedChoiceCommand selectedChoiceCommand;
// 0x0000 (size: 0x1)
FName SeqenceName;
// 0x0004 (size: 0x8)
FName CustomFuncName;
// 0x000C (size: 0x8)
bool isCloseWhenCalledCustomFunc;
// 0x0014 (size: 0x1)
class UDataTable* CustomFuncParam;
// 0x0018 (size: 0x8)
}; // Size: 0x20
struct FPalNPCTalkSystemCustomFunctionParameters
{
TScriptInterface<class IPalNPCTalkSystemCustomFunctionInterface> Interface;
// 0x0000 (size: 0x10)
class UDataTable* FuncParameter;
// 0x0010 (size: 0x8)
}; // Size: 0x18
struct FPalNPCWeaponCombatInfo
{
TSubclassOf<class UPalAIActionBase> CombatAIActionClass;
// 0x0000 (size: 0x8)
int32 NPCWeaponRange_Near_cm;
// 0x0008 (size: 0x4)
int32 NPCWeaponRange_Far_cm;
// 0x000C (size: 0x4)
float ShootInterval;
// 0x0010 (size: 0x4)
int32 MaxShootCount;
// 0x0014 (size: 0x4)
float ReloadTime;
// 0x0018 (size: 0x4)
float RandomMoveTime_Min;
// 0x001C (size: 0x4)
float AimOffset_Height;
// 0x0020 (size: 0x4)
bool UseSideDashMovement;
// 0x0024 (size: 0x1)
bool UseReloadMotion;
// 0x0025 (size: 0x1)
bool MeleeAttackWithGun;
// 0x0026 (size: 0x1)
float AimRotateSpeed;
// 0x0028 (size: 0x4)
TSubclassOf<class UPalStateMachineStateBase> FireStateClass;
// 0x0030 (size: 0x8)
}; // Size: 0x38
struct FPalNavigationDividedAreaInfo
{
}; // Size: 0x50
struct FPalNavigationUpdateFrequencySetting
{
int32 UpdateDivideRate;
// 0x0000 (size: 0x4)
FVector2D UpdatableRangeMinMaxFromPlayer;
// 0x0008 (size: 0x10)
}; // Size: 0x18
struct FPalNetArchive
{
TArray<uint8> Bytes;
// 0x0000 (size: 0x10)
}; // Size: 0x10
struct FPalNetworkChangeIndividualID
{
}; // Size: 0x60
struct FPalNetworkCharacterContainerParameter
{
}; // Size: 0x58
struct FPalNetworkContainerParameter
{
}; // Size: 0x20
struct FPalNetworkDynamicItemParameter
{
}; // Size: 0x30
struct FPalNetworkItemOperationParameter
{
}; // Size: 0x20
struct FPalNetworkMapObjectSpawnRequestParameter
{
}; // Size: 0x10
struct FPalNetworkParameter
{
}; // Size: 0x10
struct FPalNetworkPlayerObtainClientParameter
{
}; // Size: 0x10
struct FPalNetworkTransmitterDelaySpawnInfo
{
FGuid SpawnGUID;
// 0x0010 (size: 0x10)
class AActor* SpawnActor;
// 0x0020 (size: 0x8)
}; // Size: 0x28
struct FPalNoteMasterData : public FTableRowBase

{
FName TextId_Description;
// 0x0008 (size: 0x8)
}; // Size: 0x10
struct FPalNoteMasterDataTextureTableRow : public FTableRowBase

{
TSoftObjectPtr<UTexture2D> Texture;
// 0x0008 (size: 0x30)
}; // Size: 0x38
struct FPalObjectCollectorCalcNearestCharacterTickFunction : public FTickFunction

{
}; // Size: 0x30
struct FPalObjectCollectorTickFunction : public FTickFunction

{
}; // Size: 0x30
struct FPalOptimizeParameter
{
int32 FoliageISMDistance_Meters;
// 0x0000 (size: 0x4)
float TargetFPS;
// 0x0004 (size: 0x4)
float MinFPS;
// 0x0008 (size: 0x4)
float MaxFPS;
// 0x000C (size: 0x4)
int32 CharacterImportance_CheckNumberPerFrame;
// 0x0010 (size: 0x4)
int32 CharacterImportance_NearestCount;
// 0x0014 (size: 0x4)
float CharacterImportance_NearDistance;
// 0x0018 (size: 0x4)
float CharacterImportance_FarDistance;
// 0x001C (size: 0x4)
float CharacterImportance_FarthestDistance;
// 0x0020 (size: 0x4)
TMap<EPalCharacterImportanceType, float>
CharacterImportance_TickInterval_Actor; // 0x0028 (size: 0x50)
CharacterImportance_TickInterval_Movement; // 0x0078 (size: 0x50)
TMap<EPalCharacterImportanceType, float> CharacterImportance_TickInterval_Mesh;
// 0x00C8 (size: 0x50)
CharacterImportance_TickInterval_Action; // 0x0118 (size: 0x50)
CharacterImportance_TickInterval_Status; // 0x0168 (size: 0x50)
CharacterImportance_TickInterval_LookAt; // 0x01B8 (size: 0x50)
CharacterImportance_TickInterval_VisualEffect; // 0x0208 (size: 0x50)
CharacterImportance_TickInterval_Shooter; // 0x0258 (size: 0x50)
CharacterImportance_TickInterval_FlyMesh; // 0x02A8 (size: 0x50)
CharacterImportance_TickInterval_Controller; // 0x02F8 (size: 0x50)
CharacterImportance_TickInterval_AIAction; // 0x0348 (size: 0x50)
CharacterImportance_TickInterval_AISensor; // 0x0398 (size: 0x50)
CharacterImportance_TickInterval_PathFollowing; // 0x03E8 (size: 0x50)
float SpawnerImportance_NearDistance;
// 0x0438 (size: 0x4)
float SpawnerImportance_FarDistance;
// 0x043C (size: 0x4)
TMap<EPalSpwnerImportanceType, float>
SpawnerImportance_TickInterval_NPCSpawner; // 0x0440 (size: 0x50)
}; // Size: 0x490
struct FPalOptionAudioSettings
{
float Master;
// 0x0000 (size: 0x4)
float BGM;
// 0x0004 (size: 0x4)
float SE;
// 0x0008 (size: 0x4)
float PalVoice;
// 0x000C (size: 0x4)
float HumanVoice;
// 0x0010 (size: 0x4)
float Ambient;
// 0x0014 (size: 0x4)
float UI;
// 0x0018 (size: 0x4)
}; // Size: 0x1C
struct FPalOptionCommonSettings
{
float PalRideCameraLengthRate;
// 0x0000 (size: 0x4)
float FOV;
// 0x0004 (size: 0x4)
bool bEnableMotionBlur;
// 0x0008 (size: 0x1)
bool bEnableCameraShake;
// 0x0009 (size: 0x1)
TArray<FString> HistoryServerWorldGUID;
// 0x0010 (size: 0x10)
}; // Size: 0x20
struct FPalOptionGraphicsPresetRow : public FTableRowBase

{
EPalOptionGraphicsLevel GraphicsLevel;
// 0x0008 (size: 0x1)
TEnumAsByte<EAntiAliasingMethod> AntiAliasingType;
// 0x0009 (size: 0x1)
int32 CommonQuality;
// 0x000C (size: 0x4)
int32 ViewDistanceQuality;
// 0x0010 (size: 0x4)
int32 FoliageQuality;
// 0x0014 (size: 0x4)
int32 ShadowQuality;
// 0x0018 (size: 0x4)
int32 TextureQuality;
// 0x001C (size: 0x4)
}; // Size: 0x20
struct FPalOptionGraphicsSettings
{
// 0x0000 (size: 0x1)
TEnumAsByte<EWindowMode::Type> WindowMode;
// 0x0001 (size: 0x1)
FIntPoint ScreenResolution;
// 0x0004 (size: 0x8)
bool bEnableVSync;
// 0x000C (size: 0x1)
bool bEnableMotionBlur;
// 0x000D (size: 0x1)
// 0x000E (size: 0x1)
bool bEnableCameraShake;
// 0x000F (size: 0x1)
bool bEnableCameraRecoil;
// 0x0010 (size: 0x1)
float FOV;
// 0x0014 (size: 0x4)
float PalRideCameraLengthRate;
// 0x0018 (size: 0x4)
float LODBias;
// 0x001C (size: 0x4)
float DrawDistance;
// 0x0020 (size: 0x4)
float GrassDrawDistance;
// 0x0024 (size: 0x4)
bool bEnableShadow;
// 0x0028 (size: 0x1)
float ShadowResolution;
// 0x002C (size: 0x4)
int32 CommonQuality;
// 0x0030 (size: 0x4)
int32 ViewDistanceQuality;
// 0x0034 (size: 0x4)
int32 FoliageQuality;
// 0x0038 (size: 0x4)
int32 ShadowQuality;
// 0x003C (size: 0x4)
float Brightness;
// 0x0040 (size: 0x4)
bool bEnableAutoContrast;
// 0x0044 (size: 0x1)
int32 TextureQuality;
// 0x0048 (size: 0x4)
UDLSSMode DLSSMode;
// 0x004C (size: 0x1)
float MaxFPS;
// 0x0050 (size: 0x4)
}; // Size: 0x54
struct FPalOptionKeyboardSettings
{
bool bIsDashHold;
// 0x0000 (size: 0x1)
float MouseSensitivity;
// 0x0004 (size: 0x4)
float MouseAimSensitivity;
// 0x0008 (size: 0x4)
bool bIsReverseYaw;
// 0x000C (size: 0x1)
bool bIsReversePitch;
// 0x000D (size: 0x1)
bool bEnableAimAssist;
// 0x000E (size: 0x1)
bool bShowChat;
// 0x000F (size: 0x1)
}; // Size: 0x10
struct FPalOptionLocalStaticSettings
{
FPalOptionValueFloat MouseSensitivity;
// 0x0000 (size: 0x8)
FPalOptionValueFloat MouseAimSensitivity;
// 0x0008 (size: 0x8)
FPalOptionValueFloat LeftStickThreshold;
// 0x0010 (size: 0x8)
FPalOptionValueFloat RightStickSensitivity;
// 0x0018 (size: 0x8)
FPalOptionValueFloat RightStickAimSensitivity;
// 0x0020 (size: 0x8)
FPalOptionValueFloat RightStickThreshold;
// 0x0028 (size: 0x8)
FPalOptionValueFloat PalRideCameraLengthRate;
// 0x0030 (size: 0x8)
FPalOptionValueFloat FOV;
// 0x0038 (size: 0x8)
}; // Size: 0x40
struct FPalOptionPadSettings
{
bool bIsDashHold;
// 0x0000 (size: 0x1)
float LeftStickThreshold;
// 0x0004 (size: 0x4)
float RightStickSensitivity;
// 0x0008 (size: 0x4)
float RightStickAimSensitivity;
// 0x000C (size: 0x4)
float RightStickThreshold;
// 0x0010 (size: 0x4)
bool bIsRightStickReverseYaw;
// 0x0014 (size: 0x1)
bool bIsRightStickReversePitch;
// 0x0015 (size: 0x1)
bool bEnableVibration;
// 0x0016 (size: 0x1)
bool bEnableAimAssist;
// 0x0017 (size: 0x1)
}; // Size: 0x18
struct FPalOptionSaveData
{
FPalOptionKeyboardSettings KeyboardSettings;
// 0x0000 (size: 0x10)
FPalOptionPadSettings PadSettings;
// 0x0010 (size: 0x18)
FPalKeyConfigSettings KeyConfigSettings;
// 0x0028 (size: 0xC0)
FPalOptionCommonSettings CommonSettings;
// 0x00E8 (size: 0x20)
FPalOptionGraphicsSettings GraphicsSettings;
// 0x0108 (size: 0x54)
FPalOptionAudioSettings AudioSettings;
// 0x015C (size: 0x1C)
bool bHasAppliedUserSetting;
// 0x0178 (size: 0x1)
}; // Size: 0x180
struct FPalOptionValueFloat
{
float Min;
// 0x0000 (size: 0x4)
float Max;
// 0x0004 (size: 0x4)
}; // Size: 0x8
struct FPalOptionValueInt
{
int32 Min;
// 0x0000 (size: 0x4)
int32 Max;
// 0x0004 (size: 0x4)
}; // Size: 0x8
struct FPalOptionWorldModePresetRow : public FTableRowBase

{
EPalOptionWorldMode WorldMode;
// 0x0008 (size: 0x1)
bool bEnablePlayerToPlayerDamage;
// 0x0009 (size: 0x1)
bool bCanPickupOtherGuildDeathPenaltyDrop;
// 0x000A (size: 0x1)
bool bEnableNonLoginPenalty;
// 0x000B (size: 0x1)
bool bEnableFastTravel;
// 0x000C (size: 0x1)
bool bIsStartLocationSelectByMap;
// 0x000D (size: 0x1)
bool bExistPlayerAfterLogout;
// 0x000E (size: 0x1)
bool bEnableDefenseOtherGuildPlayer;
// 0x000F (size: 0x1)
}; // Size: 0x10
struct FPalOptionWorldPresetRow : public FTableRowBase

{
EPalOptionWorldDifficulty Diffculty;
// 0x0008 (size: 0x1)
float DayTimeSpeedRate;
// 0x000C (size: 0x4)
float NightTimeSpeedRate;
// 0x0010 (size: 0x4)
float ExpRate;
// 0x0014 (size: 0x4)
float PalCaptureRate;
// 0x0018 (size: 0x4)
float PalSpawnNumRate;
// 0x001C (size: 0x4)
float PalDamageRateAttack;
// 0x0020 (size: 0x4)
float PalDamageRateDefense;
// 0x0024 (size: 0x4)
float PlayerDamageRateAttack;
// 0x0028 (size: 0x4)
float PlayerDamageRateDefense;
// 0x002C (size: 0x4)
float PlayerStomachDecreaceRate;
// 0x0030 (size: 0x4)
float PlayerStaminaDecreaceRate;
// 0x0034 (size: 0x4)
float PlayerAutoHPRegeneRate;
// 0x0038 (size: 0x4)
float PlayerAutoHpRegeneRateInSleep;
// 0x003C (size: 0x4)
float PalStomachDecreaceRate;
// 0x0040 (size: 0x4)
float PalStaminaDecreaceRate;
// 0x0044 (size: 0x4)
float PalAutoHPRegeneRate;
// 0x0048 (size: 0x4)
float PalAutoHpRegeneRateInSleep;
// 0x004C (size: 0x4)
float BuildObjectDamageRate;
// 0x0050 (size: 0x4)
float BuildObjectDeteriorationDamageRate;
// 0x0054 (size: 0x4)
float CollectionDropRate;
// 0x0058 (size: 0x4)
float CollectionObjectHpRate;
// 0x005C (size: 0x4)
float CollectionObjectRespawnSpeedRate;
// 0x0060 (size: 0x4)
float EnemyDropItemRate;
// 0x0064 (size: 0x4)
EPalOptionWorldDeathPenalty DeathPenalty;
// 0x0068 (size: 0x1)
bool bActiveUNKO;
// 0x0069 (size: 0x1)
int32 DropItemMaxNum_UNKO;
// 0x006C (size: 0x4)
bool bEnableInvaderEnemy;
// 0x0070 (size: 0x1)
int32 DropItemMaxNum;
// 0x0074 (size: 0x4)
bool bAutoResetGuildNoOnlinePlayers;
// 0x0078 (size: 0x1)
float AutoResetGuildTimeNoOnlinePlayers;
// 0x007C (size: 0x4)
int32 GuildPlayerMaxNum;
// 0x0080 (size: 0x4)
float PalEggDefaultHatchingTime;
// 0x0084 (size: 0x4)
int32 BaseCampWorkerMaxNum;
// 0x0088 (size: 0x4)
}; // Size: 0x90
struct FPalOptionWorldSaveData
{
FPalOptionWorldSettings Settings;
// 0x0000 (size: 0x128)
}; // Size: 0x128
struct FPalOptionWorldSettings
{
EPalOptionWorldDifficulty Difficulty;
// 0x0000 (size: 0x1)
float DayTimeSpeedRate;
// 0x0004 (size: 0x4)
float NightTimeSpeedRate;
// 0x0008 (size: 0x4)
float ExpRate;
// 0x000C (size: 0x4)
float PalCaptureRate;
// 0x0010 (size: 0x4)
float PalSpawnNumRate;
// 0x0014 (size: 0x4)
float PalDamageRateAttack;
// 0x0018 (size: 0x4)
float PalDamageRateDefense;
// 0x001C (size: 0x4)
float PlayerDamageRateAttack;
// 0x0020 (size: 0x4)
float PlayerDamageRateDefense;
// 0x0024 (size: 0x4)
float PlayerStomachDecreaceRate;
// 0x0028 (size: 0x4)
float PlayerStaminaDecreaceRate;
// 0x002C (size: 0x4)
float PlayerAutoHPRegeneRate;
// 0x0030 (size: 0x4)
float PlayerAutoHpRegeneRateInSleep;
// 0x0034 (size: 0x4)
float PalStomachDecreaceRate;
// 0x0038 (size: 0x4)
float PalStaminaDecreaceRate;
// 0x003C (size: 0x4)
float PalAutoHPRegeneRate;
// 0x0040 (size: 0x4)
float PalAutoHpRegeneRateInSleep;
// 0x0044 (size: 0x4)
float BuildObjectDamageRate;
// 0x0048 (size: 0x4)
float BuildObjectDeteriorationDamageRate;
// 0x004C (size: 0x4)
float CollectionDropRate;
// 0x0050 (size: 0x4)
float CollectionObjectHpRate;
// 0x0054 (size: 0x4)
float CollectionObjectRespawnSpeedRate;
// 0x0058 (size: 0x4)
float EnemyDropItemRate;
// 0x005C (size: 0x4)
EPalOptionWorldDeathPenalty DeathPenalty;
// 0x0060 (size: 0x1)
bool bEnablePlayerToPlayerDamage;
// 0x0061 (size: 0x1)
bool bEnableFriendlyFire;
// 0x0062 (size: 0x1)
bool bEnableInvaderEnemy;
// 0x0063 (size: 0x1)
bool bActiveUNKO;
// 0x0064 (size: 0x1)
bool bEnableAimAssistPad;
// 0x0065 (size: 0x1)
bool bEnableAimAssistKeyboard;
// 0x0066 (size: 0x1)
int32 DropItemMaxNum;
// 0x0068 (size: 0x4)
int32 DropItemMaxNum_UNKO;
// 0x006C (size: 0x4)
int32 BaseCampMaxNum;
// 0x0070 (size: 0x4)
int32 BaseCampWorkerMaxNum;
// 0x0074 (size: 0x4)
float DropItemAliveMaxHours;
// 0x0078 (size: 0x4)
bool bAutoResetGuildNoOnlinePlayers;
// 0x007C (size: 0x1)
float AutoResetGuildTimeNoOnlinePlayers;
// 0x0080 (size: 0x4)
int32 GuildPlayerMaxNum;
// 0x0084 (size: 0x4)
float PalEggDefaultHatchingTime;
// 0x0088 (size: 0x4)
float WorkSpeedRate;
// 0x008C (size: 0x4)
bool bIsMultiplay;
// 0x0090 (size: 0x1)
bool bIsPvP;
// 0x0091 (size: 0x1)
bool bCanPickupOtherGuildDeathPenaltyDrop;
// 0x0092 (size: 0x1)
bool bEnableNonLoginPenalty;
// 0x0093 (size: 0x1)
bool bEnableFastTravel;
// 0x0094 (size: 0x1)
bool bIsStartLocationSelectByMap;
// 0x0095 (size: 0x1)
bool bExistPlayerAfterLogout;
// 0x0096 (size: 0x1)
bool bEnableDefenseOtherGuildPlayer;
// 0x0097 (size: 0x1)
int32 CoopPlayerMaxNum;
// 0x0098 (size: 0x4)
int32 ServerPlayerMaxNum;
// 0x009C (size: 0x4)
FString ServerName;
// 0x00A0 (size: 0x10)
FString ServerDescription;
// 0x00B0 (size: 0x10)
FString AdminPassword;
// 0x00C0 (size: 0x10)
FString ServerPassword;
// 0x00D0 (size: 0x10)
int32 PublicPort;
// 0x00E0 (size: 0x4)
FString PublicIP;
// 0x00E8 (size: 0x10)
bool RCONEnabled;
// 0x00F8 (size: 0x1)
int32 RCONPort;
// 0x00FC (size: 0x4)
FString Region;
// 0x0100 (size: 0x10)
bool bUseAuth;
// 0x0110 (size: 0x1)
FString BanListURL;
// 0x0118 (size: 0x10)
}; // Size: 0x128
struct FPalOptionWorldStaticSettings
{
FPalOptionValueFloat DayTimeSpeedRate;
// 0x0000 (size: 0x8)
FPalOptionValueFloat NightTimeSpeedRate;
// 0x0008 (size: 0x8)
FPalOptionValueFloat ExpRate;
// 0x0010 (size: 0x8)
FPalOptionValueFloat PalCaptureRate;
// 0x0018 (size: 0x8)
FPalOptionValueFloat PalSpawnNumRate;
// 0x0020 (size: 0x8)
FPalOptionValueFloat PalDamageRateAttack;
// 0x0028 (size: 0x8)
FPalOptionValueFloat PalDamageRateDefense;
// 0x0030 (size: 0x8)
FPalOptionValueFloat PlayerDamageRateAttack;
// 0x0038 (size: 0x8)
FPalOptionValueFloat PlayerDamageRateDefense;
// 0x0040 (size: 0x8)
FPalOptionValueFloat PlayerStomachDecreaceRate;
// 0x0048 (size: 0x8)
FPalOptionValueFloat PlayerStaminaDecreaceRate;
// 0x0050 (size: 0x8)
FPalOptionValueFloat PlayerAutoHPRegeneRate;
// 0x0058 (size: 0x8)
FPalOptionValueFloat PlayerAutoHpRegeneRateInSleep;
// 0x0060 (size: 0x8)
FPalOptionValueFloat PalStomachDecreaceRate;
// 0x0068 (size: 0x8)
FPalOptionValueFloat PalStaminaDecreaceRate;
// 0x0070 (size: 0x8)
FPalOptionValueFloat PalAutoHPRegeneRate;
// 0x0078 (size: 0x8)
FPalOptionValueFloat PalAutoHpRegeneRateInSleep;
// 0x0080 (size: 0x8)
FPalOptionValueFloat BuildObjectDamageRate;
// 0x0088 (size: 0x8)
FPalOptionValueFloat BuildObjectDeteriorationDamageRate;
// 0x0090 (size: 0x8)
FPalOptionValueFloat CollectionDropRate;
// 0x0098 (size: 0x8)
FPalOptionValueFloat CollectionObjectHpRate;
// 0x00A0 (size: 0x8)
FPalOptionValueFloat CollectionObjectRespawnSpeedRate;
// 0x00A8 (size: 0x8)
FPalOptionValueFloat EnemyDropItemRate;
// 0x00B0 (size: 0x8)
FPalOptionValueInt DropItemMaxNum;
// 0x00B8 (size: 0x8)
FPalOptionValueInt DropItemMaxNum_UNKO;
// 0x00C0 (size: 0x8)
FPalOptionValueFloat WorkSpeedRate;
// 0x00C8 (size: 0x8)
FPalOptionValueInt AutoResetGuildTimeNoOnlinePlayers;
// 0x00D0 (size: 0x8)
FPalOptionValueInt GuildPlayerMaxNum;
// 0x00D8 (size: 0x8)
FPalOptionValueInt PalEggDefaultHatchingTime;
// 0x00E0 (size: 0x8)
FPalOptionValueInt BaseCampWorkerMaxNum;
// 0x00E8 (size: 0x8)
}; // Size: 0xF0
struct FPalOrderedQuestSaveData
{
FName QuestName;
// 0x0000 (size: 0x8)
int32 BlockIndex;
// 0x0008 (size: 0x4)
}; // Size: 0xC
struct FPalPalShopCreateDataRow : public FTableRowBase

{
int32 MaxLostPalNum;
// 0x0008 (size: 0x4)
int32 CharacterNum;
// 0x000C (size: 0x4)
TArray<FPalDataTableRowName_PalMonsterData> CharacterIDArray;
// 0x0010 (size: 0x10)
int32 MinCharacterLevel;
// 0x0020 (size: 0x4)
int32 MaxCharacterLevel;
// 0x0024 (size: 0x4)
}; // Size: 0x28
struct FPalPartnerSkillDatabaseRow : public FTableRowBase

{
FName DevName;
// 0x0008 (size: 0x8)
float effectTime;
// 0x0010 (size: 0x4)
float CoolDownTime;
// 0x0014 (size: 0x4)
float ExecCost;
// 0x0018 (size: 0x4)
float IdleCost;
// 0x001C (size: 0x4)
bool CanThrowPal;
// 0x0020 (size: 0x1)
bool CanChangeWeapon;
// 0x0021 (size: 0x1)
bool IsToggleKey;
// 0x0022 (size: 0x1)
}; // Size: 0x28
struct FPalPartnerSkillParameterQueryFunction
{
}; // Size: 0x20
struct FPalPartnerSkillParameterRide
{
float JumpZVelocityScale;
// 0x0000 (size: 0x4)
float GravityScale;
// 0x0004 (size: 0x4)
}; // Size: 0x8
struct FPalPassiveAbilitySkillParameters
{
float DelayTime;
// 0x0000 (size: 0x4)
// 0x0004 (size: 0x1)
TArray<FPalDataTableRowName_MapObjectData> MapObjectId;
// 0x0008 (size: 0x10)
TArray<FPalDataTableRowName_ItemData> ItemId;
// 0x0018 (size: 0x10)
bool AssignOthers;
// 0x0028 (size: 0x1)
EPalElementType TargetElementType;
// 0x0029 (size: 0x1)
}; // Size: 0x38
struct FPalPassiveAbilitySkillStatus
{
EPalPassiveAbilitySkillState State;
// 0x0000 (size: 0x1)
float ElapsedTime;
// 0x0004 (size: 0x4)
TArray<FName> Flags;
// 0x0008 (size: 0x10)
EPalPassiveTriggerType TriggerType;
// 0x0018 (size: 0x4)
}; // Size: 0x20
struct FPalPassiveAbilitySkills
{
TArray<FPalPassiveAbilitySkillParameters> AllAbilityPassiveSkills;
// 0x0000 (size: 0x10)
}; // Size: 0x10
struct FPalPassivePartnerSkillFindOtomoParameter
{
// 0x0000 (size: 0x1)
TArray<FPalDataTableRowName_PalMonsterData> TargetPalIds;
// 0x0008 (size: 0x10)
}; // Size: 0x18
struct FPalPassivePartnerSkillIdAndParameters
{
TMap<class FPalDataTableRowName_PassiveSkillData, class
FPalPassivePartnerSkillParameters> SkillAndParameters; // 0x0000 (size: 0x50)
}; // Size: 0x50
struct FPalPassivePartnerSkillParameters
{
float DelayTime;
// 0x0000 (size: 0x4)
int32 TriggerTypeFlags;
// 0x0004 (size: 0x4)
// 0x0008 (size: 0x1)
TArray<FPalDataTableRowName_MapObjectData> MapObjectId;
// 0x0010 (size: 0x10)
TArray<FPalDataTableRowName_ItemData> ItemId;
// 0x0020 (size: 0x10)
bool AssignOthers;
// 0x0030 (size: 0x1)
// 0x0031 (size: 0x1)
TArray<FPalDataTableRowName_PalMonsterData> PalIds;
// 0x0038 (size: 0x10)
bool bNotAssignSelf;
// 0x0048 (size: 0x1)
}; // Size: 0x50
struct FPalPassivePartnerSkillStatus
{
EPalPassivePartnerSkillState State;
// 0x0000 (size: 0x1)
float ElapsedTime;
// 0x0004 (size: 0x4)
// 0x0008 (size: 0x10)
}; // Size: 0x18
struct FPalPassiveSkillAssignInfo
{
bool isDoNotSetSkills;
// 0x0000 (size: 0x1)
TArray<FName> ForceSetSkillList;
// 0x0008 (size: 0x10)
}; // Size: 0x18
struct FPalPassiveSkillDatabaseRow : public FTableRowBase

{
int32 Rank;
// 0x0008 (size: 0x4)
// 0x000C (size: 0x8)
EPalPassiveSkillEffectType EffectType1;
// 0x0014 (size: 0x1)
float EffectValue1;
// 0x0018 (size: 0x4)
EPalPassiveSkillEffectTargetType TargetType1;
// 0x001C (size: 0x1)
// 0x001D (size: 0x1)
float EffectValue2;
// 0x0020 (size: 0x4)
// 0x0024 (size: 0x1)
// 0x0025 (size: 0x1)
float EffectValue3;
// 0x0028 (size: 0x4)
// 0x002C (size: 0x1)
bool InvokeActiveOtomo;
// 0x002D (size: 0x1)
bool InvokeWorker;
// 0x002E (size: 0x1)
bool InvokeRiding;
// 0x002F (size: 0x1)
bool InvokeReserve;
// 0x0030 (size: 0x1)
bool InvokeInOtomo;
// 0x0031 (size: 0x1)
bool InvokeAlways;
// 0x0032 (size: 0x1)
bool AddPal;
// 0x0033 (size: 0x1)
bool AddRarePal;
// 0x0034 (size: 0x1)
bool AddShotWeapon;
// 0x0035 (size: 0x1)
bool AddMeleeWeapon;
// 0x0036 (size: 0x1)
bool AddArmor;
// 0x0037 (size: 0x1)
bool AddAccessory;
// 0x0038 (size: 0x1)
FName OverrideNameTextID;
// 0x003C (size: 0x8)
FName OverrideSummaryTextId;
// 0x0044 (size: 0x8)
}; // Size: 0x50
struct FPalPassiveSkillEffect
{
EPalPassiveSkillEffectType Type;
// 0x0000 (size: 0x1)
float Value;
// 0x0004 (size: 0x4)
// 0x0008 (size: 0x10)
}; // Size: 0x18
struct FPalPassiveSkillEffectInfos
{
TArray<FPalPassiveSkillEffect> SkillEffectArray;
// 0x0000 (size: 0x10)
}; // Size: 0x10
struct FPalPassiveSkillSetupInfo
{
FName SkillName;
// 0x0000 (size: 0x8)
// 0x0008 (size: 0x10)
}; // Size: 0x18
struct FPalPathFollowingBlockDetectionParams
{
float BlockDetectionDistance;
// 0x0000 (size: 0x4)
float BlockDetectionInterval;
// 0x0004 (size: 0x4)
int32 BlockDetectionSampleCount;
// 0x0008 (size: 0x4)
}; // Size: 0xC
struct FPalPettingParameter
{
float CameraCenterDistance;
// 0x0000 (size: 0x4)
float CameraHeight;
// 0x0004 (size: 0x4)
float CameraArmLength;
// 0x0008 (size: 0x4)
}; // Size: 0xC
struct FPalPhantomReplicateInfo
{
int32 ID;
// 0x0000 (size: 0x4)
class APalCharacter* Character;
// 0x0008 (size: 0x8)
}; // Size: 0x10
struct FPalPlayerAccountInitData
{
FString CharacterName;
// 0x0000 (size: 0x10)
FPalPlayerDataCharacterMakeInfo CharacterMakeData;
// 0x0010 (size: 0x94)
}; // Size: 0xA8
struct FPalPlayerBattleEnemyInfo
{
EPalBattleBGMType Rank;
// 0x0000 (size: 0x1)
TWeakObjectPtr<class AActor> WeakActor;
// 0x0004 (size: 0x8)
}; // Size: 0xC
struct FPalPlayerClassStructSet
{
TSubclassOf<class UPalPlayerDataCharacterMake> CharacterMakeDataClass;
// 0x0000 (size: 0x8)
TSubclassOf<class UPalPlayerRecordData> RecordDataClass;
// 0x0008 (size: 0x8)
TSubclassOf<class UPalWorldMapUIData> WorldMapUIDataClass;
// 0x0010 (size: 0x8)
TSubclassOf<class UPalQuestManager> LocalQuestManagerClass;
// 0x0018 (size: 0x8)
TSubclassOf<class UPalPlayerInventoryData> InventoryDataClass;
// 0x0020 (size: 0x8)
}; // Size: 0x28
struct FPalPlayerDamageCameraShakeData : public FTableRowBase

{
EPalPlayerDamageCameraShakeCategory Category;
// 0x0008 (size: 0x1)
float Scale_Min;
// 0x000C (size: 0x4)
float Scale_Default;
// 0x0010 (size: 0x4)
float Scale_Max;
// 0x0014 (size: 0x4)
int32 HPRate_Min;
// 0x0018 (size: 0x4)
int32 HPRate_Default;
// 0x001C (size: 0x4)
int32 HPRate_Max;
// 0x0020 (size: 0x4)
}; // Size: 0x28
struct FPalPlayerDataCharacterMakeInfo
{
FName BodyMeshName;
// 0x0000 (size: 0x8)
FName HeadMeshName;
// 0x0008 (size: 0x8)
FName HairMeshName;
// 0x0010 (size: 0x8)
FName EquipmentBodyMeshName;
// 0x0018 (size: 0x8)
FName EquipmentHeadMeshName;
// 0x0020 (size: 0x8)
bool DisableEquipmentHeadFlag;
// 0x0028 (size: 0x1)
float ArmVolume;
// 0x002C (size: 0x4)
float TorsoVolume;
// 0x0030 (size: 0x4)
float LegVolume;
// 0x0034 (size: 0x4)
FLinearColor HairColor;
// 0x0038 (size: 0x10)
FLinearColor BrowColor;
// 0x0048 (size: 0x10)
FLinearColor BodyColor;
// 0x0058 (size: 0x10)
FLinearColor BodySubsurfaceColor;
// 0x0068 (size: 0x10)
FLinearColor EyeColor;
// 0x0078 (size: 0x10)
FName EyeMaterialName;
// 0x0088 (size: 0x8)
int32 VoiceID;
// 0x0090 (size: 0x4)
}; // Size: 0x94
struct FPalPlayerDataInventoryInfo
{
FPalContainerId CommonContainerId;
// 0x0000 (size: 0x10)
FPalContainerId DropSlotContainerId;
// 0x0010 (size: 0x10)
FPalContainerId EssentialContainerId;
// 0x0020 (size: 0x10)
FPalContainerId WeaponLoadOutContainerId;
// 0x0030 (size: 0x10)
FPalContainerId PlayerEquipArmorContainerId;
// 0x0040 (size: 0x10)
FPalContainerId FoodEquipContainerId;
// 0x0050 (size: 0x10)
}; // Size: 0x60
struct FPalPlayerDataPalStorageSlotSaveData
{
// 0x0000 (size: 0x30)
FPalIndividualCharacterSaveParameter CharacterSaveParameter;
// 0x0030 (size: 0x218)
// 0x0248 (size: 0x14)
}; // Size: 0x260
struct FPalPlayerEquipmentMeshDataRow : public FTableRowBase

{
TMap<class FName, class TSoftObjectPtr<USkeletalMesh>> SkeletalMeshMap;
// 0x0008 (size: 0x50)
TMap<class FName, class TSoftClassPtr<UAnimInstance>> ABPAssetMap;
// 0x0058 (size: 0x50)
bool IsHairAttachAccessory;
// 0x00A8 (size: 0x1)
TMap<class FName, class FName> HairAttachSocketNameMap;
// 0x00B0 (size: 0x50)
}; // Size: 0x100
struct FPalPlayerInfoForMap
{
FString PlayerName;
// 0x0000 (size: 0x10)
// 0x0010 (size: 0x60)
}; // Size: 0x70
struct FPalPlayerInitializeParameter
{
FPalIndividualCharacterSaveParameter InitParam;
// 0x0000 (size: 0x218)
}; // Size: 0x218
struct FPalPlayerInventorySelectData
{
int32 nowSelectedContainerIndex;
// 0x0000 (size: 0x4)
class UPalItemContainer* targetItemContainer;
// 0x0008 (size: 0x8)
}; // Size: 0x10
struct FPalPlayerParameterDatabaseRow : public FTableRowBase

{
int32 Stamina;
// 0x0008 (size: 0x4)
int32 HP;
// 0x000C (size: 0x4)
int32 MeleeAttack;
// 0x0010 (size: 0x4)
int32 ShotAttack;
// 0x0014 (size: 0x4)
int32 Defense;
// 0x0018 (size: 0x4)
int32 Support;
// 0x001C (size: 0x4)
int32 CraftSpeed;
// 0x0020 (size: 0x4)
int32 Satiety;
// 0x0024 (size: 0x4)
}; // Size: 0x28
struct FPalPlayerRecordCountMapStruct
{
TMap<FName, int64> countMap;
// 0x0000 (size: 0x50)
}; // Size: 0x50
struct FPalPlayerRecordDataRepInfoArray_BoolVal : public FFastArraySerializer

{
TArray<FPalPlayerRecordDataRepInfo_BoolVal> Items;
// 0x0118 (size: 0x10)
}; // Size: 0x178
struct FPalPlayerRecordDataRepInfoArray_IntVal : public FFastArraySerializer

{
TArray<FPalPlayerRecordDataRepInfo_IntVal> Items;
// 0x0118 (size: 0x10)
}; // Size: 0x178
struct FPalPlayerRecordDataRepInfo_BoolVal : public FFastArraySerializerItem

{
FName Key;
// 0x000C (size: 0x8)
bool Value;
// 0x0014 (size: 0x1)
}; // Size: 0x18
struct FPalPlayerRecordDataRepInfo_IntVal : public FFastArraySerializerItem

{
FName Key;
// 0x000C (size: 0x8)
int32 Value;
// 0x0014 (size: 0x4)
}; // Size: 0x18
struct FPalPlayerRecordDataStruct
{
TMap<FName, int64> simpleCountRecordMap;
// 0x0000 (size: 0x50)
TMap<class FName, class bool> simpleFlagMap;
// 0x0050 (size: 0x50)
TMap<class FName, class FPalPlayerRecordCountMapStruct> countMapRecordMap;
// 0x00A0 (size: 0x50)
TMap<class FName, class FPalPlayerRecordFlagMapStruct> flagMapRecordMap;
// 0x00F0 (size: 0x50)
}; // Size: 0x140
struct FPalPlayerRecordFlagMapStruct
{
TMap<class FName, class bool> flagMap;
// 0x0000 (size: 0x50)
}; // Size: 0x50
struct FPalPlayerStatusRankMasterData : public FTableRowBase

{
int32 Rank;
// 0x0008 (size: 0x4)
int32 RequiredRelicNum;
// 0x000C (size: 0x4)
int32 ResetRequiredMoney;
// 0x0010 (size: 0x4)
}; // Size: 0x18
struct FPalQuestDataSetRow : public FTableRowBase

{
TSoftClassPtr<UPalQuestData> QuestData;
// 0x0008 (size: 0x30)
}; // Size: 0x38
struct FPalRadialCatalog
{
TMap<int32, int32> Catalog;
// 0x0000 (size: 0x50)
}; // Size: 0x50
struct FPalRandomIncidentSettings : public FTableRowBase

{
class UDataTable* MonsterSpawnData;
// 0x0008 (size: 0x8)
class UDataTable* NPCSpawnData;
// 0x0010 (size: 0x8)
bool ExcludeOtherPal;
// 0x0018 (size: 0x1)
TSubclassOf<class UPalRandomIncidentActionBase> action;
// 0x0020 (size: 0x8)
}; // Size: 0x28
struct FPalRandomIncidentSpawnIncidentParameter
{
FName IncidentId;
// 0x0000 (size: 0x8)
FName SettingName;
// 0x0008 (size: 0x8)
int32 LotteryRate;
// 0x0010 (size: 0x4)
}; // Size: 0x14
struct FPalRandomIncidentSpawnLocationData : public FTableRowBase

{
FVector2D Location;
// 0x0008 (size: 0x10)
}; // Size: 0x18
struct FPalRandomIncidentSpawnMonsterData : public FTableRowBase

{
FPalDataTableRowName_PalMonsterData CharacterID;
// 0x0008 (size: 0x8)
int32 Level;
// 0x0010 (size: 0x4)
int32 Group;
// 0x0014 (size: 0x4)
bool IsSquad;
// 0x0018 (size: 0x1)
FVector2D SpawnLocation;
// 0x0020 (size: 0x10)
float SpawnRadius;
// 0x0030 (size: 0x4)
float RotZ_Degree;
// 0x0034 (size: 0x4)
// 0x0038 (size: 0x8)
TSubclassOf<class UPalActionBase> DefaultActionClass;
// 0x0040 (size: 0x8)
}; // Size: 0x48
struct FPalRandomIncidentSpawnMonsterOutbreakData : public FTableRowBase

{
FPalDataTableRowName_PalMonsterData CharacterID;
// 0x0008 (size: 0x8)
int32 Num;
// 0x0010 (size: 0x4)
int32 LevelMin;
// 0x0014 (size: 0x4)
int32 LevelMax;
// 0x0018 (size: 0x4)
int32 Group;
// 0x001C (size: 0x4)
bool IsSquad;
// 0x0020 (size: 0x1)
class UDataTable* LocationTable;
// 0x0028 (size: 0x8)
// 0x0030 (size: 0x8)
TSubclassOf<class UPalActionBase> DefaultActionClass;
// 0x0038 (size: 0x8)
}; // Size: 0x40
struct FPalRandomIncidentSpawnNPCData : public FTableRowBase

{
FPalDataTableRowName_PalHumanData CharacterID;
// 0x0008 (size: 0x8)
FPalDataTableRowName_NPCUniqueData UniqueNPCID;
// 0x0010 (size: 0x8)
int32 Level;
// 0x0018 (size: 0x4)
int32 Group;
// 0x001C (size: 0x4)
bool IsSquad;
// 0x0020 (size: 0x1)
FVector2D SpawnLocation;
// 0x0028 (size: 0x10)
float SpawnRadius;
// 0x0038 (size: 0x4)
float RotZ_Degree;
// 0x003C (size: 0x4)
FName WalkPathName;
// 0x0040 (size: 0x8)
float WalkRadius;
// 0x0048 (size: 0x4)
// 0x0050 (size: 0x8)
TSubclassOf<class UPalAIActionBase> DefaultAIActionClass;
// 0x0058 (size: 0x8)
}; // Size: 0x60
struct FPalRandomIncidentWalkPathReferenceData
{
TArray<class AActor*> WalkPoints;
// 0x0000 (size: 0x10)
}; // Size: 0x10
struct FPalRandomRestInfo
{
class UAnimMontage* RandomRestMontage;
// 0x0000 (size: 0x8)
float Weight;
// 0x0008 (size: 0x4)
int32 LoopNum_Min;
// 0x000C (size: 0x4)
int32 LoopNum_Max;
// 0x0010 (size: 0x4)
float AfterIdleTime;
// 0x0014 (size: 0x4)
}; // Size: 0x18
struct FPalRespawnPointData : public FTableRowBase

{
FName SpawnPointID;
// 0x0008 (size: 0x8)
int32 ResourcesAbundant;
// 0x0010 (size: 0x4)
int32 PalAbundant;
// 0x0014 (size: 0x4)
}; // Size: 0x18
struct FPalShopProductRequireItemData
{
FName StaticItemId;
// 0x0000 (size: 0x8)
int32 requireNum;
// 0x0008 (size: 0x4)
}; // Size: 0xC
struct FPalSizeParameterDataRow : public FTableRowBase

{
EPalSizeType Size;
// 0x0008 (size: 0x1)
float EffectScale;
// 0x000C (size: 0x4)
float JumpEffectOffsetZ;
// 0x0010 (size: 0x4)
}; // Size: 0x18
struct FPalSlateNavigationSetting
{
bool IsEnableAnalogNavigation;
// 0x0000 (size: 0x1)
bool IsEnableLeftKeyNavigation;
// 0x0001 (size: 0x1)
bool IsEnableRightKeyNavigation;
// 0x0002 (size: 0x1)
bool IsEnableDownKeyNavigation;
// 0x0003 (size: 0x1)
bool IsEnableUpKeyNavigation;
// 0x0004 (size: 0x1)
}; // Size: 0x5
struct FPalSlotItemAndNum
{
FPalItemAndSlot itemSlot;
// 0x0000 (size: 0x40)
int32 Num;
// 0x0040 (size: 0x4)
}; // Size: 0x44
struct FPalSlotOpItemInfo
{
FPalItemAndNum Item;
// 0x0000 (size: 0x2C)
float CorruptionProgressValue;
// 0x002C (size: 0x4)
}; // Size: 0x30
struct FPalSlotOpItemSlotInfo
{
FPalSlotOpItemInfo ItemInfo;
// 0x0000 (size: 0x30)
// 0x0030 (size: 0x14)
}; // Size: 0x44
struct FPalSoundIDDataTableRow : public FTableRowBase

{
FName Description;
// 0x0008 (size: 0x8)
}; // Size: 0x10
struct FPalSoundOptions
{
int32 FadeInTime;
// 0x0000 (size: 0x4)
}; // Size: 0x4
struct FPalSoundPlayingParameter
{
class UAkAudioEvent* AudioEvent;
// 0x0000 (size: 0x8)
FPalSoundOptions Options;
// 0x0008 (size: 0x4)
bool bStopAbsolutely;
// 0x000C (size: 0x1)
}; // Size: 0x10
struct FPalSoundSource : public FTableRowBase

{
int32 Radius_Meter;
// 0x0008 (size: 0x4)
bool bIsMuteable;
// 0x000C (size: 0x1)
}; // Size: 0x10
struct FPalSpawnerGroupInfo
{
int32 Weight;
// 0x0000 (size: 0x4)
EPalOneDayTimeType OnlyTime;
// 0x0004 (size: 0x1)
EPalWeatherConditionType OnlyWeather;
// 0x0005 (size: 0x1)
TArray<FPalSpawnerOneTribeInfo> PalList;
// 0x0008 (size: 0x10)
}; // Size: 0x18
struct FPalSpawnerOneTribeInfo
{
FPalDataTableRowName_PalMonsterData PalID;
// 0x0000 (size: 0x8)
FPalDataTableRowName_PalHumanData NPCID;
// 0x0008 (size: 0x8)
int32 Level;
// 0x0010 (size: 0x4)
int32 Level_Max;
// 0x0014 (size: 0x4)
int32 Num;
// 0x0018 (size: 0x4)
int32 Num_Max;
// 0x001C (size: 0x4)
}; // Size: 0x20
struct FPalSpecialAttackRateInfo
{
EPalSpecialAttackRateType Type;
// 0x0000 (size: 0x1)
float Rate;
// 0x0004 (size: 0x4)
}; // Size: 0x8
struct FPalSphere
{
FVector Center;
// 0x0000 (size: 0x18)
float Radius;
// 0x0018 (size: 0x4)
bool bXY;
// 0x001C (size: 0x1)
}; // Size: 0x20
struct FPalStageAreaInfo
{
FBox BoundingBox;
// 0x0000 (size: 0x38)
}; // Size: 0x38
struct FPalStageInstanceId
{
FGuid InternalId;
// 0x0000 (size: 0x10)
bool bValid;
// 0x0010 (size: 0x1)
}; // Size: 0x14
struct FPalStageModelRepInfo : public FFastArraySerializerItem

{
FPalStageInstanceId InstanceId;
// 0x000C (size: 0x14)
class UPalStageModelBase* Model;
// 0x0020 (size: 0x8)
}; // Size: 0x28
struct FPalStagePlayerInfo
{
FGuid PlayerUId;
// 0x0000 (size: 0x10)
EPalStagePlayerState PlayerState;
// 0x0010 (size: 0x1)
}; // Size: 0x14
struct FPalStaticCharacterInfo_SpawnItem
{
TMap<int32, FPalDataTableRowName_FieldLotteryNameData> FieldLotteryNameByRank;
// 0x0000 (size: 0x50)
}; // Size: 0x50
struct FPalStaticItemAndSlot
{
FPalStaticItemIdAndNum ItemInfo;
// 0x0000 (size: 0xC)
// 0x000C (size: 0x14)
}; // Size: 0x20
struct FPalStaticItemDataStruct : public FTableRowBase

{
FName OverrideName;
// 0x0008 (size: 0x8)
FName OverrideDescription;
// 0x0010 (size: 0x8)
FName IconName;
// 0x0018 (size: 0x8)
EPalItemTypeA TypeA;
// 0x0020 (size: 0x1)
EPalItemTypeB TypeB;
// 0x0021 (size: 0x1)
int32 Rank;
// 0x0024 (size: 0x4)
int32 Rarity;
// 0x0028 (size: 0x4)
int32 MaxStackCount;
// 0x002C (size: 0x4)
float Weight;
// 0x0030 (size: 0x4)
int32 Price;
// 0x0034 (size: 0x4)
int32 SortID;
// 0x0038 (size: 0x4)
bool bInTreasureBox;
// 0x003C (size: 0x1)
bool bNotConsumed;
// 0x003D (size: 0x1)
bool bEnableHandcraft;
// 0x003E (size: 0x1)
int32 TechnologyTreeLock;
// 0x0040 (size: 0x4)
FName ItemStaticClass;
// 0x0044 (size: 0x8)
FName ItemDynamicClass;
// 0x004C (size: 0x8)
FName ItemActorClass;
// 0x0054 (size: 0x8)
FName ItemStaticMeshName;
// 0x005C (size: 0x8)
FName VisualBlueprintClassName;
// 0x0064 (size: 0x8)
TSoftClassPtr<AActor> VisualBlueprintClassSoft;
// 0x0070 (size: 0x30)
EPalDropItemType DropItemType;
// 0x00A0 (size: 0x1)
// 0x00A4 (size: 0x4)
int32 RestoreSatiety;
// 0x00A8 (size: 0x4)
int32 RestoreConcentration;
// 0x00AC (size: 0x4)
int32 RestoreSanity;
// 0x00B0 (size: 0x4)
int32 RestoreHealth;
// 0x00B4 (size: 0x4)
int32 GrantEffect1Id;
// 0x00B8 (size: 0x4)
float GrantEffect1Time;
// 0x00BC (size: 0x4)
// 0x00C0 (size: 0x4)
// 0x00C4 (size: 0x4)
// 0x00C8 (size: 0x4)
// 0x00CC (size: 0x4)
int32 Durability;
// 0x00D0 (size: 0x4)
EPalElementType ElementType;
// 0x00D4 (size: 0x1)
bool bSleepWeapon;
// 0x00D5 (size: 0x1)
int32 MagazineSize;
// 0x00D8 (size: 0x4)
// 0x00DC (size: 0x4)
int32 PhysicalAttackValue;
// 0x00E0 (size: 0x4)
int32 HPValue;
// 0x00E4 (size: 0x4)
int32 PhysicalDefenseValue;
// 0x00E8 (size: 0x4)
int32 ShieldValue;
// 0x00EC (size: 0x4)
int32 MagicAttackValue;
// 0x00F0 (size: 0x4)
int32 MagicDefenseValue;
// 0x00F4 (size: 0x4)
FName PassiveSkillName;
// 0x00F8 (size: 0x8)
EPalWazaID WazaID;
// 0x0100 (size: 0x1)
float CorruptionFactor;
// 0x0104 (size: 0x4)
float FloatValue1;
// 0x0108 (size: 0x4)
}; // Size: 0x110
struct FPalStaticItemIdAndDynamicItemDataSet
{
FName StaticItemId;
// 0x0000 (size: 0x8)
// 0x0008 (size: 0x8)
}; // Size: 0x10
struct FPalStaticItemIdAndNum
{
FName StaticItemId;
// 0x0000 (size: 0x8)
int32 Num;
// 0x0008 (size: 0x4)
}; // Size: 0xC
struct FPalStatusAccumulate
{
}; // Size: 0x10
struct FPalStatusEffectFoodDataRow : public FTableRowBase

{
int32 effectTime;
// 0x0008 (size: 0x4)
EPalFoodStatusEffectType EffectType1;
// 0x000C (size: 0x1)
int32 EffectValue1;
// 0x0010 (size: 0x4)
EPalFoodStatusEffectType EffectType2;
// 0x0014 (size: 0x1)
int32 EffectValue2;
// 0x0018 (size: 0x4)
}; // Size: 0x20
struct FPalSyncTeleportRequestParameter
{
FString SyncTeleportStartSE;
// 0x0000 (size: 0x10)
FVector Location;
// 0x0010 (size: 0x18)
FQuat Rotation;
// 0x0030 (size: 0x20)
bool bIsFadeOutSkip;
// 0x0050 (size: 0x1)
}; // Size: 0x60
struct FPalTalkTreeDataTableRow : public FTableRowBase

{
FName NPCID;
// 0x0008 (size: 0x8)
FName TalkName;
// 0x0010 (size: 0x8)
FName TextId;
// 0x0018 (size: 0x8)
}; // Size: 0x20
struct FPalTechnologyDataSet
{
class UDataTable* recipeUnlockDataTable;
// 0x0000 (size: 0x8)
class UDataTable* technologyNameTable;
// 0x0008 (size: 0x8)
class UDataTable* technologyDescTable;
// 0x0010 (size: 0x8)
}; // Size: 0x18
struct FPalTechnologyDataTableRowBase : public FTableRowBase

{
FName Name;
// 0x0008 (size: 0x8)
FName Description;
// 0x0010 (size: 0x8)
FName IconName;
// 0x0018 (size: 0x8)
int32 RequireBossDefeatNum;
// 0x0020 (size: 0x4)
FName RequireTechnology;
// 0x0024 (size: 0x8)
bool IsBossTechnology;
// 0x002C (size: 0x1)
int32 LevelCap;
// 0x0030 (size: 0x4)
int32 Tier;
// 0x0034 (size: 0x4)
int32 Cost;
// 0x0038 (size: 0x4)
}; // Size: 0x40
struct FPalTechnologyRecipeUnlockDataTableRow : public

FPalTechnologyDataTableRowBase
{
TArray<FName> UnlockBuildObjects;
// 0x0040 (size: 0x10)
TArray<FName> UnlockItemRecipes;
// 0x0050 (size: 0x10)
}; // Size: 0x60
struct FPalTimerGaugeWidgetCreateInfo
{
class AActor* TargetActor;
// 0x0008 (size: 0x8)
FVector TargetLocation;
// 0x0010 (size: 0x18)
TSubclassOf<class UPalUserWidgetTimerGaugeBase> timerGaugeWidgetClass;
// 0x0028 (size: 0x8)
FVector DisplayOffset;
// 0x0030 (size: 0x18)
float DisplayRange;
// 0x0048 (size: 0x4)
FString FunctionName;
// 0x0050 (size: 0x10)
float Time;
// 0x0060 (size: 0x4)
bool bLooping;
// 0x0064 (size: 0x1)
float InitialStartDelay;
// 0x0068 (size: 0x4)
float InitialStartDelayVariance;
// 0x006C (size: 0x4)
bool IsHide;
// 0x0070 (size: 0x1)
}; // Size: 0x78
struct FPalTimerHandle
{
}; // Size: 0x10
struct FPalTutorialTriggerSaveData
{
FName TutorialMsg;
// 0x0000 (size: 0x8)
bool Checked;
// 0x0008 (size: 0x1)
}; // Size: 0xC
struct FPalUIActionBindData
{
}; // Size: 0x4
struct FPalUIAimReticleMapObjectAssignableData
{
bool isAssignable;
// 0x0000 (size: 0x1)
FName targetMapObjectID;
// 0x0004 (size: 0x8)
}; // Size: 0xC
struct FPalUICaptureCameraOffsetData : public FTableRowBase

{
FVector LocationOffset;
// 0x0008 (size: 0x18)
FRotator Rotator;
// 0x0020 (size: 0x18)
FVector PointLightOffset_1;
// 0x0038 (size: 0x18)
float PointLightIntensity_1;
// 0x0050 (size: 0x4)
float PointLightSize_1;
// 0x0054 (size: 0x4)
FVector PointLightOffset_2;
// 0x0058 (size: 0x18)
float PointLightIntensity_2;
// 0x0070 (size: 0x4)
float PointLightSize_2;
// 0x0074 (size: 0x4)
FVector RectLightOffset;
// 0x0078 (size: 0x18)
FRotator RectLightRotator;
// 0x0090 (size: 0x18)
float RectLightIntensity;
// 0x00A8 (size: 0x4)
float RectLightSize;
// 0x00AC (size: 0x4)
}; // Size: 0xB0
struct FPalUICommonItemInfoDisplayData
{
class UPalItemSlot* TargetItemSlot;
// 0x0000 (size: 0x8)
FName RecipeID;
// 0x0008 (size: 0x8)
class UWidget* RelativeWidget;
// 0x0010 (size: 0x8)
FVector2D AnchorPosition;
// 0x0018 (size: 0x10)
bool IsUsableSlot;
// 0x0028 (size: 0x1)
bool IsEnableQuickEquip;
// 0x0029 (size: 0x1)
bool IsEnableQuickMove;
// 0x002A (size: 0x1)
bool IsEnableSpreadLift;
// 0x002B (size: 0x1)
bool IsShowPrice;
// 0x002C (size: 0x1)
}; // Size: 0x30
struct FPalUICommonRewardDisplayData
{
FText Message;
// 0x0000 (size: 0x18)
class UTexture2D* Texture;
// 0x0018 (size: 0x8)
TSoftObjectPtr<UTexture2D> SoftTexture;
// 0x0020 (size: 0x30)
EPalUIRewardDisplayType DisplayType;
// 0x0050 (size: 0x1)
}; // Size: 0x58
struct FPalUIGuildMemberDisplayInfo
{
FString CharacterName;
// 0x0000 (size: 0x10)
bool IsAdmin;
// 0x0010 (size: 0x1)
EPalGuildPlayerStatus PlayerStatus;
// 0x0011 (size: 0x1)
}; // Size: 0x18
struct FPalUILocalWorldDisplayData
{
FString WorldName;
// 0x0000 (size: 0x10)
FString WorldDirectoryName;
// 0x0010 (size: 0x10)
FString PlayerName;
// 0x0020 (size: 0x10)
int32 PlayerLevel;
// 0x0030 (size: 0x4)
int32 Day;
// 0x0034 (size: 0x4)
FDateTime Timestamp;
// 0x0038 (size: 0x8)
FString DirectoryPath;
// 0x0040 (size: 0x10)
}; // Size: 0x50
struct FPalUIPalCaptureInfo
{
FName CharacterID;
// 0x0000 (size: 0x8)
int32 CaptureCount;
// 0x0008 (size: 0x4)
int32 Level;
// 0x000C (size: 0x4)
TArray<FName> PassiveSkillNameList;
// 0x0010 (size: 0x10)
bool IsRarePal;
// 0x0020 (size: 0x1)
bool IsUnlockedPaldeck;
// 0x0021 (size: 0x1)
}; // Size: 0x28
struct FPalUIPaldexDistributionData : public FTableRowBase

{
FPalUIPaldexDistributionLocationStruct dayTimeLocations;
// 0x0008 (size: 0x18)
FPalUIPaldexDistributionLocationStruct nightTimeLocations;
// 0x0020 (size: 0x18)
}; // Size: 0x38
struct FPalUIPaldexDistributionLocationStruct
{
TArray<FVector> locations;
// 0x0000 (size: 0x10)
float Radius;
// 0x0010 (size: 0x4)
}; // Size: 0x18
struct FPalUIPaldex_DisplayInfo
{
int32 Index;
// 0x0000 (size: 0x4)
FString IndexSuffix;
// 0x0008 (size: 0x10)
FString CombinedIndexString;
// 0x0018 (size: 0x10)
EPalUIPaldexPanelDetailType detailType;
// 0x0028 (size: 0x1)
FName baseCharacterName;
// 0x002C (size: 0x8)
}; // Size: 0x38
struct FPalUIServerDataCollectInfo
{
EPalUIServerListSortType SortType;
// 0x0000 (size: 0x1)
FString SearchWord;
// 0x0008 (size: 0x10)
}; // Size: 0x18
struct FPalUIServerDisplayData
{
FString ServerName;
// 0x0120 (size: 0x10)
FString Description;
// 0x0130 (size: 0x10)
bool IsPvP;
// 0x0140 (size: 0x1)
int32 Day;
// 0x0144 (size: 0x4)
int32 NowPlayerNum;
// 0x0148 (size: 0x4)
int32 MaxPlayerNum;
// 0x014C (size: 0x4)
int32 Ping;
// 0x0150 (size: 0x4)
EPalUIServerListFilterType ServerListType;
// 0x0154 (size: 0x1)
FString ServerAddress;
// 0x0158 (size: 0x10)
int32 ServerPort;
// 0x0168 (size: 0x4)
FString VersionString;
// 0x0170 (size: 0x10)
bool IsLocked;
// 0x0180 (size: 0x1)
FString Region;
// 0x0188 (size: 0x10)
int32 CreateTime;
// 0x0198 (size: 0x4)
}; // Size: 0x1A0
struct FPalUMGCustomVertexData
{
FVector4 texCoords;
// 0x0000 (size: 0x20)
FVector2D materialTexCoords;
// 0x0020 (size: 0x10)
FVector2D Position;
// 0x0030 (size: 0x10)
FColor Color;
// 0x0040 (size: 0x4)
int32 pixelWidth;
// 0x0044 (size: 0x4)
int32 pixelHeight;
// 0x0048 (size: 0x4)
}; // Size: 0x50
struct FPalUniqueNPCDatabaseRow : public FTableRowBase

{
FName CharacterID;
// 0x0008 (size: 0x8)
FName NameTextID;
// 0x0010 (size: 0x8)
FName OneTalkDTName;
// 0x0018 (size: 0x8)
FName TalkBPClass;
// 0x0020 (size: 0x8)
EPalGenderType Gender;
// 0x0028 (size: 0x1)
EPalNPCSkinColor SkinColor;
// 0x0029 (size: 0x1)
EPalNPCFaceType Face;
// 0x002A (size: 0x1)
EPalNPCHairStyleType HairStyle;
// 0x002B (size: 0x1)
EPalNPCHairColorType HairColor;
// 0x002C (size: 0x1)
EPalNPCClothesType Clothes;
// 0x002D (size: 0x1)
EPalNPCScaleType Scale;
// 0x002E (size: 0x1)
int32 Level;
// 0x0030 (size: 0x4)
}; // Size: 0x38
struct FPalVisitorNPCDatabaseRow : public FPalInvaderDatabaseRow

{
EPalIVisitorNPCAction ActionTimeLimit;
// 0x0070 (size: 0x1)
bool IsSquad;
// 0x0071 (size: 0x1)
}; // Size: 0x78
struct FPalVisualEffectDynamicParameter
{
TArray<FPalVisualEffectDynamicParameterFloat> FloatValues;
// 0x0000 (size: 0x10)
}; // Size: 0x10
struct FPalVisualEffectDynamicParameterFloat
{
FName Name;
// 0x0000 (size: 0x8)
float Value;
// 0x0008 (size: 0x4)
}; // Size: 0xC
struct FPalWaitLoadingWorldPartitionParameter
{
FWorldPartitionStreamingQuerySource QuerySource;
// 0x0000 (size: 0x88)
EWorldPartitionRuntimeCellState CellState;
// 0x0088 (size: 0x1)
float IntervalTime;
// 0x008C (size: 0x4)
float InFirstDelayTime;
// 0x0090 (size: 0x4)
}; // Size: 0x98
struct FPalWazaDatabaseRaw : public FTableRowBase

{
EPalWazaID WazaType;
// 0x0008 (size: 0x1)
EPalElementType Element;
// 0x0009 (size: 0x1)
bool IgnoreRandomInherit;
// 0x000A (size: 0x1)
// 0x000B (size: 0x1)
int32 Power;
// 0x000C (size: 0x4)
bool IsLeanBack;
// 0x0010 (size: 0x1)
// 0x0011 (size: 0x1)
int32 MinRange;
// 0x0014 (size: 0x4)
int32 MaxRange;
// 0x0018 (size: 0x4)
float CoolTime;
// 0x001C (size: 0x4)
// 0x0020 (size: 0x1)
// 0x0021 (size: 0x1)
int32 EffectValue1;
// 0x0024 (size: 0x4)
// 0x0028 (size: 0x4)
// 0x002C (size: 0x1)
int32 EffectValue2;
// 0x0030 (size: 0x4)
// 0x0034 (size: 0x4)
// 0x0038 (size: 0x10)
bool bIsWeaponDamage;
// 0x0048 (size: 0x1)
bool DisabledData;
// 0x0049 (size: 0x1)
}; // Size: 0x50
struct FPalWazaMasterLevelDataRow : public FTableRowBase

{
FName PalID;
// 0x0008 (size: 0x8)
EPalWazaID WazaID;
// 0x0010 (size: 0x1)
int32 Level;
// 0x0014 (size: 0x4)
}; // Size: 0x18
struct FPalWazaMasterTamagoDataRow : public FTableRowBase

{
FName PalID;
// 0x0008 (size: 0x8)
EPalWazaID WazaID;
// 0x0010 (size: 0x1)
}; // Size: 0x18
struct FPalWeaponSubParameterData : public FTableRowBase

{
float dps;
// 0x0008 (size: 0x4)
float Range;
// 0x000C (size: 0x4)
float stability;
// 0x0010 (size: 0x4)
float accuracy;
// 0x0014 (size: 0x4)
}; // Size: 0x18
struct FPalWildSpawnerDatabaseRow : public FTableRowBase

{
FName SpawnerName;
// 0x0008 (size: 0x8)
EPalSpawnedCharacterType SpawnerType;
// 0x0010 (size: 0x1)
float Weight;
// 0x0014 (size: 0x4)
EPalOneDayTimeType OnlyTime;
// 0x0018 (size: 0x1)
EPalWeatherConditionType OnlyWeather;
// 0x0019 (size: 0x1)
FName Pal_1;
// 0x001C (size: 0x8)
FName NPC_1;
// 0x0024 (size: 0x8)
int32 LvMin_1;
// 0x002C (size: 0x4)
int32 LvMax_1;
// 0x0030 (size: 0x4)
int32 NumMin_1;
// 0x0034 (size: 0x4)
int32 NumMax_1;
// 0x0038 (size: 0x4)
FName Pal_2;
// 0x003C (size: 0x8)
FName NPC_2;
// 0x0044 (size: 0x8)
int32 LvMin_2;
// 0x004C (size: 0x4)
int32 LvMax_2;
// 0x0050 (size: 0x4)
int32 NumMin_2;
// 0x0054 (size: 0x4)
int32 NumMax_2;
// 0x0058 (size: 0x4)
FName Pal_3;
// 0x005C (size: 0x8)
FName NPC_3;
// 0x0064 (size: 0x8)
int32 LvMin_3;
// 0x006C (size: 0x4)
int32 LvMax_3;
// 0x0070 (size: 0x4)
int32 NumMin_3;
// 0x0074 (size: 0x4)
int32 NumMax_3;
// 0x0078 (size: 0x4)
}; // Size: 0x80
struct FPalWindInfo
{
FVector Direction;
// 0x0000 (size: 0x18)
float Speed;
// 0x0018 (size: 0x4)
}; // Size: 0x20
struct FPalWorkAssignDefineData
{
TArray<EPalGenusCategoryType> GenusCategories;
// 0x0000 (size: 0x10)
TArray<EPalElementType> ElementTypes;
// 0x0010 (size: 0x10)
// 0x0020 (size: 0x1)
int32 WorkSuitabilityRank;
// 0x0024 (size: 0x4)
bool bPlayerWorkable;
// 0x0028 (size: 0x1)
// 0x0029 (size: 0x1)
EPalActionType ActionType;
// 0x002A (size: 0x1)
int32 WorkerMaxNum;
// 0x002C (size: 0x4)
float AffectSanityValue;
// 0x0030 (size: 0x4)
}; // Size: 0x38
struct FPalWorkAssignDefineDataStaticSetting
{
FName RowName;
// 0x0000 (size: 0x8)
FPalWorkAssignDefineData AssignDefineData;
// 0x0008 (size: 0x38)
}; // Size: 0x40
struct FPalWorkAssignHandleId
{
FGuid WorkId;
// 0x0000 (size: 0x10)
int32 LocationIndex;
// 0x0010 (size: 0x4)
EPalWorkAssignType AssignType;
// 0x0014 (size: 0x1)
}; // Size: 0x18
struct FPalWorkAssignInfo
{
// 0x0000 (size: 0x4)
class UPalWorkAssign* WorkAssign;
// 0x0008 (size: 0x8)
}; // Size: 0x10
struct FPalWorkAssignLocalLocation
{
FVector Location;
// 0x0000 (size: 0x18)
FVector FacingDirection;
// 0x0018 (size: 0x18)
}; // Size: 0x30
struct FPalWorkAssignParameter
{
}; // Size: 0x28
struct FPalWorkAssignRepInfo : public FFastArraySerializerItem

{
// 0x000C (size: 0x4)
class UPalWorkAssign* WorkAssign;
// 0x0010 (size: 0x8)
}; // Size: 0x18
struct FPalWorkAssignRequirementParameter
{
}; // Size: 0x18
struct FPalWorkAssignSaveData : public FPalBinaryMemory

{
}; // Size: 0x10
struct FPalWorkProgressManagerWorkProcessTickFunction : public FTickFunction

{
class UPalWorkProgressManager* Target;
// 0x0028 (size: 0x8)
}; // Size: 0x30
struct FPalWorkSaveData : public FPalBinaryMemory

{
EPalWorkableType WorkableType;
// 0x0010 (size: 0x1)
TMap<int32, FPalWorkAssignSaveData> WorkAssignMap;
// 0x0018 (size: 0x50)
}; // Size: 0x68
struct FPalWorkStaticParameter
{
FGuid OwnerMapObjectModelId;
// 0x0000 (size: 0x10)
FGuid OwnerMapObjectConcreteModelId;
// 0x0010 (size: 0x10)
// 0x0020 (size: 0x80)
TArray<FPalWorkAssignLocalLocation> AssignLocalLocations;
// 0x00A0 (size: 0x10)
}; // Size: 0xC0
struct FPalWorkSuitabilityCollectionDefineData
{
FPalWorkSuitabilityDefineData CommonDefineData;
// 0x0000 (size: 0x18)
TArray<FPalCollectionRankDefineData> CollectionDefineData;
// 0x0018 (size: 0x10)
}; // Size: 0x28
struct FPalWorkSuitabilityDefineData
{
bool bIsChangeWorkAnimPlayRate;
// 0x0000 (size: 0x1)
TArray<int32> CraftSpeeds;
// 0x0008 (size: 0x10)
}; // Size: 0x18
struct FPalWorkSuitabilityDeforestDefineData
{
// 0x0000 (size: 0x18)
TArray<FPalDeforestRankDefineData> DeforestDefineData;
// 0x0018 (size: 0x10)
}; // Size: 0x28
struct FPalWorkSuitabilityInfo
{
// 0x0000 (size: 0x1)
int32 Rank;
// 0x0004 (size: 0x4)
}; // Size: 0x8
struct FPalWorkSuitabilityMiningDefineData
{
// 0x0000 (size: 0x18)
TArray<FPalMiningRankDefineData> MiningDefineData;
// 0x0018 (size: 0x10)
}; // Size: 0x28
struct FPalWorkTypeSet
{
TArray<EPalWorkType> WorkTypes;
// 0x0000 (size: 0x10)
}; // Size: 0x10
struct FPalWorkWaitParameter
{
}; // Size: 0x18
struct FPalWorldBaseInfoData
{
FPalWorldBaseInfoSaveData BaseInfoSaveData;
// 0x0000 (size: 0x28)
// 0x0028 (size: 0x8)
FString DirectoryPath;
// 0x0030 (size: 0x10)
}; // Size: 0x40
struct FPalWorldBaseInfoSaveData
{
FString WorldName;
// 0x0000 (size: 0x10)
FString HostPlayerName;
// 0x0010 (size: 0x10)
int32 HostPlayerLevel;
// 0x0020 (size: 0x4)
int32 InGameDay;
// 0x0024 (size: 0x4)
}; // Size: 0x28
struct FPalWorldHUDParameter
{
TWeakObjectPtr<class AActor> TargetActor;
// 0x0000 (size: 0x8)
// 0x0008 (size: 0x18)
TSubclassOf<class UPalUserWidgetWorldHUD> WorldHUDClass;
// 0x0020 (size: 0x8)
EPalWorldHUDWidgetBlueprintType WorldHUDType;
// 0x0028 (size: 0x1)
class UPalHUDDispatchParameterBase* HUDParameter;
// 0x0030 (size: 0x8)
FVector DisplayOffset;
// 0x0038 (size: 0x18)
FVector2D DisplayOffsetScreenPos;
// 0x0050 (size: 0x10)
float DisplayRange;
// 0x0060 (size: 0x4)
bool bEnableShow;
// 0x0064 (size: 0x1)
}; // Size: 0x68
struct FPalWorldMapUIDataSave
{
TMap<class FName, class bool> unlockedRegionMap;
// 0x0000 (size: 0x50)
}; // Size: 0x50
struct FPalWorldMapUIDataTableRow : public FTableRowBase

{
FVector2D minMapTextureBlockSize;
// 0x0008 (size: 0x10)
FVector2D mapBlockNum;
// 0x0018 (size: 0x10)
FVector landScapeRealPositionMin;
// 0x0028 (size: 0x18)
FVector landScapeRealPositionMax;
// 0x0040 (size: 0x18)
TMap<class FName, class FPalWorldMapUIRegionData> textureDataMap;
// 0x0058 (size: 0x50)
TSoftObjectPtr<UTexture2D> DefaultMaskTexture;
// 0x00A8 (size: 0x30)
}; // Size: 0xD8
struct FPalWorldMapUIRegionData
{
// 0x0000 (size: 0x30)
FVector2D blockSize;
// 0x0030 (size: 0x10)
FVector2D gridPosition;
// 0x0040 (size: 0x10)
FName regionNameMsgId;
// 0x0050 (size: 0x8)
}; // Size: 0x58
struct FPalWorldObjectRecordData_MapObjectSpawner
{
TMap<int32, FPalWorldObjectRecordData_MapObjectSpawnerItem> ItemMap;
// 0x0000 (size: 0x50)
}; // Size: 0x58
struct FPalWorldObjectRecordData_MapObjectSpawnerInStage
{
TMap<class FGuid, class FPalWorldObjectRecordData_MapObjectSpawner>
RecordDataMapByLevelObjectInstanceId; // 0x0000 (size: 0x50)
}; // Size: 0x50
struct FPalWorldObjectRecordData_MapObjectSpawnerItem
{
FGameDateTime NextSpawnLotteryGameTime;
// 0x0000 (size: 0x8)
// 0x0008 (size: 0x10)
}; // Size: 0x18
struct FPalWorldPlayerSaveData
{
FGuid PlayerUId;
// 0x0000 (size: 0x10)
// 0x0010 (size: 0x30)
FGuid RespawnPointMapObjectInstanceId;
// 0x0040 (size: 0x10)
FTransform LastTransform;
// 0x0050 (size: 0x60)
FString PlayerName;
// 0x00B0 (size: 0x10)
FPalPlayerDataCharacterMakeInfo PlayerCharacterMakeData;
// 0x00C0 (size: 0x94)
FPalContainerId OtomoCharacterContainerId;
// 0x0154 (size: 0x10)
EPalOtomoPalOrderType OtomoOrder;
// 0x0164 (size: 0x1)
FPalPlayerDataInventoryInfo inventoryInfo;
// 0x0168 (size: 0x60)
// 0x01C8 (size: 0x4)
int32 bossTechnologyPoint;
// 0x01CC (size: 0x4)
TArray<FName> UnlockedRecipeTechnologyNames;
// 0x01D0 (size: 0x10)
FPalContainerId PalStorageContainerId;
// 0x01E0 (size: 0x10)
FPalLoggedinPlayerSaveDataRecordData RecordData;
// 0x01F0 (size: 0x2B0)
bool bIsSelectedInitMapPoint;
// 0x04A0 (size: 0x1)
}; // Size: 0x4B0
struct FPalWorldSaveData
{
FString WorldName;
// 0x0000 (size: 0x10)
TMap<class FPalInstanceID, class FPalIndividualCharacterSaveParameterSaveData>
CharacterSaveParameterMap; // 0x0010 (size: 0x50)
TArray<FPalMapObjectSaveData> MapObjectSaveData;
// 0x0060 (size: 0x10)
TMap<class FPalCellCoord, class FPalFoliageGridSaveData>
FoliageGridSaveDataMap; // 0x0070 (size: 0x50)
TMap<class FGuid, class FPalMapObjectSpawnerSaveData> MapObjectSpawnerSaveData;
// 0x00C0 (size: 0x50)
TMap<class FPalStageInstanceId, class FPalMapObjectSpawnerInStageSaveData>
MapObjectSpawnerInStageSaveData; // 0x0110 (size: 0x50)
TArray<FPalWorkSaveData> WorkSaveData;
// 0x0160 (size: 0x10)
TMap<class FGuid, class FPalBaseCampSaveData> BaseCampSaveData;
// 0x0170 (size: 0x50)
TMap<class FPalContainerId, class FPalItemContainerSaveData>
ItemContainerSaveData; // 0x01C0 (size: 0x50)
TArray<FPalDynamicItemSaveData> DynamicItemSaveData;
// 0x0210 (size: 0x10)
TMap<class FPalContainerId, class FPalCharacterContainerSaveData>
CharacterContainerSaveData; // 0x0220 (size: 0x50)
TMap<class FGuid, class FPalGroupSaveData> GroupSaveDataMap;
// 0x0270 (size: 0x50)
FPalCharacterParameterStorageSaveData CharacterParameterStorageSaveData;
// 0x02C0 (size: 0x10)
FPalGameTimeSaveData GameTimeSaveData;
// 0x02D0 (size: 0x10)
FPalBossSpawnerSaveData BossSpawnerSaveData;
// 0x02E0 (size: 0x50)
FPalEnemyCampSaveData EnemyCampSaveData;
// 0x0330 (size: 0x50)
TArray<FPalDungeonPointMarkerSaveData> DungeonPointMarkerSaveData;
// 0x0380 (size: 0x10)
TArray<FPalDungeonSaveData> DungeonSaveData;
// 0x0390 (size: 0x10)
}; // Size: 0x3A0
struct FPalWorldSecurityWantedPoliceSettingData
{
FPalDataTableRowName_PalHumanData PoliceType;
// 0x0000 (size: 0x8)
int32 PoliceNum;
// 0x0008 (size: 0x4)
int32 PoliceLevel;
// 0x000C (size: 0x4)
}; // Size: 0x10
struct FPalWorldSecurityWantedStateInfo
{
FDateTime ExpiredDate;
// 0x0000 (size: 0x8)
TArray<FGuid> CrimeInstanceIdArray;
// 0x0008 (size: 0x10)
}; // Size: 0x18
struct FPlayerGenderParams
{
TMap<class EPalWeaponType, class TSoftClassPtr<UPalShooterAnimeAssetBase>>
DefaultWeaponAnimeAssetBPSoftClassMap; // 0x0000 (size: 0x50)
TMap<class TSoftClassPtr<APalWeaponBase>, class
TSoftClassPtr<UPalShooterAnimeAssetBase>> OtherWeaponAnimeAssetBPSoftClassMap; //
0x0050 (size: 0x50)
float ClavicleAdjustDegree;
// 0x00A0 (size: 0x4)
}; // Size: 0xA8
struct FReactivePropertyFloat
{
}; // Size: 0x18
struct FReserveMontage
{
class UAnimMontage* Montage;
// 0x0000 (size: 0x8)
float PlayRate;
// 0x0008 (size: 0x4)
float StartTime;
// 0x000C (size: 0x4)
}; // Size: 0x10
struct FRiderActionInfo
{
TSubclassOf<class UPalActionBase> RideAction;
// 0x0000 (size: 0x8)
TSubclassOf<class UPalActionBase> GetOffAction;
// 0x0008 (size: 0x8)
}; // Size: 0x10
struct FRidingAimingAnimationInfo
{
class UAnimSequence* ShootingAnimation;
// 0x0000 (size: 0x8)
class UAimOffsetBlendSpace* ShootingAO;
// 0x0008 (size: 0x8)
}; // Size: 0x10
struct FRidingAnimationInfo
{
class UAnimSequence* RidingAnimation;
// 0x0000 (size: 0x8)
class UAnimMontage* RidingShakingMontage;
// 0x0008 (size: 0x8)
class UAnimSequence* RideShootingAnimation;
// 0x0010 (size: 0x8)
class UAimOffsetBlendSpace* RideShootingAO;
// 0x0018 (size: 0x8)
}; // Size: 0x20
struct FShooterSpringCameraAdditionalOffset
{
FName flagName;
// 0x0000 (size: 0x8)
int32 Priority;
// 0x0008 (size: 0x4)
FShooterSpringCameraParameter CameraOffset;
// 0x0010 (size: 0x20)
}; // Size: 0x30
struct FShooterSpringCameraParameter
{
float ArmLength;
// 0x0000 (size: 0x4)
FVector CameraOffset;
// 0x0008 (size: 0x18)
}; // Size: 0x20
struct FSkillEffectSpawnParameter
{
float TimeOffset;
// 0x0000 (size: 0x4)
TSubclassOf<class APalSkillEffectBase> SkillEffectClass;
// 0x0008 (size: 0x8)
FVector SpawnOffset;
// 0x0010 (size: 0x18)
bool bAttachToOwner;
// 0x0028 (size: 0x1)
FName AttachSocketName;
// 0x002C (size: 0x8)
EPalBodyLocationType AttachLocationType;
// 0x0034 (size: 0x1)
}; // Size: 0x38
struct FSpawnedEnemyInfo
{
// 0x0000 (size: 0x8)
EPalEnemySpawnActorType WeaponType;
// 0x0008 (size: 0x1)
// 0x0010 (size: 0x8)
}; // Size: 0x18
struct FStatusDynamicParameter
{
int32 GeneralIndex;
// 0x0000 (size: 0x4)
FName GeneralName;
// 0x0004 (size: 0x8)
}; // Size: 0xC
struct FTargetAbleInfoForEnemy
{
// 0x0000 (size: 0x8)
int32 DuplicateNum;
// 0x0008 (size: 0x4)
float ThreatLevel_OnlyCharacterParam;
// 0x000C (size: 0x4)
}; // Size: 0x10
struct FTutorialDataStruct : public FTableRowBase

{
FName MsgId;
// 0x0008 (size: 0x8)
EPalTutorialTriggerType Type;
// 0x0010 (size: 0x1)
bool MultiTrigger;
// 0x0011 (size: 0x1)
EPalTutorialTriggerConditionType ConditionType;
// 0x0012 (size: 0x1)
TArray<FName> ConditionObjectIds;
// 0x0018 (size: 0x10)
FName ConditionCategoryName;
// 0x0028 (size: 0x8)
float ConditionValue;
// 0x0030 (size: 0x4)
}; // Size: 0x38
struct FUITransientData
{
int32 RadialMenuLastTab;
// 0x0000 (size: 0x4)
bool IsCampTaskUIOpen;
// 0x0004 (size: 0x1)
FName LastOpenedPaldexCharacter;
// 0x0008 (size: 0x8)
bool NewsOpened;
// 0x0010 (size: 0x1)
bool IsOpenedSurvivalGuide;
// 0x0011 (size: 0x1)
bool ServerLobbyDialogOpened;
// 0x0012 (size: 0x1)
}; // Size: 0x14
struct FWeaponAnimationInfo
{
class UBlendSpace1D* NormalMoveBlendSpace;
// 0x0000 (size: 0x8)
class UBlendSpace1D* CrouchMoveBlendSpace;
// 0x0008 (size: 0x8)
class UBlendSpace* AimingMoveBlendSpace;
// 0x0010 (size: 0x8)
class UBlendSpace* HipShootingMoveBlendSpace;
// 0x0018 (size: 0x8)
class UBlendSpace* CrouchAimingMoveBlendSpace;
// 0x0020 (size: 0x8)
class UAnimMontage* JumpPreliminary;
// 0x0028 (size: 0x8)
class UAnimSequence* JumpStart;
// 0x0030 (size: 0x8)
class UAnimSequence* JumpLoopUp;
// 0x0038 (size: 0x8)
class UAnimSequence* JumpLoopDown;
// 0x0040 (size: 0x8)
class UAnimSequence* JumpEnd;
// 0x0048 (size: 0x8)
class UAnimSequence* Sliding;
// 0x0050 (size: 0x8)
class UAnimSequence* SlidingEnd;
// 0x0058 (size: 0x8)
class UAnimSequence* Sprint;
// 0x0060 (size: 0x8)
class UAnimMontage* ReloadMontage;
// 0x0068 (size: 0x8)
class UAnimMontage* WeaponChangeMontage;
// 0x0070 (size: 0x8)
TMap<class EWeaponAnimationPoseType, class UAnimSequence*> IdlePoseMap;
// 0x0078 (size: 0x50)
TMap<class EWeaponAnimationPoseType, class UAnimSequence*> JogPoseMap;
// 0x00C8 (size: 0x50)
TMap<class EWeaponAnimationPoseType, class UAnimSequence*> AimBaseMap;
// 0x0118 (size: 0x50)
TMap<class EWeaponAnimationPoseType, class UAimOffsetBlendSpace*> AimOffsetMap;
// 0x0168 (size: 0x50)
TMap<class EWeaponAnimationType, class FWeaponNotifyAnimationInfo>
AnimationMap; // 0x01B8 (size: 0x50)
TMap<class EPalRidePositionType, class FRidingAnimationInfo>
RidingAnimationMap; // 0x0208 (size: 0x50)
}; // Size: 0x258
struct FWeaponNotifyAnimationInfo
{
TMap<class EWeaponAnimationPoseType, class UAnimMontage*> PoseMap;
// 0x0000 (size: 0x50)
bool isAutoStop;
// 0x0050 (size: 0x1)
}; // Size: 0x58
class APalAIController : public AAIController

{
TArray<class AActor*> TargetPlayers;
// 0x03B8 (size: 0x10)
TArray<class AActor*> TargetNPCs;
// 0x03C8 (size: 0x10)
TSubclassOf<class UPalAICombatModule> CombatModuleClass;
// 0x03D8 (size: 0x8)
class UPalActiveSkillSlot* SkillSlot;
// 0x03E0 (size: 0x8)
FString DebugOrganizationName;
// 0x03E8 (size: 0x10)
class APalCharacter* R1AttackTarget;
// 0x03F8 (size: 0x8)
float MinAIActionComponentTickInterval;
// 0x0400 (size: 0x4)
bool bIsActive;
// 0x0410 (size: 0x1)
bool IsSquadBehaviour;
// 0x0411 (size: 0x1)
bool IsNotSleepWildLife;
// 0x0412 (size: 0x1)
class UPalSquad* MySquad;
// 0x0418 (size: 0x8)
class UPalHate* HateSystem;
// 0x0420 (size: 0x8)
class UPalAIActionComponent* AIActionComponent;
// 0x0428 (size: 0x8)
class UPalAIBlackboardBase* PalAIBlackboard;
// 0x0430 (size: 0x8)
bool bOverwriteBlockDetectionParams;
// 0x04C0 (size: 0x1)
FPalPathFollowingBlockDetectionParams BlockDetectionParams;
// 0x04C4 (size: 0xC)
TSubclassOf<class UPalAIBlackboardBase> PalBlackboardClass;
// 0x04D0 (size: 0x8)
FTimerHandle DeadBodyDeleteTimerHandle;
// 0x04E0 (size: 0x8)
bool IsDeadBodyTimeDelate;
// 0x04E8 (size: 0x1)
bool IsSelfTimeDelate_FromSpawnTime;
// 0x04E9 (size: 0x1)
FTimerHandle SelfDeleteTimerHandle;
// 0x04F0 (size: 0x8)
void WaitForSeconds(float Time);

void SimpleMoveToActorWithLineTraceGround(const class AActor* GoalActor);
void ShowHateArrow();
void ShowActionDebug();
void SetInitialValue(bool IsSquad, bool NotSleep);
void SetActiveAI(bool Active);
void RPCDummy();
TEnumAsByte<EPathFollowingRequestResult::Type> PalMoveToLocation(const FVector&
Dest, float AcceptanceRadius, bool bStopOnOverlap, bool bUsePathfinding, bool
bProjectDestinationToNavigation, bool bCanStrafe, TSubclassOf<class
UNavigationQueryFilter> FilterClass, bool bAllowPartialPaths);
void OnDeadTimerStart(FPalDeadInfo Info);
void OnChangedActiveCharacter(const bool bActive);
void OnChangeChangeImportance(EPalCharacterImportanceType Next);
void NotifyTalkStart(class APalPlayerCharacter* TalkPlayer);
void NotifyTalkEnd(class APalPlayerCharacter* TalkPlayer);
void MoveToLocation_ErrorSupportMove(FVector GoalLocation);
void MoveToDirectly(FVector GoalLocation);
bool IsOnNavMesh_TargetLocation(FVector TargetLocation);
bool IsOnNavMesh();
bool IsLeader();
bool IsExistPathForLocation_ForBP_HeightRangeCheck(const FVector Location,
const float AcceptanceRadius, const float UpOffset, const float DownOffset,
FVector& OutGoalLocation);
bool IsExistPathForLocation_ForBP(const FVector Location, const float
AcceptanceRadius);
bool IsActiveAI();
class APalCharacter* GetSquadLeader();
class UPalSquad* GetSquad();
class UPalAIBlackboardBase* GetMyPalBlackboard();
class UPalAIBlackboardBase* GetLeaderPalBlackboard();
bool GetIsSquadBehaviour();
bool GetIsnotSleepWildLife();
class UPalHate* GetHateSystem();
class UPalAIActionComponent* GetAIActionComponent();
bool FindReachablePathLocation(TArray<FVector> RequestLocationArray, FVector&
OutGoalLocation);
bool FindNearestNavmeshPointFromSelf(FVector& OutLocation);
void DeleteSelfDeadBody();
void CreatePalBlackboard();
class AActor* CopyTargetFromOtherAI(const class AActor* FromAcotr);
void AddTargetPlayer_ForEnemy(class AActor* PlayerOrPal);
void AddTargetNPC(class AActor* NPC);
}; // Size: 0x4F8
class APalActionDummyTargetActor : public AActor

{
}; // Size: 0x290
class APalAmbientSoundAreaBase : public AActor

{
int32 AmbientPriority;
// 0x0290 (size: 0x4)
TArray<class UAkAudioEvent*> DayAmbientEvents;
// 0x0298 (size: 0x10)
TArray<class UAkAudioEvent*> NightAmbientEvents;
// 0x02A8 (size: 0x10)
bool bIsOverlappedLocalPlayer;
// 0x02B8 (size: 0x1)
void OnEndOverlap(class UPrimitiveComponent* OverlappedComponent, class

APalPlayerCharacter* PlayerCharacter);
void OnBeginOverlap(class UPrimitiveComponent* OverlappedComponent, class
class UPrimitiveComponent* GetAreaCollision();
FPalAmbientSoundAreaData GetAmbientSoundAreaData();
}; // Size: 0x2C0
class APalAmbientSoundLineBase : public AActor

{
class UAkComponent* AkComponent;
// 0x0290 (size: 0x8)
class UBoxComponent* ActivateTrigger;
// 0x0298 (size: 0x8)
class UPalAmbientSoundLineObject* AmbinetSoundLineObject;
// 0x02A0 (size: 0x8)
}; // Size: 0x2A8
class APalBackWeaponBase : public AActor

{
bool InFirstOrSecondSlot;
// 0x0290 (size: 0x1)
bool IsEquipHand;
// 0x0291 (size: 0x1)
FFlagContainer HiddenBackWeapon;
// 0x0298 (size: 0x50)
}; // Size: 0x2E8
class APalBiomeAreaTriggerBase : public AActor

{
EPalBiomeType BindBiomeType;
// 0x0290 (size: 0x1)
void OnOverlap(class AActor* OtherActor, EPalBiomeType BiomeType);

void OnEndOverlap(class AActor* OtherActor, EPalBiomeType BiomeType);
EPalBiomeType GetBiomeType();
}; // Size: 0x298
class APalBossBattleLevelInstance : public ALevelInstance

{
FPalBossBattleLevelInstanceOnBossSpawnedDelegate OnBossSpawnedDelegate;
// 0x0320 (size: 0x10)
void OnBossSpawnedDelegate(class APalCharacter* SpawnedCharacter);
bool bIsLoaded;
// 0x0330 (size: 0x1)
void SpawnBossSpawner(EPalBossType BossType, int32 JoinPlayerNum);

void ResetBossLocation();
void OnBossSpawnedDelegate__DelegateSignature(class APalCharacter*
SpawnedCharacter);
FTransform GetSequencerTransform();
FTransform GetPlayerStartTransform();
bool CheckLevelLoaded();
void BossSpawned(class APalCharacter* SpawnedCharacter);
}; // Size: 0x338
class APalBossTower : public AActor

{
FPalBossTowerOnChangeBossTowerEntryWaitUI OnChangeBossTowerEntryWaitUI;
// 0x0298 (size: 0x10)
void OnChangeBossTowerEntryWaitUI(bool bIsCountDown, FDateTime TimeLimit);
EPalBossType BossType;
// 0x02A8 (size: 0x1)
FGuid EntryWaitInfoHUDId;
// 0x02AC (size: 0x10)
class UPalBossBattleInstanceModel* InstanceModel;
// 0x02C0 (size: 0x8)
FDateTime CombatTimeLimit;
// 0x02C8 (size: 0x8)
FGuid LocationInstanceId;
// 0x02D0 (size: 0x10)
TArray<class APalPlayerCharacter*> InDoorPlayerList;
// 0x02E0 (size: 0x10)
FTimerHandle TimerHandle;
// 0x02F0 (size: 0x8)
bool WriteBossDefeatRecord_ServerInternal(class APalPlayerCharacter*

TargetPlayer);
void ShowWaitInfo(const FVector TargetLocation, const FVector DisplayOffset,
bool isWaiting);
void RequestBossBattleStart(class APalPlayerCharacter* Player);
void RequestBossBattleEntry(class APalPlayerCharacter* Player);
void RemoveInDoorPlayer(class APalPlayerCharacter* Player);
void OnRep_InstanceModel();
void OnChangeEntryPlayer(TArray<class APalPlayerCharacter*> EntryPlayers);
void OnChangeCombatTimeLimit(FDateTime NewCombatTimeLimit);
void OnChangeBossTowerEntryWaitUI__DelegateSignature(bool bIsCountDown,
FDateTime TimeLimit);
void OnChangeBossBattleStateBP(EPalBossBattleState NewState);
void OnChangeBossBattleState(EPalBossBattleState NewBossBattleState);
bool IsEntered(class APalPlayerCharacter* Player);
FTransform GetTopWarpPoint();
TArray<class APalPlayerCharacter*> GetStartablePlayers();
FTransform GetFrontWarpPoint();
TArray<class APalPlayerCharacter*> GetForceWarpTargets();
FTransform GetDeadItemDropPoint();
FName GetBossBattleRowName();
void CloseWaitInfo();
void AddInDoorPlayer(class APalPlayerCharacter* Player);
}; // Size: 0x2F8
class APalBotBuilderLocationBase : public AActor

{
int32 BuilderIndex;
// 0x0290 (size: 0x4)
bool bIsBuilded;
// 0x0294 (size: 0x1)
}; // Size: 0x298
class APalBoxSpawnerPlacementTool : public AActor

{
FVector BoxExtent;
// 0x0290 (size: 0x18)
class UBoxComponent* BoxComp;
// 0x02A8 (size: 0x8)
}; // Size: 0x2B0
class APalBuildObject : public APalMapObject
{
FPalBuildObjectOnChangeState OnChangeState;
// 0x03C0 (size: 0x10)
void OnChangeStateDelegate(EPalBuildObjectState State);
EPalBuildObjectInstallStrategy InstallStrategy;
// 0x03E8 (size: 0x1)
float InstallCapacitySlopeAngle;
// 0x03EC (size: 0x4)
float InstallCapacitySinkRateByHeight;
// 0x03F0 (size: 0x4)
class UPalBuildObjectVisualControlComponent* VisualCtrl;
// 0x03F8 (size: 0x8)
// 0x0400 (size: 0x8)
class UShapeComponent* OverlapCheckCollision;
// 0x0408 (size: 0x8)
FComponentReference OverlapCheckCollisionRef;
// 0x0410 (size: 0x28)
FBox LocalBounds;
// 0x0438 (size: 0x38)
class UPalBuildObjectOverlapChecker* OverlapChecker;
// 0x0470 (size: 0x8)
TArray<class UMeshComponent*> AllMeshes;
// 0x0478 (size: 0x10)
TArray<class UPrimitiveComponent*> VirtualMeshCollisions;
// 0x0488 (size: 0x10)
EPalBuildObjectState CurrentState;
// 0x0498 (size: 0x1)
FGuid WorldHUDId;
// 0x049C (size: 0x10)
FGuid buildProgressWorldHUDId;
// 0x04AC (size: 0x10)
FVector WorldHUDDisplayOffset;
// 0x04C0 (size: 0x18)
float WorldHUDDisplayRange;
// 0x04D8 (size: 0x4)
FVector buildProgressHUDDisplayOffset;
// 0x04E0 (size: 0x18)
FVector2D buildProgressHUDDisplayOffsetScreen;
// 0x04F8 (size: 0x10)
float buildProgressHUDDisplayRange;
// 0x0508 (size: 0x4)
class UAkAudioEvent* BuildCompleteSEOverride;
// 0x0510 (size: 0x8)
float BuildProgressVisualRate;
// 0x0518 (size: 0x4)
bool bDismantleTargetInLocal;
// 0x051C (size: 0x1)
TMap<class UPrimitiveComponent*, class FPalBuildObjectMeshDefaultSetting>
DefaultMeshSettingMap; // 0x0520 (size: 0x50)
void PlayBuildCompleteFX_ToALL();
void OnUpdateHp(class UPalMapObjectModel* DamagedModel);
void OnUpdateBuildWorkAmount(class UPalWorkProgress* WorkProgress);
void OnTriggerInteractBuilding(class AActor* OtherActor,
EPalInteractiveObjectIndicatorType IndicatorType);
void OnTickRepairCompleteAnimation();
void OnTickBuildCompleteAnimation();
void OnStartTriggerInteractBuilding(class AActor* OtherActor,
void OnRep_CurrentState();
void OnRep_BuildProgressVisualRate();
void OnNotAvailable_BlueprintImpl();
void OnFinishBuildWork_ServerInternal(class UPalBuildProcess* BuildProcess);
void OnEndTriggerInteractBuilding(class AActor* OtherActor,
void OnDamage(class UPalMapObjectModel* DamagedModel, const FPalDamageInfo&
DamageInfo);
void OnChangeStateDelegate__DelegateSignature(EPalBuildObjectState State);
void OnBeginInteractBuilding(class AActor* OtherActor, TScriptInterface<class
IPalInteractiveObjectComponentInterface> InteractiveObject);
void OnAvailable_BlueprintImpl();
bool IsAvailable();
class UShapeComponent* GetBuildWorkableBoundsShape();
}; // Size: 0x570
class APalBuildObjectBaseCampPoint : public APalBuildObject

{
FTransform GetWorkerSpawnLocalTransform();
FTransform GetFastTravelLocalTransform();
}; // Size: 0x570
class APalBuildObjectBreedFarm : public APalBuildObject

{
FComponentReference ChestInteractRef;
// 0x0570 (size: 0x28)
FComponentReference WalkAroundVolumeRef;
// 0x0598 (size: 0x28)
}; // Size: 0x5C0
class APalBuildObjectDefenseBase : public APalBuildObject

{
TSubclassOf<class UPalAIActionBaseCampDefenseBase> DefenseAIActionClass;
// 0x0570 (size: 0x8)
FPalDataTableRowName_ItemData BulletItemId;
// 0x0578 (size: 0x8)
int32 MagazineSize;
// 0x0580 (size: 0x4)
}; // Size: 0x588
class APalBuildObjectFarmBlockV2 : public APalBuildObject

{
FPalDataTableRowName_FarmCropData CropDataId;
// 0x0570 (size: 0x8)
class UNiagaraSystem* GrowupFX;
// 0x0578 (size: 0x8)
class APalMapObjectFarmCrop* CropActor;
// 0x0580 (size: 0x8)
void OnUpdateState_ServerInternal(EPalFarmCropState LastCropState,

EPalFarmCropState NextCropState);
}; // Size: 0x598
class APalBuildObjectGenerateEnergy : public APalBuildObject
{
EPalEnergyType GenerateEnergyType;
// 0x0570 (size: 0x1)
float GenerateEnergyRateByWorker;
// 0x0574 (size: 0x4)
float MaxEnergyStorage;
// 0x0578 (size: 0x4)
void OnUpdateWorkAssigned_ServerInternal(class UPalWorkBase* Work);

void OnStartGenerate();
void OnEndGenerate();
void BroadcastStartGenerate();
void BroadcastEndGenerate();
}; // Size: 0x580
class APalBuildObjectInstallChecker : public AActor

{
class APalBuildObject* TargetBuildObject;
// 0x0290 (size: 0x8)
class UShapeComponent* OverlapCheckComponent;
// 0x0298 (size: 0x8)
class UPalBuildObjectOverlapChecker* OverlapChecker;
// 0x02A0 (size: 0x8)
class UPalBuildObjectInstallStrategyBase* InstallStrategy;
// 0x02A8 (size: 0x8)
}; // Size: 0x2B0
class APalBuildObjectMonsterFarm : public APalBuildObject

{
FComponentReference WalkAroundVolumeRef;
// 0x0570 (size: 0x28)
}; // Size: 0x598
class APalBuildObjectPalStorage : public APalBuildObject

{
FPalBuildObjectPalStorageOnOverlapBeginCageArea OnOverlapBeginCageArea;
// 0x0570 (size: 0x10)
void OverlapAreaDelegate(class UPrimitiveComponent* OverlappedComp, class
AActor* OtherActor, class UPrimitiveComponent* OtherComp);
FPalBuildObjectPalStorageOnOverlapEndCageArea OnOverlapEndCageArea;
// 0x0580 (size: 0x10)
FPalBuildObjectPalStorageOnOverlapBeginCageWalls OnOverlapBeginCageWalls;
// 0x0590 (size: 0x10)
FPalBuildObjectPalStorageOnOverlapEndCageWalls OnOverlapEndCageWalls;
// 0x05A0 (size: 0x10)
float BaseCampAreaRange;
// 0x05B0 (size: 0x4)
FComponentReference AccessPointObjectRef;
// 0x05B8 (size: 0x28)
FComponentReference AccessPointMovableRangeRef;
// 0x05E0 (size: 0x28)
FComponentReference AccessPointInteractRef;
// 0x0608 (size: 0x28)
FComponentReference ChestObjectRef;
// 0x0630 (size: 0x28)
FComponentReference ChestMovableRangeRef;
// 0x0658 (size: 0x28)
FComponentReference ChestInteractRef;
// 0x0680 (size: 0x28)
FName ChestWorkableBoundsName;
// 0x06A8 (size: 0x8)
int32 ChestSlotNum;
// 0x06B0 (size: 0x4)
void PlaySpawnCharacterFX(class APalCharacter* TargetActor);

void OverlapAreaDelegate__DelegateSignature(class UPrimitiveComponent*
OverlappedComp, class AActor* OtherActor, class UPrimitiveComponent* OtherComp);
void OnSpawnCharacter(FPalInstanceID IndividualId, int32 PhantomId);
FTransform GetWorkerSpawnLocalTransform();
FTransform GetFastTravelLocalTransform();
FTransform GetDisplayCharacterSpawnLocalTransform();
class USceneComponent* GetChestObject();
class UBoxComponent* GetChestMovableRange();
class UShapeComponent* GetCageAreaShape();
class UStaticMeshComponent* GetAccessPointObject();
class UBoxComponent* GetAccessPointMovableRange();
}; // Size: 0x6B8
class APalBullet : public AActor

{
FPalBulletOnDestroyDelegate OnDestroyDelegate;
// 0x0290 (size: 0x10)
void DestroyBulletDelegate(class UPrimitiveComponent* HitComp, class AActor*
OtherCharacter, class UPrimitiveComponent* OtherComp, const FHitResult& Hi);
class USphereComponent* CollisionComp;
// 0x02A0 (size: 0x8)
class UProjectileMovementComponent* ProjectileMovement;
// 0x02A8 (size: 0x8)
EPalPlayerDamageCameraShakeCategory PlayerDamageCameraShake;
// 0x02B0 (size: 0x1)
bool bIsHitFriend;
// 0x02B1 (size: 0x1)
int32 WeaponDamage;
// 0x02B4 (size: 0x4)
FTimerHandle Handle;
// 0x02B8 (size: 0x8)
bool isDamageable;
// 0x02C0 (size: 0x1)
bool AISoundEmitable;
// 0x02C1 (size: 0x1)
// 0x02C4 (size: 0x4)
float DeleteTime;
// 0x02C8 (size: 0x4)
float DamageDecayStartRate;
// 0x02CC (size: 0x4)
float LifeTimer;
// 0x02D0 (size: 0x4)
EPalDamageAnimationReactionType weaponBulletDamageReactionType;
// 0x02D4 (size: 0x1)
TArray<FPalPassiveSkillEffect> skillEffectList;
// 0x02D8 (size: 0x10)
TMap<TEnumAsByte<EPhysicalSurface>, FBulletHoleDecalInfo> BulletHoleDecalsMap;
// 0x02E8 (size: 0x50)
FBulletHoleDecalInfo DefaultBulletHoleDecals;
// 0x0338 (size: 0x30)
void SetWeaponDamage(int32 Damage);

void SetSneakAttackRate(float Rate);
void SetSkillEffectList(const TArray<FPalPassiveSkillEffect>& inList);
void SetDeleteTime(float DeleteSecound, float DecayStartRate);
void SetDamageable(bool damageable);
bool SetBulletHoleDecal(const FHitResult& Hit, float LifeSpan, float FadeTime,
float fadeScreenSize);
void OnHitToPalEnemy(class UPrimitiveComponent* HitComp, class APalCharacter*
OtherCharacter, class UPrimitiveComponent* OtherComp, const FHitResult& Hit);
void OnHitToPalCharacter(class UPrimitiveComponent* HitComp, class
APalCharacter* OtherCharacter, class UPrimitiveComponent* OtherComp, const
FHitResult& Hit);
void OnHitToActor(class UPrimitiveComponent* HitComp, class AActor* OtherActor,
class UPrimitiveComponent* OtherComp, const FHitResult& Hit);
void OnHit(class UPrimitiveComponent* HitComp, class AActor* OtherActor, class
UPrimitiveComponent* OtherComp, const FHitResult& Hit);
void OnDestroy(class UPrimitiveComponent* HitComp, class AActor*
void OnBlock(class UPrimitiveComponent* HitComp, class AActor* OtherActor,
class UPrimitiveComponent* OtherComp, FVector NormalImpulse, const FHitResult&
Hit);
void OnBeginOverlap(class UPrimitiveComponent* HitComp, class AActor*
OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool
bFromSweep, const FHitResult& Hit);
bool IsDestroy(class UPrimitiveComponent* HitComp, class AActor*
int32 GetWeaponDamage();
float GetSneakAttackRate();
float GetParameterWithPassiveSkillEffect(float originalValue,
EPalPassiveSkillEffectType EffectType);
float GetDecayDamageRate();
void DestroyBulletDelegate__DelegateSignature(class UPrimitiveComponent*
HitComp, class AActor* OtherCharacter, class UPrimitiveComponent* OtherComp, const
FHitResult& Hi);
}; // Size: 0x368
class APalCaptureJudgeObject : public AActor

{
void OnSuccessFinish();
void OnFailedFinish();
void OnFailedByTest(const class APalCharacter* Character, FCaptureResult
Result);
void OnFailedByMP(const class APalCharacter* Character, FCaptureResult Result);
void OnCaptureSuccess(const class APalCharacter* Character, FCaptureResult
Result);
void ChallengeCapture_ToServer(class APalCharacter* Character, float
capturePower);
void ChallengeCapture(class APalCharacter* Character, float capturePower);
void CaptureResult_ToALL(class APalCharacter* Character, FCaptureResult
Result);
}; // Size: 0x2B8
class APalCapturedCage : public AActor

{
FName FieldKeyName;
// 0x0298 (size: 0x8)
// 0x02A0 (size: 0x8)
float SpawnRange;
// 0x02A8 (size: 0x4)
float DespawnRange;
// 0x02AC (size: 0x4)
FName SpawnedPalId;
// 0x02B0 (size: 0x8)
int32 SpawnedPalLevel;
// 0x02B8 (size: 0x4)
bool IsRequestedInteract;
// 0x02BC (size: 0x1)
bool IsDisableInteractive;
// 0x02BD (size: 0x1)
bool IsInSpawnedRange;
// 0x02BE (size: 0x1)
class UPalIndividualCharacterHandle* SpawnedPalHandle;
// 0x02C0 (size: 0x8)
void SpawnPal(FName InPalID, int32 InPalLevel);

void SetOverrideKeyName(FName Key);
void SetDisableInteractive();
void RequestInteract(class APalPlayerCharacter* Attacker);
void OnCreateHandle(FPalInstanceID ID);
void LotteryAndSpawnPal();
class APalCharacter* GetSpawnedPal();
EPalInteractiveObjectIndicatorType GetIndicatorType();
FName GetCampSpawnerName();
}; // Size: 0x2C8
class APalCharacter : public ACharacter

{
float UpdateGroundInterval;
// 0x0618 (size: 0x4)
class UPalActionComponent* ActionComponent;
// 0x0620 (size: 0x8)
class UPalCharacterParameterComponent* CharacterParameterComponent;
// 0x0628 (size: 0x8)
class UPalStaticCharacterParameterComponent* StaticCharacterParameterComponent;
// 0x0630 (size: 0x8)
class UPalDamageReactionComponent* DamageReactionComponent;
// 0x0638 (size: 0x8)
class UPalStatusComponent* StatusComponent;
// 0x0640 (size: 0x8)
class UPalShooterSpringArmComponent* CameraBoom;
// 0x0648 (size: 0x8)
class UPalCharacterCameraComponent* FollowCamera;
// 0x0650 (size: 0x8)
class UPalNetworkMulticastGateComponent* MulticastGateComponent;
// 0x0658 (size: 0x8)
class UPalLookAtComponent* LookAtComponent;
// 0x0660 (size: 0x8)
class UPalNavigationInvokerComponent* NavInvokerComponent;
// 0x0668 (size: 0x8)
class UPalFootIKComponent* FootIKComponent;
// 0x0670 (size: 0x8)
class UPalVisualEffectComponent* VisualEffectComponent;
// 0x0678 (size: 0x8)
class UPalPassiveSkillComponent* PassiveSkillComponent;
// 0x0680 (size: 0x8)
class UPalHeadUpDisplayComponent* HUDComponent;
// 0x0688 (size: 0x8)
class UPalAnimNotifyParameterComponent* AnimNotifyComponent;
// 0x0690 (size: 0x8)
class UPalCharacterAroundInfoCollectorComponent* AroundInfoCollectorComponent;
// 0x0698 (size: 0x8)
FPalCharacterOnChangeActiveActorDelegate OnChangeActiveActorDelegate;
// 0x06A0 (size: 0x10)
void OnChangeActiveActor(bool bIsActive);
FPalCharacterOnRollingDelegate OnRollingDelegate;
// 0x06B0 (size: 0x10)
void RollingDelegate();
FPalCharacterOnRollingFinishDelegate OnRollingFinishDelegate;
// 0x06C0 (size: 0x10)
void RollingDelegate();
FPalCharacterOnCompleteSyncPlayerFromServer_InClient
OnCompleteSyncPlayerFromServer_InClient; // 0x06D0 (size: 0x10)
void OnCompleteSyncPlayerFromServer_InClient();
FPalCharacterOnChangeBattleModeDelegate OnChangeBattleModeDelegate;
// 0x06E0 (size: 0x10)
void OnChangeBattleMode(bool bIsBattleMode);
FPalCharacterOnChangeImportanceDelegate OnChangeImportanceDelegate;
// 0x06F0 (size: 0x10)
void OnChangeImportance(EPalCharacterImportanceType NextType);
FPalCharacterOnCapturedDelegate OnCapturedDelegate;
// 0x0700 (size: 0x10)
void OnCaptured(class APalCharacter* SelfCharacter, class APalCharacter*
Attacker);
bool bIsBattleMode;
// 0x0710 (size: 0x1)
bool bIsTalkMode;
// 0x0711 (size: 0x1)
bool bIsPalActiveActor;
// 0x0712 (size: 0x1)
bool bIsLocalInitialized;
// 0x0713 (size: 0x1)
bool bIsDisable_ChangeTickInterval_ByImportance;
// 0x0714 (size: 0x1)
FTimerHandle GroundCheckTimerHandle;
// 0x0718 (size: 0x8)
FVector SpawnLocation_ForServer;
// 0x0720 (size: 0x18)
FFlagContainer IsDisableChangeTickInterval;
// 0x0738 (size: 0x50)
EPalCharacterImportanceType ImportanceType;
// 0x0788 (size: 0x1)
FTimerHandle CheckIndividualParameterReplicateTimerHandle;
// 0x0790 (size: 0x8)
FName RootCollisionProfileName;
// 0x0798 (size: 0x8)
TMap<class EPalCharacterCompleteDelegatePriority, class
UPalCharacterOnCompleteInitializeParameterWrapper*>
OnCompleteInitializeParameterDelegateMap; // 0x07A8 (size: 0x50)
void UpdateGroundRayCast();
void SetVisibleHandAttachMesh(bool Active);
void SetVisibleCharacterMesh(bool Active);
void SetDisableChangeIntervalByImportance(FName flagName, bool isDisable);
void SetActiveCollisionMovement(bool Active);
void SetActiveActorStayVisible(bool Active);
void SetActiveActor(bool Active);
void RPCDummy();
void RollingDelegate__DelegateSignature();
void ReviveCharacter_ToServer(FFixedPoint HP);
void ReviveCharacter(FFixedPoint HP);
void ResetTickInterval();
void RequestJump();
void Play2Montage(class UAnimMontage* firstMontage, class UAnimMontage*
nextMontage);
void OnTeleport_ToClient(const FVector& Location, const FQuat& Rotation);
void OnRep_RootCollisionProfileName();
void OnRep_IsPalActiveActor(bool PrevIsActiveActor);
void OnOverlapEndByAroundInfo(class AActor* OtherActor);
void OnOverlapBeginByAroundInfo(class AActor* OtherActor);
void OnCompleteSyncPlayerFromServer_InClient__DelegateSignature();
void OnCompleteInitializeParameter__DelegateSignature(class APalCharacter*
InCharacter);
void OnChangeWetnessStatus(bool IsSwim);
void OnChangeImportance__DelegateSignature(EPalCharacterImportanceType
NextType);
void OnChangeBattleMode__DelegateSignature(bool bIsBattleMode);
void OnChangeActiveActor__DelegateSignature(bool bIsActive);
void OnCaptured__DelegateSignature(class APalCharacter* SelfCharacter, class
APalCharacter* Attacker);
bool IsInitialized();
bool IsCooping();
void GetVisual_ExceptMainMesh_SyncAnyway(TArray<class USceneComponent*>&
OutComponent);
bool GetTalkMode();
class UPalCharacterMovementComponent* GetPalCharacterMovementComponent();
TSoftObjectPtr<UNiagaraSystem> GetOverrideSleepFX();
class USkeletalMeshComponent* GetOverrideFaceMesh();
class UPalCharacterOnCompleteInitializeParameterWrapper*
GetOnCompleteInitializeParameterDelegate(EPalCharacterCompleteDelegatePriority
Priority);
class UPalSkeletalMeshComponent* GetMainMesh();
class USkeletalMeshComponent* GetHandAttachMesh();
class UPalCharacterParameterComponent* GetCharacterParameterComponent();
bool GetBattleMode();
bool GetActiveActorFlag();
class UPalActionComponent* GetActionComponent();
void ChangeWantFood_ToAll(bool IsWantFood, bool IsExistFood);
void ChangeTalkModeFlag_ToAll(bool IsTalk);
void ChangeBattleModeFlag_ToAll(bool IsBattle);
void ChangeBattleModeFlag(bool IsBattle);
void BroadcastOnCompleteInitializeParameter();
void
BindFonctionToOnCompleteInitializeParameter(EPalCharacterCompleteDelegatePriority
Priority, FBindFonctionToOnCompleteInitializeParameterCallback Callback);
}; // Size: 0x800
class APalCopyMeshVisualEffect : public AActor
{
class UCapsuleComponent* RootCapsule;
// 0x0290 (size: 0x8)
class UPalPoseableMeshComponent* PoseableSkeletalMeshComponent;
// 0x0298 (size: 0x8)
void Setup(class USkeletalMeshComponent* MeshComponent);

TArray<class UMaterialInstanceDynamic*> GetMainMeshMaterials();
class USkinnedMeshComponent* GetMainMesh();
void GetAllMesh(TArray<class USceneComponent*>& OutComponent);
}; // Size: 0x2A0
class APalCutsceneActor : public ALevelSequenceActor

{
float OpeningFadeOutDelay;
// 0x0308 (size: 0x4)
float OpeningFadeOutTime;
// 0x030C (size: 0x4)
void OnPrePlayCutscene();
void OnFinishedCutscene();
}; // Size: 0x310
class APalDebug_SpawnInfoReporter : public AActor

{
TArray<class APalNPCSpawnerBase*> CacheSpawner;
// 0x0290 (size: 0x10)
FString GetDebugInfoString(class APalNPCSpawnerBase* spawner);

}; // Size: 0x2A0
class APalDismantleObjectChecker : public AActor

{
// 0x0290 (size: 0x8)
class APalBuildObject* GetTargetObject();

}; // Size: 0x298
class APalDungeonAreaVolume : public APalStageAreaVolume

{
void OnOverlapActor(class AActor* Other);

}; // Size: 0x298
class APalDungeonEnemySpawnerPoint : public AActor

{
EPalDungeonEnemySpawnerRankType RankType;
// 0x02A0 (size: 0x1)
void ReturnIndividualHandleDelegate__DelegateSignature(class
UPalIndividualCharacterHandle* IndividualHandle);
void OnEnterCharacterToGroup(class UPalIndividualCharacterHandle*
IndividualHandle);
void OnCreatedGroup();
void OnChangeBossState_ServerInternal(class UPalDungeonInstanceModel*
InstanceModel);
void CheckLevelStreamingCompleted();
}; // Size: 0x2C8
class APalDungeonEntrance : public AActor

{
class UPalStageModelDungeon* StageModel;
// 0x0298 (size: 0x8)
bool TryGetDungeonInstanceModel(class UPalDungeonInstanceModel*& OutModel);

void OnTriggerInteract(class AActor* Other, EPalInteractiveObjectIndicatorType
IndicatorType);
void OnResponseDialogEnterDungeon(const bool bResponse);
FTransform GetWarpPoint();
class UPalStageModelDungeon* GetStageModel();
FPalStageInstanceId GetStageInstanceId();
FGuid GetDungeonInstanceId();
FTransform GetDeadItemDropPoint();
}; // Size: 0x2A0
class APalDungeonExit : public AActor

{
bool bStartPoint;
// 0x0298 (size: 0x1)

IndicatorType);
void OnResponseDialogExitDungeon(const bool bResponse);
bool IsStartPoint();
FTransform GetWarpPoint();
}; // Size: 0x2A0
class APalDungeonFixedEntrance : public APalDungeonEntrance

{
// 0x02A8 (size: 0x10)
FDataTableRowHandle DungeonNameRowHandle;
// 0x02B8 (size: 0x10)
class UDataLayerAsset* DataLayerAsset;
// 0x02C8 (size: 0x8)
TSoftClassPtr<APalNPCSpawnerBase> EnemySpawnerSoftClass;
// 0x02D0 (size: 0x30)
float RespawnCoolTimeMinutesAfterBossDefeated;
// 0x0300 (size: 0x4)
TSubclassOf<class APalNPCSpawnerBase> EnemySpawnerClass;
// 0x0318 (size: 0x8)
FGuid GetLevelObjectInstanceId();
TSoftClassPtr<APalNPCSpawnerBase> GetEnemySpawnerSoftClass();
TSubclassOf<class APalNPCSpawnerBase> GetEnemySpawner();
class UDataLayerAsset* GetDataLayerAsset();
}; // Size: 0x320
class APalDungeonGimmickUnlockableDoor : public AActor

{
}; // Size: 0x290
class APalDungeonGimmickUnlockableDoor_DefeatBoss : public

APalDungeonGimmickUnlockableDoor
{
// 0x0290 (size: 0x1)
void OnRep_BossState();
void OnChangeBossStateImpl(const EPalDungeonInstanceBossState ToState);
void OnChangeBossState_ServerInternal(class UPalDungeonInstanceModel*
InstanceModel);
}; // Size: 0x298
class APalDungeonItemSpawnerPoint : public APalLevelObjectActor

{
EPalDungeonItemSpawnerType ItemSpawnerType;
// 0x02A8 (size: 0x1)
TSoftClassPtr<APalMapObjectSpawnerTreasureBox> TreasureBoxSpawnerSoftClass;
// 0x02B0 (size: 0x30)
}; // Size: 0x2F8
class APalDungeonPointMarker : public APalLevelObjectActor

{
TArray<FPalDataTableRowName_DungeonSpawnAreaData> SpawnAreaIds;
// 0x02A8 (size: 0x10)
bool bEditSpawnParameter;
// 0x02B8 (size: 0x1)
FPalDungeonMarkerPointSpawnParameter EditSpawnParameter;
// 0x02BC (size: 0x10)
TSubclassOf<class APalDungeonEntrance> DungeonEntranceClass;
// 0x02D0 (size: 0x8)
}; // Size: 0x2D8
class APalDungeonStartPointMarker : public AActor

{
}; // Size: 0x290
class APalDynamicObjectBase : public AActor

{
}; // Size: 0x290
class APalEditorMapObjectCheckPlacer : public AActor

{
class UArrowComponent* LeftEdgeArrow;
// 0x0290 (size: 0x8)
class UArrowComponent* RightEdgeArrow;
// 0x0298 (size: 0x8)
class UArrowComponent* StackRowArrow;
// 0x02A0 (size: 0x8)
FVector2D PlacementMargin;
// 0x02A8 (size: 0x10)
TArray<FPalDataTableRowName_MapObjectData> IgnoreRowNames;
// 0x02B8 (size: 0x10)
void PlaceMapObjects();
}; // Size: 0x2D8
class APalEnemySpawner : public AActor

{
EPalEnemySpawnActorType EnemyActorType;
// 0x0290 (size: 0x1)
EPalEnemySpawnDefaultAction DefaultAction;
// 0x0291 (size: 0x1)
}; // Size: 0x298
class APalEnemyVirtualCommander : public AActor

{
}; // Size: 0x290
class APalExponentialHeightFogVolume : public AActor

{
class UExponentialHeightFogComponent* Component;
// 0x0290 (size: 0x8)
uint8 bEnabled;
// 0x0298 (size: 0x1)
bool bEnableSwitchVisibility;
// 0x029C (size: 0x1)
bool bDisableEnabledFlag;
// 0x029D (size: 0x1)
void OnRep_bEnabled();
}; // Size: 0x2A0
class APalFoliageModelChunk : public AActor

{
FPalFoliageInstanceRepInfoArray RepInfoArray;
// 0x0290 (size: 0x148)
int32 ChunkGridSize;
// 0x03D8 (size: 0x4)
int32 InstanceNum;
// 0x03DC (size: 0x4)
void OnRep_ChunkGridSize();
void OnReceivedChunkGridSize(const int32 NewChunkGridSize);
}; // Size: 0x3E0
class APalFunnelCharacter : public APalCharacter

{
TSubclassOf<class UPalAIActionFunnelSkillBase> FunnelSkillAIActionClass;
// 0x07F8 (size: 0x8)
TSubclassOf<class UPalFunnelSkillModule> FunnelSkillModuleClass;
// 0x0800 (size: 0x8)
FPalInstanceID OwnerCharacterId;
// 0x0808 (size: 0x30)
void SetOwnerCharacterId(const FPalInstanceID OwnerCharacterId);

void SetLocationNearTrainer();
void OnTrainerMoveToRespawnLocation(class APalPlayerCharacter* Player, FVector
Location);
void OnTrainerDead(FPalDeadInfo DeadInfo);
void OnSpawned();
void OnRep_OwnerCharacterId();
void OnOwnerDead(FPalDeadInfo DeadInfo);
void OnInactive();
void OnActive();
void InactivateSelf();
class APalCharacter* GetTrainer();
int32 GetRank();
class APalCharacter* GetOwnerPal();
FName GetCharacterID();
void ActivateSelf();
}; // Size: 0x840
class APalGameInstanceViewActor : public AActor

{
TWeakObjectPtr<class UObject> Target;
// 0x0290 (size: 0x8)
}; // Size: 0x298
class APalGameMode : public APalGameModeBase

{
void RestartGame();
void RespawnPlayer(int32 PlayerIndex);
void OnServerLobbyUpdate();
void OnEOSLoginDedicatedServerComplete(const class UPocketpairUserInfo*
UserInfo, bool bSuccess, FString ErrorStr);
void OnCompleteCreateSession(bool IsSuccess, FString ErrorStr);
void CreateSession(FString Address);
}; // Size: 0x358
class APalGameModeBase : public AGameModeBase

{
EPalGameModeType GameModeType;
// 0x0330 (size: 0x1)
}; // Size: 0x338
class APalGameModeLogin : public APalGameModeBase

{
void OnSwitchUserUICompleted(const class UPocketpairUserInfo* UserInfo, bool

bSuccess, FString ErrorStr);
void OnLoginEOSCompleted(const class UPocketpairUserInfo* UserInfo, bool
bSuccess, FString ErrorStr);
void OnLoginCompleted(const class UPocketpairUserInfo* UserInfo, bool bSuccess,
FString ErrorStr);
void OnConfirmAlert_MultiplayRestricted(bool bSuccess);
void OnConfirmAlert_EOSLogin(bool bSuccess);
void OnCloseEalryAccess(bool _);
void GoToTitle();
}; // Size: 0x340
class APalGameModeServerEntry : public APalGameModeBase

{
void LoadLevel();
}; // Size: 0x338
class APalGameModeTitle : public APalGameModeBase

{
}; // Size: 0x338
class APalGameState : public AGameStateBase

{
}; // Size: 0x2E0
class APalGameStateInGame : public APalGameState

{
class UPalCharacterManagerReplicator* CharacterManagerReplicator;
// 0x02E0 (size: 0x8)
class UPalBaseCampReplicator* BaseCampReplicator;
// 0x02E8 (size: 0x8)
class UPalOptionReplicator* OptionReplicator;
// 0x02F0 (size: 0x8)
class UPalStageReplicator* StageReplicator;
// 0x02F8 (size: 0x8)
class UPalLocationReplicator* LocationReplicator;
// 0x0300 (size: 0x8)
class APalNetworkTransmitter* DedicatedServerTransmitter;
// 0x0358 (size: 0x8)
class UPalGameSystemInitManagerComponent* GameSystemInitManager;
// 0x0360 (size: 0x8)
TArray<class APalBotBuilderLocationBase*> BotBuilderLocation;
// 0x0368 (size: 0x10)
FString WorldName;
// 0x0378 (size: 0x10)
FString WorldSaveDirectoryName;
// 0x0388 (size: 0x10)
bool bIsDedicatedServer;
// 0x0398 (size: 0x1)
int32 MaxPlayerNum;
// 0x039C (size: 0x4)
FGameDateTime WorldTime;
// 0x03A0 (size: 0x8)
FDateTime RealUtcTime;
// 0x03A8 (size: 0x8)
float ServerFrameTime;
// 0x03B0 (size: 0x4)
FString ServerSessionId;
// 0x03B8 (size: 0x10)
int32 ServerWildMonsterCount;
// 0x03C8 (size: 0x4)
int32 ServerOtomoMonsterCount;
// 0x03CC (size: 0x4)
int32 ServerBaseCampMonsterCount;
// 0x03D0 (size: 0x4)
int32 ServerNPCCount;
// 0x03D4 (size: 0x4)
int32 ServerOtherCharacterCount;
// 0x03D8 (size: 0x4)
int32 ImportanceCharacterCount_AllUpdate;
// 0x03DC (size: 0x4)
int32 ImportanceCharacterCount_Nearest;
// 0x03E0 (size: 0x4)
int32 ImportanceCharacterCount_Near;
// 0x03E4 (size: 0x4)
int32 ImportanceCharacterCount_MidInSight;
// 0x03E8 (size: 0x4)
int32 ImportanceCharacterCount_FarInSight;
// 0x03EC (size: 0x4)
int32 ImportanceCharacterCount_MidOutSight;
// 0x03F0 (size: 0x4)
int32 ImportanceCharacterCount_FarOutSight;
// 0x03F4 (size: 0x4)
int32 ImportanceCharacterCount_Farthest;
// 0x03F8 (size: 0x4)
int32 BaseCampCount;
// 0x03FC (size: 0x4)
int32 NavMeshInvokerCount;
// 0x0400 (size: 0x4)
TArray<FPalChatMessage> ChatMessages;
// 0x0408 (size: 0x10)
FPalGameStateInGameOnRecievedChatMessageDelegate OnRecievedChatMessageDelegate;
// 0x0418 (size: 0x10)
void OnRecievedChatMessageDelegate(const FPalChatMessage& Message);
void OnRep_WorldSaveDirectoryName();
void OnRep_StageReplicator();
void OnRep_OptionReplicator();
void OnRep_LocationReplicator();
void OnRep_CharacterManagerReplicator();
void OnRep_BaseCampReplicator();
void OnRecievedChatMessageDelegate__DelegateSignature(const FPalChatMessage&
Message);
FString GetWorldName();
float GetServerFrameTime();
int32 GetMaxPlayerNum();
void BroadcastChatMessage(const FPalChatMessage& ChatMessage);
}; // Size: 0x428
class APalGliderObject : public AActor

{
float GliderMaxSpeed;
// 0x0290 (size: 0x4)
float GliderSP;
// 0x0294 (size: 0x4)
float GliderAirControl;
// 0x0298 (size: 0x4)
float GliderGravityScale;
// 0x029C (size: 0x4)
FVector OffsetLocation;
// 0x02A0 (size: 0x18)
FRotator OffsetRotation;
// 0x02B8 (size: 0x18)
bool bUseLeftHand;
// 0x02D0 (size: 0x1)
bool bUseRightHand;
// 0x02D1 (size: 0x1)
FName attachBoneName;
// 0x02D4 (size: 0x8)
class UAnimMontage* GliderStartAnimation;
// 0x02E0 (size: 0x8)
class UAnimMontage* GliderLoopAnimation;
// 0x02E8 (size: 0x8)
class UAnimMontage* GliderStartPlayerAnimation;
// 0x02F0 (size: 0x8)
class UAnimMontage* GliderLoopPlayerAnimation;
// 0x02F8 (size: 0x8)
class UPalSoundPlayerComponent* SoundPlayerComponent;
// 0x0300 (size: 0x8)
class UPalSkeletalMeshComponent* GetMainMesh();

class USceneComponent* GetAkOwnerComponent();
}; // Size: 0x308
class APalGuildInfo : public AInfo
{
FGuid GroupID;
// 0x0290 (size: 0x10)
class UPalGroupGuildBase* Guild;
// 0x02A0 (size: 0x8)
void OnRep_Guild(const class UPalGroupGuildBase* OldValue);

}; // Size: 0x2A8
class APalHUD : public AHUD

{
}; // Size: 0x380
class APalHUDInGame : public AHUD

{
TSubclassOf<class UPalUIHUDLayoutBase> HUDLayoutClass;
// 0x0388 (size: 0x8)
TSubclassOf<class UPalUIInputGuard> PlayerInputGuardClass;
// 0x0390 (size: 0x8)
class UPalUIHUDLayoutBase* HUDLayout;
// 0x0398 (size: 0x8)
TMap<class FGuid, class UPalUserWidgetWorldHUD*> WorldHUDWidgetMap;
// 0x03A0 (size: 0x50)
TArray<class UPalUserWidget*> HUDWidgets;
// 0x03F0 (size: 0x10)
TArray<class UPalUserWidgetStackableUI*> StackableUIWidgets;
// 0x0400 (size: 0x10)
class UPalUILiftSlotModel* LiftSlotModel;
// 0x0410 (size: 0x8)
class UUserWidget* HoverWidget;
// 0x0418 (size: 0x8)
TArray<class UPalWorldHUDDisplayInfo*> WorldHUDDisplayInfos;
// 0x0420 (size: 0x10)
TArray<class UPalWorldHUDDisplayInfo*> ActiveWorldHUDDisplayInfos;
// 0x0430 (size: 0x10)
TMap<class EPalWidgetBlueprintType, class
TSoftClassPtr<UPalUserWidgetStackableUI>> CommonUIClassMap; // 0x0440 (size: 0x50)
TMap<class EPalWorldHUDWidgetBlueprintType, class
TSoftClassPtr<UPalUserWidgetWorldHUD>> WorldHUDClassMap; // 0x0490 (size: 0x50)
TMap<class EPalWidgetBlueprintType, class
TSubclassOf<UPalUserWidgetStackableUI>> LoadedCommonUIClassMap; // 0x04E0 (size:
0x50)
TMap<class EPalWorldHUDWidgetBlueprintType, class
TSubclassOf<UPalUserWidgetWorldHUD>> LoadedWorldHUDClassMap; // 0x0530 (size: 0x50)
class UPalSoundPlayer* SoundPlayer;
// 0x0598 (size: 0x8)
TArray<FGameplayTag> GameMenuLayerTagOrder;
// 0x05A8 (size: 0x10)
TMap<class FGameplayTag, class FFlagContainer> LayerHideFlagMap;
// 0x05B8 (size: 0x50)
void TickWorldHUDs();
void ShowLiftIcon();
void RemoveWorldHUDFromWidgetId(const FGuid& ID);
void RemoveWorldHUD(const FGuid& ID);
void RemoveHUD(const FGuid& ID);
FGuid PushWidgetStackableUI(TSubclassOf<class UPalUserWidgetStackableUI>
WidgetClass, class UPalHUDDispatchParameterBase* Parameter);
void OnApplicationActivationStateChanged(bool bIsFocused);
void Initialize();
void HideLiftIcon();
class UPalUserWidgetWorldHUD* CreateWorldHUDWidget(TSubclassOf<class
UPalUserWidgetWorldHUD> WidgetClass, class UPalHUDDispatchParameterBase*
Parameter);
class UPalUserWidget* CreateHUDWidget(TSubclassOf<class UPalUserWidget>
WidgetClass, const EPalHUDWidgetPriority Priority, class
UPalHUDDispatchParameterBase* Parameter);
void CloseWorldHUDWidget(const FGuid WidgetId);
void CloseOverlayUI(const FGuid& ID);
void CloseHUDWidget(class UPalUserWidget* Widget);
void BP_SetupPlayerUI();
void BindGameOverUI();
FGuid AddWorldHUD(FPalWorldHUDParameter Parameter);
FGuid AddHUD(TSubclassOf<class UPalUserWidget> WidgetClass, const
EPalHUDWidgetPriority Priority, class UPalHUDDispatchParameterBase* Parameter);
}; // Size: 0x608
class APalHiddenAreaBase : public AActor

{
class UPalProceduralFoliageComponent* ProceduralComponent;
// 0x0290 (size: 0x8)
}; // Size: 0x298
class APalHiddenAreaBox : public APalHiddenAreaBase

{
class UPalHiddenBoxComponent* HiddenBoxComponent;
// 0x0298 (size: 0x8)
}; // Size: 0x2A0
class APalHiddenAreaCapsule : public APalHiddenAreaBase

{
class UPalHiddenCapsuleComponent* HiddenCapsuleComponent;
// 0x0298 (size: 0x8)
}; // Size: 0x2A0
class APalHitCollision : public AActor

{
class UPalHitFilter* HitFilter;
// 0x0290 (size: 0x8)
}; // Size: 0x298
class APalHitCollisionBox : public APalHitCollision

{
class UBoxComponent* BoxComponent;
// 0x0298 (size: 0x8)
void DrawHitCollision();
}; // Size: 0x2A0
class APalImGui : public AActor

{
TWeakObjectPtr<class APalCharacter> WeakCharacterForParameterDisplay;
// 0x03A8 (size: 0x8)
}; // Size: 0x3B8
class APalInvaderStartPoint : public AActor

{
EPalBiomeType BiomeType;
// 0x02A0 (size: 0x1)
}; // Size: 0x2A8
class APalLevelInstance : public ALevelInstance

{
}; // Size: 0x330
class APalLevelObjectActor : public AActor

{
// 0x0298 (size: 0x10)
}; // Size: 0x2A8
class APalLevelObjectCharacterStatusOperator : public APalLevelObjectActor

{
TScriptInterface<class IPalInteractiveObjectComponentInterface> InteractComp;
// 0x02B0 (size: 0x10)

IndicatorType);
}; // Size: 0x2C0
class APalLevelObjectNote : public APalLevelObjectObtainable

{
FPalDataTableRowName_NoteData NoteRowName;
// 0x0308 (size: 0x8)
}; // Size: 0x310
class APalLevelObjectObtainable : public APalLevelObjectActor

{
FPalLevelObjectObtainableOnUpdatePickupStatusInClient
OnUpdatePickupStatusInClient; // 0x02B0 (size: 0x10)
void ReturnSelfDelegate(class APalLevelObjectObtainable* Self);
TSoftObjectPtr<UNiagaraSystem> ObtainFXSoftObj;
// 0x02C0 (size: 0x30)
// 0x02F0 (size: 0x10)
bool bPickedInClient;
// 0x0300 (size: 0x1)
void ReturnSelfDelegate__DelegateSignature(class APalLevelObjectObtainable*

Self);
void OnUpdateFlagMapRecord(const FName Key, const bool bFlag);
IndicatorType);
void OnCompleteSyncPlayer(class APalPlayerState* PlayerState);
FVector GetObtainFXLocation();
}; // Size: 0x308
class APalLevelObjectRelic : public APalLevelObjectObtainable
{
}; // Size: 0x308
class APalLevelObjectRespawnPoint : public APalLevelObjectActor

{
FName RespawnPointID;
// 0x02A8 (size: 0x8)
}; // Size: 0x2B0
class APalLevelObjectUnlockableFastTravelPoint : public APalLevelObjectActor

{
FPalLevelObjectUnlockableFastTravelPointOnUpdateUnlockStateDelegate
OnUpdateUnlockStateDelegate; // 0x02B0 (size: 0x10)
void ReturnSelfDelegate(class APalLevelObjectUnlockableFastTravelPoint* Self);
// 0x02C0 (size: 0x10)
bool bUnlocked;
// 0x02D0 (size: 0x1)
bool EnableRequestUnlock;
// 0x02D1 (size: 0x1)
FName FastTravelPointID;
// 0x02D4 (size: 0x8)
void ReturnSelfDelegate__DelegateSignature(class
APalLevelObjectUnlockableFastTravelPoint* Self);
void OnUpdateFlagMapRecord(const FName Key, const bool bFlag);
IndicatorType);
void OnCompleteSyncPlayer(class APalPlayerState* PlayerState);
bool IsUnlocked();
class UAkAudioEvent* GetUnlockAkAudioEvent();
}; // Size: 0x2E0
class APalMapLevelObject : public APalMapObject

{
// 0x03A8 (size: 0x10)
}; // Size: 0x3B8
class APalMapObject : public AActor

{
FPalMapObjectOnNotifiedShowStatusHUDDelegate OnNotifiedShowStatusHUDDelegate;
// 0x02A0 (size: 0x10)
void ReturnSelf(class APalMapObject* Self, EPalHUDDisplayType DisplayType);
FPalMapObjectOnNotifiedShowBuildProgressHUDDelegate
OnNotifiedShowBuildProgressHUDDelegate; // 0x02B0 (size: 0x10)
void ToggleBuildProgressHUD(EPalHUDDisplayType DisplayType);
FPalMapObjectOnSetConcreteModelDelegate OnSetConcreteModelDelegate;
// 0x02C0 (size: 0x10)
void PalMapObjectConcreteModelMulticastDelegate(class
UPalMapObjectConcreteModelBase* Model);
FVector SpawnLocationOffset;
// 0x02D0 (size: 0x18)
TSubclassOf<class UPalMapObjectConcreteModelBase> ConcreteModelClass;
// 0x02E8 (size: 0x8)
TArray<TScriptInterface<IPalInteractiveObjectComponentInterface>>
InteractComps; // 0x02F0 (size: 0x10)
class UPalMapObjectDamageReactionComponent* DamageReaction;
// 0x0300 (size: 0x8)
class UPalMapObjectVisualEffectComponent* VisualEffect;
// 0x0308 (size: 0x8)
bool bSpawnableIfOverlapped;
// 0x0310 (size: 0x1)
bool bLevelSpawnObject;
// 0x0311 (size: 0x1)
TArray<FName> AllowOverlapCollisionPresetNames;
// 0x0318 (size: 0x10)
bool bSpawnSlipAboveIfAnyOverlap;
// 0x0328 (size: 0x1)
bool bShakeOnDamaged;
// 0x0329 (size: 0x1)
// 0x032A (size: 0x1)
bool bShowOutlineInTargettingReticle;
// 0x032B (size: 0x1)
bool bShowOutlineNearPlayer;
// 0x032C (size: 0x1)
bool bAutoDestroyByOverlapSpawning;
// 0x032D (size: 0x1)
bool bInDoorObject;
// 0x032E (size: 0x1)
bool bBaseObject;
// 0x032F (size: 0x1)
FGuid HPHUDId;
// 0x0330 (size: 0x10)
// 0x0340 (size: 0x1)
FGuid ModelInstanceId;
// 0x0344 (size: 0x10)
class UPalMapObjectModel* MapObjectModel;
// 0x0358 (size: 0x8)
bool bUnmanagedInLocal;
// 0x0360 (size: 0x1)
TSubclassOf<class UPalUserWidgetWorldHUD> IndicatorWidgetClass;
// 0x0368 (size: 0x8)
TArray<FPalMapObjectMeshVisibleData> MeshVisibleDataSet;
// 0x0370 (size: 0x10)
EPalMapObjectChangeMeshFXType ChangeMeshFXType;
// 0x0380 (size: 0x1)
FGuid OpenWidgetId;
// 0x0384 (size: 0x10)
bool bWorkLocationGroupRaycastStartOffsetOrigin;
// 0x0394 (size: 0x1)
bool bShouldPlayDestroyFX;
// 0x0395 (size: 0x1)
void TryGetConcreteModel(EPalMapObjectGetModelOutPinType& OutputPin, class

UPalMapObjectConcreteModelBase*& ConcreteModel);
void ToggleBuildProgressHUD__DelegateSignature(EPalHUDDisplayType DisplayType);
void SetIgnoreSave_ServerInternal(const bool bIgnore);
void ReturnSelf__DelegateSignature(class APalMapObject* Self,
EPalHUDDisplayType DisplayType);
void OnUpdatedEnableTickByModel(class UPalMapObjectModel* Model);
void OnRep_MapObjectModel();
void OnInteractEnd(class AActor* Other, TScriptInterface<class
IPalInteractiveObjectComponentInterface> Component);
void OnInteractBegin(class AActor* Other, TScriptInterface<class
void OnDisposeModel_ServerInternal(class UPalMapObjectModel* DisposeModel,
const FPalMapObjectDisposeOptions& Options);
void OnDamaged(class UPalMapObjectModel* TargetModel, const FPalDamageInfo&
DamageInfo);
void OnCloseParameter(class UPalHUDDispatchParameterBase* Parameter);
class UPalMapObjectModel* GetModel();
FGuid GetGroupIdBelongTo();
void DisposeSelf_ServerInternal();
void CallOrRegisterOnSetConcreteModel(FCallOrRegisterOnSetConcreteModelDelegate
Delegate);
void BroadcastShouldPlayDestroyFX();
void BP_OnSetConcreteModel(class UPalMapObjectConcreteModelBase*
ConcreteModel);
}; // Size: 0x3A0
class APalMapObjectDropItem : public APalMapObject

{
}; // Size: 0x3A0
class APalMapObjectFarmCrop : public AActor

{
TArray<FPalFarmCropGrowupProcessSet> GrowupProcessSets;
// 0x0290 (size: 0x10)
}; // Size: 0x2A0
class APalMapObjectPalEgg : public APalMapObject

{
class UPalMapObjectPickupItemPalEggParameterComponent* ParameterComponent;
// 0x03A0 (size: 0x8)
}; // Size: 0x3A8
class APalMapObjectSpawnerBase : public APalLevelObjectActor

{
int32 ProbabilityRespawn;
// 0x02A8 (size: 0x4)
float LotteryCoolTimeMinutes;
// 0x02AC (size: 0x4)
FPalStageInstanceId StageInstanceIdBelongTo;
// 0x02B0 (size: 0x14)
class USphereComponent* LocateSphere;
// 0x02C8 (size: 0x8)
void OnWorldMapObjectSpawnableInServer();
}; // Size: 0x2D0
class APalMapObjectSpawnerMultiItem : public APalMapObjectSpawnerBase

{
FPalDataTableRowName_FieldLotteryNameData FieldLotteryName;
// 0x0320 (size: 0x8)
float RespawnTimeMinutesObtained;
// 0x0328 (size: 0x4)
}; // Size: 0x330
class APalMapObjectSpawnerPalEgg : public APalMapObjectSpawnerSingleBase

{
TArray<FPalMapObjectPickupItemPalEggLotteryData> SpawnPalEggLotteryDataArray;
// 0x02D0 (size: 0x10)
// 0x02E0 (size: 0x4)
bool bRespawnableMulti;
// 0x02E4 (size: 0x1)
void OnFinishedSpawningMapObjectModel(FGuid InstanceId, const

EPalMapObjectOperationResult Result);
}; // Size: 0x2E8
class APalMapObjectSpawnerSimple : public APalMapObjectSpawnerSingleBase

{
FPalDataTableRowName_MapObjectData MapObjectId;
// 0x02D0 (size: 0x8)

}; // Size: 0x2D8
class APalMapObjectSpawnerSingleBase : public APalMapObjectSpawnerBase

{
}; // Size: 0x2D0
class APalMapObjectSpawnerTreasureBox : public APalMapObjectSpawnerSingleBase

{
FPalDataTableRowName_MapObjectData SpawnMapObjectId;
// 0x02D0 (size: 0x8)
FPalDataTableRowName_FieldLotteryNameData FieldLotteryName;
// 0x02D8 (size: 0x8)
// 0x02E0 (size: 0x4)
bool bRespawnableMulti;
// 0x02E4 (size: 0x1)

}; // Size: 0x2E8
class APalMapObjectTreasureBox : public APalMapObject

{
FVector DropItemLocalLocation;
// 0x03A0 (size: 0x18)
void TriggerOpen();
void OnReceiveOpenInServer(class UPalMapObjectConcreteModelBase*
ConcreteModel);
void NotifyStartOpenInAnimation();
void BroadcastTriggerOpen();
}; // Size: 0x3D0
class APalMonsterCharacter : public APalNPC

{
TScriptInterface<class IPalInteractiveObjectComponentInterface> InteractiveObj;
// 0x0818 (size: 0x10)
class UPalCharacterLiftupObjectComponent* LiftupObjectComponent;
// 0x0828 (size: 0x8)
void SelectedFeedingItem(const FPalItemSlotId& itemSlotId, const int32 Num);

void OnTriggerInteract(class AActor* OtherActor,
void OnSelectedOrderWorkerRadialMenu(class UPalHUDDispatchParameterBase*
Parameter);
void MasterWazaUpdateWhenLevelUp(int32 addLevel, int32 nowLevel);
void MasterWazaSetup(class APalCharacter* InCharacter);
bool IsLiftupObject();
}; // Size: 0x890
class APalMonsterEquipWeaponBase : public APalWeaponBase

{
FVector BattleAimTargetLocation;
// 0x0538 (size: 0x18)
class APalBullet* ShootOneBulletDefault();

class APalBullet* ShootOneBullet(TSubclassOf<class APalBullet> bulletClass,
class UNiagaraSystem* MuzzleEffect, FVector MuzzleLocation, FRotator MuzzleRotate,
float BulrAngle);
FRotator GetMuzzleRotation();
FVector GetMuzzleLocation();
class UNiagaraSystem* GetMuzzleEffect();
FVector GetCommonTargetLocation();
float GetBulrAngle();
TSubclassOf<class APalBullet> GetBulletClass();
}; // Size: 0x550
class APalNPC : public APalCharacter

{
class UPalNPCWeaponGenerator* WeaponGenerator;
// 0x07F8 (size: 0x8)
bool IsEnableJumpEffect;
// 0x0800 (size: 0x1)
int32 DefaultVoiceID;
// 0x0804 (size: 0x4)
void OnCompletedInitParam(class APalCharacter* InCharacter);

}; // Size: 0x810
class APalNPCCampSpawnerBase : public AActor

{
FName CampSpawnerName;
// 0x0290 (size: 0x8)
float CalcRemainRespawnTime(const FPalEnemyCampStatus& CampStatus);

float CalcRemainDespawnTime(const FPalEnemyCampStatus& CampStatus);
}; // Size: 0x298
class APalNPCSpawnerBase : public AActor

{
bool bIsRunOnAnyThread;
// 0x0290 (size: 0x1)
bool Ignore_DebugSettingDisable;
// 0x0291 (size: 0x1)
bool Ignore_DistanceLocationReset;
// 0x0292 (size: 0x1)
bool Ignore_FarCheck;
// 0x0293 (size: 0x1)
bool bDoSpawnedTick;
// 0x0294 (size: 0x1)
EPalSpawnRadiusType SpawnRadiusType;
// 0x0295 (size: 0x1)
bool IsSquadBehaviour;
// 0x0296 (size: 0x1)
FString DebugOrganizationName;
// 0x0298 (size: 0x10)
float LocationResetDistance_SpawnerToCharacterTooFar;
// 0x02A8 (size: 0x4)
float LocationResetHeight_SpawnerToCharacterTooLow;
// 0x02AC (size: 0x4)
FString GroupName;
// 0x02B0 (size: 0x10)
class UPalNavigationInvokerComponent* NavInvokerComponent;
// 0x02C0 (size: 0x8)
TArray<FVector> NPCLocations;
// 0x02C8 (size: 0x10)
FPalNPCSpawnerBaseOnCreatedGroupDelegate OnCreatedGroupDelegate;
// 0x02D8 (size: 0x10)
void CreatedGroupDelegate();
FGuid WildGroupGuid;
// 0x02F8 (size: 0x10)
// 0x0308 (size: 0x8)
FFlagContainer DisableSpawn;
// 0x0310 (size: 0x50)
EPalSpwnerImportanceType ImportanceType;
// 0x0360 (size: 0x1)
void Tick_Spawning(float DeltaTime);

void Tick_Spawned(float DeltaTime);
void Tick_Despawning(float DeltaTime);
void SpawnRequest_ByOutside(bool IsDeleteAliveCharacter);
void SetSpawnedFlag(bool IsSpawned);
void SetSpawnDisableFlag(const FName& Name, bool isDisable);
void SetDisableBossSpawner_ToSaveData(FName KeyName);
void SetCheckRadius(float SpawnRadius, float DespawnRadius);
void SetAllNPCLocation();
void RequestCreateGroup(TArray<FName> CharacterIDList);
void Request_TickSpawningForGameThread(float DeltaTime);
void Request_TickSpawnedForGameThread(float DeltaTime);
void Request_TickDespawningForGameThread(float DeltaTime);
void RemoveGroupWhenDestoryActor(class AActor* DestoryActor);
void RemoveGroupCharacter(class UPalIndividualCharacterHandle*
RemoveIndividualHandle);
bool RandomSpawnLocationByRadiusLineTraceWithWorldLocation(FVector&
OutLocation, float Radius, float RayStartUpOffset, float RayEndDownOffset, const
FVector& WorldPos, int32 SumSpawnNum, int32 SelfIndexInAll);
bool RandomSpawnLocationByRadiusLineTrace(FVector& OutLocation, float Radius,
float RayStartUpOffset, float RayEndDownOffset, int32 SumSpawnNum, int32
SelfIndexInAll);
void ProcessBossDefeatInfo_ServerInternal(class AActor* BossActor, FName
SpawnerName);
void PathWalkNameSort(TArray<class UObject*> WalkPoint, TArray<class UObject*>&
OutSortedWalkPoint);
void OnInitialized();
bool IsSuppressedByRandomIncident();
bool IsSpawned();
bool IsSpawnDisable();
bool IsNearBaseCamp();
float GetSpawnRadiusCM();
float GetSpawnPointRadius();
int32 GetSpawnNumRandom_OneTribe(FPalSpawnerOneTribeInfo Info);
int32 GetSpawnLevelRandom_OneTribe(FPalSpawnerOneTribeInfo Info);
float GetSpawnerRadiusByType();
FString GetSpawnDisableDebugInfo();
int32 GetMaxMonsterLevel();
bool GetIsServer();
bool GetDisableBossSpawnerFlag_FromSaveData(FName KeyName);
void GetAllSpawnedNPCHandle(TArray<class UPalIndividualCharacterHandle*>&
Handles);
void GetAllNPCLocation(TArray<FVector>& OutLocations);
void CreatedGroupDelegate__DelegateSignature();
void CreateDebugSpawnerGroupInfo(FPalSpawnerGroupInfo OneGroupInfo);
EPalCheckSpawnResultType CheckSpawnDistance(bool IsSpawned);
void BlueprintTick_Spawning(float DeltaTime);
void BlueprintTick_Spawned(float DeltaTime);
void BlueprintTick_Despawning(float DeltaTime);
void BlueprintTick_AnyThread(float DeltaTime);
void BlueprintTick(float DeltaTime);
void AddGroupCharacterByGroupId(class UPalIndividualCharacterHandle*
AddIndividualHandle, const FGuid& GroupID, FString DebugName);
void AddGroupCharacter(class UPalIndividualCharacterHandle*
AddIndividualHandle);
}; // Size: 0x368
class APalNetworkTransmitter : public AActor

{
class UPalNetworkMapObjectComponent* MapObject;
// 0x02E0 (size: 0x8)
class UPalNetworkItemComponent* Item;
// 0x02E8 (size: 0x8)
class UPalNetworkBaseCampComponent* BaseCamp;
// 0x02F0 (size: 0x8)
class UPalNetworkCharacterContainerComponent* CharacterContainer;
// 0x02F8 (size: 0x8)
class UPalNetworkGroupComponent* Group;
// 0x0300 (size: 0x8)
class UPalNetworkPlayerComponent* Player;
// 0x0308 (size: 0x8)
class UPalNetworkCharacterComponent* Character;
// 0x0310 (size: 0x8)
class UPalNetworkWorkProgressComponent* WorkProgress;
// 0x0318 (size: 0x8)
class UPalNetworkWorldSecurityComponent* WorldSecurity;
// 0x0320 (size: 0x8)
class UPalNetworkBossBattleComponent* BossBattle;
// 0x0328 (size: 0x8)
class UPalNetworkTimeComponent* Time;
// 0x0330 (size: 0x8)
class UPalNetworkShopComponent* Shop;
// 0x0338 (size: 0x8)
class UPalNetworkInvaderComponent* Invader;
// 0x0340 (size: 0x8)
class UPalNetworkCharacterStatusOperationComponent* CharacterStatusOperation;
// 0x0348 (size: 0x8)
class UPalNetworkIndividualComponent* NetworkIndividualComponent;
// 0x0350 (size: 0x8)
TArray<FPalNetworkTransmitterDelaySpawnInfo> DelayDelegateCallQueue;
// 0x0358 (size: 0x10)
FGuid SpawnReliableActorBroadcast(UClass* actorClass,

FNetworkActorSpawnParameters SpawnParameter,
FSpawnReliableActorBroadcastSpawnDelegate SpawnDelegate);
FGuid SpawnNonReliableActorBroadcast(UClass* actorClass,
FNetworkActorSpawnParameters SpawnParameter,
FSpawnNonReliableActorBroadcastSpawnDelegate SpawnDelegate);
void SpawnNonReliableActor_ToServer(UClass* actorClass,
FNetworkActorSpawnParameters SpawnParameter, int32 issuerID);
void SpawnedNonReliableActor_ToALL(UClass* actorClass,
FNetworkActorSpawnParameters SpawnParameter, int32 issuerID);
void SpawnedActor_ToALL(class AActor* SpawnedActor, class AActor*
SpawnedController, FNetworkActorSpawnParameters SpawnParameter, FGuid Guid);
FGuid SpawnActorBroadcast(UClass* actorClass, FNetworkActorSpawnParameters
SpawnParameter, FSpawnActorBroadcastSpawnDelegate SpawnDelegate);
void SpawnActor_ToServer(UClass* actorClass, FNetworkActorSpawnParameters
SpawnParameter, FGuid Guid);
void SetupBroadcast_FromServer();
class UPalNetworkWorldSecurityComponent* GetWorldSecurity();
class UPalNetworkWorkProgressComponent* GetWorkProgress();
class UPalNetworkTimeComponent* GetTime();
class UPalNetworkShopComponent* GetShop();
class UPalNetworkPlayerComponent* GetPlayer();
class UPalNetworkMapObjectComponent* GetMapObject();
class UPalNetworkItemComponent* GetItem();
class UPalNetworkInvaderComponent* GetInvader();
class UPalNetworkGroupComponent* GetGroup();
class UPalNetworkCharacterStatusOperationComponent*
GetCharacterStatusOperation();
class UPalNetworkCharacterContainerComponent* GetCharacterContainer();
class UPalNetworkCharacterComponent* GetCharacter();
class UPalNetworkBossBattleComponent* GetBossBattle();
class UPalNetworkBaseCampComponent* GetBaseCamp();
void DummyReliableFunction();
void Debug_RequestLogTreasureBoxLocalPlayerAround_ToServer();
void Debug_ReceiveLogTreasureBoxLocalPlayerAround_ToRequestPlayer(FString
Message);
}; // Size: 0x368
class APalPlayerCharacter : public APalCharacter

{
class UPalShooterComponent* ShooterComponent;
// 0x0800 (size: 0x8)
class UPalInteractComponent* InteractComponent;
// 0x0808 (size: 0x8)
class UPalBuilderComponent* BuilderComponent;
// 0x0810 (size: 0x8)
class UPalLoadoutSelectorComponent* LoadoutSelectorComponent;
// 0x0818 (size: 0x8)
class UPalInsideBaseCampCheckComponent* InsideBaseCampCheckComponent;
// 0x0820 (size: 0x8)
class UPalObjectReplicatorComponent* HighPriorityObjectReplicatorComponent;
// 0x0828 (size: 0x8)
FPalPlayerCharacterOnPlayerReviveDelegate OnPlayerReviveDelegate;
// 0x0830 (size: 0x10)
void OnPlayerReviveDelegate(class APalPlayerCharacter* Player);
FPalPlayerCharacterOnPlayerRespawnDelegate OnPlayerRespawnDelegate;
// 0x0840 (size: 0x10)
void OnPlayerRespawnDelegate(class APalPlayerCharacter* Player);
FPalPlayerCharacterOnPlayerMoveToRespawnLocationDelegate
OnPlayerMoveToRespawnLocationDelegate; // 0x0850 (size: 0x10)
void OnPlayerMoveToRespawnLocationDelegate(class APalPlayerCharacter* Player,
FVector Location);
FPalPlayerCharacterOnCombatRankDownDelegate OnCombatRankDownDelegate;
// 0x0860 (size: 0x10)
void OnCombatRankDownDelegate(EPalPlayerBattleFinishType FinishType);
FPalPlayerCharacterOnAddRemoveEnemyDelegate OnAddRemoveEnemyDelegate;
// 0x0870 (size: 0x10)
void OnAddRemoveEnemyDelegate(EPalBattleBGMType Rank, bool IsAdd);
FPalPlayerCharacterOnChangeBattleModeDelegate_ForPlayer
OnChangeBattleModeDelegate_ForPlayer; // 0x0880 (size: 0x10)
void OnChangePlayerBattleMode(bool IsBattle);
FPalPlayerCharacterOnPlayerDeathAction OnPlayerDeathAction;
// 0x0890 (size: 0x10)
void OnPlayerDeathAction();
FPalPlayerCharacterOnChangeBossTowerEntrancePlayer
OnChangeBossTowerEntrancePlayer; // 0x08A0 (size: 0x10)
void OnChangeBossTowerEntrancePlayer(FName BossType, const TArray<class
APalPlayerCharacter*>& PlayerList);
FPalPlayerCharacterOnChangeBossEntrancePlayer OnChangeBossEntrancePlayer;
// 0x08B0 (size: 0x10)
void OnChangeBossTowerEntrancePlayer(FName BossType, const TArray<class
APalPlayerCharacter*>& PlayerList);
FPalPlayerCharacterOnCombatStartUIAction OnCombatStartUIAction;
// 0x08C0 (size: 0x10)
void OnCombatStartUIActionDelegate();
FPalPlayerCharacterOnChangeRegionArea OnChangeRegionArea;
// 0x08D0 (size: 0x10)
void OnChangeRegionAreaDelegate(const FName& RegionNameID);
FName LastInsideRegionNameID;
// 0x08E0 (size: 0x8)
float PlayerCameraYaw;
// 0x08E8 (size: 0x4)
float PlayerCameraPitch;
// 0x08EC (size: 0x4)
bool IsAdjustedLocationByLoad;
// 0x08F0 (size: 0x1)
class UAnimMontage* IdleAnimMontage;
// 0x08F8 (size: 0x8)
class UPalPlayerBattleSituation* PlayerBattleSituation;
// 0x0900 (size: 0x8)
bool IsNearCommonEnemyFlag;
// 0x0908 (size: 0x1)
bool bIsSetRespawnTelemetry;
// 0x0909 (size: 0x1)
FTimerHandle InDoorTimerHandle;
// 0x0910 (size: 0x8)
TSubclassOf<class UPalPlayerGenderChanger> GenderChangerClass;
// 0x0920 (size: 0x8)
class UPalPlayerGenderChanger* GenderChanger;
// 0x0928 (size: 0x8)
bool bSpectatorMode;
// 0x0930 (size: 0x1)
FPalPlayerDataCharacterMakeInfo CharacterMakeInfo;
// 0x0934 (size: 0x94)
void StopIdleAnimation();
void SetSpectatorMode(bool bSpectator);
void SetNearCommonEnemy(bool IsExistNearEnemy);
void PlayIdleAnimation(class UAnimMontage* Montage);
void PlayEatAnimation();
void OnUpdateEssentialItemContainer(class UPalItemContainer* Container);
void OnStartGliding();
void OnSPOverhead();
void OnRep_SpectatorMode(bool before);
void OnRep_CharacterMakeInfo();
void OnReloadStart();
void OnPlayerReviveDelegate__DelegateSignature(class APalPlayerCharacter*
Player);
void OnPlayerRespawnDelegate__DelegateSignature(class APalPlayerCharacter*
Player);
void OnPlayerMoveToRespawnLocationDelegate__DelegateSignature(class
APalPlayerCharacter* Player, FVector Location);
void OnPlayerDeathAction__DelegateSignature();
void OnMontageEnded(class UAnimMontage* Montage, bool bInterrupted);
void OnJumpDisable();
void OnEnterBaseCamp_StartBaseCampCombat(class UPalBaseCampModel* CampModel);
void OnEndIdle();
void OnEndGliding();
void OnDownBattleEnemyRank(EPalPlayerBattleFinishType FinishType);
void OnDamagePlayer_Server(FPalDamageResult DamageResult);
void OnCombatStartUIActionDelegate__DelegateSignature();
void OnCombatRankDownDelegate__DelegateSignature(EPalPlayerBattleFinishType
FinishType);
void OnChangeShooterState(bool IsAim, bool IsShoot);
void OnChangeRegionAreaDelegate__DelegateSignature(const FName& RegionNameID);
void OnChangePrevWeapon();
void OnChangePlayerBattleMode__DelegateSignature(bool IsBattle);
void OnChangeNextWeapon();
void OnChangeNearEnemy_ToAll(bool IsExist);
void OnChangeMovementMode(class UPalCharacterMovementComponent* Component,
TEnumAsByte<EMovementMode> prevMode, TEnumAsByte<EMovementMode> newMode,
EPalCharacterMovementCustomMode PrevCustomMode, EPalCharacterMovementCustomMode
NewCustomMode);
void OnChangeBossTowerEntrancePlayer__DelegateSignature(FName BossType, const
TArray<class APalPlayerCharacter*>& PlayerList);
void OnChangeBattleEnemyRank(EPalBattleBGMType Rank, bool IsAdd);
void OnBeginAction(const class UPalActionBase* action);
void OnAddRemoveEnemyDelegate__DelegateSignature(EPalBattleBGMType Rank, bool
IsAdd);
bool IsIdle();
bool IsGuildMaster();
bool IsGliding();
bool IsAdjustedLocation();
class APalPlayerController* GetPalPlayerController();
void GetLastInsideRegionNameID(FName& OutNameID);
FPalPlayerDataCharacterMakeInfo GetCharacterMakeInfo();
FRotator GetCameraRotator();
void CreateLantern();
void ChangeToMale();
void ChangeToFemale();
void CallReviveDelegate();
void CallRespawnDelegate();
void CallMoveToRespawnLocationDelegate(FVector Location);
void AdjustLocationByLoad(class APalCharacter* InCharacter);
}; // Size: 0x9D0
class APalPlayerController : public ACommonPlayerController

{
bool bAdmin;
// 0x0850 (size: 0x1)
class UPalAIActionComponent* AIActionComponent;
// 0x0858 (size: 0x8)
class UPalNetworkMulticastGateComponent* MulticastGateComponent;
// 0x0860 (size: 0x8)
class UPalCutsceneComponent* CutsceneComponent;
// 0x0868 (size: 0x8)
class APalNetworkTransmitter* Transmitter;
// 0x0870 (size: 0x8)
float WeaponPaletteLongPressTime;
// 0x0878 (size: 0x4)
float PawnChangeCameraInterpChangeTime;
// 0x087C (size: 0x4)
bool isOpenConstructionMenu;
// 0x0880 (size: 0x1)
FPalPlayerControllerOnCoopRequestDelegate OnCoopRequestDelegate;
// 0x0888 (size: 0x10)
void OnCoopRequestDelegate();
FPalPlayerControllerOnCoopReleaseDelegate OnCoopReleaseDelegate;
// 0x0898 (size: 0x10)
void OnCoopReleaseDelegate();
FPalPlayerControllerOnInteractDelegate OnInteractDelegate;
// 0x08A8 (size: 0x10)
void OnInteractDelegate();
FPalPlayerControllerOnPressedJumpDelegate OnPressedJumpDelegate;
// 0x08B8 (size: 0x10)
void OnPressedJumpDelegate();
FPalPlayerControllerOnInputMoveForwardDelegate OnInputMoveForwardDelegate;
// 0x08C8 (size: 0x10)
void OnPressedMoveForwardDelegate(float InputValue, bool IsController);
FPalPlayerControllerOnPressedThrowPalButtonDelegate
OnPressedThrowPalButtonDelegate; // 0x08E8 (size: 0x10)
void OnPressedThrowPalButtonDelegate();
FPalPlayerControllerOnReleasedThrowPalButtonDelegate
OnReleasedThrowPalButtonDelegate; // 0x08F8 (size: 0x10)
void OnReleasedThrowPalButtonDelegate();
FPalPlayerControllerOnPressedSpawnPalButtonDelegate
OnPressedSpawnPalButtonDelegate; // 0x0908 (size: 0x10)
void OnPressedSpawnPalButtonDelegate();
FPalPlayerControllerOnLongPressedSpawnPalButtonDelegate
OnLongPressedSpawnPalButtonDelegate; // 0x0918 (size: 0x10)
void OnLongPressedSpawnPalButtonDelegate();
FPalPlayerControllerOnReleasedSpawnPalButtonDelegate
OnReleasedSpawnPalButtonDelegate; // 0x0928 (size: 0x10)
void OnReleasedSpawnPalButtonDelegate();
FPalPlayerControllerOnLongReleasedSpawnPalButtonDelegate
OnLongReleasedSpawnPalButtonDelegate; // 0x0938 (size: 0x10)
void OnLongReleasedSpawnPalButtonDelegate();
FPalPlayerControllerOnPressedPartnerInstructionsButtonDelegate
OnPressedPartnerInstructionsButtonDelegate; // 0x0948 (size: 0x10)
void OnPressedPartnerInstructionsButtonDelegate();
FPalPlayerControllerOnPressConstructionMenuButtonDelegate
OnPressConstructionMenuButtonDelegate; // 0x0958 (size: 0x10)
void OnPressConstructionMenuButtonDelegate();
class UCurveFloat* RecoilCurve;
// 0x0A30 (size: 0x8)
FVector TimerGaugeDisplayOffset;
// 0x0AA8 (size: 0x18)
TSubclassOf<class UCameraShakeBase> DamageCameraShake;
// 0x0AC0 (size: 0x8)
TSubclassOf<class UPalPlayerDamageCamShakeRegulator>
DamageCamShakeRegulatorClass; // 0x0AC8 (size: 0x8)
class UPalPlayerDamageCamShakeRegulator* DamageCamShakeRegulator;
// 0x0AD0 (size: 0x8)
TArray<class UPalLongPressObject*> LongPressObjects;
// 0x0AD8 (size: 0x10)
TMap<FName, float> cameraRotateModifierMap;
// 0x0AE8 (size: 0x50)
TArray<FRotator> AutoAimRotatorList;
// 0x0B38 (size: 0x10)
FDelegateTickFunction PawnAfterTickFunction;
// 0x0C48 (size: 0x38)
class AActor* AutoAimTarget;
// 0x0C80 (size: 0x8)
FVector ReticleTargetOffset;
// 0x0C88 (size: 0x18)
FVector2D GamePadNativeAxis;
// 0x0CA0 (size: 0x10)
FVector2D MouseNativeAxis;
// 0x0CB0 (size: 0x10)
FRotator CacheActorRotator;
// 0x0CC0 (size: 0x18)
bool TrySwitchOtomo();
void ThrowPalByOutSide(class AActor* PreOtomoPal);
void TeleportToSafePoint_ToServer();
void StartStepCoolDownCoolTimer();
void StartFlyToServer();
void SetRiderRelativeRotation_ToServer(FRotator Rotator);
void SetOtomoSlot(int32 SlotID);
void SetHoldOtomo(int32 HoldID, class UPalIndividualCharacterHandle*
OtomoHandle);
void SetDisableThrowPalFlag(FName flagName, bool isDisable);
void SetDisableSwitchPalFlag(FName flagName, bool isDisable);
void SetDisableInputFlag(FName flagName, bool isDisable);
void SetCameraRotatorToPlayerCharacter_ToServer(FRotator CameraRotator);
void SendScreenLogToClient(FString Message, FLinearColor Color, float Duration,
const FName& Key);
void SendLog_ToClient(const EPalLogPriority Priority, const FText& Text, const
FPalLogAdditionalData& AdditionalData);
void RPCDummy();
void RequestLiftupThrow_ToServer(class AActor* Target);
void RequestLiftup_ToServer(class APalCharacter* TargetCharacter);
void RequestFastTravel_ToServer(const FGuid& LocationId);
void RemoveCameraRotateSpeedModifierRate(const FName& modifierName);
void ReceiveLiftupRequestResult_ToClient(EPalLiftupRequestResult Result);
void PlaySkill(int32 SlotID);
void PalDeprojectScreenPositionToWorld(FVector& StartLocation, FVector&
RayDirection);
void OnWeaponNotify(EWeaponNotifyType Type);
void OnUpdateWeightInventory(float Weight);
void OnSwitchOtomoSpawn();
void OnStartCoopRequest();
void OnStartAim();
void OnSpawnAndRideSupportPal();
void OnReleasedThrowPalButtonDelegate__DelegateSignature();
void OnReleasedSpawnPalButtonDelegate__DelegateSignature();
void OnReleasedSpawnPalButton();
void OnPressedUseRecoveryItemButton();
void OnPressedThrowPalButtonDelegate__DelegateSignature();
void OnPressedSpawnPalButtonDelegate__DelegateSignature();
void OnPressedPartnerInstructionsButtonDelegate__DelegateSignature();
void OnPressedMoveForwardDelegate__DelegateSignature(float InputValue, bool
IsController);
void OnPressedJumpDelegate__DelegateSignature();
void OnPressConstructionMenuButtonDelegate__DelegateSignature();
void OnOverWeightInventory(float Weight);
void OnOtomoChangeIncrement();
void OnOtomoChangeDecrement();
void OnOtomo_ShortReleased();
void OnOtomo_Pressed();
void OnOtomo_LongReleased();
void OnOtomo_LongPressed();
void OnLongReleasedSpawnPalButtonDelegate__DelegateSignature();
void OnLongReleasedSpawnPalButton();
void OnLongPressedSpawnPalButtonDelegate__DelegateSignature();
void OnLongPressedCoopButton();
void OnLanded(class UPalCharacterMovementComponent* MovementComponent, const
FHitResult& Hit);
void OnJump(class UPalCharacterMovementComponent* MovementComponent);
void OnInteractDelegate__DelegateSignature();
void OnInitializeLocalPlayer_BP();
void OnGetOffAndDespawnSupportPal();
void OnFlyRideTakeOff();
void OnFixedWeightInventory(float Weight);
void OnEndRolling();
void OnEndCoopRequest();
void OnEndAim();
void OnDestroyPawn(class AActor* DestroyedActor);
void OnDamage(FPalDamageResult DamageResult);
void OnCoopRequestDelegate__DelegateSignature();
void OnCoopReleaseDelegate__DelegateSignature();
void OnChangeSwimming(bool IsInSwimming);
void OnChangePadOption(const FPalOptionPadSettings& PrevSettings, const
FPalOptionPadSettings& NewSettings);
void OnChangeOtomoSlot();
void OnChangeKeyboardOption(const FPalOptionKeyboardSettings& PrevSettings,
const FPalOptionKeyboardSettings& NewSettings);
void OnChangeInstructions();
void JumpCancelPalThrow(class UPalCharacterMovementComponent*
MovementComponent);
bool IsSwimming();
bool IsRidingFlyPal();
bool IsRiding();
bool IsCooping();
void InactiveOtomo();
TSubclassOf<class UPalUserWidgetTimerGaugeBase> GetTimerGaugeWidgetClass();
class AActor* GetRidingCharacter();
FGuid GetPlayerUId();
class APalPlayerState* GetPalPlayerState();
void GetOffToServer();
class APawn* GetLowBodyPawn();
class APalCharacter* GetLowBodyPalCharacter();
class UPalLoadoutSelectorComponent* GetLoadoutSelectorComponent();
FVector2D GetKeyboardMoveValue();
class APalCharacter* GetDefaultPlayerCharacter();
class APalCharacter* GetControlPalCharacter();
FVector2D GetControllerRightStickValue();
FVector2D GetControllerLeftStickValue();
void EndFlyToServer();
void EnableShootingByAction(const class UPalActionComponent* Component);
void DoStep(EPalStepAxisType Axis, FVector2D StepDirection);
void Debug_TogglePartnerSkillNoDecrease();
void Debug_TeleportToNearestPlayer();
void Debug_TeleportToNearestCamp();
void Debug_TeleportToBotLocation(int32 botIndex);
void Debug_TeleportToBotCamp(int32 botIndex);
void Debug_Teleport2D(const FVector& Location);
void Debug_ShowInvaderDeubgLog();
void Debug_SetPalWorldTimeScale(float Rate);
void Debug_SetPalWorldTime(int32 Hour);
void Debug_SetFPSForServer(float fps);
void Debug_RerollCharacterMake();
void Debug_ReceiveCheatCommand_ToClient(FString Message);
void Debug_ParallelForUpdateActiveTiles();
void Debug_NotConsumeMaterialsInCraft();
void Debug_NotConsumeMaterialsInBuild();
void Debug_Muteki_ToServer();
void Debug_InvaderMarchRandom();
void Debug_InvaderMarch();
void Debug_InsightsTraceStop_ToServer();
void Debug_InsightsTraceStart_ToServer();
void Debug_IgnoreRestrictedByItemsForPartnerSkill();
void Debug_ForceSpawnRarePal_ToServer();
void Debug_EnableCollectPalCount();
void Debug_CheatCommand_ToServer(FString Command);
void Debug_AddPlayerExp_ToServer(int32 addExp);
void Debug_AddPartyExp_ToServer(int32 addExp);
void Debug_AddMoney_ToServer(int64 addValue);
void Debug_AddExpForALLPlayer_ToServer(int32 addExp);
bool CanCooping();
void CallOnCoopReleaseDelegate_ToServer();
void AddCameraRotateSpeedModifierRate(const FName& modifierName, float Rate);
void ActivateCurrentOtomoNearThePlayer();
}; // Size: 0xCE8
class APalPlayerState : public APlayerState

{
FUniqueNetIdRepl WinGDKUniqueId;
// 0x03A8 (size: 0x30)
FPalPlayerStateOnReportCrimeIdsDelegate OnReportCrimeIdsDelegate;
// 0x0460 (size: 0x10)
void ReportCrimeIdsDelegate(class UPalIndividualCharacterHandle*
CriminalHandle, const TArray<FName>& CrimeIds);
FPalPlayerStateOnReleaseWantedDelegate OnReleaseWantedDelegate;
// 0x0470 (size: 0x10)
void ReleaseWantedDelegate(class UPalIndividualCharacterHandle*
CriminalHandle);
FPalPlayerStateOnStartCrimeDelegate OnStartCrimeDelegate;
// 0x0480 (size: 0x10)
void StartCrimeDelegate(FGuid CrimeInstanceId);
FPalPlayerStateOnEndCrimeDelegate OnEndCrimeDelegate;
// 0x0490 (size: 0x10)
void EndCrimeDelegate(FGuid CrimeInstanceId);
FPalPlayerStateOnCompleteLoadInitWorldPartitionDelegate_InClient
OnCompleteLoadInitWorldPartitionDelegate_InClient; // 0x04A0 (size: 0x10)
void OnCompleteLoadInitWorldPartitionDelegate();
FGuid PlayerUId;
// 0x04B0 (size: 0x10)
FPalInstanceID IndividualHandleId;
// 0x04C0 (size: 0x30)
FVector CachedPlayerLocation;
// 0x04F0 (size: 0x18)
FQuat CachedPlayerRotation;
// 0x0510 (size: 0x20)
class UPalPlayerOtomoData* OtomoData;
// 0x0530 (size: 0x8)
class UPalPlayerDataCharacterMake* CharacterMakeData;
// 0x0538 (size: 0x8)
class UPalPlayerInventoryData* InventoryData;
// 0x0540 (size: 0x8)
class UPalPlayerDataPalStorage* PalStorage;
// 0x0548 (size: 0x8)
class UPalTechnologyData* TechnologyData;
// 0x0550 (size: 0x8)
class UPalPlayerRecordData* RecordData;
// 0x0558 (size: 0x8)
// 0x0560 (size: 0x1)
bool bDetectedInValidPlayer;
// 0x0561 (size: 0x1)
class UPalPlayerLocalRecordData* LocalRecordData;
// 0x0568 (size: 0x8)
class UPalWorldMapUIData* WorldMapData;
// 0x0570 (size: 0x8)
class UPalQuestManager* QuestManager;
// 0x0578 (size: 0x8)
class UPalGroupGuildBase* GuildBelongTo;
// 0x0580 (size: 0x8)
class UPalNetworkPlayerStateComponent* NetworkComp;
// 0x05A8 (size: 0x8)
class UPalSyncTeleportComponent* SyncTeleportComp;
// 0x05B0 (size: 0x8)
FDateTime StartPlayTime;
// 0x05B8 (size: 0x8)
bool bIsNewCharacter;
// 0x05C0 (size: 0x1)
FGuid LoginTryingPlayerUId_InServer;
// 0x05C4 (size: 0x10)
bool bIsCompleteSyncPlayerFromServer_InClient;
// 0x05EE (size: 0x1)
FPalPlayerAccountInitData AcountInitData;
// 0x05F0 (size: 0xA8)
TArray<FPalLogInfo_DropPal> DropPalInfo;
// 0x0698 (size: 0x10)
class UPalDialogParameter_RequestJoinGuild* RequestJoinGuildDialogParameter;
// 0x06A8 (size: 0x8)
TMap<class FGuid, class FTimerHandle> WaitLoadingWorldPartitionTimerMap;
// 0x06B0 (size: 0x50)
int32 ChatCounter;
// 0x0750 (size: 0x4)
void WaitWorldPartitionDelegate(FTimerHandle& OutTimerHandle,

FWaitWorldPartitionDelegateDelegate Delegate);
void StartCrimeDelegate__DelegateSignature(FGuid CrimeInstanceId);
void ShowTowerBossDefeatRewardUI();
void ShowBossDefeatRewardUI(int32 TechPoint);
void SendDeath_ToServer(class APalCharacter* Target);
void SendDamage_ToServer(class APalCharacter* Target, const FPalDamageInfo&
Info);
void SendAccountInitData_ForServer(const FPalPlayerAccountInitData&
accountInitData);
void ReturnSelfSingleDelegate__DelegateSignature(class APalPlayerState*
PlayerState);
void ReturnSelfDelegate__DelegateSignature(class APalPlayerState* PlayerState);
void RequestUnlockFastTravelPoint_ToServer(const FName UnlockFlagKey);
void RequestSpawnMonsterForPlayer(const FName& CharacterID, int32 Num, int32
Level);
void RequestRespawn();
void RequestObtainLevelObject_ToServer(class APalLevelObjectObtainable*
TargetObject);
void RequestJoinPlayer_ToServer(const FGuid& JoinPlayerUId, const
FPalPlayerInitializeParameter& InitPlayerParam);
void RequestBotLocation();
void RequestAccountInitData_ForClient();
void ReportCrimeIdsDelegate__DelegateSignature(class
UPalIndividualCharacterHandle* CriminalHandle, const TArray<FName>& CrimeIds);
void ReleaseWantedDelegate__DelegateSignature(class
UPalIndividualCharacterHandle* CriminalHandle);
void RegisterForPalDex_ToClient(const FPalUIPalCaptureInfo& CaptureInfo);
void RegisterForPalDex_ServerInternal(FPalInstanceID IndividualId);
void ReceiveNotifyLoginComplete();
void OpenRequestJoinGuildDialog_ToClient(const FPalInstanceID&
RequestPlayerInstanceId);
void OnUpdatePlayerInfoInGuildBelongTo(const class UPalGroupGuildBase* Guild,
const FGuid& InPlayerUId, const FPalGuildPlayerInfo& InPlayerInfo);
void OnRep_WinGDKUniqueId();
void OnRep_PlayerUId();
void OnRep_GuildBelongTo(class UPalGroupGuildBase* OldValue);
void OnRelicNumAdded(int32 AddNum);
void OnRecievedGuildJoinRequestResult(const EPalGuildJoinRequestResult
ResultType, const FPalInstanceID& RequestPlayerInstanceId, const FPalInstanceID&
TargerPlayerInstanceId);
void OnNotifiedReturnToFieldFromStage_ToClient();
void OnNotifiedEnteredStage_ToClient();
void OnCreatePlayerIndividualHandle_InServer(FPalInstanceID ID);
void OnCreatedGrantedIndividualHandle_ServerInternal(FPalInstanceID
IndividualId);
void OnCompleteSyncWorld_InClient(class APalPlayerState* PlayerState);
void OnCompleteSyncPlayer_InClient(class APalPlayerState* PlayerState);
void OnCompleteSyncAll_InClient(class APalPlayerState* PlayerState);
void OnCompleteLoadWorldPartitionDelegate__DelegateSignature();
void OnCompleteLoadInitWorldPartitionDelegate__DelegateSignature();
void OnCompleteLoadInitWorldPartition_InClient(class APalPlayerState*
PlayerState);
void OnClosedRequestJoinGuildDialog(bool Result);
void OnClosedOverBaseCampDialog(bool Result);
void OnClosedCheckBaseCampAuthorityDialog(bool Result);
void NotifyStartInitSelectMap_ToServer();
void NotifyRunInitialize_ToClient();
void NotifyRemovedCharacterFromPalBox_ToServer(const FPalInstanceID&
IndividualId);
void NotifyOpenClosePalBox_ToServer(bool IsOpen);
void NotifyObtainComplete_ToServer(const FPalInstanceID& IndividualId);
void NotifyInvalidPlayer_ToClient();
void NotifyForceUpdateInventory_ToServer(bool IsOpen);
void NotifyFailedJoin_ToClient(const EPalPlayerJoinResult Result);
void NotifyDropOtomoInfo(const TArray<FPalLogInfo_DropPal>& InDropPalInfo);
void NotifyCompleteInitSelectMap_ToServer();
void NotifyClientInitializeToServer(FUniqueNetIdRepl ReceiveUniqueId);
void NotifyClientInitializedEssential_ToServer();
void LoadTitleLevel(bool bIsSaveSuccess);
bool IsSelectedInitMapPoint();
bool IsInStage();
bool IsCompleteLoadInitWorldPartition();
void GrantExpForParty(const int32 ExpValue);
class UPalWorldMapUIData* GetWorldMapData();
class UPalTechnologyData* GetTechnologyData();
class UPalSyncTeleportComponent* GetSyncTeleportComp();
class UPalPlayerRecordData* GetRecordData();
class UPalQuestManager* GetQuestManager();
FPalPlayerInfoForMap GetPlayerInfoForMap();
class UPalPlayerDataPalStorage* GetPalStorage();
class UPalPlayerOtomoData* GetPalPlayerOtomoData();
class UPalPlayerDataCharacterMake* GetPalPlayerCharacterMakeData();
class UPalPlayerLocalRecordData* GetLocalRecordData();
class UPalPlayerInventoryData* GetInventoryData();
TArray<FPalLogInfo_DropPal> GetAndClearLastDropPalInfo();
void FixedCharacterName(FString CharacterName);
void FixedCharacterMakeData(const FPalPlayerDataCharacterMakeInfo& MakeInfo);
void EnterChat_Receive(const FPalChatMessage& ChatMessage);
bool EnterChat(FText Msg, EPalChatCategory Category);
void EndCrimeDelegate__DelegateSignature(FGuid CrimeInstanceId);
void DropOtomoSingle_ToServer(const FVector DropLocation, const FPalInstanceID&
dropID);
void Debug_ShutdownToClient();
void Debug_SetDestructionByCompleteBuiltFlag_ToServer();
void Debug_RequestStopAICheckOfCharacter_ToServer(class APalCharacter*
TargetCharacter);
void Debug_RequestStartAICheckOfCharacter_ToServer(class APalCharacter*
TargetCharacter);
void Debug_RequestShutdownRemoteServer_ToServer();
void Debug_RequestShutdownRemoteServer();
void Debug_RequestDeletePlayerSelf_ToServer();
void Debug_RequestDeletePlayerSelf();
void Debug_RequestCauseServerCrash_ToServer();
void Debug_RequestCauseServerCrash();
void Debug_RequestAllowBroadcastAIInfoOfCharacter_ToServer(class APalCharacter*
TargetCharacter);
void Debug_RepairEquipment_ToServer();
void Debug_ReceiveDeletePlayerSelf_ToRequestClient(const bool bResult);
void Debug_OnCreatedIndividual(FPalInstanceID ID);
void Debug_DeleteWorldAndShutdownRemoteServer_ToServer();
void Debug_DeleteWorldAndShutdownRemoteServer();
void Debug_CaptureNewMonsterByDebugOtomoInfo_ToServer(const
FPalDebugOtomoPalInfo& Info);
void Debug_CaptureNewMonster_ToServer(FName CharacterID);
void Debug_BuildDebugBaseCamp_ToServer(FName CampMode, int32 workerCount);
void CapturePalDelegate__DelegateSignature(const FPalUIPalCaptureInfo&
CaptureInfo);
void
CallOrRegisterOnCompleteSyncPlayerFromServer_InClient(FCallOrRegisterOnCompleteSync
PlayerFromServer_InClientDelegate Delegate);
void
CallOrRegisterOnCompleteLoadInitWorldPartition_InClient(FCallOrRegisterOnCompleteLo
adInitWorldPartition_InClientDelegate Delegate);
void AddItemGetLog_ToClient(const FPalStaticItemIdAndNum& ItemAndNum);
void AddFullInventoryLog_ToClient();
}; // Size: 0x7B0
class APalRandomIncidentNPCSpawner : public APalNPCSpawnerBase

{
FPalRandomIncidentNPCSpawnerOnNPCSpawnedDelegate OnNPCSpawnedDelegate;
// 0x0368 (size: 0x10)
void NPCSpawned(const FName& RowName);
FPalRandomIncidentNPCSpawnerOnNPCDespawnedDelegate OnNPCDespawnedDelegate;
// 0x0378 (size: 0x10)
void NPCDespawned(const FName& RowName);
TMap<int32, FGuid> GroupMap;
// 0x0388 (size: 0x50)
void SpawnNPC(const FName& RowName, const FPalRandomIncidentSpawnNPCData&

SpawnData, int32 SpawnPointIndex, int32 SpawnPointCount);
void SpawnMonster(const FName& RowName, const
FPalRandomIncidentSpawnMonsterData& SpawnData, int32 SpawnPointIndex, int32
SpawnPointCount);
void RequestCreateGroups(TArray<int32> Groups);
void NPCSpawned__DelegateSignature(const FName& RowName);
void NPCDespawned__DelegateSignature(const FName& RowName);
bool IsSpawnedCharacter(const class UPalIndividualCharacterHandle* Handle);
void GetSpawnedCharacters(TArray<class AActor*>& SpawnedCharacters);
class UPalIndividualCharacterHandle* FindIndividualCharacterHandleByName(const
TMap<class UPalIndividualCharacterHandle*, class FName>& RowNames, const FName&
Name);
class APalCharacter* FindCharacterByName(const FName& Name);
void DespawnCharacters();
void AddGroupCharacterByGroupNo(class UPalIndividualCharacterHandle*
AddIndividualHandle, int32 GroupNo);
}; // Size: 0x3D8
class APalRandomIncidentSpawnerBase : public AActor

{
TMap<class FName, class FPalRandomIncidentWalkPathReferenceData>
WalkPointRefarences; // 0x0290 (size: 0x50)
TSubclassOf<class UPalRandomIncidentLotteryBase> LotteryClass;
// 0x02E0 (size: 0x8)
float CoolDownTimeMinute;
// 0x02E8 (size: 0x4)
double CoolDownTimeSecRemain;
// 0x02F0 (size: 0x8)
TMap<EPalRandomIncidentSpawnerAreaType, float> AreaRadius;
// 0x02F8 (size: 0x50)
int32 PlayerId;
// 0x0348 (size: 0x4)
class UPalIncidentBase* ExecIncident;
// 0x0350 (size: 0x8)
EPalRandomIncidentSpawnerStatus Status;
// 0x0358 (size: 0x1)
class UPalIncidentDynamicParameterRandom* Parameter;
// 0x0360 (size: 0x8)
class UPalRandomIncidentLotteryBase* Lottery;
// 0x0368 (size: 0x8)
void UpdateStatusWaitPlayerOutside(float DeltaTime);

void UpdateStatusIdle(float DeltaTime);
void UpdateStatusExecuting(float DeltaTime);
void UpdateStatusCoolDown(float DeltaTime);
void StartCoolDown();
void SetStatus(EPalRandomIncidentSpawnerStatus NewStatus);
void SetAreaRadius(EPalRandomIncidentSpawnerAreaType AreaType, float Radius);
void OnIncidentSpawned(class UPalIncidentBase* Incident, class
UPalIncidentDynamicParameterRandom* DynamicParameter);
bool IsInsideArea(EPalRandomIncidentSpawnerAreaType Area, const class
ACharacter* pPlayer);
TMap<EPalRandomIncidentSpawnerAreaType, float> GetAreaRadiusAll();
float GetAreaRadius(EPalRandomIncidentSpawnerAreaType AreaType);
class APalCharacter* FindPlayerInsideArea(EPalRandomIncidentSpawnerAreaType
AreaType);
void EndIncident();
void DestroyUnuseActors(TArray<class AActor*>& OutList);
void CreateWalkPathList();
void CollectWalkPoints(const TArray<class AActor*>& WalkPoints);
void CollectChildActors(TArray<class AActor*>& OutList);
void AddWalkPath(const FName& PathName, const TArray<class AActor*>&
PointList);
}; // Size: 0x3C0
class APalRecastNavMesh : public ARecastNavMesh

{
}; // Size: 0x638
class APalRegionAreaTriggerBase : public AActor

{
FName BindRegionNameMsgID;
// 0x0290 (size: 0x8)
void OnOverlap(class AActor* OtherActor);

void OnEndOverlap(class AActor* OtherActor);
}; // Size: 0x298
class APalSimpleInteractableObject : public AActor

{
EPalInteractiveObjectIndicatorType GetIndicatorType();
}; // Size: 0x298
class APalSkillEffectBase : public AActor

{
float EffectSize;
// 0x02E8 (size: 0x4)
float MinSize;
// 0x02EC (size: 0x4)
float MaxSize;
// 0x02F0 (size: 0x4)
float LifeTime;
// 0x02F4 (size: 0x4)
class UPalAttackFilter* AttackFilter;
// 0x02F8 (size: 0x8)
class UPalHitFilter* HitFilterGround;
// 0x0300 (size: 0x8)
class UPalHitFilter* HitFilterCustomRange;
// 0x0308 (size: 0x8)
class AActor* AttackTarget;
// 0x0310 (size: 0x8)
FTimerHandle LifeTimeHandler;
// 0x0318 (size: 0x8)
// 0x0320 (size: 0x8)
FRandomStream RandomStream;
// 0x0328 (size: 0x8)
void StopAllNiagaraSound();
void StopAkSound();
FTimerHandle SetTimeCallbackBySkillEffectSpawnParameter(const class UObject*
WorldContextObject, const FSkillEffectSpawnParameter& Parameter, class UObject*
callObject, FSetTimeCallbackBySkillEffectSpawnParameterTimeDelegate timeDelegate);
void SetActorTransformByOwner(const class AActor* SkillOwner, const FVector&
MyOffset);
void SetActionTargetActor(class AActor* Target);
void PlayAkSound(class UAkAudioEvent* AudioEvent);
void OnInitialize();
void LifeTimeCallback();
bool IsSelfOwnerCharacterOrRaider(class AActor* HitTarget);
bool IsRidden();
void Initialize(const class AActor* SkillOwner, const FVector& MyOffset, class
AActor* Target, FRandomStream RandomStream);
class APalCharacter* GetOwnerCharacter();
FVector GetActionTargetLocation();
class AActor* GetActionTargetActor();
class APalSkillEffectBase* CreateChildSkillEffect(TSubclassOf<class
APalSkillEffectBase> EffectClass, FTransform SpawnTransform, FRandomStream
RandomStream, ESpawnActorCollisionHandlingMethod collisionMethod, class AActor*
ownerActor);
}; // Size: 0x330
class APalSkyLightVolume : public AActor

{
class USkyLightComponent* Component;
// 0x0290 (size: 0x8)
uint8 bEnabled;
// 0x0298 (size: 0x1)
bool bDisableEnabledFlag;
// 0x029C (size: 0x1)
void OnRep_bEnabled();
}; // Size: 0x2A0
class APalSoundDebugModel : public AActor

{
void Initialize(class UAkAudioEvent* AudioEvent);
}; // Size: 0x290
class APalSpectator : public APalCharacter

{
}; // Size: 0x800
class APalSphereBodyBase : public AActor

{
void RPCDummy();
}; // Size: 0x290
class APalSpotAreaBase : public AActor

{
EPalAudioState AudioState;
// 0x0290 (size: 0x1)
bool bIsOverlappedLocalPlayer;
// 0x0291 (size: 0x1)
void OnEndOverlap(class UPrimitiveComponent* OverlappedComponent, class

void OnBeginOverlap(class UPrimitiveComponent* OverlappedComponent, class
EPalAudioState GetAudioState();
class UPrimitiveComponent* GetAreaCollision();
}; // Size: 0x298
class APalStageAreaBounds : public AActor

{
}; // Size: 0x290
class APalStageAreaVolume : public AActor

{
class UDataLayerAsset* RelatedDataLayerAsset;
// 0x0290 (size: 0x8)
void SetRelatedDataLayerAsset(class UDataLayerAsset* DataLayerAsset);

class UDataLayerAsset* GetRelatedDataLayerAsset();
FBox GetBoundingBox();
}; // Size: 0x298
class APalStationaryWeaponBase : public APalWeaponBase

{
float GetAttackableDistance();
float GetAttackableAngle();
}; // Size: 0x538
class APalTestMapObjectRegistrationToManager : public AActor

{
bool bReadyVirtualBaseCamp;
// 0x0290 (size: 0x1)
void ForceBuildComplete();
}; // Size: 0x298
class APalTestNetArchiveTransmition : public AActor

{
void SendTest();
void OnRecieveTest(const FPalNetArchive& Ar);
}; // Size: 0x290
class APalTreasureBoxVisualBase : public AActor

{
class UPalSkeletalMeshComponent* SkeletalMeshComponent;
// 0x0290 (size: 0x8)
void SetTickEnabled(bool bEnabled);

void OnPlayMontageNotifyBegin_BP(FName NotifyName);
void OnPlayMontageNotifyBegin(FName NotifyName, const
FBranchingPointNotifyPayload& BranchingPointPayload);
}; // Size: 0x298
class APalTriggerAreaBase : public AActor

{
FPalTriggerAreaBaseOnTriggerHitBeginDelegate OnTriggerHitBeginDelegate;
// 0x0290 (size: 0x10)
void PalEventNotifyTriggerHitDelegate(class AActor* HitActor, const FGuid&
AreaInstanceId);
FPalTriggerAreaBaseOnTriggerHitEndDelegate OnTriggerHitEndDelegate;
// 0x02A0 (size: 0x10)
void PalEventNotifyTriggerHitDelegate(class AActor* HitActor, const FGuid&
AreaInstanceId);
FGuid InstanceId;
// 0x02B0 (size: 0x10)
FGuid GetInstanceId();
}; // Size: 0x2C0
class APalUIDisplayCharacter : public AActor

{
class USceneComponent* DefaultSceneRoot;
// 0x0290 (size: 0x8)
class UPalSkeletalMeshComponent* PalSkeletalMeshComponent;
// 0x0298 (size: 0x8)
void GetHairBaseColor(class UPalSkeletalMeshComponent* TargetSkeletalMesh,

FLinearColor& OutColor);
void GetEyeBaseColor(class UPalSkeletalMeshComponent* TargetSkeletalMesh,
void GetBrowBaseColor(class UPalSkeletalMeshComponent* TargetSkeletalMesh,
void GetBodyBaseColor(class UPalSkeletalMeshComponent* TargetSkeletalMesh,
void ApplyCharacterMakeInfoFromPlayerData();
void ApplyCharacterMakeInfo(const FPalPlayerDataCharacterMakeInfo& MakeInfo);
}; // Size: 0x2A0
class APalUIInframeRenderer : public AActor

{
class UPalStaticCharacterParameterComponent*
GetStaticParameteComponentFromActorClassr(const TSubclassOf<class AActor>&
TargetActorClass);
class USkeletalMeshComponent* GetSkeletalMeshComponentFromActorClass(const
TSubclassOf<class AActor>& TargetActorClass);
void ClearOverrideMaterials(class USkeletalMeshComponent* TargetSkeletalMesh);
}; // Size: 0x290
class APalUniqueRideWeaponBase : public APalWeaponBase

{
void ShootOneBulletByDefault();
void ShootOneBullet(TSubclassOf<class APalBullet> bulletClass, class
UNiagaraSystem* MuzzleEffect, FVector MuzzleLocation, FRotator MuzzleRotate, float
BulrAngle, TSubclassOf<class AActor> AmmoClass, FTransform AmmoEject);
void OnUniqueShoot();
void OnCancellShooting();
void OnActionCompleted(const class UPalActionComponent* ActionComp);
void OnActionBegin(const class UPalActionBase* action);
FRotator GetMuzzleRotation();
FVector GetMuzzleLocation();
class UNiagaraSystem* GetMuzzleEffect();
FVector GetCommonTargetLocation();
float GetBulrAngle();
TSubclassOf<class APalBullet> GetBulletClass();
FTransform GetAmmoEjectTransform();
TSubclassOf<class AActor> GetAmmoClass();
void GetAllMeshComponent(TArray<class UMeshComponent*>& OutMesh);
bool CanUse();
}; // Size: 0x540
class APalWeaponBase : public AActor

{
FPalWeaponBaseOnReloadDelegate OnReloadDelegate;
// 0x0298 (size: 0x10)
void ReloadBulletsDelegate(int32 bulletsNum);
FPalWeaponBaseOnUseBulletDelegate OnUseBulletDelegate;
// 0x02A8 (size: 0x10)
void UseBulletDelegate(int32 remainingBulletsNum);
FPalWeaponBaseOnShootBulletDelegate OnShootBulletDelegate;
// 0x02B8 (size: 0x10)
void OnShootBulletDelegate();
FPalWeaponBaseOnChangeCoolDownStateDelegate OnChangeCoolDownStateDelegate;
// 0x02C8 (size: 0x10)
void OnChangeCoolDownStateDelegate(bool IsStart);
FPalWeaponBaseOnCoolDownUpdateDelegate OnCoolDownUpdateDelegate;
// 0x02D8 (size: 0x10)
void OnCoolDownUpdateDelegate(float RemainingTime, float CoolDownTime);
FPalWeaponBaseOnCreatedBulletDelegate OnCreatedBulletDelegate;
// 0x02E8 (size: 0x10)
void CreatedBulletDelegate(class APalBullet* Bullet);
FPalWeaponBaseOnGetWeaponDamageDelegate OnGetWeaponDamageDelegate;
// 0x02F8 (size: 0x10)
int32 GetWeaponDamageDelegate();
FPalWeaponBaseOnAttachWeaponDelegate OnAttachWeaponDelegate;
// 0x0308 (size: 0x10)
void OnAttachWeaponDelegate();
FPalWeaponBaseOnDetachWeaponDelegate OnDetachWeaponDelegate;
// 0x0318 (size: 0x10)
void OnDetachWeaponDelegate();
FPalWeaponBaseOnWeaponNotifyDelegate OnWeaponNotifyDelegate;
// 0x0328 (size: 0x10)
void WeaponNotifyDelegate(EWeaponNotifyType NotifyType);
float BulletDeleteTime;
// 0x0338 (size: 0x4)
float BulletDecayStartRate;
// 0x033C (size: 0x4)
class UCurveFloat* RecoilCurve;
// 0x0340 (size: 0x8)
float RecoilYawRange;
// 0x0348 (size: 0x4)
float RecoilPitchTotalMax;
// 0x034C (size: 0x4)
float RecoilDecaySpeed;
// 0x0350 (size: 0x4)
TSubclassOf<class UCameraShakeBase> ShotCameraShake;
// 0x0358 (size: 0x8)
EWeaponCoopType WeaponCoopType;
// 0x0360 (size: 0x1)
EPalWeaponType WeaponType;
// 0x0361 (size: 0x1)
bool IsRequiredBullet;
// 0x0362 (size: 0x1)
FName BulletItemName;
// 0x0364 (size: 0x8)
class UMaterialInterface* ShootBlurMaterial;
// 0x0370 (size: 0x8)
class UCurveFloat* ShootBlurAlphaCurve;
// 0x0378 (size: 0x8)
// 0x0380 (size: 0x10)
TSoftObjectPtr<UTexture2D> weaponIconTexture;
// 0x0390 (size: 0x30)
EPalDamageAnimationReactionType weaponBulletDamageReactionType;
// 0x03C0 (size: 0x1)
TSoftClassPtr<UPalSoundSlot> PalSoundSlotClass;
// 0x03C8 (size: 0x30)
TMap<class EWeaponPlaySoundType, class FPalDataTableRowName_SoundID>
PlaySoundIds; // 0x03F8 (size: 0x50)
bool IsEmptyOtomoPal;
// 0x0448 (size: 0x1)
float CoolDownTime;
// 0x044C (size: 0x4)
class UMaterialInstanceDynamic* ShootBlurMaterialDynamic;
// 0x0450 (size: 0x8)
FPalItemId ownItemID;
// 0x046C (size: 0x28)
FPalItemData ownItemData;
// 0x0498 (size: 0x10)
class UPalStaticWeaponItemData* ownWeaponStaticData;
// 0x04A8 (size: 0x8)
class UPalDynamicWeaponItemDataBase* ownWeaponDynamicData;
// 0x04B0 (size: 0x8)
FFlagContainer HiddenWeapon;
// 0x04B8 (size: 0x50)
class UPalSoundSlot* PalSoundSlotCache;
// 0x0508 (size: 0x8)
float RecoilPowerRate;
// 0x0510 (size: 0x4)
bool IsScopeMode;
// 0x0514 (size: 0x1)
bool IsOneBulletReloadWeapon;
// 0x0515 (size: 0x1)
float DelayDestorySecond;
// 0x0518 (size: 0x4)
bool IsUnnecessaryDynamicData;
// 0x051C (size: 0x1)
EPalShooterFlagContainerPriority ShooterFlagPriority;
// 0x051D (size: 0x1)
TSubclassOf<class APalBackWeaponBase> BackWeaponClass;
// 0x0520 (size: 0x8)
class APalBackWeaponBase* BackWeaponModel;
// 0x0528 (size: 0x8)
int32 LoadoutSelectorIndex;
// 0x0530 (size: 0x4)
void WeaponNotifyDelegate__DelegateSignature(EWeaponNotifyType NotifyType);

void UseBulletDelegate__DelegateSignature(int32 remainingBulletsNum);
void UnbindGetWeaponDamageDelegate();
class UPalDynamicWeaponItemDataBase* TryGetDynamicWeaponData();
void StartCoolDown();
void SetupWeaponSkill();
void SetHiddenWeaponMyself(bool isHidden);
void SetHiddenWeaponDefault(bool isHidden);
void SetHiddenWeapon(FName flagName, bool isHidden);
void SendWeaponNotify(EWeaponNotifyType Type);
bool SeekRightHandOpen();
bool SeekLeftHandOpen();
void RPCDummy();
void RequestConsumeItem_ForThrowWeapon(const FName& StaticItemId, int32
ConsumeNum);
void RequestConsumeItem(const FName& StaticItemId, int32 ConsumeNum);
void ReloadBulletsDelegate__DelegateSignature(int32 bulletsNum);
bool ReloadBullets();
void PlaySoundWithOption(const FPalDataTableRowName_SoundID& ID, const
FPalSoundOptions& Arg);
void PlaySound(const FPalDataTableRowName_SoundID& ID);
void OnStartAim();
void OnShootBulletDelegate__DelegateSignature();
void OnRequestClosing();
void OnReleaseTrigger();
void OnPullTrigger();
void OnPullCancel();
void OnEndAim();
void OnDetachWeaponDelegate__DelegateSignature();
void OnDetachWeapon(class AActor* detachActor);
void OnCreatedBullet(class APalBullet* Bullet);
void OnCoolDownUpdateDelegate__DelegateSignature(float RemainingTime, float
CoolDownTime);
void OnChangeTargetDirection(FVector Direction);
void OnChangeCoolDownStateDelegate__DelegateSignature(bool IsStart);
void OnAttachWeaponDelegate__DelegateSignature();
void OnAttachWeapon(class AActor* attachActor);
bool IsUseLeftHandAttach();
bool IsHiddenWeapon();
bool IsFullMagazine();
bool IsExistBulletInPlayerInventory();
bool IsEnableAutoAim();
bool IsEmptyMagazine();
bool IsCoolDown();
int32 GetWeaponEffectValue();
EPalAdditionalEffectType GetWeaponEffectType();
int32 GetWeaponDamageFromDelegate();
int32 GetWeaponDamageDelegate__DelegateSignature();
int32 GetWeaponDamage();
int32 GetWeaponBaseDamage();
class AActor* GetWeaponAttacker();
TArray<FPalPassiveSkillEffect> GetSkillEffectList();
float GetShooterComponentBlurRate();
void GetRequiredBulletName(FName& outName);
float GetRemainingCoolDownTime();
int32 GetRemainBulletCount();
float GetRandomFloat(float Min, float Max);
int32 GetNPCWeaponDamage();
class USceneComponent* GetMainMesh();
int32 GetMagazineSize();
FTransform GetLeftHandTransform();
FPalItemId GetItemId();
FName GetEquipSocketName();
float GetDefaultBlurAngle();
float GetBlurModifierValue();
int32 DecrementCurrentSelectPalSphere(int32 RequestConsumeNum, FName&
UsedItemID);
bool DecrementBullet();
void CreatedBulletDelegate__DelegateSignature(class APalBullet* Bullet);
void ClearWeaponSkill();
float CalcStability();
float CalcRange();
float CalcDPS();
float CalcAccuracy();
}; // Size: 0x538
class APalWindController : public AInfo

{
FFloatInterval WindDirectionChangeInterval;
// 0x0290 (size: 0x8)
float WindDirectionResponse;
// 0x0298 (size: 0x4)
FFloatInterval WindSpeedInterval;
// 0x029C (size: 0x8)
FFloatInterval WindSpeedChangeInterval;
// 0x02A4 (size: 0x8)
float LastChangedDirectionTime;
// 0x0B40 (size: 0x4)
float LastChangedSpeedTime;
// 0x0B44 (size: 0x4)
void UpdateNiagaraParameterCollection(const FPalWindInfo& WindInfo);

void OnActorSpawned(class AActor* InActor);
}; // Size: 0xB60
class APalWorldMapCapture : public AActor

{
class USceneCaptureComponent2D* SceneCaptureComponent;
// 0x0290 (size: 0x8)
class UTexture2D* worldMapTexture;
// 0x0298 (size: 0x8)
class UTextureRenderTarget2D* worldMapDetailRenderTexture;
// 0x02A0 (size: 0x8)
class UTexture2D* worldMapHeightTexture;
// 0x02A8 (size: 0x8)
class UTexture2D* GetWorldMapHeightMap();

class UTextureRenderTarget2D* GetRenderedWorldMapTexture();
bool CreateWorldMapTexture();
void CaptureWorldMapTexture_Perspective();
void CaptureWorldMapTexture_Ortho();
}; // Size: 0x2B0
class APalWorldPartitionLoadingRangeVolume : public AActor

{
TMap<int32, float> LoadingRangeMap;
// 0x0290 (size: 0x50)
void SetOverrideLoadingRange(bool Enable);

}; // Size: 0x2E0
class APalWorldSettings : public AWorldSettings

{
TSubclassOf<class UPalDungeonWorldSubsystem> DungeonWorldSubsystemClass;
// 0x04B8 (size: 0x8)
FVector DungeonCreateInitialLocation;
// 0x04C0 (size: 0x18)
class UDataLayerAsset* FieldEnvironmentDataLayerAsset;
// 0x04D8 (size: 0x8)
TSubclassOf<class UPalAudioWorldSubsystem> AudioWorldSubsystemClass;
// 0x04E0 (size: 0x8)
bool bIsPalTimerEnabled;
// 0x04E8 (size: 0x1)
TSubclassOf<class UPalOptionSubsystem> OptionWorldSubsystemClass;
// 0x04F0 (size: 0x8)
TSubclassOf<class UPalTimeManager> TimeManagerClass;
// 0x04F8 (size: 0x8)
TSubclassOf<class UPalInvaderManager> InvaderManagerClass;
// 0x0500 (size: 0x8)
TSubclassOf<class UPalIncidentSystem> IncidentSystemClass;
// 0x0508 (size: 0x8)
TSubclassOf<class UPalFunnelCharacterManager> FunnelCharacterManagerClass;
// 0x0510 (size: 0x8)
bool bRequestCharacterMake;
// 0x0518 (size: 0x1)
}; // Size: 0x520
class IBossBattleLevelSequenceRootInterface : public IInterface

{
}; // Size: 0x28
class IPalAIActionCompositeOrderCommandInterface : public IInterface

{
}; // Size: 0x28
class IPalAIActionWorkerInterruptInterface : public IInterface

{
bool IsInterruptibleBySleep();
bool IsInterruptibleByRecoverHungry();
}; // Size: 0x28
class IPalAIControllerWorkerInterface : public IInterface

{
TSubclassOf<class UPalAIControllerWorkerModule> GetWorkerModuleClass();

}; // Size: 0x28
class IPalAISightResponseTransitionableInterface : public IInterface

{
void GetTransitionableJudgementType(TArray<EPalAISightJudgementType>&
JudgeTypeList);
}; // Size: 0x28
class IPalBaseCampAssignableObjectInterface : public IInterface

{
TScriptInterface<class IPalMapObjectModelInterface> ToMapObjectModel();

EPalBaseCampAssignType GetAssignType();
}; // Size: 0x28
class IPalBaseCampEnergyGeneratorInterface : public IInterface

{
}; // Size: 0x28
class IPalBaseCampModulePassiveEffectWorkSpeedApplierInterface : public IInterface

{
}; // Size: 0x28
class IPalBaseCampModuleResourceCollectorTargetInterface : public IInterface

{
}; // Size: 0x28
class IPalBaseCampModuleTransportItemDepotInterface : public IInterface

{
}; // Size: 0x28
class IPalBaseCampModuleTransportItemRequirerInterface : public IInterface

{
}; // Size: 0x28
class IPalBuildObjectSpawnValidationCheckInterface : public IInterface

{
}; // Size: 0x28
class IPalGamePlayerDataSaveInterface : public IInterface

{
}; // Size: 0x28
class IPalGameSystemNeedSync : public IInterface

{
}; // Size: 0x28
class IPalGameSystemNeedWorldSync : public IInterface

{
}; // Size: 0x28
class IPalGameWorldDataSaveInterface : public IInterface

{
}; // Size: 0x28
class IPalHUDServiceProviderInterface : public IInterface

{
void PlayAkSound(class UAkAudioEvent* AkEvent);

class UPalSoundPlayer* GetSoundPlayer();
}; // Size: 0x28
class IPalInflictDamageNotifyInterface : public IInterface

{
void OnInflictDamage(const FPalDamageResult& DamageResult);

void OnDefeatCharacter(const FPalDeadInfo& DeadInfo);
}; // Size: 0x28
class IPalInteractiveInterface : public IInterface

{
bool IsEnableTriggerInteract();
}; // Size: 0x28
class IPalInteractiveObjectComponentInterface : public IPalInteractiveInterface

{
void SetIndicatorInterface(TScriptInterface<class
IPalInteractiveObjectIndicatorInterface> InIndicatorInterface);
class UObject* Self();
FText GetIndicatorText(const class UObject* WorldContextObject,
FVector GetIndicatorLocation();
void GetIndicatorInfo(FPalInteractiveObjectActionInfoSet& ActionInfo, const
FPalInteractiveObjectActionBy& SituationInfo);
void EnableTriggerInteract();
class UPalInteractDelegates* Delegates();
}; // Size: 0x28
class IPalInteractiveObjectIndicatorInterface : public IInterface

{
}; // Size: 0x28
class IPalLevelObjectInterface : public IInterface

{
}; // Size: 0x28
class IPalLimitVolumeInterface : public IInterface

{
}; // Size: 0x28
class IPalMapObjectConcreteModelModuleItemHolderInterface : public IInterface

{
}; // Size: 0x28
class IPalMapObjectItemCollectableInterface : public IInterface

{
EPalMapObjectItemCollectableType GetItemCollectableType();
void GetCollectableStaticItemIds(TArray<FName>& OutStaticItemIds);
}; // Size: 0x28
class IPalMapObjectLauncherControlInterface : public IInterface

{
void TurnToTarget(const class AActor* TargetActor, float DeltaTime);

void SetOwnerCharacter(const class APalCharacter* OwnerCharacter);
void SetEnableTrigger(bool EnableTrigger);
FRotator GetCharacterRotation();
FVector GetCharacterLocation();
}; // Size: 0x28
class IPalMapObjectModelInterface : public IInterface

{
FGuid GetModelId();
}; // Size: 0x28
class IPalMapObjectWaterRecievableInterface : public IInterface

{
void OnWaterOneshot(class AActor* Waterer);

void OnWateringEnd(class AActor* Waterer);
void OnWateringBegin(class AActor* Waterer);
}; // Size: 0x28
class IPalMapObjectWorkerAvailableFacilityInterface : public IInterface

{
}; // Size: 0x28
class IPalMonsterControllerBaseCampInterface : public IInterface

{
void TerminateBaseCampActionByClass(TSubclassOf<class UPalAIActionBase>

actionClass);
void SetDefaultPositionAction();
void SetCapturedStorageAction();
void SetBaseCampFighterGunnerAction();
void SetBaseCampFighterAction();
void SetBaseCampActionWithFixAssign(const FGuid& TargetWorkProgressId, const
float DistanceFixAssignTargetting);
void SetBaseCampActionSpawningForWork();
void SetBaseCampActionSleepMedicalBed(const FGuid& TargetBedConcreteModelId);
class UPalAIActionBaseCampSleep* SetBaseCampActionSleep();
void SetBaseCampActionLift();
class UPalAIActionBase* SetBaseCampActionByClass(TSubclassOf<class
UPalAIActionBase> actionClass);
void SetBaseCampAction();
void NotifyOrderCommand(const EPalMapBaseCampWorkerOrderType OrderType);
void InterruptSleepActivelyAction(const
FPalAIActionBaseCampSleepActivelyParameter& Parameter);
void InterruptReturnBackToBaseCamp();
void InterruptRecoverHungryAction(const
FPalMonsterControllerBaseCampHungryParameter Parameter);
void InterruptPlayWorkerEventAction(class UPalAIActionBase* action, const
TEnumAsByte<EAIRequestPriority::Type> Priority);
}; // Size: 0x28
class IPalMonsterControllerLogInterface : public IInterface

{
void ShowBaseCampLog(const FPalMonsterControllerBaseCampLogContent& Content);

}; // Size: 0x28
class IPalNPCTalkSystemCustomFunctionInterface : public IInterface

{
void SetCustomFunctionResult(EPalNPCTalkCustomFunctionResult
CustomFunctionResult);
void SetCustomFunctionChoseIndex(int32 Index);
void AddArgument(FString Key, const FText& Text);
}; // Size: 0x28
class IPalNiagaraSoundStopInterface : public IInterface

{
}; // Size: 0x28
class IPalObjectDurabilityInterface : public IInterface

{
void SetDurability(float NewDurability);

float GetMaxDurability();
float GetDurability();
}; // Size: 0x28
class IPalOwnerCharacterAcquirableInterface : public IInterface

{

}; // Size: 0x28
class IPalReticleTargetableInterface : public IInterface

{
bool IsShowOutlineInReticleTargetting();
}; // Size: 0x28
class IPalSystemInitializeInterface : public IInterface

{
}; // Size: 0x28
class IPalUICharacterDisplayOptionInterface : public IInterface

{
bool IsSelectableSlot(const class UPalIndividualCharacterSlot* Slot);

}; // Size: 0x28
class IPalWorkProgressWorkableCheckInterface : public IInterface

{
}; // Size: 0x28
class UActionDynamicParameterUtility : public UBlueprintFunctionLibrary

{
void SetBlackboard(FActionDynamicParameter& DynamicParameterRef,

FPalNetArchive& Blackboard);
}; // Size: 0x28
class UFixedPoint64MathLibrary : public UBlueprintFunctionLibrary

{
FFixedPoint64 Subtract_FixedPoint64Integer(FFixedPoint64 A, int64 B);

FFixedPoint64 Subtract_FixedPoint64Float(FFixedPoint64 A, float B);
FFixedPoint64 Subtract_FixedPoint64FixedPoint64(FFixedPoint64 A, FFixedPoint64
B);
bool NotEqual_FixedPoint64Integer(FFixedPoint64 A, int64 B);
bool NotEqual_FixedPoint64Float(FFixedPoint64 A, float B);
bool NotEqual_FixedPoint64FixedPoint64(FFixedPoint64 A, FFixedPoint64 B);
FFixedPoint64 Multiply_FixedPoint64Integer(FFixedPoint64 A, int64 B);
FFixedPoint64 Multiply_FixedPoint64Float(FFixedPoint64 A, float B);
FFixedPoint64 Multiply_FixedPoint64FixedPoint64(FFixedPoint64 A, FFixedPoint64
B);
bool LessEqual_FixedPoint64Integer(FFixedPoint64 A, int64 B);
bool LessEqual_FixedPoint64Float(FFixedPoint64 A, float B);
bool LessEqual_FixedPoint64FixedPoint64(FFixedPoint64 A, FFixedPoint64 B);
bool Less_FixedPoint64Integer(FFixedPoint64 A, int64 B);
bool Less_FixedPoint64Float(FFixedPoint64 A, float B);
bool Less_FixedPoint64FixedPoint64(FFixedPoint64 A, FFixedPoint64 B);
bool GreaterEqual_FixedPoint64Integer(FFixedPoint64 A, int64 B);
bool GreaterEqual_FixedPoint64Float(FFixedPoint64 A, float B);
bool GreaterEqual_FixedPoint64FixedPoint64(FFixedPoint64 A, FFixedPoint64 B);
bool Greater_FixedPoint64Integer(FFixedPoint64 A, int64 B);
bool Greater_FixedPoint64Float(FFixedPoint64 A, float B);
bool Greater_FixedPoint64FixedPoint64(FFixedPoint64 A, FFixedPoint64 B);
bool EqualEqual_FixedPoint64Integer(FFixedPoint64 A, int64 B);
bool EqualEqual_FixedPoint64Float(FFixedPoint64 A, float B);
bool EqualEqual_FixedPoint64FixedPoint64(FFixedPoint64 A, FFixedPoint64 B);
FFixedPoint64 Divide_FixedPoint64Integer(FFixedPoint64 A, int64 B);
FFixedPoint64 Divide_FixedPoint64Float(FFixedPoint64 A, float B);
FFixedPoint64 Divide_FixedPoint64FixedPoint64(FFixedPoint64 A, FFixedPoint64
B);
FFixedPoint64 Convert_IntToFixedPoint64(int32 Value);
FFixedPoint64 Convert_Int64ToFixedPoint64(int64 Value);
FFixedPoint64 Convert_FloatToFixedPoint64(float Value);
int64 Convert_FixedPoint64ToInt64(FFixedPoint64 Value);
int32 Convert_FixedPoint64ToInt(FFixedPoint64 Value);
float Convert_FixedPoint64ToFloat(FFixedPoint64 Value);
FFixedPoint64 Add_FixedPoint64Integer(FFixedPoint64 A, int64 B);
FFixedPoint64 Add_FixedPoint64Float(FFixedPoint64 A, float B);
FFixedPoint64 Add_FixedPoint64FixedPoint64(FFixedPoint64 A, FFixedPoint64 B);
}; // Size: 0x28
class UFixedPointMathLibrary : public UBlueprintFunctionLibrary

{
FFixedPoint Subtract_FixedPointInteger(FFixedPoint A, int32 B);

FFixedPoint Subtract_FixedPointFloat(FFixedPoint A, float B);
FFixedPoint Subtract_FixedPointFixedPoint(FFixedPoint A, FFixedPoint B);
bool NotEqual_FixedPointInteger(FFixedPoint A, int32 B);
bool NotEqual_FixedPointFloat(FFixedPoint A, float B);
bool NotEqual_FixedPointFixedPoint(FFixedPoint A, FFixedPoint B);
FFixedPoint Multiply_FixedPointInteger(FFixedPoint A, int32 B);
FFixedPoint Multiply_FixedPointFloat(FFixedPoint A, float B);
FFixedPoint Multiply_FixedPointFixedPoint(FFixedPoint A, FFixedPoint B);
bool LessEqual_FixedPointInteger(FFixedPoint A, int32 B);
bool LessEqual_FixedPointFloat(FFixedPoint A, float B);
bool LessEqual_FixedPointFixedPoint(FFixedPoint A, FFixedPoint B);
bool Less_FixedPointInteger(FFixedPoint A, int32 B);
bool Less_FixedPointFloat(FFixedPoint A, float B);
bool Less_FixedPointFixedPoint(FFixedPoint A, FFixedPoint B);
bool GreaterEqual_FixedPointInteger(FFixedPoint A, int32 B);
bool GreaterEqual_FixedPointFloat(FFixedPoint A, float B);
bool GreaterEqual_FixedPointFixedPoint(FFixedPoint A, FFixedPoint B);
bool Greater_FixedPointInteger(FFixedPoint A, int32 B);
bool Greater_FixedPointFloat(FFixedPoint A, float B);
bool Greater_FixedPointFixedPoint(FFixedPoint A, FFixedPoint B);
bool EqualEqual_FixedPointInteger(FFixedPoint A, int32 B);
bool EqualEqual_FixedPointFloat(FFixedPoint A, float B);
bool EqualEqual_FixedPointFixedPoint(FFixedPoint A, FFixedPoint B);
FFixedPoint Divide_FixedPointInteger(FFixedPoint A, int32 B);
FFixedPoint Divide_FixedPointFloat(FFixedPoint A, float B);
FFixedPoint Divide_FixedPointFixedPoint(FFixedPoint A, FFixedPoint B);
FFixedPoint Convert_IntToFixedPoint(int32 Value);
FFixedPoint Convert_FloatToFixedPoint(float Value);
int32 Convert_FixedPointToInt(FFixedPoint Value);
float Convert_FixedPointToFloat(FFixedPoint Value);
FFixedPoint Add_FixedPointInteger(FFixedPoint A, int32 B);
FFixedPoint Add_FixedPointFloat(FFixedPoint A, float B);
FFixedPoint Add_FixedPointFixedPoint(FFixedPoint A, FFixedPoint B);
}; // Size: 0x28
class UPaRichTextDecorator_KeyGuideIcon : public URichTextBlockDecorator

{
FString GetTextStringInternal(const class UObject* WorldContextObject, FName

ID);
class UWidget* CreateWidget(FName KeyGuideActionName, float IconScale, int32
OverrideType);
}; // Size: 0x28
class UPalAIActionBase : public UPawnAction_BlueprintBase

{
bool bIsAutoStopBehaviorTree;
// 0x0090 (size: 0x1)
EPalAIActionCategory AiActionCategory;
// 0x0091 (size: 0x1)
FPalAIActionDynamicParameter DynamicParameter;
// 0x0098 (size: 0x50)
TEnumAsByte<EAIRequestPriority::Type> DefaultPriority;
// 0x00E8 (size: 0x1)
FPalAIActionBaseOnStartActionDelegate OnStartActionDelegate;
// 0x00F0 (size: 0x10)
void OnActionDelegate(class UPalAIActionBase* action);
FPalAIActionBaseOnPauseActionDelegate OnPauseActionDelegate;
// 0x0100 (size: 0x10)
void OnActionByDelegate(class UPalAIActionBase* action, const class
UPawnAction* byAction);
FPalAIActionBaseOnResumeActionDelegate OnResumeActionDelegate;
// 0x0110 (size: 0x10)
FPalAIActionBaseOnFinishActionDelegate OnFinishActionDelegate;
// 0x0120 (size: 0x10)
void SetWalkSpeed_ForAIAction(EPalMovementSpeedType MoveSpeedType);
class UPalAIActionBase* SetAIActionClassParameter(TSubclassOf<class
UPalAIActionBase> NewActionClass, FPalAIActionDynamicParameter Parameter);
bool PushChildAction(class UPawnAction* action);
void OnChildActionFinished(class UPawnAction* action,
TEnumAsByte<EPawnActionResult::Type> WithResult);
void OnActionDelegate__DelegateSignature(class UPalAIActionBase* action);
void OnActionByDelegate__DelegateSignature(class UPalAIActionBase* action,
const class UPawnAction* byAction);
bool IsPaused();
bool IsActive();
FString GetSimpleName();
TEnumAsByte<EAIRequestPriority::Type> GetRequestPriority();
class APalAIController* GetPalAIController();
class UPawnActionsComponent* GetOwnerComponent();
class AController* GetController();
class UPalCharacterParameterComponent* GetCharacterParameter();
class APalCharacter* GetCharacter();
class UPalAIActionComponent* GetAIActionComponent();
class UPawnAction* CreateActionInstanceFixName(class UObject*
WorldContextObject, TSubclassOf<class UPawnAction> actionClass, FName ActionName);
void ActionAbort(class APawn* ControlledPawn);
}; // Size: 0x130
class UPalAIActionBaseCampBase : public UPalAIActionBase

{
float WalkSpeedDefault;
// 0x0138 (size: 0x4)
void StartCombatAction(TSubclassOf<class UPalAIActionCombatBase>

CombatActionClass);
void OnUpdateFullStomach(const float Current, const float Last);
void OnClosedWorkerRadialMenu(class UPalHUDDispatchParameterBase* Parameter);
void InterruptActionToRecoverHungry(const
FPalMonsterControllerBaseCampHungryParameter Parameter);
FGuid GetBaseCampIdBelongTo();
class UPalBaseCampModel* GetBaseCampBelongTo();
void FinishCombatAction();
void ChangeChildAction(class UPalAIActionBaseCampChildBase* action);
void ChangeActionToWorker();
void ChangeActionToFighter();
}; // Size: 0x140
class UPalAIActionBaseCampCage : public UPalAIActionBase

{
}; // Size: 0x138
class UPalAIActionBaseCampChildBase : public UPalAIActionBase

{
TWeakObjectPtr<class UPalAIActionBaseCampBase> BaseCampParentAction;
// 0x0130 (size: 0x8)
}; // Size: 0x138
class UPalAIActionBaseCampDefenseBase : public UPalAIActionBase
{
// 0x0138 (size: 0x8)
class APalCharacter* SelfActor;
// 0x0140 (size: 0x8)
class UPalAICombatModule* CombatModule;
// 0x0148 (size: 0x8)
EPalWorkType CurrentWorkType;
// 0x0150 (size: 0x1)
FPalWorkAssignHandleId CurrentWorkAssignId;
// 0x0154 (size: 0x18)
EPalWorkDefenseCombatType DefenseCombatType;
// 0x016C (size: 0x1)
TSubclassOf<class UPalActionBase> DefenseActionClass;
// 0x0170 (size: 0x8)
TSubclassOf<class UPalActionBase> DefenseWaitActionClass;
// 0x0178 (size: 0x8)
TWeakObjectPtr<class UPalMapObjectDefenseBulletLauncherModel> WeakDefenseModel;
// 0x0180 (size: 0x8)
class APalAIController* GetControllerRef();

}; // Size: 0x188
class UPalAIActionBaseCampDefenseGunner : public UPalAIActionBaseCampDefenseBase

{
void StopTrigger();
void OnShootBullet();
}; // Size: 0x190
class UPalAIActionBaseCampDefenseWait : public UPalAIActionBaseCampDefenseBase

{
}; // Size: 0x188
class UPalAIActionBaseCampDodgeWork : public UPalAIActionBase

{
float WalkAroundArrivalRange;
// 0x0130 (size: 0x4)
float WalkAroundNextDistance;
// 0x0134 (size: 0x4)
FFloatInterval WalkAroundRandomTime;
// 0x0138 (size: 0x8)
}; // Size: 0x160
class UPalAIActionBaseCampFighter : public UPalAIActionBaseCampBase

{
bool TryGetDefenseMapObjectModel(class UPalMapObjectDefenseModelBase*&

OutModel);
void RegisterAssignDefenseModelId(const FGuid& InDefenseMapObjectModelId);
void ChangeActionWait();
}; // Size: 0x140
class UPalAIActionBaseCampFighterChildBase : public UPalAIActionBaseCampChildBase

{
TWeakObjectPtr<class UPalAIActionBaseCampFighter> WeakParentFighterActionCache;
// 0x0138 (size: 0x8)
class UPalAIActionBaseCampFighter* GetParentFighterAction();
}; // Size: 0x140
class UPalAIActionBaseCampFighterCombat : public UPalAIActionCombatBase

{
}; // Size: 0x178
class UPalAIActionBaseCampFighterCombatGunner : public UPalAIActionCombatBase

{
float FaceAngleRange;
// 0x0178 (size: 0x4)
TWeakObjectPtr<class UPalMapObjectDefenseBulletLauncherModel> WeakDefenseModel;
// 0x017C (size: 0x8)
}; // Size: 0x188
class UPalAIActionBaseCampFighterWait : public UPalAIActionBaseCampFighterChildBase

{
bool TrySearchEnemy();
bool TryGetWaitLocation(FVector& Location);
}; // Size: 0x140
class UPalAIActionBaseCampInUsingAmusement : public UPalAIActionBaseCampBase

{
float GetUsingTime();
}; // Size: 0x150
class UPalAIActionBaseCampRecoverHungry : public UPalAIActionBaseCampBase

{
FGuid WantFoodHUDId;
// 0x0148 (size: 0x10)
TSubclassOf<class UPalUserWidgetWorldHUD> WantFoodHUDClass;
// 0x0158 (size: 0x8)
FVector WantFoodHUDOffset;
// 0x0160 (size: 0x18)
FPalMonsterControllerBaseCampHungryParameter HungeryParameter;
// 0x0178 (size: 0xC)
void ChangeActionEat();
void ChangeActionApproach();
}; // Size: 0x188
class UPalAIActionBaseCampRecoverHungryApproachToFoodBox : public

UPalAIActionBaseCampRecoverHungryChildBase
{
}; // Size: 0x148
class UPalAIActionBaseCampRecoverHungryChildBase : public

UPalAIActionBaseCampChildBase
{
bool TryGetTargetMapObjectConcreteModel(class UPalMapObjectConcreteModelBase*&

OutTargetModel);
void ToggleShowWantFoodHUD(const bool bShow);
bool IsExistEnoughFoodInTarget();
bool IsAvailableDistance();
FVector GetTargetLocation();
class UPalAIActionBaseCampRecoverHungry* GetParentRecoverHungryAction();
void GetHungryParameter(FPalMonsterControllerBaseCampHungryParameter&
HungeryParameter);
}; // Size: 0x140
class UPalAIActionBaseCampRecoverHungryEat : public

{
float EatTime;
// 0x0140 (size: 0x4)
float TurnSpeed;
// 0x0144 (size: 0x4)
void OnFinishEatingTime();
}; // Size: 0x170
class UPalAIActionBaseCampRecoverHungryProductFood : public

{
}; // Size: 0x148
class UPalAIActionBaseCampReturnBack : public UPalAIActionBase

{
}; // Size: 0x138
class UPalAIActionBaseCampSleep : public UPalAIActionBaseCampBase

{
}; // Size: 0x150
class UPalAIActionBaseCampSleepActively : public UPalAIActionBaseCampBase

{
FGuid ReservedBedModelInstanceId;
// 0x0148 (size: 0x10)
EPalAIActionBaseCampSleepActivelyMode Mode;
// 0x0158 (size: 0x1)
void SetParameter(const FPalAIActionBaseCampSleepActivelyParameter& Parameter);

}; // Size: 0x198
class UPalAIActionBaseCampSpawningForWorker : public UPalAIActionBase

{
FPalAIActionBaseCampSpawningForWorkerOnLandedWorldStaticDelegate
OnLandedWorldStaticDelegate; // 0x0130 (size: 0x10)
void SimpleMulticastDelegate();
void SimpleMulticastDelegate__DelegateSignature();
void OnLanded(const FHitResult& Hit);
}; // Size: 0x140
class UPalAIActionBaseCampTrantrum : public UPalAIActionBase

{
float Duration;
// 0x0130 (size: 0x4)
float RadiusAttackTo;
// 0x0134 (size: 0x4)
FInt32Interval AttackNumRange;
// 0x0138 (size: 0x8)
float TurnSpeedToAttack;
// 0x0140 (size: 0x4)
FGuid AttackTargetMapObjectInstanceId;
// 0x0144 (size: 0x10)
}; // Size: 0x160
class UPalAIActionBaseCampUtility : public UBlueprintFunctionLibrary

{
TEnumAsByte<EAIRequestPriority::Type> GetRequestSoftScriptPriority(const
EPalRequestSoftScriptPriorityAdd AddPriority);
}; // Size: 0x28
class UPalAIActionCollectItemToStorage : public UPalAIActionBase

{
}; // Size: 0x130
class UPalAIActionCombatBase : public UPalAIActionBase

{
FPalAIActionCombatBaseOnCombatFinish OnCombatFinish;
// 0x0138 (size: 0x10)
void CombatFinishDelegate();
// 0x0148 (size: 0x8)
// 0x0150 (size: 0x8)
class UPalAICombatModule* CombatModule;
// 0x0158 (size: 0x8)
bool NextIsWaza;
// 0x0160 (size: 0x1)
int32 NextWazaSlotIndex;
// 0x0164 (size: 0x4)
TSubclassOf<class UPalActionBase> NextActionClass;
// 0x0168 (size: 0x8)
int32 InterruptSkillSlotID;
// 0x0170 (size: 0x4)
bool bInterruptSkill;
// 0x0174 (size: 0x1)
void StartNextAction_Event(const class UPalActionComponent* ActionComponent);

void SkillSlotSetUp();
void SetTargetAndNextAction(class AActor* Target);
bool PreTickFinishCheck();
void PlayActionWhenDarknessStatus();
void OnDeadDeledate_Event(FPalDeadInfo DeadInfo);
void MoveToTarget();
bool LineTraceTarget();
void InterruptAction(int32 SkillSlotID);
class UPalStaticCharacterParameterComponent* GetStaticParamCompRef();
class UPalActiveSkillSlot* GetSkillSlotRef();
class UPalCharacterParameterComponent* GetParamCompRef();
class APalAIController* GetControllerRef();
class UPalActionComponent* GetActorActionComponentRef();
void CombatFinishDelegate__DelegateSignature();
void ChangeNextAction();
}; // Size: 0x178
class UPalAIActionCombat_BaseCamp : public UPalAIActionCombatBase

{
}; // Size: 0x178
class UPalAIActionCombat_Standard : public UPalAIActionCombatBase

{
}; // Size: 0x178
class UPalAIActionComponent : public UPawnActionsComponent

{
TArray<class UPalAIActionCompositeBase*> ActionCompositeRoots;
// 0x00E0 (size: 0x10)
void TerminateCurrentActionByClass(TSubclassOf<class UPalAIActionBase>

actionClass);
void SetWalkSpeed_ForAIAction(EPalMovementSpeedType MoveSpeedType);
void SetRootComposite(class UPalAIActionCompositeBase* NewCompositeAction,
TEnumAsByte<EAIRequestPriority::Type> Priority);
class UPalAIActionBase* SetActionClassParameter(TSubclassOf<class
UPalAIActionBase> NewActionClass, FPalAIActionDynamicParameter Parameter);
void SetAction(class UPawnAction* NewAction,
TEnumAsByte<EAIRequestPriority::Type> Priority, class UObject* Instigator);
bool IsActionEmpty();
bool HasAction(const TSubclassOf<class UPawnAction>& checkClass,
TEnumAsByte<EAIRequestPriority::Type> checkPriority);
class UPawnAction* GetCurrentTopParentAction_BP();
EPalAIActionCategory GetCurrentAIActionCategory();
class UPawnAction* GetCurrentAction_BP();
class UPalAIActionCompositeBase*
GetCompositeRoot(TEnumAsByte<EAIRequestPriority::Type> Priority);
void CacheControlledPawn_BP();
void AllCancelPushedAction(const class UObject* Instigator);
void AllCancelActionPriorThanSoftScript(const class UObject* Instigator);
void AllCancelAction_Logic_HardScript_Reaction(const class UObject*
Instigator);
}; // Size: 0xF0
class UPalAIActionCompositeActionDummy : public UPalAIActionCompositeBase

{
void OnResumeAction(class UPalAIActionBase* action);

void OnPauseAction(class UPalAIActionBase* action, const class UPawnAction*
PausedBy);
void OnFinishAction(class UPalAIActionBase* action);
}; // Size: 0x50
class UPalAIActionCompositeBase : public UObject

{
class UPalAIActionCompositeBase* Child;
// 0x0030 (size: 0x8)
class UPalAIActionComponent* OwnerComponent;
// 0x0040 (size: 0x8)
void SetChildActionComposite(class UPalAIActionCompositeBase* Composite);

void SetChildAction(class UPalAIActionBase* action, class UObject* Instigator);
bool IsPaused();
class APawn* GetPawn();
class UPalAIActionComponent* GetOwnerComponent();
class AController* GetController();
class UPalAIActionCompositeBase* GetChild();
class UPalCharacterParameterComponent* GetCharacterParameter();
}; // Size: 0x48
class UPalAIActionCompositeBaseCamp : public UPalAIActionCompositeBase

{
float WalkSpeedDefault;
// 0x0048 (size: 0x4)

void InterruptActionToSleep();
void InterruptActionToRecoverHungry(const
FPalMonsterControllerBaseCampHungryParameter& Parameter);
void ChangeActionToWorker();
void ChangeActionToFighter();
}; // Size: 0x98
class UPalAIActionCompositeWorker : public UPalAIActionCompositeBase

{
TSubclassOf<class UPalAIActionBase> WaitActionClass;
// 0x0048 (size: 0x8)
TSubclassOf<class UPalAIActionBase> ApproachActionClass;
// 0x0050 (size: 0x8)
TSubclassOf<class UPalAIActionBase> WaitForWorkableActionClass;
// 0x0058 (size: 0x8)
TSubclassOf<class UPalAIActionBase> WorkingActionClass;
// 0x0060 (size: 0x8)
TSubclassOf<class UPalAIActionBase> CurrentActionClass;
// 0x0068 (size: 0x8)
FName SpeedFlagName;
// 0x0070 (size: 0x8)
float DefaultWalkSpeed;
// 0x0078 (size: 0x4)
void UnregisterFixAssignWork();
bool TryFindNextWork();
void RegisterFixedAssignWorkAttack(const FGuid& MapObjectModelInstanceId);
void RegisterFixedAssignWork(const FGuid& WorkId);
void OnTickInWaitAction(float DeltaTime);
void OnStartAction(class UPalAIActionBase* action);
bool IsTargetWorkable();
bool IsTargetAssignable();
bool IsAssignedToTarget();
void ChangeActionWorking();
void ChangeActionWaitForWorkable();
void ChangeActionWait();
void ChangeActionApproachToWorkArea();
}; // Size: 0x88
class UPalAIActionCompositeWorkerBaseCamp : public UPalAIActionCompositeWorker

{
TSubclassOf<class UPalAIActionCombatBase> CombatActionClass;
// 0x0090 (size: 0x8)
TSubclassOf<class UPalAIActionBaseCampDefenseBase> DefenseActionClass;
// 0x0098 (size: 0x8)
}; // Size: 0xA0
class UPalAIActionCompositeWorkerModuleBase : public UObject

{
class UPalAIActionCompositeWorker* Owner;
// 0x0028 (size: 0x8)
}; // Size: 0x30
class UPalAIActionCompositeWorkerModuleBaseCamp : public

UPalAIActionCompositeWorkerModuleBase
{
class UPalBaseCampModel* GetBaseCampBelongTo();
}; // Size: 0x30
class UPalAIActionCompositeWorkerModuleNormal : public

UPalAIActionCompositeWorkerModuleBase
{
}; // Size: 0x30
class UPalAIActionCoopAssaultrifleMode : public UPalAIActionBase

{
float SearchEnemyRadius;
// 0x0130 (size: 0x4)
float SearchLocationRadiusMax;
// 0x0134 (size: 0x4)
float SearchLocationRadiusStep;
// 0x0138 (size: 0x4)
float SearchLocationDegStep;
// 0x013C (size: 0x4)
float SearchingLocationRadius;
// 0x0140 (size: 0x4)
class APalCharacter* TargetCharacter;
// 0x0148 (size: 0x8)
class APalCharacter* ReticleTarget;
// 0x0150 (size: 0x8)
FVector AimStartPoint;
// 0x0158 (size: 0x18)
void Update(float DeltaTime);

void SetAimStartPoint(const FVector& OffsetLocation);
void SearchForTargetAndShootingLocation();
void ProgressSeraching(float DeltaTime);
void Progress_VerifyShootableEnemy();
void Progress_CollectShootableLocation();
void OnUpdateShootingLocation(class APalCharacter* Target, const FVector&
ShootLocation);
void OnRoadBlocked();
bool IsSearching();
bool HasReached(const FVector& Goal);
class APalCharacter* GetTrainer();
void GetTargetEnemies(TArray<class APalCharacter*>& Enemies);
class APalCharacter* GetTargetCharacter();
class APalCharacter* GetReticleTarget();
void GetCandidateLocations(float Radius, float DegStep,
TArray<FPalCoopSkillAssaultrifleModeCandidateLocation>& Results);
bool FindLocationToShootEnemy(class APalCharacter* Target,
FPalCoopSkillAssaultrifleModeCandidateLocation& OutLocation);
void ClearTargetCharacter();
}; // Size: 0x1E8
class UPalAIActionFed : public UPalAIActionBase
{
class APalCharacter* ApproachTarget;
// 0x0138 (size: 0x8)
}; // Size: 0x148
class UPalAIActionFunnelCharacterDefault : public UPalAIActionCompositeBase

{
bool ShouldSetSkillAction();
void SetSkillAction();
void SetOtomoFollowAction();
void OnTick_BP(float DeltaTime);
void CreateSkillActionModule(TSubclassOf<class UPalFunnelSkillModule>
FunnelSkillModuleClass);
}; // Size: 0x50
class UPalAIActionFunnelSkillBase : public UPalAIActionBase

{
class UPalFunnelSkillModule* Module;
// 0x0130 (size: 0x8)
void SetModule(class UPalFunnelSkillModule* InModule);

}; // Size: 0x138
class UPalAIActionLiftup : public UPalAIActionBase

{
void OnLanded();
void CallOnLanded(const FHitResult& Hit);
}; // Size: 0x140
class UPalAIActionOtomoDefault : public UPalAIActionCompositeBase

{
bool ShouldSetCombatAction();
void SetOtomoWorkActionFixedAssign(class AActor* HitActor);
void SetOtomoWorkAction();
void SetOtomoFollowAction();
void SetOtomoCombatAction();
void SetOtomoBaseCampAction();
}; // Size: 0x50
class UPalAIActionWorkerApproachToWorkArea : public UPalAIActionWorkerChildBase

{
void OnReceiveMoveCompleted(FAIRequestID AIRequestID,

TEnumAsByte<EPathFollowingResult::Type> Result);
}; // Size: 0x158
class UPalAIActionWorkerChildBase : public UPalAIActionBase

{
void LookToTarget(const float TurnSpeed, const float DeltaTime);

bool IsTargetWorkable();
bool IsTargetAssignable();
bool IsAssignedToTarget();
FVector GetWorkLookAtLocation();
class UPalAIActionCompositeWorker* GetParent();
}; // Size: 0x138
class UPalAIActionWorkerReaction : public UPalAIActionBase

{
class APalCharacter* LookTargetCharacter;
// 0x0130 (size: 0x8)
}; // Size: 0x140
class UPalAIActionWorkerWait : public UPalAIActionWorkerChildBase

{
void ReturnToDefaultPosition();
void OnTickForWait(float DeltaTime);
TEnumAsByte<EPathFollowingRequestResult::Type> MoveToLocation(const FVector&
ToLocation);
bool CalcWalkAroundDestination(const float Radius, FVector& OutDestination);
}; // Size: 0x138
class UPalAIActionWorkerWaitForWorkable : public UPalAIActionWorkerChildBase

{
}; // Size: 0x150
class UPalAIActionWorkerWorking : public UPalAIActionWorkerChildBase

{
EPalWorkType CurrentWorkType;
// 0x0138 (size: 0x1)
float TurnSpeedToTarget;
// 0x013C (size: 0x4)
}; // Size: 0x158
class UPalAIAction_LeaveBase : public UPalAIActionBase

{
// 0x0130 (size: 0x8)
// 0x0138 (size: 0x8)
class UPalCharacterMovementComponent* Movement;
// 0x0140 (size: 0x8)
void InitializeObject(class AActor* CombatTarget, class APalCharacter*

SelfCharactor);
}; // Size: 0x148
class UPalAIBlackboardBase : public UObject

{
}; // Size: 0x28
class UPalAICombatModule : public UObject

{
void UpdateBattleState();
void Setup();
void OnBattleFinish();
bool IsReachable_NavMesh_ForActor(class AActor* Target);
bool IsReachable_NavMesh(FVector TargetPos);
bool IsBattleMode();
class AActor* GetTargetActor();
bool AIMoveToTargetActor(class AActor* Target);
}; // Size: 0x28
class UPalAICombatModule_BaseCamp : public UPalAICombatModule

{
TWeakObjectPtr<class UPalAIActionBaseCampFighter> ParentFighterAction;
// 0x0028 (size: 0x8)
}; // Size: 0x30
class UPalAICombatModule_EnemyNormal : public UPalAICombatModule

{
}; // Size: 0x28
class UPalAICombatModule_Invader : public UPalAICombatModule

{
void OnBattleFinish_forDelegate(class AActor* Actor);

}; // Size: 0x40
class UPalAICombatModule_Otomo : public UPalAICombatModule

{
}; // Size: 0x28
class UPalAICombatModule_Wild : public UPalAICombatModule

{
void OnBattleFinish_forDelegate(class AActor* Actor);

bool JudgeReturnCombatStartPosition();
}; // Size: 0x50
class UPalAIControllerBaseCampStatus : public UObject

{
FGuid GetBaseCampId();
class UPalBaseCampModel* GetBaseCamp();
}; // Size: 0x38
class UPalAIControllerWorkerModule : public UObject

{
}; // Size: 0x28
class UPalAIControllerWorkerModuleBaseCamp : public UPalAIControllerWorkerModule

{
}; // Size: 0x28
class UPalAIControllerWorkerModuleNormal : public UPalAIControllerWorkerModule

{
}; // Size: 0x28
class UPalAIDamageReactionComponent : public UActorComponent

{
void FunctionTest();
}; // Size: 0xA0
class UPalAIResponsePreset : public UObject

{
EPalAIResponseType Discover_Player;
// 0x0028 (size: 0x1)
EPalAIResponseType Discover_Greater;
// 0x0029 (size: 0x1)
EPalAIResponseType Discover_Equal;
// 0x002A (size: 0x1)
EPalAIResponseType Discover_Smaller;
// 0x002B (size: 0x1)
EPalAIResponseType Damaged_Player;
// 0x002C (size: 0x1)
EPalAIResponseType Damaged_Greater;
// 0x002D (size: 0x1)
EPalAIResponseType Damaged_Equal;
// 0x002E (size: 0x1)
EPalAIResponseType Damaged_Smaller;
// 0x002F (size: 0x1)
}; // Size: 0x30
class UPalAISensorComponent : public UActorComponent

{
class AActor* SelfPawn;
// 0x00A0 (size: 0x8)
float SightAngleThreshold;
// 0x00A8 (size: 0x4)
float SightDistance;
// 0x00AC (size: 0x4)
float HearingRate;
// 0x00B0 (size: 0x4)
bool HumanAndNoneWeapon;
// 0x00B4 (size: 0x1)
bool IsIgnoreSoundReaction;
// 0x00B5 (size: 0x1)
float RecentMaxSoundLevel;
// 0x00B8 (size: 0x4)
int32 ResponsedMaxBiologicalGrade;
// 0x00C4 (size: 0x4)
class UPalAIResponsePreset* AIResponsePreset;
// 0x00C8 (size: 0x8)
class UPalAISightResponse* AISightResponse;
// 0x00D0 (size: 0x8)
FFlagContainer DisableSightFlag;
// 0x00D8 (size: 0x50)
FPalAISensorComponentOnFReceiveSoundDelegate OnFReceiveSoundDelegate;
// 0x0128 (size: 0x10)
void ReceiveSoundDelegate(FVector EmitLocation);
void SightCheckAllPlayer(TArray<class APalCharacter*>& InSightPlayers, float

RangeRate);
void SightCheckAllEdibleDeadNPC(TArray<class APalCharacter*>&
InSightCharacters);
void SightCheckAllAliveNPC(TArray<class APalCharacter*>& InSightCharacters);
void Setup();
void SetDisableSightFlag(FName flagName, bool isDisable);
void SetDebugAIResponse(TSubclassOf<class UPalAIResponsePreset> PresetClass);
EPalAIResponseType SelectResponseBySenses(EPalAIResponseType CurrentBehavior,
const TArray<class APalCharacter*>& FindCharacters, bool IsDamaged, class
APalCharacter*& OutTargetCharacter);
void ResetResponsedMaxBiologicalGrade();
void ReceiveSoundDelegate__DelegateSignature(FVector EmitLocation);
void ReceiveSound(int32 SoundRadius, FVector EmitLocation, class AActor*
Emitter);
void OnResponseSpecialLookat();
class APalCharacter* MaximumStrengthEnemy(const TArray<class APalCharacter*>&
FindCharacters, EPalBiologicalGradeComparedResult& Result);
bool IsInSightKillerAndDeadBody(class AActor* Killer, class AActor* DeadBody);
void EnableHearing();
void DisableHearing();
void DeadAutoRemoveDelegate(FPalDeadInfo DeadInfo);
}; // Size: 0x138
class UPalAISightResponse : public UObject

{
class UPalAISightResponsePreset* SightResponsePreset;
// 0x0028 (size: 0x8)
}; // Size: 0x80
class UPalAISightResponsePreset : public UObject

{
TMap<class EPalAISightJudgementType, class TSubclassOf<UPalAIActionBase>>
AIActionMap; // 0x0028 (size: 0x50)
FPalAISightResponsePresetAimedByPlayerDelegate AimedByPlayerDelegate;
// 0x0078 (size: 0x10)
void FindDelegate(class APalCharacter* SelfCharacter, class APalCharacter*
FoundCharacter);
TMap<class EPalAISightJudgementType, class
FPalAISightResponsePresetDelegateMap> DelegateMap; // 0x0088 (size: 0x50)
void FindDelegate__DelegateSignature(class APalCharacter* SelfCharacter, class

APalCharacter* FoundCharacter);
void BlueprintDelegateSetup();
}; // Size: 0xD8
class UPalAbilityPassiveSkill : public UObject

{
FPalAbilityPassiveSkillIsRestrictedDelegate IsRestrictedDelegate;
// 0x0028 (size: 0x10)
bool IsRestricted(class AActor* Trainer);
bool isReserving;
// 0x0038 (size: 0x1)
bool bIsRestricted;
// 0x0039 (size: 0x1)
bool bRequireWorkerWorkingPassiveSkill;
// 0x003A (size: 0x1)
bool bIsWorking;
// 0x003B (size: 0x1)
TArray<FPalPassiveAbilitySkills> PassiveSkills;
// 0x0040 (size: 0x10)
FPalPassiveAbilitySkillStatus> SkillStatus; // 0x0050 (size: 0x50)
int32 CurrentRank;
// 0x00A0 (size: 0x4)
void OnWorkerAssignChanged(class UPalCharacterParameterComponent* Parameter);

void OnUpdateOtomoHolder(class APalCharacter* Character);
void OnUpdateInventoryContainer(class UPalItemContainer* Container);
void OnRideInactivated();
void OnRideActivated();
void OnReserveInactivated();
void OnReserveActivated();
void OnInactivatedAsWorker();
void OnInactivatedAsOtomoHolder();
void OnInactivatedAsOtomo();
void OnActivatedAsWorker();
void OnActivatedAsOtomoHolder();
void OnActivatedAsOtomo();
void ObserveWorking();
bool IsRestricted__DelegateSignature(class AActor* Trainer);
bool IsRestricted();
void Initialize(const TArray<FPalPassiveAbilitySkills>& _PassiveSkills);
void InactivateWorkingSkill();
class APalPlayerController* GetTrainerController();
class APalCharacter* GetTrainerActor();
class ACharacter* GetTrainer();
TArray<FName> GetPassiveSkillList();
class APalCharacter* GetOwner();
int32 GetOtomoRank();
}; // Size: 0xF8
class UPalAbilitySkillParameterComponent : public UActorComponent

{
TArray<FPalPassiveAbilitySkills> AbilitySkills;
// 0x00A0 (size: 0x10)
class UPalAbilityPassiveSkill* PassiveSkill;
// 0x00B0 (size: 0x8)
void OnOwnerCharacterSpawned(FPalInstanceID ID);
void OnInitializedCharacter(class APalCharacter* OwnerCharacter);
void OnInactivatedAsPartner();
void OnActivatedAsPartner();
}; // Size: 0xB8
class UPalActionBase : public UObject

{
FPalActionBaseOnActionEndDelegate OnActionEndDelegate;
// 0x0028 (size: 0x10)
void ActionEndDelegate();
bool bIsEndAction;
// 0x0038 (size: 0x1)
bool bCanDeleteInstance;
// 0x0039 (size: 0x1)
bool bCanInterruptWaza;
// 0x003A (size: 0x1)
bool bIsChangeWorkAnimPlayRate;
// 0x003B (size: 0x1)
bool bIsChangeWalkableFloorAngle;
// 0x003C (size: 0x1)
float ActionWalkableFloorAngle;
// 0x0040 (size: 0x4)
bool bIsReflectForClient;
// 0x0044 (size: 0x1)
FActionDynamicParameter DynamicParameter;
// 0x0050 (size: 0xE0)
void TickAction(float DeltaTime);

void SetAnimRateScale(FName flagName, float AnimRateScale);
void SendNotify(FName NotifyName);
void OnUpdatePassiveSkill(EPalPassiveSkillEffectType EffectType, float Value);
void OnEndPassiveSkill(EPalPassiveSkillEffectType EffectType);
void OnEndAction();
void OnChangeCurrentWorkSuitability();
void OnBreakAction();
void OnBeginAction();
bool IsInServer();
bool IsInLocalControlled();
bool IsEndAction();
FVector GetTargetLocation();
FString GetSimpleName();
FRandomStream GetRandomStream();
int32 GetGeneralPurposeIndex();
FPalNetArchive GetBlackboard();
FVector GetActionVelocity();
class AActor* GetActionTarget();
class UPalIndividualCharacterParameter*
GetActionIndividualCharacterParameter();
class APalCharacter* GetActionCharacter();
bool CanStepCancel();
bool CanNextActionCancel();
bool CanGainSP();
bool CanDeleteInstance();
void AnimEventSpawn();
void AnimEventOther();
void AnimEventAttack();
void ActionEndDelegate__DelegateSignature();
}; // Size: 0x140
class UPalActionComponent : public UActorComponent

{
TMap<class EPalActionType, class TSubclassOf<UPalActionBase>> ActionMap;
// 0x00A0 (size: 0x50)
FPalActionComponentOnAllActionFinishDelegate OnAllActionFinishDelegate;
// 0x00F0 (size: 0x10)
void AllActionFinishDelegate(const class UPalActionComponent* ActionComponent);
FPalActionComponentOnActionBeginDelegate OnActionBeginDelegate;
// 0x0100 (size: 0x10)
void ActionStartDelegate(const class UPalActionBase* action);
FPalActionComponentOnActionNotifyDelegate OnActionNotifyDelegate;
// 0x0110 (size: 0x10)
void ActionNotify(const class UPalActionBase* action, FName NotifyName);
class UPalActionBase* CurrentAction;
// 0x0120 (size: 0x8)
TArray<class UPalActionBase*> ActionQueue;
// 0x0128 (size: 0x10)
TArray<class UPalActionBase*> TerminateWaitActionList;
// 0x0138 (size: 0x10)
class UPalActionBase* PlayActionParameter(FActionDynamicParameter Param,

TSubclassOf<class UPalActionBase> actionClass);
class UPalActionBase* PlayActionLocationByType(FVector Location, EPalActionType
Type);
class UPalActionBase* PlayActionLocation(FVector Location, TSubclassOf<class
UPalActionBase> actionClass);
class UPalActionBase* PlayActionByTypeParameter(FActionDynamicParameter Param,
EPalActionType Type);
class UPalActionBase* PlayActionByType(class AActor* ActionTarget,
EPalActionType Type);
void PlayAction_ToServer(FActionDynamicParameter Param, TSubclassOf<class
UPalActionBase> actionClass, int32 issuerID);
void PlayAction_ToALL(FActionDynamicParameter Param, TSubclassOf<class
UPalActionBase> actionClass, int32 issuerID);
class UPalActionBase* PlayAction_LocalOnly(FActionDynamicParameter Param,
class UPalActionBase* PlayAction_Internal(FActionDynamicParameter Param,
class UPalActionBase* PlayAction(class AActor* ActionTarget, TSubclassOf<class
UPalActionBase> actionClass);
void OnOwnerEndPlay(class AActor* Actor, TEnumAsByte<EEndPlayReason::Type>
reasonType);
void OnCompleteCharacter(class APalCharacter* InCharacter);
EPalActionType GetCurrentActionType();
class UPalActionBase* GetCurrentAction();
void CancelAllAction_Internal();
void CancelAllAction();
void CancelActionByType(EPalActionType Type);
void CancelAction_Internal(FGuid ActionID);
void CancelAction(class UPalActionBase* action);
void BeginPlay();
void AllActionFinishDelegate__DelegateSignature(const class
UPalActionComponent* ActionComponent);
void ActionStartDelegate__DelegateSignature(const class UPalActionBase*
action);
void ActionNotify__DelegateSignature(const class UPalActionBase* action, FName
NotifyName);
bool ActionIsEmpty();
}; // Size: 0x150
class UPalActionDummyTargetManager : public UPalWorldSubsystem

{
TArray<class APalActionDummyTargetActor*> ActionDummyTargetCache;
// 0x0070 (size: 0x10)
}; // Size: 0x80
class UPalActionOneShotAnimation : public UPalActionBase

{
void OnEndMontage(class UAnimMontage* Montage, bool bInterrupted);

}; // Size: 0x150
class UPalActionSpawnItem : public UPalActionBase

{
FName SpawnSocketName;
// 0x0138 (size: 0x8)
// 0x0140 (size: 0x18)
FRotator SpawnItemRotator;
// 0x0158 (size: 0x18)
void WriteBlackboard(FPalNetArchive& BlackboardRef, const
FPalStaticItemIdAndNum& ItemInfo);
void SpawnItemInServer();
void ReadBlackboard(FPalStaticItemIdAndNum& ItemInfo);
}; // Size: 0x170
class UPalActionTransportItem : public UPalActionBase

{
FName ItemAttachSocketName;
// 0x0138 (size: 0x8)
class AActor* ItemActor;
// 0x0140 (size: 0x8)
void WriteBlackboard(FPalNetArchive& BlackboardRef, const FName StaticItemId);

void StartSetupItemActor(const FName StaticItemId);
void ReadBlackboard(FName& StaticItemId);
}; // Size: 0x160
class UPalActionWazaBase : public UPalActionBase

{
EPalWazaID WazaID;
// 0x0138 (size: 0x1)
// 0x0140 (size: 0x8)
bool bApplyFullStomachCost;
// 0x0148 (size: 0x1)
void StopAkSound();
void PlayAkSound(class UAkAudioEvent* AudioEvent);
EPalWazaID GetWazaID();
class APalPlayerCharacter* GetRiderPlayer();
}; // Size: 0x150
class UPalAction_BeLiftup : public UPalActionBase

{
void OnStartLifting();
void OnStartInterpTransform();
void OnEndInterpTransform();
void OnDeadOwner_ServerInternal(FPalDeadInfo DeadInfo);
void OnAttachedForBP();
}; // Size: 0x140
class UPalAction_BeThrown : public UPalActionBase

{
class UAnimMontage* PlayingMontage;
// 0x0138 (size: 0x8)
class UNiagaraComponent* NiagaraComponent;
// 0x0140 (size: 0x8)
void PlayThrownMontage();
void PlayThrownFX();
}; // Size: 0x150
class UPalAction_DrownCheckBase : public UPalStatusBase

{
}; // Size: 0x60
class UPalAction_FeedItemToCharacter : public UPalActionBase

{
float TurnSpeed;
// 0x0148 (size: 0x4)
class UPalAIActionFed* TargetCharacterAction;
// 0x0150 (size: 0x8)
void TimeoutStartTargetCharacterApproachAction();
void SimpleDelegate__DelegateSignature();
void PlayMontageFeeding();
void OnNotifiedMontage_OnReachFeeding();
void OnFinishPlayMontageFeeding();
void OnCancelByInputGuard();
}; // Size: 0x180
class UPalAction_Liftup : public UPalActionBase

{
float AttachRelativeLocationOffsetZ;
// 0x0138 (size: 0x4)
bool bIsAttachToLeftHand;
// 0x013C (size: 0x1)
void StartRagdollForTargetCharacter();
void StartInterpTransformForAttachCharacter();
void PlayWeaponChangeAnime();
void PlayTargetBeLiftupAction(class APalCharacter* TargetCharacter);
void PlayStartLiftupMontage();
void OnTriggerPlayerInteract();
void OnCompleteStartLiftupMontage();
void AttachLiftedCharacter();
}; // Size: 0x140
class UPalAction_LiftupThrow : public UPalActionBase

{
float AttachRelativeLocationOffsetZ;
// 0x0138 (size: 0x4)
bool bIsAttachToLeftHand;
// 0x013C (size: 0x1)
void PlayWeaponChangeAnime();
void PlayPlayerThrowMontage();
void LaunchLiftObject();
}; // Size: 0x140
class UPalAction_SleepPlayerBed : public UPalActionBase

{
FPalAction_SleepPlayerBedOnGetupTriggerDelegate OnGetupTriggerDelegate;
// 0x0138 (size: 0x10)
void OnGetupTriggerDelegate();
void OnGetupTriggerDelegate__DelegateSignature();
void OnGetupPlayerBedFromModel();
bool IsSleepLooping();
void GetupBroadcast();
}; // Size: 0x150
class UPalActivatableWidget : public UCommonActivatableWidget

{
EPalWidgetInputMode InputConfig;
// 0x03C8 (size: 0x1)
EMouseCaptureMode GameMouseCaptureMode;
// 0x03C9 (size: 0x1)
}; // Size: 0x3D0
class UPalActiveSkill : public UObject

{
FPalActiveSkillOnCoolTimeUpdate OnCoolTimeUpdate;
// 0x0028 (size: 0x10)
void OnCoolTimeUpdateDelegate(float CoolRate);
FPalActiveSkillOnCoolStart OnCoolStart;
// 0x0038 (size: 0x10)
void OnCoolStateChange();
FPalActiveSkillOnCoolFinish OnCoolFinish;
// 0x0048 (size: 0x10)
void OnCoolStateChange();
bool IsCooling;
// 0x0058 (size: 0x1)
float ReuseCoolTimer;
// 0x005C (size: 0x4)
EPalWazaID WazaType;
// 0x0060 (size: 0x1)
bool IsStopTimer;
// 0x0061 (size: 0x1)
float DatabaseCoolTime;
// 0x0064 (size: 0x4)
bool bIsTransient;
// 0x0068 (size: 0x1)
void OnRep_UpdateCoolTime();
void OnRep_ChangeCTState();
void OnCoolTimeUpdateDelegate__DelegateSignature(float CoolRate);
void OnCoolStateChange__DelegateSignature();
bool IsCoolTimeFinish();
}; // Size: 0x70
class UPalActiveSkillSlot : public UObject

{
// 0x0028 (size: 0x8)
TMap<int32, UPalActiveSkill*> SkillMap;
// 0x0030 (size: 0x50)
bool IsEndInit;
// 0x0080 (size: 0x1)
FFloatContainer CoolDownSpeedRateMap;
// 0x0088 (size: 0x10)
void UpdateCoolTime(float DeltaTime);

void StopCoolTime(int32 SlotID);
void SetTransient(int32 SlotID, bool IsTransient);
void SetSkill(int32 SlotID, EPalWazaID WazaType);
void SetCoolTimeRate(FName Key, float Rate);
void RestartCoolTime(int32 SlotID);
void RemoveSkill(int32 SlotID);
void OnChangeEquipWaza(class UPalIndividualCharacterParameter*
IndividualParameter);
bool IsValidSkill(int32 SlotID);
bool IsTransient(int32 SlotID);
bool IsNearMaxRange(int32 SlotID, class AActor* TargetActor);
bool IsFarMinRange(int32 SlotID, class AActor* TargetActor);
bool IsCoolTimeFinish(int32 SlotID);
void InitObject(class AActor* ActorSelf);
EPalWazaID GetWazaType(int32 SlotID);
TMap<int32, UPalActiveSkill*> GetSkillMap();
TArray<int32> GetEnableSlotIDs();
float GetCoolTimeRate(int32 SlotID);
float GetCoolTime(int32 SlotID);
int32 FindMostEffectiveSlotID(class AActor* TargetActor);
int32 ChoiceEnableSlotIDByRandom();
bool CanUse(int32 SlotID, class AActor* TargetActor);
}; // Size: 0x98
class UPalActorChannel : public UActorChannel

{
}; // Size: 0x290
class UPalAkComponent : public UAkComponent

{
bool PersistAcrossLevelTransition;
// 0x0488 (size: 0x1)
}; // Size: 0x490
class UPalAmbientSoundLineComponent : public UBoxComponent

{
class UAkAudioEvent* AmbientEvent;
// 0x0578 (size: 0x8)
bool bIsEnableAmbientSound;
// 0x0580 (size: 0x1)
class UPalAmbientSoundLineObject* AmbinetSoundLineObject;
// 0x0588 (size: 0x8)
// 0x0590 (size: 0x8)
}; // Size: 0x5A0
class UPalAmbientSoundLineObject : public UObject

{
TArray<class USplineComponent*> SplineComponents;
// 0x0030 (size: 0x10)
class UBoxComponent* ActivateTrigger;
// 0x0040 (size: 0x8)
// 0x0048 (size: 0x8)
void OnActivateTriggerOverlapBegin(class UPrimitiveComponent* OverlappedComp,

class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32
OtherBodyIndex, bool bFromSweep, const FHitResult& SweepResult);
void OnActivateTriggerLineOverlapEnd(class UPrimitiveComponent*
OverlappedComponent, class AActor* OtherActor, class UPrimitiveComponent*
OtherComp, int32 OtherBodyIndex);
}; // Size: 0x50
class UPalAnimInstance : public UAnimInstance

{
FPalAnimInstanceOnMontageNotifyBeginDelegate OnMontageNotifyBeginDelegate;
// 0x0348 (size: 0x10)
void OnMontageNotifyBegin(class UAnimMontage* Montage, FName NotifyName);
FPalAnimInstanceOnMontageNotifyEndDelegate OnMontageNotifyEndDelegate;
// 0x0358 (size: 0x10)
void OnMontageNotifyEnd(class UAnimMontage* Montage, FName NotifyName);
TArray<class TSubclassOf<UAnimInstance>> ImplementationClassList;
// 0x0368 (size: 0x10)
FGeneralAnimationParameter GeneralAnimationParameter;
// 0x0378 (size: 0x168)
bool IsRotateYawInterpolation;
// 0x04E0 (size: 0x1)
float RotateYawInterpolation_Acceleration;
// 0x04E4 (size: 0x4)
TMap<class FName, class UPalBoneInfo*> BoneListFullBody;
// 0x04E8 (size: 0x50)
TMap<class FName, class UPalBoneInfo*> BoneListOnlySpines;
// 0x0538 (size: 0x50)
TArray<FReserveMontage> ReservedMontageList;
// 0x0588 (size: 0x10)
FFloatContainer AdditiveAnimationRate;
// 0x05A0 (size: 0x10)
FFlagContainer DisableUpperOverrideFlag;
// 0x05B8 (size: 0x50)
void SetUpperOverrideDisableFlag(FName flagName, bool isDisable);

void SetAdditiveAnimationRate(FName flagName, float Rate);
void OnNotifyEndReceived(FName NotifyName, const FBranchingPointNotifyPayload&
BranchingPointNotifyPayload);
void OnNotifyBeginReceived(FName NotifyName, const
FBranchingPointNotifyPayload& BranchingPointNotifyPayload);
void OnMontageNotifyEnd__DelegateSignature(class UAnimMontage* Montage, FName
NotifyName);
void OnMontageNotifyBegin__DelegateSignature(class UAnimMontage* Montage, FName
NotifyName);
void OnMontageEndedCallback(class UAnimMontage* Montage, bool bInterrupted);
void Montage_PlayList(TArray<FReserveMontage> montageList);
FName GetNearBoneInSpines(FVector fromPos);
FName GetNearBoneInFullBody(FVector fromPos);
float GetCurrentMontagePlayTimeToEnd();
FTransform GetBoneTransform(FName BoneName);
FQuat GetBoneRotationComponentSpace(FName BoneName);
FQuat GetBoneRotation(FName BoneName);
FVector GetBonePosition(FName BoneName);
class UPalBoneInfo* GetBoneInfo(FName BoneName);
void CalcLength(FName Target, FName nextBone, float tipLength);
void BodyInstance_SetSimulate(FName BoneName, bool SimulateActive);
void AddSpinesListFromBoneList(FName BoneName);
void AddList(FName BoneName);
}; // Size: 0x610
class UPalAnimNotifyDynamicParameterAttackCollision : public

UPalAnimNotifyDynamicParameterBase
{
class UPalHitFilter* AttackFilter;
// 0x0030 (size: 0x8)
TArray<class UShapeComponent*> TransientShapeComponents;
// 0x0038 (size: 0x10)
float HitStopCount;
// 0x0048 (size: 0x4)
class USkeletalMeshComponent* MyMesh;
// 0x0050 (size: 0x8)
class AActor* MyActor;
// 0x0058 (size: 0x8)
}; // Size: 0x60
class UPalAnimNotifyDynamicParameterAvoidTime : public

UPalAnimNotifyDynamicParameterBase
{
TMap<UPrimitiveComponent*, TEnumAsByte<ECollisionResponse>> AttackResponseMap;
// 0x0030 (size: 0x50)
}; // Size: 0x80
class UPalAnimNotifyDynamicParameterBase : public UObject

{
}; // Size: 0x30
class UPalAnimNotifyParameterComponent : public UActorComponent

{
TMap<class FString, class UPalAnimNotifyDynamicParameterBase*>
DynamicParameterMap; // 0x00A0 (size: 0x50)
}; // Size: 0xF0
class UPalAnimNotifyState_AttackCollision : public UAnimNotifyState

{
FName attachBoneName;
// 0x0030 (size: 0x8)
bool bIsEnableHitStop;
// 0x0038 (size: 0x1)
float OverrideHitStopTime;
// 0x003C (size: 0x4)
class UPalHitFilter* AttackFilter;
// 0x0040 (size: 0x8)
class UShapeComponent* ShapeComponent;
// 0x0048 (size: 0x8)
TArray<class UShapeComponent*> ShapeComponents;
// 0x0050 (size: 0x10)
void OnHit(class UPrimitiveComponent* MyHitComponent, class AActor* HitActor,

class UPrimitiveComponent* HitComponent, const TArray<int32>& FoliageIndex, FVector
HitLocation, int32 HitCount);
}; // Size: 0x60
class UPalAnimNotifyState_AvoidTime : public UAnimNotifyState

{
TMap<UPrimitiveComponent*, TEnumAsByte<ECollisionResponse>> AttackResponseMap;
// 0x0030 (size: 0x50)
TMap<UPrimitiveComponent*, TEnumAsByte<ECollisionResponse>> BulletResponseMap;
// 0x0080 (size: 0x50)
}; // Size: 0xD0
class UPalAnimNotifyState_Effect : public UAnimNotifyState_TimedNiagaraEffect

{
TMap<FName, float> UserParameterMap;
// 0x0078 (size: 0x50)
}; // Size: 0xC8
class UPalAnimNotifyState_FacialEye : public UAnimNotifyState
{
EPalFacialEyeType EyeType;
// 0x0030 (size: 0x1)
bool AutoDefaultWhenEnd;
// 0x0031 (size: 0x1)
}; // Size: 0x38
class UPalAnimNotifyState_FacialMouth : public UAnimNotifyState

{
EPalFacialMouthType MouthType;
// 0x0030 (size: 0x1)
bool AutoDefaultWhenEnd;
// 0x0031 (size: 0x1)
}; // Size: 0x38
class UPalAnimNotifyState_FlyMeshHeight : public UAnimNotifyState

{
bool IsToLand;
// 0x0030 (size: 0x1)
}; // Size: 0x38
class UPalAnimNotifyState_HidePalWeapon : public UAnimNotifyState

{
}; // Size: 0x30
class UPalAnimNotifyState_LookAtDisable : public UAnimNotifyState

{
}; // Size: 0x30
class UPalAnimNotifyState_MovementControl : public UAnimNotifyState

{
float MovementSpeedRate;
// 0x0030 (size: 0x4)
float AirControlXYRate;
// 0x0034 (size: 0x4)
float YawRotatorRate;
// 0x0038 (size: 0x4)
float GravityRate;
// 0x003C (size: 0x4)
float FixedGravityZ;
// 0x0040 (size: 0x4)
float SlideAlpha;
// 0x0044 (size: 0x4)
bool bIsDisableMovement;
// 0x0048 (size: 0x1)
bool bIsDisableJump;
// 0x0049 (size: 0x1)
}; // Size: 0x50
class UPalAnimNotifyState_WeaponControl : public UAnimNotifyState

{
bool bIsDisableShoot;
// 0x0030 (size: 0x1)
bool bIsDisableAim;
// 0x0031 (size: 0x1)
bool bIsDisableAttachLeftHand;
// 0x0032 (size: 0x1)
bool bIsDisableReload;
// 0x0033 (size: 0x1)
bool bIsDisableChangeWeapon;
// 0x0034 (size: 0x1)
EPalShooterFlagContainerPriority Priority;
// 0x0035 (size: 0x1)
}; // Size: 0x38
class UPalAnimNotify_FacialEye : public UAnimNotify

{
EPalFacialEyeType EyeType;
// 0x0038 (size: 0x1)
}; // Size: 0x40
class UPalAnimNotify_FacialMouth : public UAnimNotify

{
EPalFacialMouthType MouthType;
// 0x0038 (size: 0x1)
}; // Size: 0x40
class UPalAnimNotify_FootStep : public UAnimNotify

{
TSoftClassPtr<UPalFootStepEffectAssetBase> DefaultEffectAssetClass;
// 0x0038 (size: 0x30)
class UPalFootStepEffectAssetBase* EffectAssetCache;
// 0x0068 (size: 0x8)
void SpawnFootStepEffect(class UObject* WorldObject, EPalLandingType

LandingType, TEnumAsByte<EPhysicalSurface> PhysicalSurface, const FVector&
Location, const FRotator& Rotation, class UPalStaticCharacterParameterComponent*
StaticParam);
void SpawnFootStepDecal(class AActor* Owner, TEnumAsByte<EPhysicalSurface>
PhysicalSurface, EPalFootType FootType, FVector Location, FVector CurrentNormal,
float LifeSpan, float FadeTime);
bool GetFloorPosition(class AActor* Owner, FTransform FootTransform,
FHitResult& HitResult);
}; // Size: 0x70
class UPalAnimNotify_PlayNiagaraEffect : public UAnimNotify_PlayNiagaraEffect

{
TMap<FName, float> UserParameterMap;
// 0x00D0 (size: 0x50)
}; // Size: 0x120
class UPalAnimNotify_RequestJump : public UAnimNotify

{
}; // Size: 0x38
class UPalAnimNotify_RequestRideShakeAnimation : public UAnimNotify

{
float ApplyRate;
// 0x0038 (size: 0x4)
float PlaySpeedRate;
// 0x003C (size: 0x4)
bool bIsAdjustAnimationSpeed;
// 0x0040 (size: 0x1)
TWeakObjectPtr<class APalCharacter> cacheCharacter;
// 0x0044 (size: 0x8)
TArray<float> RateList;
// 0x0050 (size: 0x10)
void OnStartAim();
void OnEndMotion(class UAnimMontage* Montage, bool bInterrupted);
}; // Size: 0x60
class UPalAnimNotify_SendActionEvent : public UAnimNotify

{
EPalCurrentActionNotifyType NotifyType;
// 0x0038 (size: 0x1)
}; // Size: 0x40
class UPalAnimNotify_SpawnActor : public UAnimNotify

{
TSubclassOf<class AActor> SpawnActorClass;
// 0x0038 (size: 0x8)
// 0x0040 (size: 0x18)
FRotator SpawnRotationOffset;
// 0x0058 (size: 0x18)
}; // Size: 0x70
class UPalAnimNotify_StaminaMeleeAttack : public UAnimNotify

{
}; // Size: 0x38
class UPalAnimNotify_WeaponNotify : public UAnimNotify

{
EWeaponNotifyType WeaponNotifyType;
// 0x0038 (size: 0x1)
}; // Size: 0x40
class UPalAssetStreamableManager : public UObject

{
}; // Size: 0x60
class UPalAttackFilter : public UPalHitFilter

{
FPalAttackFilterOnAttackDelegate OnAttackDelegate;
// 0x0158 (size: 0x10)
void OnAttackDelegate(class AActor* Defencer, FPalDamageInfo DamageInfo, int32
HitCount, class UPrimitiveComponent* AttackerComponent);
EPalWazaID Waza;
// 0x0168 (size: 0x1)
EPalBlowVelocityOwner VelocityOwner;
// 0x0169 (size: 0x1)
FVector NativeBlowVelocity;
// 0x0170 (size: 0x18)
float WazaPowerRate;
// 0x0188 (size: 0x4)
// 0x0190 (size: 0x8)
}; // Size: 0x198
class UPalAudioSettingSystem : public UObject

{
TMap<class EPalAudioBus, class FFloatContainer> BusVolumeMap;
// 0x0030 (size: 0x50)
TMap<class EPalAudioBus, class FPalAudioFadeParameter> BussFadeMap;
// 0x0080 (size: 0x50)
void Tick_BP(float DeltaTime);

void StartAudioFade(EPalAudioBus AudioBus, EPalAudioFadeType FadeType, bool
bImmediately);
void SetAudioBusVolume(EPalAudioBus AudioBus, const FName& Key, float Volume);
void SetAudioBusMute(EPalAudioBus AudioBus, bool IsMute);
FString PalAudioBusToString(EPalAudioBus AudioBus);
bool IsAudioBusMute(EPalAudioBus AudioBus);
void Initialize();
float GetAudioBusVolume(EPalAudioBus AudioBus);
}; // Size: 0xD0
class UPalAudioUtility : public UBlueprintFunctionLibrary

{
void OnPlayerExitSpot(class UObject* WorldContextObject, class

APalPlayerCharacter* Player, class APalSpotAreaBase* SpotArea);
void OnPlayerExitBaseCamp(class UObject* WorldContextObject, class
APalPlayerCharacter* Player, class UPalBaseCampModel* BaseCampModel);
void OnPlayerExitAmbientArea(class UObject* WorldContextObject, class
APalPlayerCharacter* Player, class APalAmbientSoundAreaBase* SpotArea);
void OnPlayerEnterSpot(class UObject* WorldContextObject, class
APalPlayerCharacter* Player, class APalSpotAreaBase* SpotArea);
void OnPlayerEnterBaseCamp(class UObject* WorldContextObject, class
APalPlayerCharacter* Player, class UPalBaseCampModel* BaseCampModel);
void OnPlayerEnterAmbientArea(class UObject* WorldContextObject, class
APalPlayerCharacter* Player, class APalAmbientSoundAreaBase* SpotArea);
}; // Size: 0x28
class UPalAudioWorldSubsystem : public UPalWorldSubsystem

{
int32 FadeDuration;
// 0x0070 (size: 0x4)
// 0x0078 (size: 0x8)

void StopSound();
void SetSwitch(FString SwitchGroup, FString SwitchState);
void SetStateFlagByName(FName StateGroup, bool flg);
void SetStateFlagByEnum(EPalAudioStateGroup StateGroup, bool flg);
void SetStateByName(FName StateGroup, FName State);
void SetStateByEnum(EPalAudioStateGroup StateGroup, EPalAudioState State);
void SetSoundPlayerLocation(const FVector& Location);
void SetRTPCValueByName(const FName& Name, float Value, float interpolSec);
void SetRTPCValueByEnum(EPalAudioRTPC RTPC, float Value, float interpolSec);
void SetOutputBusVolume(float Volume);
void PostTriggerByString(FString Trigger);
void PostTriggerByEnum(EPalAudioTrigger Trigger);
int32 PlaySound(class UAkAudioEvent* AudioEvent, const FPalSoundOptions&
Options);
void OnSpawnedLocalPlayerCharacter(class APawn* Pawn, class AController*
Controller);
void OnPlayerExitSpotArea(class APalPlayerCharacter* Player, class
APalSpotAreaBase* SpotArea);
void OnPlayerExitBaseCamp(class APalPlayerCharacter* Player, class
UPalBaseCampModel* BaseCampModel);
void OnPlayerExitAmbientArea(class APalPlayerCharacter* Player, class
APalAmbientSoundAreaBase* AmbientSoundArea);
void OnPlayerEnterSpotArea(class APalPlayerCharacter* Player, class
APalSpotAreaBase* SpotArea);
void OnPlayerEnterBaseCamp(class APalPlayerCharacter* Player, class
UPalBaseCampModel* BaseCampModel);
void OnPlayerEnterAmbientArea(class APalPlayerCharacter* Player, class
APalAmbientSoundAreaBase* AmbientSoundArea);
void OnEndOfEvent();
void OnAkPostEventCallback(EAkCallbackType CallbackType, class UAkCallbackInfo*
CallbackInfo);
void InitializeSystem(class AActor* AkOwnerActor);
void GetSoundPlayerLocation(FVector& OutLocation);
void FadeOutByPlayingId(int32 PlayingID);
void BeginPlay();
}; // Size: 0x80
class UPalAutoDestroyActorHolder : public UObject

{
TArray<TWeakObjectPtr<AActor>> HoldActors;
// 0x0028 (size: 0x10)
void AddActor(class AActor* TargetActor);

}; // Size: 0x38
class UPalBaseCampEnemyObserver : public UObject

{
FPalBaseCampEnemyObserverOnFirstAppearEnemyDelegate OnFirstAppearEnemyDelegate;
// 0x0028 (size: 0x10)
void BaseCampEnemyDelegate();
FPalBaseCampEnemyObserverOnEmptyEnemyDelegate OnEmptyEnemyDelegate;
// 0x0038 (size: 0x10)
FPalBaseCampEnemyObserverOnPassedTimeAfterEmptyEnemyDelegate
OnPassedTimeAfterEmptyEnemyDelegate; // 0x0048 (size: 0x10)
FGuid BaseCampId;
// 0x0058 (size: 0x10)
TArray<class UPalIndividualCharacterHandle*> EnemyList;
// 0x0068 (size: 0x10)
float CampAreaRange;
// 0x0078 (size: 0x4)
FVector CampLocation;
// 0x0080 (size: 0x18)
void OnEndPlayEnemy(class AActor* Actor, TEnumAsByte<EEndPlayReason::Type>

EndPlayReason);
void OnDeadEnemy(FPalDeadInfo DeadInfo);
void BaseCampEnemyDelegate__DelegateSignature();
}; // Size: 0xA0
class UPalBaseCampFunctionModuleBase : public UObject

{
}; // Size: 0x28
class UPalBaseCampManager : public UPalWorldSubsystem

{
FName WorkerEventClassDirectoryPath;
// 0x00A0 (size: 0x8)
TSubclassOf<class AController> BaseCampAIControllerClass;
// 0x00A8 (size: 0x8)
int32 WorkerCapacityNumDefault;
// 0x00B0 (size: 0x4)
FString WorkableBoundShapeName;
// 0x00B8 (size: 0x10)
int32 DisplayCapacityNum;
// 0x00C8 (size: 0x4)
FDataTableRowHandle WarningSanityValueTextId;
// 0x00D0 (size: 0x10)
TMap<class EPalBaseCampWorkerEventType, class UPalBaseCampWorkerEventBase*>
WorkerEventMap; // 0x0130 (size: 0x50)
class UDataTable* WorkerEventMasterDataTable;
// 0x0180 (size: 0x8)
class UDataTable* WorkerSickMasterDataTable;
// 0x0188 (size: 0x8)
int32 WorkerEventTriggerTickMaxCount;
// 0x0190 (size: 0x4)
TArray<class TSubclassOf<UPalAIActionBaseCampDefenseBase>>
DefenseAIActionArray; // 0x0198 (size: 0x10)
TArray<FPalBaseCampSignificanceInfo> BaseCampSignificanceInfoList;
// 0x01A8 (size: 0x10)
float UpdateIntervalSquaredDistanceFromPlayer;
// 0x01B8 (size: 0x4)
int32 BaseCampTickInvokeMaxNumInOneTick;
// 0x01C4 (size: 0x4)
bool TryGetModel(const FGuid& BaseCampId, class UPalBaseCampModel*& OutModel);

void RequestDismantalDistanceBaseCamp(const FGuid& InstanceId);
void OnUpdateLocationWork_ServerInternal(class UPalWorkBase* Work);
void OnUnregisteredWork_ServerInternal(class UPalWorkBase* Work);
void OnRegisteredNewWork_ServerInternal(class UPalWorkBase* Work);
void OnCreateMapObjectModelInServer(class UPalMapObjectModel* CreatedModel,
const FVector& Location);
class UPalBaseCampModel* GetNearestBaseCamp(const FVector& Location);
class UPalBaseCampModel* GetInRangedBaseCamp(const FVector& Location, const
float Margin);
void GetBaseCampIds(TArray<FGuid>& OutIds);
}; // Size: 0x1C8
class UPalBaseCampMapObjectCollection : public UObject

{
FPalBaseCampMapObjectCollectionOnRegisteredMapObjectInstance
OnRegisteredMapObjectInstance; // 0x0028 (size: 0x10)
void MapObjectInstanceDelegate(class UPalMapObjectModel* Model);
FPalBaseCampMapObjectCollectionOnAvailableConcreteModelDelegate
OnAvailableConcreteModelDelegate; // 0x0038 (size: 0x10)
void MapObjectConcreteModelDelegate(class UPalMapObjectConcreteModelBase*
Model);
FPalBaseCampMapObjectCollectionOnNotAvailableConcreteModelDelegate
OnNotAvailableConcreteModelDelegate; // 0x0048 (size: 0x10)
void MapObjectConcreteModelDelegate(class UPalMapObjectConcreteModelBase*
Model);
TArray<FGuid> MapObjectInstanceIds;
// 0x0058 (size: 0x10)
void OnNotAvailableConcreteModel(class UPalMapObjectConcreteModelBase* Model);

void OnDisposeMapObject(class UPalMapObjectModel* Model, const
FPalMapObjectDisposeOptions& Options);
void OnAvailableConcreteModel(class UPalMapObjectConcreteModelBase* Model);
void MapObjectInstanceDelegate__DelegateSignature(class UPalMapObjectModel*
Model);
void MapObjectConcreteModelDelegate__DelegateSignature(class
UPalMapObjectConcreteModelBase* Model);
}; // Size: 0x78
class UPalBaseCampModel : public UObject

{
FPalBaseCampModelOnUpdateStatusDelegate OnUpdateStatusDelegate;
// 0x0028 (size: 0x10)
void SimpleDelegate(class UPalBaseCampModel* Model);
FPalBaseCampModelOnDisposeDelegate OnDisposeDelegate;
// 0x0038 (size: 0x10)
void SimpleDelegate(class UPalBaseCampModel* Model);
FGuid ID;
// 0x0058 (size: 0x10)
FString BaseCampName;
// 0x0068 (size: 0x10)
EPalBaseCampState CurrentState;
// 0x0078 (size: 0x1)
// 0x0080 (size: 0x60)
float AreaRange;
// 0x00E0 (size: 0x4)
FGuid GroupIdBelongTo;
// 0x00E4 (size: 0x10)
FTransform FastTravelLocalTransform;
// 0x0100 (size: 0x60)
class UPalBaseCampWorkerDirector* WorkerDirector;
// 0x0160 (size: 0x8)
class UPalBaseCampMapObjectCollection* MapObjectCollection;
// 0x0168 (size: 0x8)
class UPalBaseCampWorkCollection* WorkCollection;
// 0x0170 (size: 0x8)
class UPalBaseCampEnemyObserver* EnemyObserver;
// 0x0178 (size: 0x8)
TArray<class UPalBaseCampFunctionModuleBase*> ModuleArray;
// 0x0180 (size: 0x10)
TArray<FGuid> PlayerUIdsExistsInsideInServer;
// 0x0190 (size: 0x10)
FGuid OwnerMapObjectInstanceId;
// 0x01A0 (size: 0x10)
int32 Level_InGuildProperty;
// 0x01B0 (size: 0x4)
FGuid LocationId;
// 0x01B4 (size: 0x10)
FPalBaseCampSignificanceInfo SignificanceInfo;
// 0x01C4 (size: 0x8)
float ProgressTimeSinceLastTick;
// 0x01CC (size: 0x4)
void UpdateLevel_ServerInternal(int32 PlayerId, int32 NewLevel);

bool TryGetRandomPositionInside(const FVector& Origin, const float Radius,
FVector& ToLocation);
void SimpleDelegate__DelegateSignature(class UPalBaseCampModel* Model);
void ReflectLevel_InGuildProperty_Internal(int32 NewLevel);
void OnRep_Level_InGuildProperty(int32 OldLevel);
void OnPassedTimeAfterEmptyEnemy();
void OnFirstAppearEnemy();
void OnDamageInCampActor(FPalDamageResult DamageResult);
void OnAddNewWorker(class UPalIndividualCharacterHandle* AddCharacterHandle);
class UPalBaseCampWorkCollection* GetWorkCollection();
FTransform GetTransform();
EPalBaseCampState GetState();
float GetRange();
FGuid GetOwnerMapObjectInstanceId();
int32 GetLevel();
FGuid GetId();
FGuid GetGroupIdBelongTo();
class UPalBaseCampEnemyObserver* GetEnemyObserver();
FString GetBaseCampName();
bool FindWorkAssignableObject(const class UPalIndividualCharacterHandle*
AssignIndividualHandle, const FGuid& WorkId, const bool bFixedAssign, class
UPalWorkBase*& FoundObject);
bool FindNearestAssignableObject(const class UPalIndividualCharacterHandle*
AssignIndividualHandle, const FTransform& Origin, const float Range, const bool
bFixedAssign, TScriptInterface<class IPalBaseCampAssignableObjectInterface>&
FoundObject);
void BaseCampGuildPalStorageUpdateDelegate__DelegateSignature(class
UPalBaseCampModel* Model, class UPalGuildPalStorage* GuildPalStorage);
}; // Size: 0x1D0
class UPalBaseCampModuleEnergy : public UPalBaseCampFunctionModuleBase

{
TArray<class UPalBaseCampModuleEnergy_FunctionBase*> FunctionArray;
// 0x0028 (size: 0x10)
}; // Size: 0x38
class UPalBaseCampModuleEnergy_Electric : public

UPalBaseCampModuleEnergy_FunctionBase
{
}; // Size: 0x60
class UPalBaseCampModuleEnergy_FunctionBase : public UObject

{
FPalBaseCampModuleEnergy_FunctionBaseOnUpdateEnergyAmountDelegate
OnUpdateEnergyAmountDelegate; // 0x0028 (size: 0x10)
void UpdateEnergyAmountDelegate(class UPalBaseCampModuleEnergy_FunctionBase*
Function);
TArray<FGuid> EnergyGeneratorConcreteModelIds;
// 0x0038 (size: 0x10)
TArray<FGuid> EnergyConsumerConcreteModelIds;
// 0x0048 (size: 0x10)
EPalBaseCampModuleEnergyState CurrentState;
// 0x0058 (size: 0x1)
float ProvideWaitRemainTime;
// 0x005C (size: 0x4)
void UpdateEnergyAmountDelegate__DelegateSignature(class
UPalBaseCampModuleEnergy_FunctionBase* Function);
void InvokeOnUpdateEnergyAmount(class UPalMapObjectGenerateEnergyModel* Model);
}; // Size: 0x60
class UPalBaseCampModuleFacilityReservation : public UPalBaseCampFunctionModuleBase

{
TMap<class EPalMapObjectWorkerAvailableFacilityType, class
FPalBaseCampFacilityUsageInfoSet> FacilityUsageInfoSetMap; // 0x0028 (size: 0x50)
TArray<FPalBaseCampFacilityCountPair> FacilityCounts;
// 0x0078 (size: 0x10)
void OnStartUseFacility_ServerInternal(class UPalMapObjectConcreteModelBase*

Model, class UPalIndividualCharacterHandle* IndividualHandle);
void OnNotAvailableMapObjectInServer(class UPalMapObjectConcreteModelBase*
ConcreteModel);
void OnFinishUseFacility_ServerInternal(class UPalMapObjectConcreteModelBase*
Model);
void OnAvailableMapObjectInServer(class UPalMapObjectConcreteModelBase*
ConcreteModel);
}; // Size: 0x88
class UPalBaseCampModuleItemStorage : public UPalBaseCampFunctionModuleBase

{
FPalBaseCampModuleItemStorageOnUpdateAnyItemContainerDelegate
OnUpdateAnyItemContainerDelegate; // 0x0028 (size: 0x10)
void MulticastReturnSelfAndUpdatedContainerDelegate(class
UPalBaseCampModuleItemStorage* Self, class UPalItemContainer* UpdatedContainer);
TArray<FPalBaseCampItemContainerInfo> ContainerInfos;
// 0x0038 (size: 0x10)
TMap<class FGuid, class FPalBaseCampItemExistsInfo> RepairKitItemExistsInfos;
// 0x0048 (size: 0x50)
void OnUpdateItemContainer(class UPalMapObjectItemContainerModule*

ItemContainerModule);
void OnNotAvailableConcreteModel(class UPalMapObjectConcreteModelBase*
ConcreteModel);
void OnAvailableConcreteModel(class UPalMapObjectConcreteModelBase*
ConcreteModel);
void MulticastReturnSelfAndUpdatedContainerDelegate__DelegateSignature(class
UPalBaseCampModuleItemStorage* Self, class UPalItemContainer* UpdatedContainer);
void GetContainerIds(TArray<FPalContainerId>& OutContainerIds);
}; // Size: 0x98
class UPalBaseCampModuleMedical : public UPalBaseCampFunctionModuleBase

{
TArray<FGuid> ReviveWorkIds;
// 0x0028 (size: 0x10)
void OnReviveCharacter_ServerInternal(class UPalIndividualCharacterParameter*

void OnRemovedWorkerInServer(class UPalIndividualCharacterHandle*
IndividualHandle);
}; // Size: 0x38
class UPalBaseCampModuleObjectMaintenance : public UPalBaseCampFunctionModuleBase
{
TArray<class UPalBaseCampModuleObjectMaintenance_WayBase*> MaintenanceWayDOs;
// 0x0028 (size: 0x10)
void OnRegisteredMapObject_ServerInternal(class UPalMapObjectModel* Model);

void OnGrantedEffectToMapObject_ServerInternal(class UPalMapObjectModel* Model,
class UPalMapObjectModelEffectBase* Effect);
void OnDisposeMapObject_ServerInternal(class UPalMapObjectModel* Model, const
}; // Size: 0x38
class UPalBaseCampModuleObjectMaintenance_ExtinguishFire : public

UPalBaseCampModuleObjectMaintenance_WayBase
{
void OnTriggerByReachAccumulateTriggerValue(class
UPalMapObjectModelEffect_AccumulateTrigger* Effect_AccumulateTrigger, class
UPalMapObjectModel* OwnerModel);
}; // Size: 0x28
class UPalBaseCampModuleObjectMaintenance_WayBase : public UObject

{
}; // Size: 0x28
class UPalBaseCampModulePassiveEffect : public UPalBaseCampFunctionModuleBase

{
FPalFastBaseCampPassiveEffectRepInfoArray RepInfoArray;
// 0x0028 (size: 0x118)

Model);
void OnAvailableMapObjectInServer(class UPalMapObjectConcreteModelBase* Model);
}; // Size: 0x140
class UPalBaseCampModuleResourceCollector : public UPalBaseCampFunctionModuleBase

{
TMap<class FGuid, class FPalBaseCampModuleResourceCollectWorkInfo>
MapObjectWorkInfoMap; // 0x0028 (size: 0x50)
void OnRegisteredMapObjectModel(class UPalMapObjectModel* Model);

void OnRegisteredFoliageModel(TScriptInterface<class
IPalMapObjectModelInterface> Model);
void OnDestroyedMapObjectModel(class UPalMapObjectModel* Model, const
void OnDestroyedFoliageInstance(class UPalFoliageInstance* Instance);
}; // Size: 0x78
class UPalBaseCampModuleTransportItemDirector : public

UPalBaseCampFunctionModuleBase
{
TMap<class FGuid, class FPalBaseCampModuleTransportItemStatus>
TransportItemStatusMap; // 0x0028 (size: 0x50)
TMap<class FGuid, class FPalBaseCampModuleTransportItemTarget>
TransportTargetMap; // 0x0078 (size: 0x50)
void OnUpdateMapObjectContainer(class UPalMapObjectItemContainerModule*

ContainerModule);
void OnUnassignWorkTransportItemTarget(class UPalWorkBase* Work, const
FPalInstanceID& IndividualId);
void OnUnassignWorkRequirement(class UPalWorkBase* Work, const FPalInstanceID&
IndividualId);
void OnNotAvailableMapObjectConcreteModel(class UPalMapObjectConcreteModelBase*
ConcreteModel);
void OnAvailableMapObjectConcreteModel(class UPalMapObjectConcreteModelBase*
ConcreteModel);
void OnAssignWorkTransportItemTarget(class UPalWorkBase* Work, const
void OnAssignWorkRequirement(class UPalWorkBase* Work, const FPalInstanceID&
IndividualId);
}; // Size: 0xC8
class UPalBaseCampPassiveEffectBase : public UObject

{
TMap<class FName, class FPalBaseCampPassiveEffectMapObjectInfo>
MapObjectInfoMapByMapObjectId; // 0x0028 (size: 0x50)
}; // Size: 0x78
class UPalBaseCampPassiveEffect_WorkHard : public UPalBaseCampPassiveEffectBase

{
FPalBaseCampPassiveEffect_WorkHardOnUpdateWorkHardTypeDelegate
OnUpdateWorkHardTypeDelegate; // 0x0080 (size: 0x10)
void ReturnSelfDelegate(class UPalBaseCampPassiveEffect_WorkHard* Self);
EPalBaseCampPassiveEffectWorkHardType WorkHardType;
// 0x0090 (size: 0x1)
UPalBaseCampPassiveEffect_WorkHard* Self);
void OnRep_WorkHardType();
EPalBaseCampPassiveEffectWorkHardType GetWorkHardType();
}; // Size: 0x98
class UPalBaseCampPassiveEffect_WorkSuitability : public

UPalBaseCampPassiveEffectBase
{
TMap<EPalWorkSuitability, float> WorkSpeedAdditionalRateMap;
// 0x0080 (size: 0x50)
}; // Size: 0xD0
class UPalBaseCampReplicator : public UPalGameStateReplicatorBase

{
FFastPalBaseCampRepInfoArray RepInfoArray;
// 0x0028 (size: 0x148)
}; // Size: 0x1C0
class UPalBaseCampTaskChecker : public UObject

{
class UDataTable* taskDataTable;
// 0x0028 (size: 0x8)
}; // Size: 0x30
class UPalBaseCampUtility : public UObject

{
}; // Size: 0x28
class UPalBaseCampWorkCollection : public UObject
{
FPalBaseCampWorkCollectionOnUnassignWorkDelegate OnUnassignWorkDelegate;
// 0x0038 (size: 0x10)
void WorkAssignUpdateDelegate(class UPalWorkBase* Work, const FPalInstanceID&
IndividualId);
FGuid BaseCampId;
// 0x0048 (size: 0x10)
TArray<FGuid> WorkIds;
// 0x0058 (size: 0x10)
TMap<class FGuid, class FPalBaseCampWorkCollectionStashInfo>
CannotMoveToWorkInfoMap; // 0x0070 (size: 0x50)
void WorkAssignUpdateDelegate__DelegateSignature(class UPalWorkBase* Work,

const FPalInstanceID& IndividualId);
void WorkAssignRequirementDelegate__DelegateSignature(class UPalWorkBase* Work,
const FPalWorkAssignRequirementParameter& RequirementParameter);
void OnUnassignWork_ServerInternal(class UPalWorkBase* Work, const
void OnRequiredAssign_ServerInternal(class UPalWorkBase* Work, const
FPalWorkAssignRequirementParameter& RequirementParameter);
}; // Size: 0xC0
class UPalBaseCampWorkerDirectionBattleTypeUtility : public

UBlueprintFunctionLibrary
{
}; // Size: 0x28
class UPalBaseCampWorkerDirector : public UObject

{
FPalBaseCampWorkerDirectorOnAddNewWorkerDelegate OnAddNewWorkerDelegate;
// 0x0040 (size: 0x10)
void AddNewWorkerDelegate(class UPalIndividualCharacterHandle* NewCharacter);
FPalBaseCampWorkerDirectorOnRemovedWorkerInServerDelegate
OnRemovedWorkerInServerDelegate; // 0x0050 (size: 0x10)
void RemovedWorkerDelegate(class UPalIndividualCharacterHandle*
IndividualHandle);
FGuid BaseCampId;
// 0x0060 (size: 0x10)
FTransform SpawnTransform;
// 0x0070 (size: 0x60)
class UPalIndividualCharacterContainer* CharacterContainer;
// 0x00D0 (size: 0x8)
EPalMapBaseCampWorkerOrderType CurrentOrderType;
// 0x00D8 (size: 0x1)
EPalBaseCampWorkerDirectionBattleType CurrentBattleType;
// 0x00D9 (size: 0x1)
class UPalIndividualCharacterSlotsObserver* SlotObserverForServer;
// 0x00E0 (size: 0x8)
TArray<FPalBaseCampWorkAssignRequest> RequiredAssignWorks;
// 0x00E8 (size: 0x10)
TArray<FPalInstanceID> WaitingWorkerIndividualIds;
// 0x00F8 (size: 0x10)
int32 WorkerEventTickCount;
// 0x0108 (size: 0x4)
TArray<class UPalBaseCampWorkerTaskBase*> WorkerTasks;
// 0x0110 (size: 0x10)
EPalBaseCampWorkerDirectorState State;
// 0x0121 (size: 0x1)
void RemovedWorkerDelegate__DelegateSignature(class
void OrderCommand(const EPalMapBaseCampWorkerOrderType OrderType);
void OnUpdateOwnerBaseCampStatus_ServerInternal(class UPalBaseCampModel*
OwnerBaseCamp);
void OnSpawnedCharacterInServer(FPalInstanceID IndividualId);
void OnRequiredAssignWork_ServerInternal(class UPalWorkBase* Work, const
void OnRep_CharacterContainer();
void OnRemovedNewCharacterInServer(const FPalInstanceID& IndividualId);
void OnReflectSlotCompleteInServer();
void OnRaisedPhantomCharacterInServer(FPalInstanceID IndividualId, int32
PhantomId);
void OnNotifiedUnassignWork_ServerInternal(class UPalWorkBase* Work, const
void OnDeadWorkerInServer_Internal(class APalCharacter* DeadCharacter);
void OnDeadWorkerInServer(const FPalDeadInfo Info);
void OnChangeWorldSettings_ServerInternal(const FPalOptionWorldSettings&
PrevSettings, const FPalOptionWorldSettings& NewSettings);
void OnAddedNewCharacterInServer(const FPalInstanceID& IndividualId);
void GetCharacterHandleSlots(TArray<class UPalIndividualCharacterSlot*>&
OutSlots);
class UPalIndividualCharacterSlot* FindSlotByHandle(class
UPalIndividualCharacterHandle* Handle);
void AddNewWorkerDelegate__DelegateSignature(class
UPalIndividualCharacterHandle* NewCharacter);
}; // Size: 0x130
class UPalBaseCampWorkerEventBase : public UObject

{
FPalDataTableRowName_BaseCampWorkerEventData MasterDataId;
// 0x0028 (size: 0x8)
EPalLogType logType;
// 0x0030 (size: 0x1)
FPalBaseCampWorkerEventMasterData MasterData;
// 0x0038 (size: 0x28)
TSoftObjectPtr<UNiagaraSystem> OverrideSleepFX;
// 0x0060 (size: 0x30)
bool IsTriggerEventBySanity(const float SanityValue);

bool IsTriggerEventByCharacter(const class APalCharacter* Character);
FString Debug_CreateTextTriggerEventSanity();
FText CreateNotifyMessageText(const FText& LocalizedFormatText, class
APalCharacter* Character);
}; // Size: 0x90
class UPalBaseCampWorkerEventUtility : public UObject

{
}; // Size: 0x28
class UPalBaseCampWorkerEvent_DestroyBuilding : public UPalBaseCampWorkerEventBase

{
}; // Size: 0x90
class UPalBaseCampWorkerEvent_DodgeWork : public UPalBaseCampWorkerEventBase

{
TSubclassOf<class UPalAIActionBase> actionClass;
// 0x0090 (size: 0x8)
float AIActionDuration;
// 0x0098 (size: 0x4)
float TerminateSanityValueOver;
// 0x009C (size: 0x4)
}; // Size: 0xA0
class UPalBaseCampWorkerEvent_DodgeWork_Short : public

UPalBaseCampWorkerEvent_DodgeWork
{
}; // Size: 0xA0
class UPalBaseCampWorkerEvent_DodgeWork_Sleep : public

UPalBaseCampWorkerEvent_DodgeWork
{
int32 SleepMinTime;
// 0x00A0 (size: 0x4)
int32 SanityValueStillSleeping;
// 0x00A4 (size: 0x4)
FFloatInterval WalkTime_BeforeSleep;
// 0x00A8 (size: 0x8)
}; // Size: 0xB0
class UPalBaseCampWorkerEvent_EatTooMuch : public UPalBaseCampWorkerEventBase

{
float RecoverSanityTo;
// 0x0090 (size: 0x4)
int32 EatMaxNum;
// 0x0094 (size: 0x4)
}; // Size: 0x98
class UPalBaseCampWorkerEvent_Escape : public UPalBaseCampWorkerEventBase

{
}; // Size: 0x90
class UPalBaseCampWorkerEvent_FightWithFriend : public UPalBaseCampWorkerEventBase

{
}; // Size: 0x90
class UPalBaseCampWorkerEvent_OverworkDeath : public UPalBaseCampWorkerEventBase

{
}; // Size: 0x90
class UPalBaseCampWorkerEvent_Sick : public UPalBaseCampWorkerEventBase

{
}; // Size: 0x90
class UPalBaseCampWorkerEvent_Tantrum : public UPalBaseCampWorkerEventBase

{
TSubclassOf<class UPalAIActionBaseCampTrantrum> actionClass;
// 0x0090 (size: 0x8)
}; // Size: 0x98
class UPalBaseCampWorkerEvent_TurnFoodBox : public UPalBaseCampWorkerEventBase

{
}; // Size: 0x90
class UPalBaseCampWorkerTaskBase : public UObject

{
FGuid OwnerBaseCampId;
// 0x0028 (size: 0x10)
}; // Size: 0x38
class UPalBaseCampWorkerTask_IgnitionTorchAtNight : public

UPalBaseCampWorkerTaskBase
{
TArray<FGuid> TorchInstanceIds;
// 0x0038 (size: 0x10)

ConcreteModel);
void OnAvailableMapObjectInServer(class UPalMapObjectConcreteModelBase*
ConcreteModel);
}; // Size: 0x48
class UPalBattleManager : public UPalWorldSubsystem

{
TMap<class AActor*, class FActorArray> EnemyListPerPlayer;
// 0x0070 (size: 0x50)
TSubclassOf<class APalNPCSpawnerBase> DebugSpawnerClass;
// 0x00C8 (size: 0x8)
FPalBattleManagerOnFExclamationMarkDelegate OnFExclamationMarkDelegate;
// 0x00D0 (size: 0x10)
void ExclamationMarkDelegate(class APalCharacter* TargetCharacter);
FPalBattleManagerOnFQuestionMarkDelegate OnFQuestionMarkDelegate;
// 0x00E0 (size: 0x10)
void QuestionMarkDelegate(class APalCharacter* TargetCharacter);
FPalBattleManagerOnFEmitSoundDelegate OnFEmitSoundDelegate;
// 0x00F0 (size: 0x10)
void EmitSoundDelegate(int32 SoundRadius, FVector EmitLocation, class AActor*
Emitter);
FPalBattleManagerOnFEmitSoundOnlyPalmiDelegate OnFEmitSoundOnlyPalmiDelegate;
// 0x0100 (size: 0x10)
void EmitSoundOnlyPalmiDelegate(int32 SoundLevel);
bool TargetIsPlayerOrPlayersOtomoPal(class AActor* TargetCharacter);

void SoundReactionStart(class APalCharacter* SelfCharacter);
void SetUpPlayerMap(class AActor* Player);
void RemovePlayerMap(class AActor* Player);
void RemoveEnemyActor_AllPlayer(class AActor* Enemy, EPalPlayerBattleFinishType
FinishType);
void RemoveEnemyActor(class AActor* Player, class AActor* Enemy,
EPalPlayerBattleFinishType FinishType);
void QuestionMarkDelegate__DelegateSignature(class APalCharacter*
TargetCharacter);
bool IsBattleModeAnyPlayer();
class AActor* GetRandomActor(TArray<class AActor*> targetList);
class AActor* GetNearestActor(TArray<class AActor*> targetList, FVector
Location);
bool GetConflictEnemies(class AActor* Player, TArray<class AActor*>&
OutEnemyes, bool IgnoreOtomoStopByBall);
void GetAllPlayerAndOtomo_ForEnemySelf(TArray<class AActor*> TargetPlayers,
TArray<class AActor*>& OutCharacters);
void ExclamationMarkDelegate__DelegateSignature(class APalCharacter*
TargetCharacter);
void EnemyNearPlayerListUpdate(class AActor* Enemy, float Distance);
void EmitSoundOnlyPalmiDelegate__DelegateSignature(int32 SoundLevel);
void EmitSoundDelegate__DelegateSignature(int32 SoundRadius, FVector
EmitLocation, class AActor* Emitter);
void EmitSound(FName SoundRowName, class AActor* Emitter, FVector EmitLocation,
float VolumeRate);
void AddEnemyActor_PlayerOrOtomo(class AActor* PlayerOrOtomo, class AActor*
Enemy);
void ActionMenaceStart(class APalCharacter* SelfCharacter);
}; // Size: 0x110
class UPalBiomeDetectComponent : public UActorComponent

{
FPalBiomeDetectComponentOnChangedBiome OnChangedBiome;
// 0x00A0 (size: 0x10)
void OnChangedBiomeDelegate(class AActor* OverlapActor, class
APalBiomeAreaTriggerBase* BiomeTriggerActor);
void OnChangedBiomeDelegate__DelegateSignature(class AActor* OverlapActor,

class APalBiomeAreaTriggerBase* BiomeTriggerActor);
void ChangeBiome(class APalBiomeAreaTriggerBase* BiomeTriggerActor);
}; // Size: 0xB8
class UPalBlueprintLibrary : public UBlueprintFunctionLibrary

{
bool NotEqual_PalInstanceIDPalInstanceID(FPalInstanceID A, FPalInstanceID B);

bool EqualEqual_PalInstanceIDPalInstanceID(FPalInstanceID A, FPalInstanceID B);
}; // Size: 0x28
class UPalBodyPartsBoxComponent : public UBoxComponent

{
// 0x0578 (size: 0x1)
FName DefaultCollisionProfileName;
// 0x057C (size: 0x8)
FName BroadcastCollisionProfileName;
// 0x0584 (size: 0x8)
void OnRep_BroadcastCollisionProfileName();
}; // Size: 0x590
class UPalBodyPartsCapsuleComponent : public UCapsuleComponent

{
// 0x0560 (size: 0x1)
// 0x0564 (size: 0x8)
// 0x056C (size: 0x8)
}; // Size: 0x580
class UPalBodyPartsSphereComponent : public USphereComponent

{
// 0x0560 (size: 0x1)
// 0x0564 (size: 0x8)
// 0x056C (size: 0x8)
}; // Size: 0x580
class UPalBodyTemperatureComponent : public UActorComponent

{
FPalBodyTemperatureComponentOnChangeTemperatureDelegate
OnChangeTemperatureDelegate; // 0x00A0 (size: 0x10)
void OnChangeTemperatureDelegate(int32 NextTemperature);
FPalBodyTemperatureComponentOnChangeResistRankDelegate
OnChangeResistRankDelegate; // 0x00B0 (size: 0x10)
void OnChangeResistRankDelegate(int32 NextResistHeat, int32 NextResistCold);
FPalBodyTemperatureComponentOnChangeBodyStateDelegate
OnChangeBodyStateDelegate; // 0x00C0 (size: 0x10)
void OnChangeBodyStateDelegate(EPalBodyTemperatureState BodyState);
TMap<class FName, class FPalHeatSourceInfo> HeatSourceInfoMap;
// 0x00D0 (size: 0x50)
int32 CurrentTemperature;
// 0x0120 (size: 0x4)
FName SelfKeyName;
// 0x0124 (size: 0x8)
FTimerHandle SlipDamageTimer;
// 0x0130 (size: 0x8)
int32 CurrentResistRank_Heat;
// 0x0138 (size: 0x4)
int32 CurrentResistRank_Cold;
// 0x013C (size: 0x4)
EPalBodyTemperatureState CurrentBodyState;
// 0x0140 (size: 0x1)
void RequestReSend_ToServer();
void RemoveHeatSource(FName UniqueName);
void OnUpdateEquipment(class UPalItemSlot* itemSlot,
EPalPlayerEquipItemSlotType slotType);
void OnInitializedPlayer_ForClient(class APalCharacter* Character);
void OnInitializedPlayer(class APalCharacter* Character);
void OnChangeTemperatureDelegate__DelegateSignature(int32 NextTemperature);
void OnChangeResistRankDelegate__DelegateSignature(int32 NextResistHeat, int32
NextResistCold);
void OnChangeHour();
void OnChangeBodyStateDelegate__DelegateSignature(EPalBodyTemperatureState
BodyState);
void CallOnChangeTemperature(int32 Next);
void CallOnChangeResistRank(int32 Heat, int32 Cold);
void CallOnChangeBodyState(EPalBodyTemperatureState State);
void CallAllDelegate();
void AddHeatSourceInfo(FName UniqueName, FPalHeatSourceInfo HeatInfo);
void AddHeatSource(FName UniqueName, int32 HeatLevel);
}; // Size: 0x148
class UPalBoneInfo : public UObject

{
float Length;
// 0x0028 (size: 0x4)
float Radius;
// 0x002C (size: 0x4)
}; // Size: 0x30
class UPalBossBattleInstanceModel : public UObject

{
FTransform FrontWarpPointTransform;
// 0x0080 (size: 0x60)
FVector_NetQuantize RepFrontWarpPointtLocation;
// 0x00E0 (size: 0x18)
FTransform TopWarpPointTransform;
// 0x0100 (size: 0x60)
FTransform StartPointTransform;
// 0x0160 (size: 0x60)
FTransform DeadItemDropTransform;
// 0x01C0 (size: 0x60)
// 0x0220 (size: 0x14)
EPalBossType BossType;
// 0x0234 (size: 0x1)
TSoftClassPtr<APalCutsceneActor> IntroCutsceneActor;
// 0x0238 (size: 0x30)
TSoftClassPtr<ALevelInstance> BossRoomLevelInstanceAsset;
// 0x0268 (size: 0x30)
// 0x0298 (size: 0x30)
int32 Level;
// 0x02C8 (size: 0x4)
int32 CombatTimeMax;
// 0x02CC (size: 0x4)
class APalBossBattleLevelInstance* BossBattleLevelInstance;
// 0x02D0 (size: 0x8)
// 0x02D8 (size: 0x8)
EPalBossBattleState BossBattleState;
// 0x02E0 (size: 0x1)
TArray<class APalPlayerCharacter*> EntryPlayers;
// 0x02E8 (size: 0x10)
TArray<class APalPlayerCharacter*> WonPlayers;
// 0x02F8 (size: 0x10)
FDateTime CombatTimeLimit;
// 0x0308 (size: 0x8)
class UPalBossBattleSequencer* LocalBattleSequencer;
// 0x0310 (size: 0x8)
// 0x0318 (size: 0x8)
void OnUpdateCombatTimeLimit();
void OnUpdateBossBattleState();
void OnRep_EntryPlayers();
void OnRep_CombatTimeLimit();
void OnRep_BossBattleState();
void OnRep_BossBattleLevelInstance();
void OnChangeEntryPlayerDelegate__DelegateSignature(TArray<class
APalPlayerCharacter*> EntryPlayers);
void OnChangeCombatTimeLimitDelegate__DelegateSignature(FDateTime
CombatTimeLimit);
void OnChangeBossBattleStateDelegate__DelegateSignature(EPalBossBattleState
BossBattleState);
bool IsLevelInstanceLoaded();
int32 GetLevel();
EPalBossType GetBossType();
EPalBossBattleState GetBossBattleState();
}; // Size: 0x320
class UPalBossBattleManager : public UPalWorldSubsystem

{
FPalBossBattleManagerOnLocalBossBattleSuccessDelegate
OnLocalBossBattleSuccessDelegate; // 0x0070 (size: 0x10)
void OnLocalPlayerBossBattleSuccessDelegate(class APalPlayerCharacter*
LocalJoinedPlayer, EPalBossType BossType);
FPalBossBattleManagerOnCombatStartUIDelegate OnCombatStartUIDelegate;
// 0x0080 (size: 0x10)
void OnCombatStartUIDelegate(class APalBossTower* BossTower);
FPalBossBattleManagerOnCombatEndUIAction OnCombatEndUIAction;
// 0x0090 (size: 0x10)
void OnCombatEndUIActionDelegate(EPalBossBattleCombatResult CombatResult);
int32 MAX_TIME_LIMIT;
// 0x00A0 (size: 0x4)
float PlayerRespawnTimeLimit;
// 0x00A4 (size: 0x4)
float BGMFadeDuration;
// 0x00A8 (size: 0x4)
TMap<int32, float> MultiPlayerBossHPMap;
// 0x00B0 (size: 0x50)
TSubclassOf<class UPalBossBattleSequencer> BossBattleSequencerClass;
// 0x0100 (size: 0x8)
TMap<class EPalBossType, class FPalBossBattleStaticInfo> BossInfoMap;
// 0x0108 (size: 0x50)
TMap<class EPalBossType, class UPalBossBattleInstanceModel*> InstanceModelMap;
// 0x0158 (size: 0x50)
TMap<class EPalBossType, class UPalBossBattleSequencer*>
BossBattleSequencerMap; // 0x01A8 (size: 0x50)
FGuid GroupGuid;
// 0x01F8 (size: 0x10)
EPalBossType DisableSkyBossType_LocalPlayer;
// 0x0208 (size: 0x1)
void UnlockAchievement(EPalBossType BossType);

void UnloadBossBattle_ServerInternal(EPalBossType BossType);
void OnLocalPlayerBossBattleSuccessDelegate__DelegateSignature(class
APalPlayerCharacter* LocalJoinedPlayer, EPalBossType BossType);
void OnCombatStartUIDelegate__DelegateSignature(class APalBossTower*
BossTower);
void OnCombatEndUIActionDelegate__DelegateSignature(EPalBossBattleCombatResult
CombatResult);
void OnBossBattleCombatStart(EPalBossType BossType);
void LoadAsyncBossBattle_ServerInternal(EPalBossType BossType);
FTransform GetTopWarpPointTransform(EPalBossType BossType);
FPalBossBattleStaticInfo GetStaticInfo(EPalBossType BossType);
FTransform GetPlayerSpawnTransformForMultiPlayer(int32 Index, FVector Location,
FRotator Rotate, float Offset);
int32 GetMaxJoinablePlayerNum();
bool GetIsServer();
float GetBossHPMultiPlayerRate(int32 JoinedPlayerNum);
int32 GetBossAchievementIndex(EPalBossType BossType);
float GetBattleTimeLimit();
void EmptyInstanceCleanup();
void DisableSkyCreator(bool Disable);
bool CanStartBossBattle(EPalBossType BossType);
void BossBattleExit(EPalBossType BossType, class APalPlayerCharacter*
ExitPlayer);
void BossBattleEntryCancel(EPalBossType BossType, class APalPlayerCharacter*
EntryPlayer);
void BossBattleEntry(EPalBossType BossType, class APalPlayerCharacter*
EntryPlayer);
AddIndividualHandle);
}; // Size: 0x210
class UPalBossBattleSequenceBase : public UObject

{
FPalBossBattleSequenceBaseOnSequenceFinishDelegate OnSequenceFinishDelegate;
// 0x0028 (size: 0x10)
void SequenceFinishDelegate(bool IsSuccess);
EPalBossBattleSequenceType NextSequenceType;
// 0x0038 (size: 0x1)
void TickSequence(float DeltaTime);

void SetupLevelSequenceActor(class ALevelSequenceActor* LevelSequenceActor,
class ULevelSequence* LevelSequence, class ALevelInstance* LevelInstance);
void SequenceFinishDelegate__DelegateSignature(bool IsSuccess);
void SelfFinish_ForBP();
void OnBeginSequence();
void NoticeSequenceEnd_ToServer();
bool IsServer();
class UPalBossBattleSequencer* GetOuterSequencer();
class APalPlayerCharacter* GetJoinedLocalControlPlayer();
class AActor* GetBossRoomSequenceRootActor(class ALevelInstance*
LevelInstance);
FPalBossBattleStaticInfo GetBossBattleStaticInfo();
void FinishSequence(bool IsSuccess);
}; // Size: 0x40
class UPalBossBattleSequencer : public UObject

{
FPalBossBattleSequencerOnCombatStartDelegate OnCombatStartDelegate;
// 0x0028 (size: 0x10)
void BossBattleCombatStart(EPalBossType BossType);
float RemainBattleTimer;
// 0x0038 (size: 0x4)
bool IsBattleTimerCountDown;
// 0x003C (size: 0x1)
EPalBossBattleCombatResult CombatResult;
// 0x003D (size: 0x1)
TMap<class EPalBossBattleSequenceType, class
TSubclassOf<UPalBossBattleSequenceBase>> SequenceClassMap; // 0x0040 (size: 0x50)
TMap<class EPalBossBattleSequenceType, class UPalBossBattleSequenceBase*>
SequenceMap; // 0x0090 (size: 0x50)
class UPalBossBattleSequenceBase* CurrentSequence;
// 0x00E0 (size: 0x8)
class UPalBossBattleInstanceModel* BossBattleInstanceModel;
// 0x00E8 (size: 0x8)
TArray<class APalPlayerCharacter*> InRoomPlayers;
// 0x00F0 (size: 0x10)
TArray<class APalPlayerCharacter*> SequenceEndPlayers;
// 0x0100 (size: 0x10)
EPalBossType SelfBossType;
// 0x0111 (size: 0x1)
class APalCharacter* BossCharacter;
// 0x0118 (size: 0x8)
int32 PlayingBGMId;
// 0x0120 (size: 0x4)
bool bIsClientOnly;
// 0x0124 (size: 0x1)
void Tick_ForBP(float DeltaTime);

void StopBGM();
void SetPlayerMoveDisable(class APalPlayerCharacter* Player, bool Disable);
void SetMutekiAllPlayer(bool bIsMuteki);
void SetBossCharacter(class APalCharacter* BossActor);
void SetAllPlayerMoveDisable(bool Disable);
void RemovePlayerFromInRoomList(class APalPlayerCharacter* Player);
void RemoveDyingStatus();
void PlayBGM(class UAkAudioEvent* BGMAudioEvent);
void OnPlayerRespawn(class APalPlayerCharacter* Player);
void OnPlayerDeadStopBGM(class APalPlayerCharacter* PlayerCharacter);
void OnOpeningEnd(bool Success);
void OnEndingEnd(bool Success);
void OnDyingDeadEndDelegate(class APalPlayerCharacter* PlayerCharacter);
void OnCompletedEnd(bool Success);
void OnCombatFinish(EPalBossBattleCombatResult InCombatResult);
void OnCombatEnd(bool Success);
void NoticeClientCombatResult();
void KillAllPlayer();
bool IsClientOnly();
bool IsAllPlayerDead();
TArray<class APalPlayerCharacter*> GetSequencePlayers();
float GetRemainTimeSecond();
class APalPlayerCharacter* GetJoinedLocalPlayer();
class APalPlayerCharacter* GetJoinedAndServerLocalPlayer();
TArray<class APalPlayerCharacter*> GetInRoomPlayers();
EPalBossType GetBossType();
class APalCharacter* GetBossCharacter();
class UPalBossBattleInstanceModel* GetBossBattleInstanceModel();
TArray<class APalPlayerCharacter*> GetAliveOrDyingPlayers();
void FullRecoveryHPAllPlayer();
void ForceRespawnPlayer();
class APalPlayerCharacter* FindFirstCombatTargetForBossAI();
void BossBattleCombatStart__DelegateSignature(EPalBossType BossType);
}; // Size: 0x128
class UPalBossEntryWaitInfoHUD : public UPalUserWidgetWorldHUD

{
bool EnableCountDown;
// 0x0408 (size: 0x1)
// 0x0410 (size: 0x8)
FDateTime TimeLimitDate;
// 0x0418 (size: 0x8)
void UpdateWaitInfo(bool bIsCountDown, FDateTime TimeLimit);

void UpdateCountDown();
void OnCloseHUD();
}; // Size: 0x420
class UPalBuildObjectDataMap : public UObject

{
TMap<class FName, class FPalBuildObjectData> BuildObjectDataIdMap;
// 0x0028 (size: 0x50)
FPalBuildObjectData GetByMapObjectId(const FName MapObjectId);

FPalBuildObjectData GetById(const FName ID);
void GetBuildObjectDataMapForType(const EPalBuildObjectTypeA TypeA,
TArray<FPalBuildObjectData>& OutArray);
void GetBuildObjectDataArrayForTypeAByTypeB(const EPalBuildObjectTypeA TypeA,
TArray<FPalBuildObjectDataSetTypeB>& OutArray);
}; // Size: 0x90
class UPalBuildObjectDataUtility : public UBlueprintFunctionLibrary

{
int32 ToSortPriorityTypeB(const EPalBuildObjectTypeB TypeB);

int32 ToSortPriorityTypeA(const EPalBuildObjectTypeA TypeA);
int32 ToInt(const EPalBuildObjectTypeA TypeA);
EPalBuildObjectTypeA ToBuildObjectTypeA(const int32 Value);
void MaterialInfos(const FPalBuildObjectData& BuildObjectData,
TArray<FPalItemRecipeMaterialInfo>& MaterialInfos);
}; // Size: 0x28
class UPalBuildObjectInstallStrategyAttachToCeil : public

UPalBuildObjectInstallStrategyAttachToObjectBase
{
}; // Size: 0x38
class UPalBuildObjectInstallStrategyAttachToObjectBase : public

UPalBuildObjectInstallStrategyBase
{
}; // Size: 0x38
class UPalBuildObjectInstallStrategyAttachToWall : public

UPalBuildObjectInstallStrategyAttachToObjectBase
{
}; // Size: 0x38
class UPalBuildObjectInstallStrategyBase : public UObject

{
// 0x0028 (size: 0x8)
}; // Size: 0x38
class UPalBuildObjectInstallStrategyBaseCampPoint : public

UPalBuildObjectInstallStrategySinkableNormal
{
class APalBuildObjectBaseCampPoint* TargetBuildObjectCache;
// 0x0038 (size: 0x8)
}; // Size: 0x40
class UPalBuildObjectInstallStrategyFloor : public

{
class AActor* HitActorCache;
// 0x0038 (size: 0x8)
class APalBuildObject* HitBuildObjectCache;
// 0x0040 (size: 0x8)
}; // Size: 0x50
class UPalBuildObjectInstallStrategyFoundation : public

{
// 0x0038 (size: 0x8)
// 0x0040 (size: 0x8)
}; // Size: 0x50
class UPalBuildObjectInstallStrategyGroundWall : public

{
// 0x0038 (size: 0x8)
// 0x0040 (size: 0x8)
}; // Size: 0x68
class UPalBuildObjectInstallStrategyNormal : public

{
}; // Size: 0x38
class UPalBuildObjectInstallStrategyPalStorage : public

UPalBuildObjectInstallStrategySinkableNormal
{
class APalBuildObjectPalStorage* TargetPalStorageCache;
// 0x0038 (size: 0x8)
}; // Size: 0x40
class UPalBuildObjectInstallStrategyRoof : public

{
// 0x0038 (size: 0x8)
// 0x0040 (size: 0x8)
}; // Size: 0x50
class UPalBuildObjectInstallStrategySinkableNormal : public

{
}; // Size: 0x38
class UPalBuildObjectInstallStrategyStairs : public

{
// 0x0038 (size: 0x8)
// 0x0040 (size: 0x8)
}; // Size: 0x50
class UPalBuildObjectInstallStrategyWall : public

{
// 0x0038 (size: 0x8)
// 0x0040 (size: 0x8)
}; // Size: 0x68
class UPalBuildObjectInstallStrategyWallV2 : public

{
// 0x0038 (size: 0x8)
// 0x0040 (size: 0x8)
}; // Size: 0x68
class UPalBuildObjectOverlapChecker : public UObject

{
class UShapeComponent* Collision;
// 0x0030 (size: 0x8)
class APalBuildObject* Owner;
// 0x0038 (size: 0x8)
TArray<class APalBuildObject*> OverlapBuildObjects;
// 0x0040 (size: 0x10)
TArray<class UObject*> OverlapOtherObjects;
// 0x0050 (size: 0x10)
class AActor* OverlappedActor;
// 0x0060 (size: 0x8)
TArray<FName> AllowOverlapCollisionPresetNames;
// 0x0068 (size: 0x10)
void OnOverlapEnd(class UPrimitiveComponent* OverlappedComp, class AActor*

OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex);
void OnOverlapBegin(class UPrimitiveComponent* OverlappedComp, class AActor*
bFromSweep, const FHitResult& SweepResult);
}; // Size: 0x78
class UPalBuildObjectVisualControlComponent : public UActorComponent

{
TMap<class UMeshComponent*, class FPalBuildObjectMaterialArray>
NormalMaterialMapCache; // 0x00A0 (size: 0x50)
TMap<class UDecalComponent*, class UMaterialInterface*>
DecalNormalMaterialMapCache; // 0x00F0 (size: 0x50)
class UNiagaraComponent* DamageNiagaraComp;
// 0x0158 (size: 0x8)
}; // Size: 0x160
class UPalBuildOperator : public UObject
{
FPalBuildOperatorOnCompleteBuildInServerDelegate
OnCompleteBuildInServerDelegate; // 0x0028 (size: 0x10)
void MapObjectModelDynamicDelegate(class UPalMapObjectModel* MapObjectModel);
FBuildingSurfaceMaterialSet BuildingSurfaceMaterialSet;
// 0x0038 (size: 0x38)
class UPalBuildObjectDataMap* DataMap;
// 0x0070 (size: 0x8)
TArray<class APalBuildObject*> BuildObjects;
// 0x0078 (size: 0x10)
}; // Size: 0x88
class UPalBuildProcess : public UObject

{
FPalBuildProcessOnUpdateStateDelegate OnUpdateStateDelegate;
// 0x0028 (size: 0x10)
void UpdateStateDelegate(class UPalBuildProcess* BuildProcess);
FPalBuildProcessOnFinishBuildDelegate OnFinishBuildDelegate;
// 0x0038 (size: 0x10)
void UpdateStateDelegate(class UPalBuildProcess* BuildProcess);
EPalBuildProcessState State;
// 0x0048 (size: 0x1)
class UPalWorkProgress* BuildWork;
// 0x0050 (size: 0x8)
void UpdateStateDelegate__DelegateSignature(class UPalBuildProcess*

BuildProcess);
void OnRep_StateChanged();
void OnRep_BuildWork();
void OnReflectFinishBuildWork(class UPalWorkBase* Work);
void OnFinishWorkInServer(class UPalWorkBase* Work);
bool IsCompleted();
class UPalWorkProgress* GetWorkProgress();
}; // Size: 0x68
class UPalBuildProgressWorldHUDParameter : public UPalHUDDispatchParameterBase

{
class UPalBuildProcess* BuildProcess;
// 0x0038 (size: 0x8)
class APalBuildObject* BuildObject;
// 0x0040 (size: 0x8)
}; // Size: 0x48
class UPalBuilderComponent : public UActorComponent

{
FPalBuilderComponentOnUpdatePossessMaterials OnUpdatePossessMaterials;
// 0x00A0 (size: 0x10)
void MulticastReturnSelfDelegate(class UPalBuilderComponent* Self);
FPalBuilderComponentOnStartBuildingMode_Local OnStartBuildingMode_Local;
// 0x00B0 (size: 0x10)
FPalBuilderComponentOnEndBuildingMode_Local OnEndBuildingMode_Local;
// 0x00C0 (size: 0x10)
float InstallDistanceNormalFromOwner;
// 0x00D0 (size: 0x4)
float InstallableRange;
// 0x00D4 (size: 0x4)
class UCameraComponent* OwnerCamera;
// 0x00D8 (size: 0x8)
class APalBuildObjectInstallChecker* InstallChecker;
// 0x00E0 (size: 0x8)
class APalDismantleObjectChecker* DismantleChecker;
// 0x00E8 (size: 0x8)
void RequestBuild_ToServer(const FName BuildObjectId, const FVector& Location,

const FQuat& Rotation, const TArray<FPalNetArchive>& ExtraParameterArchives,
FPalBuildRequestDebugParameter DebugParameter);
void ReceiveBuildResult_ToRequestClient(const EPalMapObjectOperationResult
Result);
void OnExitBaseCamp(class UPalBaseCampModel* BaseCampModel);
void OnEnterBaseCamp(class UPalBaseCampModel* BaseCampModel);
void MulticastReturnSelfDelegate__DelegateSignature(class UPalBuilderComponent*
Self);
bool IsInstallAtReticle();
bool IsExistsMaterialForBuildObject(const FPalBuildObjectData&
BuildObjectData);
bool IsExecuting();
bool IsEnableDismantle();
EPalMapObjectOperationResult IsEnableBuild();
class APalBuildObject* GetDismantleTargetObject();
void CollectItemInfoEnableToUseMaterial(TArray<FName> StaticItemIds,
TArray<FPalStaticItemIdAndNum>& OutItemInfos);
}; // Size: 0x100
class UPalBulletCreator : public UObject

{
class APalBullet* SpawnBullet(const class UObject* WorldContextObject,

TSubclassOf<class APalBullet> bulletClass, const FTransform& SpawnTransform,
ESpawnActorCollisionHandlingMethod collisionHandlingOverride, class AActor* Owner,
class APawn* instigato);
class APalBullet* CreateBullet(const class UObject* WorldContextObject, class
APalWeaponBase* weapon, TSubclassOf<class APalBullet> bulletClass, const
FTransform& SpawnTransform, ESpawnActorCollisionHandlingMethod
collisionHandlingOverride, class AActor* Owner, class APawn* Instigator);
}; // Size: 0x28
class UPalBulletModifierComponent : public UActorComponent

{
void Initialize(const class APalBullet* Bullet);

}; // Size: 0xA0
class UPalBurnBoxComponent : public UBoxComponent

{
void EndOverlapEvent(class UPrimitiveComponent* OverlappedComponent, class

AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex);
void BeginOverlapEvent(class UPrimitiveComponent* OverlappedComponent, class
AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex,
bool bFromSweep, const FHitResult& SweepResult);
}; // Size: 0x580
class UPalCameraShakeBase : public UCameraShakeBase
{
class UCurveFloat* CurveAsset;
// 0x00E8 (size: 0x8)
float OscillationDuration;
// 0x00F0 (size: 0x4)
float OscillationBlendInTime;
// 0x00F4 (size: 0x4)
float OscillationBlendOutTime;
// 0x00F8 (size: 0x4)
FROscillator RotOscillation;
// 0x00FC (size: 0x24)
FVOscillator LocOscillation;
// 0x0120 (size: 0x24)
FFOscillator FOVOscillation;
// 0x0144 (size: 0xC)
float OscillatorTimeRemaining;
// 0x0150 (size: 0x4)
}; // Size: 0x1D0
class UPalCameraShakePattern : public UCameraShakePattern

{
}; // Size: 0x28
class UPalCaptureBallEffectSettingDataAsset : public UDataAsset

{
TMap<class EPalSizeType, class FPalCaptureBallEffectSettingData>
EffectSettingDataArray; // 0x0030 (size: 0x50)
FPalCaptureBallEffectSettingData GetEffectSettingData(const EPalSizeType

PalSizeType);
}; // Size: 0x80
class UPalCaptureReactionComponent : public UActorComponent

{
}; // Size: 0xA0
class UPalCharacterAroundInfoCollectorComponent : public USphereComponent

{
FPalCharacterAroundInfoCollectorComponentOnOverlapBeginDelegate
OnOverlapBeginDelegate; // 0x0560 (size: 0x10)
void OverlapDelegate(class AActor* OtherActor);
FPalCharacterAroundInfoCollectorComponentOnOverlapEndDelegate
OnOverlapEndDelegate; // 0x0570 (size: 0x10)
void OverlapDelegate(class AActor* OtherActor);
TArray<FGuid> MapObjectModelIds;
// 0x0580 (size: 0x10)
void OverlapDelegate__DelegateSignature(class AActor* OtherActor);

}; // Size: 0x590
class UPalCharacterCameraComponent : public UCameraComponent

{
float WalkFOV;
// 0x0A30 (size: 0x4)
float SprintFOV;
// 0x0A34 (size: 0x4)
float SprintFOVInterpSpeed;
// 0x0A38 (size: 0x4)
float PostProcessInterpTime;
// 0x0A3C (size: 0x4)
float DepthOfFieldFocalDistance_NoAim;
// 0x0A40 (size: 0x4)
float DepthOfFieldDepthBlurAmount_NoAim;
// 0x0A44 (size: 0x4)
float DepthOfFieldDepthBlurRadius_NoAim;
// 0x0A48 (size: 0x4)
float DepthOfFieldFstop_NoAim;
// 0x0A4C (size: 0x4)
float DepthOfFieldFocalDistance_Aim;
// 0x0A50 (size: 0x4)
float DepthOfFieldDepthBlurAmount_Aim;
// 0x0A54 (size: 0x4)
float DepthOfFieldDepthBlurRadius_Aim;
// 0x0A58 (size: 0x4)
float DepthOfFieldFstop_Aim;
// 0x0A5C (size: 0x4)
TMap<class EPalWeaponType, class FPalCameraDOFSetting> DefaultWeaponDOFSetting;
// 0x0A60 (size: 0x50)
TMap<class TSoftClassPtr<APalWeaponBase>, class FPalCameraDOFSetting>
UniqueWeaponDOFSetting; // 0x0AB0 (size: 0x50)
bool bIsDynamicDOFFocalDistance;
// 0x0B00 (size: 0x1)
float DynamicDOFFocalDistanceSpeed;
// 0x0B04 (size: 0x4)
float DynamicDOFFocalDistanceMAX;
// 0x0B08 (size: 0x4)
bool bIsEnableSpeedBlur;
// 0x0B0C (size: 0x1)
class UMaterialInterface* DynamicSpeedBlurMaterial;
// 0x0B10 (size: 0x8)
float SpeedBlurInterpSpeed;
// 0x0B18 (size: 0x4)
float MinSpeedBlurSpeed;
// 0x0B1C (size: 0x4)
float MaxSpeedBlurSpeed;
// 0x0B20 (size: 0x4)
float MaxSpeedBlurAlpha;
// 0x0B24 (size: 0x4)
bool bIsEnableAimBlur;
// 0x0B28 (size: 0x1)
class UMaterialInterface* DynamicAimBlurMaterial;
// 0x0B30 (size: 0x8)
float BlendInAimBlurInterpTime;
// 0x0B38 (size: 0x4)
float BlendOutAimBlurInterpTime;
// 0x0B3C (size: 0x4)
float AimFOVInterpTime;
// 0x0B40 (size: 0x4)
float AimFOV;
// 0x0B44 (size: 0x4)
float RotateSpeedRate;
// 0x0B48 (size: 0x4)
class UMaterialInstanceDynamic* DynamicSpeedBlurMaterialDynamic;
// 0x0BB8 (size: 0x8)
class UMaterialInstanceDynamic* DynamicAimBlurMaterialDynamic;
// 0x0BC0 (size: 0x8)
void OnStartAim();
void OnEndAim();
}; // Size: 0xBD0
class UPalCharacterContainerDefine : public UBlueprintFunctionLibrary

{
}; // Size: 0x28
class UPalCharacterContainerManager : public UPalWorldSubsystem

{
TMap<class FPalContainerId, class UPalIndividualCharacterContainer*>
ContainerMap_InServer; // 0x0080 (size: 0x50)
TMap<class FPalContainerId, class UPalIndividualCharacterContainer*>
LocalContainerMap; // 0x0120 (size: 0x50)
bool TryGetContainer(const FPalContainerId& ContainerId, class

UPalIndividualCharacterContainer*& Container);
class UPalIndividualCharacterSlot* GetLocalSlot(const FPalContainerId&
ContainerId, const int32 SlotIndex);
class UPalIndividualCharacterContainer* GetLocalContainer(const
FPalContainerId& ContainerId);
class UPalIndividualCharacterContainer* GetContainer(const FPalContainerId&
ContainerId);
}; // Size: 0x170
class UPalCharacterImportanceManager : public UObject

{
TArray<class APalPlayerCharacter*> PlayerList;
// 0x0030 (size: 0x10)
TArray<class APalPlayerCharacter*> PlayerList_ForOutsideGet;
// 0x0040 (size: 0x10)
TMap<class EPalCharacterImportanceType, class
FCharacterListForImportanceManager> CharacterMap; // 0x0050 (size: 0x50)
TArray<class APalNPCSpawnerBase*> SpawnerList;
// 0x00A0 (size: 0x10)
void GetImportantNPC(TArray<class APalCharacter*>& OutArray);

void GetAllPlayer(TArray<class APalCharacter*>& OutArray);
void GetAllPalCharacter(TArray<class APalCharacter*>& OutArray);
void GetAllNPC(TArray<class APalCharacter*>& OutArray);
}; // Size: 0xD0
class UPalCharacterLiftupObjectComponent : public UActorComponent

{
bool bIsLifting;
// 0x00AA (size: 0x1)
bool bEnableLiftup;
// 0x00B4 (size: 0x1)
void SetEnable(const bool bInEnable);

void OnOverlapEndCageAreaWalls();
void OnHitOwnerMainMesh(class UPrimitiveComponent* HitComponent, class AActor*
OtherActor, class UPrimitiveComponent* OtherComponent, FVector NormalImpulse, const
FHitResult& Hit);
bool IsLifting();
FGuid GetLastLiftRequestedPlayerUId();
void BroadcastSetBeingThrown(const bool bInBeingThrown);
}; // Size: 0x100
class UPalCharacterManager : public UPalWorldSubsystem

{
FPalCharacterManagerOnIndividualParameterSynced OnIndividualParameterSynced;
// 0x00C8 (size: 0x10)
void CharacterParameterAddedDelegate(FPalInstanceID InstanceId);
TSubclassOf<class UPalActionBase> AttackNearBaseClass;
// 0x00D8 (size: 0x8)
TSubclassOf<class UPalActionBase> AttackFarBaseClass;
// 0x00E0 (size: 0x8)
TMap<class FPalInstanceID, class UPalIndividualCharacterParameter*>
IndividualParameterMap; // 0x00E8 (size: 0x50)
TMap<class FPalInstanceID, class TWeakObjectPtr<UPalIndividualCharacterHandle>>
WeakIndividualHandleMap; // 0x0138 (size: 0x50)
TArray<class UPalIndividualCharacterHandle*> InitializeWaitingHandles;
// 0x0188 (size: 0x10)
TArray<class UPalIndividualCharacterHandle*> NoHoldHandles;
// 0x0198 (size: 0x10)
TMap<class FPalInstanceID, class UPalIndividualCharacterHandleReference*>
CachedRefenrenceOnlyHandles; // 0x01A8 (size: 0x50)
TArray<class UPalIndividualCharacterHandle*> CreatingHandles;
// 0x0200 (size: 0x10)
TArray<class UPalIndividualCharacterHandle*> SpawningActorHandles;
// 0x0210 (size: 0x10)
TArray<class UPalIndividualCharacterHandle*> ReserveDestroyActorHandles;
// 0x0220 (size: 0x10)
TArray<class UPalIndividualCharacterParameter*> CachedIndividualParameterList;
// 0x0230 (size: 0x10)
void SpawnPhantomByHandle(class UPalIndividualCharacterHandle* Handle,

FNetworkActorSpawnParameters SpawnParameter, FSpawnPhantomByHandleSpawnCallback
spawnCallback);
class UPalIndividualCharacterHandle*
SpawnNewCharacterWithInitializeParameterCallback(FPalIndividualCharacterSaveParamet
er initParameter, FNetworkActorSpawnParameters SpawnParameter,
EPalCharacterCompleteDelegatePriority InitializeParameterCallbackPriority,
FSpawnNewCharacterWithInitializeParameterCallbackInitializeParameterCallback
InitializeParameterCallback,
FSpawnNewCharacterWithInitializeParameterCallbackSpawnCallback spawnCallback);
SpawnNewCharacter(FPalIndividualCharacterSaveParameter initParameter,
FNetworkActorSpawnParameters SpawnParameter, FSpawnNewCharacterSpawnCallback
spawnCallback);
void SpawnCharacterByHandleWithInitializeParameterCallback(class
UPalIndividualCharacterHandle* Handle, FNetworkActorSpawnParameters SpawnParameter,
EPalCharacterCompleteDelegatePriority InitializeParameterCallbackPriority,
FSpawnCharacterByHandleWithInitializeParameterCallbackInitializeParameterCallback
InitializeParameterCallback,
FSpawnCharacterByHandleWithInitializeParameterCallbackSpawnCallback spawnCallback);
void SpawnCharacterByHandle(class UPalIndividualCharacterHandle* Handle,
FNetworkActorSpawnParameters SpawnParameter, FSpawnCharacterByHandleSpawnCallback
spawnCallback);
void RaiseToMainActor(class UPalIndividualCharacterHandle* Handle, int32
PhantomId, FRaiseToMainActorCallback Callback);
void OnCreateIndividualID(FPalInstanceID ID);
void IndividualPhantomIDCallback__DelegateSignature(FPalInstanceID ID, int32
PhantomId);
void IndividualIDCallback__DelegateSignature(FPalInstanceID ID);
class UPalIndividualCharacterHandleReference*
GetIndividualHandleReference(FPalInstanceID ID);
GetIndividualHandleFromCharacterParameter(class UPalIndividualCharacterParameter*
Parameter);
class UPalIndividualCharacterHandle* GetIndividualHandle(FPalInstanceID ID);
class UPalIndividualCharacterParameter* GetIndividualCharacterParameter(const
void DespawnPhantomByHandle(class UPalIndividualCharacterHandle* Handle, int32
PhantomId, FDespawnPhantomByHandleSpawnCallback spawnCallback);
void DespawnCharacterByHandle(class UPalIndividualCharacterHandle* Handle,
FDespawnCharacterByHandleSpawnCallback spawnCallback);
class UPalIndividualCharacterHandle* CreateIndividualByFixedID(FPalInstanceID
ID, FPalIndividualCharacterSaveParameter initParameter,
FCreateIndividualByFixedIDSpawnCallback spawnCallback);
CreateIndividual(FPalIndividualCharacterSaveParameter initParameter,
FCreateIndividualSpawnCallback spawnCallback);
void CharacterParameterAddedDelegate__DelegateSignature(FPalInstanceID
InstanceId);
void CharacterHandleDelegate__DelegateSignature(class
UPalIndividualCharacterHandle* CharacterHandle);
}; // Size: 0x240
class UPalCharacterManagerReplicator : public UPalGameStateReplicatorBase

{
FFastCharacterParameterRepInfoArray CharacterParameterInfosFast;
// 0x0028 (size: 0x148)
void OnPreReplicatedRemoveItem(const FCharacterParameterRepInfo& Item);

void OnPostReplicatedChangeItem(const FCharacterParameterRepInfo& Item);
void OnPostReplicatedAddItem(const FCharacterParameterRepInfo& Item);
void OnPep_CharacterParameterInfos();
}; // Size: 0x170
class UPalCharacterMovementComponent : public UCharacterMovementComponent

{
FPalCharacterMovementComponentOnMovementModeChangedDelegate
OnMovementModeChangedDelegate; // 0x0EF8 (size: 0x10)
void OnMovementModeChangedDelegate(class UPalCharacterMovementComponent*
Component, TEnumAsByte<EMovementMode> prevMode, TEnumAsByte<EMovementMode> newMode,
NewCustomMode);
FPalCharacterMovementComponentOnJumpDelegate OnJumpDelegate;
// 0x0F08 (size: 0x10)
void OnJumpDelegate(class UPalCharacterMovementComponent* Component);
FPalCharacterMovementComponentOnFlyDelegate OnFlyDelegate;
// 0x0F18 (size: 0x10)
void OnFlyDelegate(class UPalCharacterMovementComponent* Component);
FPalCharacterMovementComponentOnLandedDelegate OnLandedDelegate;
// 0x0F28 (size: 0x10)
void OnLandedDelegate(class UPalCharacterMovementComponent* Component, const
FHitResult& Hit);
FPalCharacterMovementComponentOnChangeCrouchDelegate OnChangeCrouchDelegate;
// 0x0F38 (size: 0x10)
void OnChangeCrouch(class UPalCharacterMovementComponent* Component, bool
IsInCrouch);
FPalCharacterMovementComponentOnChangeSprintDelegate OnChangeSprintDelegate;
// 0x0F48 (size: 0x10)
void OnChangeSprint(class UPalCharacterMovementComponent* Component, bool
IsInSprint);
FPalCharacterMovementComponentOnChangeSlidingDelegate OnChangeSlidingDelegate;
// 0x0F58 (size: 0x10)
void OnChangeSliding(class UPalCharacterMovementComponent* Component, bool
IsInSliding);
FPalCharacterMovementComponentOnChangeSwimmingDelegate
OnChangeSwimmingDelegate; // 0x0F68 (size: 0x10)
void OnChangeSwimming(bool IsInSwimming);
FPalCharacterMovementComponentOnEnterWaterDelegate OnEnterWaterDelegate;
// 0x0F78 (size: 0x10)
void OnEnterWater();
FPalCharacterMovementComponentOnExitWaterDelegate OnExitWaterDelegate;
// 0x0F88 (size: 0x10)
void OnExitWater();
FPalCharacterMovementComponentOnJumpDisableDelegate OnJumpDisableDelegate;
// 0x0F98 (size: 0x10)
void OnJumpDisable();
float DyingMaxSpeed;
// 0x0FA8 (size: 0x4)
float FatigueMaxSpeed;
// 0x0FAC (size: 0x4)
float SprintMaxSpeed;
// 0x0FB0 (size: 0x4)
float SprintMaxAcceleration;
// 0x0FB4 (size: 0x4)
float SprintYawRate;
// 0x0FB8 (size: 0x4)
float GliderMaxSpeed;
// 0x0FBC (size: 0x4)
float GliderAirControl;
// 0x0FC0 (size: 0x4)
float GliderGravityScale;
// 0x0FC4 (size: 0x4)
float SlidingStartSpeed;
// 0x0FC8 (size: 0x4)
float SlidingMaxSpeed;
// 0x0FCC (size: 0x4)
float SlidingAddRate;
// 0x0FD0 (size: 0x4)
float SlidingSubRate;
// 0x0FD4 (size: 0x4)
float SlidingYawRate;
// 0x0FD8 (size: 0x4)
bool bIsEnableSkySliding;
// 0x0FDC (size: 0x1)
float ClimbMaxSpeed;
// 0x0FE0 (size: 0x4)
float RollingMaxSpeed;
// 0x0FE4 (size: 0x4)
int32 LastLandedTransformCacheNum;
// 0x0FE8 (size: 0x4)
bool bIsUseLastLandedCache;
// 0x0FEC (size: 0x1)
TMap<int32, float> OverrideJumpZVelocityMap;
// 0x0FF0 (size: 0x50)
TMap<FName, float> MaxAccelerationMultiplierMap;
// 0x1040 (size: 0x50)
TMap<FName, float> WalkSpeedMultiplierMap;
// 0x1090 (size: 0x50)
TMap<FName, float> YawRotatorMultiplierMap;
// 0x10E0 (size: 0x50)
TMap<FName, float> GravityZMultiplierMap;
// 0x1130 (size: 0x50)
TMap<FName, float> AirControlXYMultiplierMap;
// 0x1180 (size: 0x50)
TMap<FName, float> SlideAlphaMultiplierMap;
// 0x11D0 (size: 0x50)
FFlagContainer MoveDisableFlag;
// 0x1220 (size: 0x50)
FFlagContainer InputDisableFlag;
// 0x1270 (size: 0x50)
FFlagContainer JumpDisableFlag;
// 0x12C0 (size: 0x50)
FFlagContainer DriveMoveFlag;
// 0x1310 (size: 0x50)
FFlagContainer PysicsAccelerationFlag;
// 0x1360 (size: 0x50)
FVector ClientLocation;
// 0x13B0 (size: 0x18)
FFlagContainer CrouchDisableFlag;
// 0x13D0 (size: 0x50)
FFlagContainer SlidingDisableFlag;
// 0x1420 (size: 0x50)
FFlagContainer GliderDisableFlag;
// 0x1470 (size: 0x50)
FFlagContainer SplintDisableFlag;
// 0x14C0 (size: 0x50)
bool bRequestCrouch;
// 0x1510 (size: 0x1)
bool bRequestSprint;
// 0x1511 (size: 0x1)
FVector LastLandingInputVelocity;
// 0x1518 (size: 0x18)
TArray<FVector> LastLandingLocationCache;
// 0x1530 (size: 0x10)
FFlagContainer StepDisableFlag;
// 0x1540 (size: 0x50)
TMap<EPalWalkableFloorAnglePriority, float> WalkableFloorAngleOverridesMap;
// 0x1590 (size: 0x50)
float SlowWalkSpeed_Default;
// 0x15E0 (size: 0x4)
float WalkSpeed_Default;
// 0x15E4 (size: 0x4)
float RunSpeed_Default;
// 0x15E8 (size: 0x4)
float RideSprintSpeed_Default;
// 0x15EC (size: 0x4)
float TransportSpeed_Default;
// 0x15F0 (size: 0x4)
float TemporaryAccelerationTimeCount;
// 0x15F4 (size: 0x4)
bool IsFlyDashMode;
// 0x15F8 (size: 0x1)
bool bIsGrapplingMoving;
// 0x15F9 (size: 0x1)
float DefaultMaxStepHeight;
// 0x15FC (size: 0x4)
EPalCharacterMovementCustomMode CustomMovementMode_ForReplicate;
// 0x1600 (size: 0x1)
float InWaterRate;
// 0x1604 (size: 0x4)
float DashSwimMaxSpeed;
// 0x1608 (size: 0x4)
float JumpableInWaterDepth;
// 0x160C (size: 0x4)
EEnterWaterFlag EnteredWaterFlag;
// 0x1610 (size: 0x1)
float WaterPlaneZ;
// 0x1614 (size: 0x4)
float WaterPlaneZPrev;
// 0x1618 (size: 0x4)
float WaitTimeToSwimInFalling;
// 0x161C (size: 0x4)
bool bIsDashSwim;
// 0x1620 (size: 0x1)
void SetYawRotatorMultiplier(FName flagName, float Rate);

void SetWalkSpeedMultiplier(FName flagName, float Speed);
void SetWalkSpeedByType(FName flagName, EPalMovementSpeedType MoveSpeedType);
void SetWalkableFloorAngleOverrides(EPalWalkableFloorAnglePriority Priority,
float Angle);
void SetupDatabaseSpeedByCharacterId(class APalCharacter* InCharacter, FName
charaID);
void SetupDatabaseSpeed(class APalCharacter* InCharacter);
void SetStepDisableFlag(FName flagName, bool isDisable);
void SetSplintDisbleFlag(FName flagName, bool Disable);
void SetSlidingDisbleFlag(FName flagName, bool Disable);
void SetSlideAlphaMultiplier(FName flagName, float Rate);
void SetPysicsAccelerationFlag(FName flagName, bool isEnable);
void SetMoveDisableFlag(FName flagName, bool isDisable);
void SetMaxAccelerationMultiplier(FName flagName, float Speed);
void SetJumpDisableFlag(FName flagName, bool isDisable);
void SetInputDisableFlag(FName flagName, bool isDisable);
void SetGravityZMultiplier(FName flagName, float Rate);
void SetGrapplingMoving(bool IsMoving);
void SetGliderDisbleFlag(FName flagName, bool Disable);
void SetForceMaxAccel(bool bIsEnable);
void SetFlyDashMode_ToServer(bool IsDash);
void SetDriveMoveFlag(FName flagName, bool isEnable);
void SetDisableLeftHandAttachFlag(bool isDisable);
void SetDashSwimming_ToServer(bool _isDash);
void SetDashSwimming(bool _isDash);
void SetCustomMovementMode(EPalCharacterMovementCustomMode NewCustomMode);
void SetCrouchDisbleFlag(FName flagName, bool Disable);
void SetAirControlXYMultiplier(FName flagName, float Rate);
void ResetLastLandingLocationCache();
void RequestTemporaryAcceleration();
void RemoveWalkableFloorAngleOverrides(EPalWalkableFloorAnglePriority
Priority);
void OnRep_CustomMovementMode_ForReplicate();
void OnMovementModeChangedDelegate__DelegateSignature(class
UPalCharacterMovementComponent* Component, TEnumAsByte<EMovementMode> prevMode,
TEnumAsByte<EMovementMode> newMode, EPalCharacterMovementCustomMode PrevCustomMode,
EPalCharacterMovementCustomMode NewCustomMode);
void OnLandedDelegate__DelegateSignature(class UPalCharacterMovementComponent*
Component, const FHitResult& Hit);
void OnJumpDisable__DelegateSignature();
void OnJumpDelegate__DelegateSignature(class UPalCharacterMovementComponent*
Component);
void OnFlyDelegate__DelegateSignature(class UPalCharacterMovementComponent*
Component);
void OnExitWater__DelegateSignature();
void OnExitWater();
void OnEnterWater__DelegateSignature();
void OnEnterWater();
void OnDeactivated(class UActorComponent* Component);
void OnChangeSwimming__DelegateSignature(bool IsInSwimming);
void OnChangeSprint__DelegateSignature(class UPalCharacterMovementComponent*
Component, bool IsInSprint);
void OnChangeSliding__DelegateSignature(class UPalCharacterMovementComponent*
Component, bool IsInSliding);
void OnChangeCrouch__DelegateSignature(class UPalCharacterMovementComponent*
Component, bool IsInCrouch);
IsInCrouch);
void MergeLastLandingLocationCache(const class UPalCharacterMovementComponent*
MovementComponent);
void Jump();
bool IsStepDisabled();
bool IsSprint();
bool IsSliding();
bool IsRequestSliding();
bool IsPysicsAcceleration();
bool IsMoveDisabled();
bool IsJumpDisabled();
bool IsInputDisabled();
bool IsGrapplingMoving();
bool IsGliding();
bool IsFallingFromSwimming();
bool IsEnteredWater();
bool IsEnableSkySliding();
bool IsDriveMove();
bool IsDashSwimming();
bool IsClimbing();
float GetYawRotatorMultiplier();
FVector GetWaterPlaneNormal();
FVector GetWaterPlaneLocation();
float GetWalkSpeedMultiplier();
float GetWalkableFloorAngleByPriority();
FVector GetVelocity();
float GetSlideAlphaMultiplier();
float GetMaxAccelerationMultiplier();
FVector GetLastLandingLocationFromLastOfCache();
FVector GetLastLandingLocation();
float GetInWaterRate();
float GetGravityZMultiplier();
float GetDefaultRunSpeed();
EPalCharacterMovementCustomMode GetCustomMovementMode();
float GetAirControlXYMultiplier();
void CheckReturnToNavWakl();
bool CanSliding();
bool CanGainSP();
bool CanDashSwimming();
}; // Size: 0x1680
class UPalCharacterOnCompleteInitializeParameterWrapper : public UObject

{
FPalCharacterOnCompleteInitializeParameterWrapperOnCompleteInitializeParameterDeleg
ate OnCompleteInitializeParameterDelegate; // 0x0028 (size: 0x10)
void OnCompleteInitializeParameter(class APalCharacter* InCharacter);
void Broadcast(class APalCharacter* Character);

}; // Size: 0x38
class UPalCharacterParameterComponent : public UActorComponent

{
bool bIsCooping;
// 0x00A0 (size: 0x1)
bool bIsEnableSendReticleTarget;
// 0x00A1 (size: 0x1)
bool bIsEnableMuteki;
// 0x00A2 (size: 0x1)
FFixedPoint64 LeanBackPoint;
// 0x00A8 (size: 0x8)
FFixedPoint64 LeanBackMaxPoint;
// 0x00B0 (size: 0x8)
FFixedPoint64 StunPoint;
// 0x00B8 (size: 0x8)
FFixedPoint64 StunMaxPoint;
// 0x00C0 (size: 0x8)
bool IsSPOverheat;
// 0x00C8 (size: 0x1)
bool bIsHyperArmor;
// 0x00C9 (size: 0x1)
bool bIsDebugMuteki;
// 0x00CA (size: 0x1)
// 0x00CB (size: 0x1)
// 0x00CC (size: 0x1)
bool IsOverrideTarget;
// 0x00CD (size: 0x1)
FVector OverrideTargetLocation;
// 0x00D0 (size: 0x18)
class APalCharacter* Trainer;
// 0x00E8 (size: 0x8)
class APalCharacter* OtomoPal;
// 0x00F0 (size: 0x8)
TWeakObjectPtr<class AActor> ReticleTargetActor;
// 0x00F8 (size: 0x8)
class UPalIndividualCharacterHandle* IndividualHandle;
// 0x0100 (size: 0x8)
class UPalIndividualCharacterParameter* IndividualParameter;
// 0x0108 (size: 0x8)
bool IsStun;
// 0x0110 (size: 0x1)
bool IsEnableSpeedCollision;
// 0x0111 (size: 0x1)
bool IsCanSneakAttacked;
// 0x0112 (size: 0x1)
bool IsFriendBulletIgnore;
// 0x0113 (size: 0x1)
int32 BiologicalGrade;
// 0x0114 (size: 0x4)
bool IsPredator;
// 0x0118 (size: 0x1)
bool IsEdible;
// 0x0119 (size: 0x1)
int32 HiddenCollisionOverlapCount;
// 0x011C (size: 0x4)
int32 BurnCollisionOverlapCount;
// 0x0120 (size: 0x4)
int32 LavaCollisionOverlapCount;
// 0x0124 (size: 0x4)
EPalElementType DamageUpElement_ByElementStatus;
// 0x0129 (size: 0x1)
EPalElementType DamageDownElement_ByElementStatus;
// 0x012A (size: 0x1)
bool IsDarknessRandomAttack;
// 0x012B (size: 0x1)
int32 AttackUp;
// 0x012C (size: 0x4)
int32 DefenseUp;
// 0x0130 (size: 0x4)
TMap<class EPalAdditionalEffectType, class FPalStatusAccumulate>
StatusAccumulateMap; // 0x0138 (size: 0x50)
bool IsSleepAction;
// 0x0188 (size: 0x1)
FVector WildPalDrinkWaterPoint;
// 0x0190 (size: 0x18)
bool IsDisableOtomoReturnEffect;
// 0x01A8 (size: 0x1)
FHitResult GroundHitResult;
// 0x01B0 (size: 0xE8)
bool bIsUseGroundRayCast;
// 0x029C (size: 0x1)
FFlagContainer DisableGroundRayCast;
// 0x02A0 (size: 0x50)
FFixedPoint64 SP;
// 0x02F0 (size: 0x8)
FGuid BaseCampDefenseModelId;
// 0x02F8 (size: 0x10)
EPalMapBaseCampWorkerOrderType BaseCampWorkerOrderType;
// 0x0308 (size: 0x1)
bool bBaseCampWorkerAttackableFriend;
// 0x0309 (size: 0x1)
TMap<class FGuid, class FPalMapObjectAppearanceData> UnreachableMapObjectInfos;
// 0x0310 (size: 0x50)
FPalCharacterParameter_Work Work;
// 0x0360 (size: 0x78)
FPalWorkAssignHandleId WorkAssignId;
// 0x03D8 (size: 0x18)
// 0x03F0 (size: 0x1)
FGuid BaseCampWalkAroundExcludeMapObjectInstanceId;
// 0x03F4 (size: 0x10)
FName PossessStaticItemId;
// 0x0404 (size: 0x8)
bool bBeingRescued;
// 0x040C (size: 0x1)
float DyingHP;
// 0x0410 (size: 0x4)
float DyingMaxHP;
// 0x0414 (size: 0x4)
class UPalItemContainer* ItemContainer;
// 0x0418 (size: 0x8)
bool IsCapturedProcessing;
// 0x0420 (size: 0x1)
FPalCharacterParameterComponentOnUpdatePossessItemDelegate
OnUpdatePossessItemDelegate; // 0x0428 (size: 0x10)
void UpdateParameterDelegate(class UPalCharacterParameterComponent* Parameter);
FPalCharacterParameterComponentOnUpdateWorkAssignIdDelegate
OnUpdateWorkAssignIdDelegate; // 0x0438 (size: 0x10)
void UpdateWorkAssignIdDelegate(class UPalCharacterParameterComponent*
Parameter);
FPalCharacterParameterComponentOnSPOverheatDelegate OnSPOverheatDelegate;
// 0x0448 (size: 0x10)
void SPOverheatDelegate();
FPalCharacterParameterComponentOnChangeTrapLegHoldDelegate
OnChangeTrapLegHoldDelegate; // 0x0458 (size: 0x10)
void OnChangeTrapDelegate(bool IsExist);
FPalCharacterParameterComponentOnChangeTrapMovingPanelDelegate
OnChangeTrapMovingPanelDelegate; // 0x0468 (size: 0x10)
void OnChangeTrapDelegate(bool IsExist);
FVector TrapDirection;
// 0x0478 (size: 0x18)
TMap<FPalInstanceID, int32> DamageMap;
// 0x0490 (size: 0x50)
bool CanDropItem;
// 0x04E0 (size: 0x1)
FFlagContainer DisableNaturalHealing_Component;
// 0x04E8 (size: 0x50)
TArray<TWeakObjectPtr<AActor>> TrapLegHoldList;
// 0x0638 (size: 0x10)
TArray<TWeakObjectPtr<AActor>> TrapMovingPanelList;
// 0x0648 (size: 0x10)
class UPalOtomoAttackStopJudgeByBallList* OtomoAttackStopJudge;
// 0x0658 (size: 0x8)
TArray<FPalMapObjectAppearanceDataWithId> UnreachableMapObjectRepInfoArray;
// 0x0660 (size: 0x10)
void ZeroDyingHP_ToServer();
void ZeroDyingHP();
void UpdateWorkAssignIdDelegate__DelegateSignature(class
UPalCharacterParameterComponent* Parameter);
void UpdateParameterDelegate__DelegateSignature(class
UPalCharacterParameterComponent* Parameter);
void SubDyingHP(float SubHP);
void SPOverheatDelegate__DelegateSignature();
void SetupBiologicalGradeFromDatabase();
void SetTrainer(class APalCharacter* inTrainer);
void SetSP(FFixedPoint64 NewSP);
void SetReticleTarget_ToServer(class AActor* Actor);
void SetOverrideTargetLocation_ToServer(FVector TargetLocation);
void SetOverrideTargetLocation(FVector TargetLocation);
void SetMuteki(FName flagName, bool isEnable);
void SetMP(FFixedPoint64 NewMP);
void SetMaxSP(FFixedPoint64 NewMaxSP);
void SetMaxMP(FFixedPoint64 NewMaxMP);
void SetMaxHP(FFixedPoint64 NewMaxHP);
void SetIsOverrideTarget_Innner(bool IsOverride);
void SetIsOverrideTarget(bool IsOverride);
void SetIsCapturedProcessing(bool IsCaptureProcess);
void SetHP(FFixedPoint64 NewHP);
void SetEnableSendReticleTarget(FName flagName, bool isEnable);
void SetElementTypeFromDatabase(class APalCharacter* InCharacter);
void SetDisableNaturalHealing_Component(FName Key, bool Disable);
void SetDisableCreateUNKO(FName flagName, bool isDisable);
void SetCoopingFlag(bool isEnable);
void ReviveFromDying();
void ResetSP();
void ResetDyingHP();
void RemoveTrapMovingPanel(class AActor* TrapActor);
void RemoveTrapLegHold(class AActor* TrapActor);
void OnSlipDamage(int32 Damage);
void OnRep_Trainer();
void OnRep_PossessStaticItemId();
void OnRep_ItemContainer();
void OnRep_IndividualParameter();
void OnInitialize_AfterSetIndividualParameter(class APalCharacter* Character);
void OnChangeTrapDelegate__DelegateSignature(bool IsExist);
bool IsOtomo();
bool IsMuteki();
bool IsLive();
bool IsInHiddenCollision();
bool IsHyperArmor();
bool IsHittingLava();
bool IsDyingHPZero();
bool IsDyingHPMax();
bool IsDying();
bool IsDead();
bool IsCooping();
bool IsAssignedToAnyWork();
bool IsAssignedFixed();
bool HasFloorPhysMaterial();
bool HasElementType(const EPalElementType ElementType);
FGuid GetWorkId();
class UPalWorkAssign* GetWorkAssign();
class UPalWorkBase* GetWork();
FFixedPoint64 GetSP();
int32 GetShotAttack();
float GetSanity();
float GetRadius();
FVector GetOverrideTargetLocation_ConsiderRide();
class UPalOtomoAttackStopJudgeByBallList* GetOtomoAttackStopJudge();
void GetNickname(FString& outName);
FFixedPoint64 GetMP();
int32 GetMeleeAttack();
FFixedPoint64 GetMaxSP();
float GetMaxSanity();
FFixedPoint64 GetMaxMP();
FFixedPoint64 GetMaxHP();
float GetMaxFullStomach();
FGuid GetMapObjectInstanceIdApproachTo();
int32 GetLevel();
int32 GetLegHoldResistLevel();
bool GetIsCapturedProcessing();
class UPalIndividualCharacterParameter* GetIndividualParameter();
FFixedPoint64 GetHP();
FHitResult GetHitGroundResult();
float GetFullStomach();
TEnumAsByte<EPhysicalSurface> GetFloorPhisicalSurface();
FVector GetFloorLocation();
int32 GetDefense();
int32 GetCraftSpeed_WorkSuitability(const EPalWorkSuitability WorkSuitability);
int32 GetCraftSpeed();
void AddTrapMovingPanel(class AActor* TrapActor);
void AddTrapLegHold(class AActor* TrapActor);
void AddDyingHP(float AddHP);
}; // Size: 0x670
class UPalCharacterParameterStorageSubsystem : public UPalWorldSubsystem

{
FPalCharacterParameterStorageSubsystemOnStoredParameterDelegate_ForServer
OnStoredParameterDelegate_ForServer; // 0x0078 (size: 0x10)
void StoredParameterDelegate(const FPalCharacterStoredParameterId& StoredID);
FPalCharacterParameterStorageSubsystemOnRemovedParameterDelegate_ForServer
OnRemovedParameterDelegate_ForServer; // 0x0088 (size: 0x10)
void RemovedParameterDelegate(const FPalCharacterStoredParameterId& RemovedID);
TMap<class FPalCharacterStoredParameterId, class
FPalCharacterStoredParameterInfo> StoredParameterInfoMap; // 0x0098 (size: 0x50)
}; // Size: 0xE8
class UPalCharacterShop : public UPalShopBase

{
TArray<class UPalShopProduct_LostPal*> LocalLostPalProductArray;
// 0x00B8 (size: 0x10)
}; // Size: 0xC8
class UPalCharacterStatusOperation : public UObject

{
TMap<FName, int32> GetReturnItemsForResetCharacterStatusAll(const class

UObject* WorldContextObject, const class UPalIndividualCharacterParameter*
TargetIndividualParameter);
int32 GetRequiredRelicCountForLocalPlayer(const class UObject*
WorldContextObject);
int32 GetRequiredMoneyCountForResetLocalPlayer(const class UObject*
int32 GetRequiredMoneyCountForResetCharacterStatusAll(const class UObject*
WorldContextObject, class UPalIndividualCharacterHandle* targetHandle);
int32 GetRequiredMoneyCountForResetCharacterStatus(const class UObject*
WorldContextObject, class UPalIndividualCharacterHandle* targetHandle, const
EPalCharacterStatusOperationName StatusName);
void GetRequiredItemCountForCharacterStatus(const class UObject*
WorldContextObject, class UPalIndividualCharacterHandle* targetHandle, const
EPalCharacterStatusOperationName StatusName, FName& OutStaticItemId, int32&
OutItemNum);
int32 GetCurrentStatusRank(const class UPalIndividualCharacterParameter*
TargetIndividualParameter, const EPalCharacterStatusOperationName StatusName);
int32 GetCurrentLocalPlayerStatusPoint(const class UObject* WorldContextObject,
const FName StatusName);
}; // Size: 0x28
class UPalCheatManager : public UCheatManager

{
class UPalDebugWindowSetting* DebugWindowSetting;
// 0x0090 (size: 0x8)
class UDataTable* DebugProgressPresetDataTable;
// 0x0098 (size: 0x8)
TSubclassOf<class APalDebug_SpawnInfoReporter> SpawnerInfoReporterClass;
// 0x00A0 (size: 0x8)
class APalImGui* PalImGui;
// 0x00A8 (size: 0x8)
class UPalStatPalCount* PalCountSystem;
// 0x00B0 (size: 0x8)
class APalDebug_SpawnInfoReporter* SpawnInfoReporter;
// 0x00B8 (size: 0x8)
void WorkerEventLog();
void WorkerEventInterval(const float Interval);
void WildPalCombatStart();
void WazaCoolTimeFastMode();
void VisitorTravel();
void UpdateBaseCampWorkerSlotNum(const int32 SlotNum);
void UpdateBaseCampTickInvokeMaxNumInOneTick(const int32 Value);
void UpdateBaseCampLevelMax();
void UnlockTechnologyByLvCap(int32 Lv);
void UnlockOneTechnology(FName technologyName);
void UnlockMap(FName regionId);
void UnlockAllRecipeTechnology();
void UnlockAllCategoryTechnology();
void UnlockAchievement(FString AchievementId, int32 Progress);
void UNKO();
void TriggerBaseCampWorkerEvent(const EPalBaseCampWorkerEventType EventType);
void ToggleVisibleFoliageChunk();
void ToggleShowReticleLocation();
void ToggleShowDropItemHitEventLog();
void ToggleRevision_BP();
void ToggleRevision();
void TogglePartnerSkillNoDecrease();
void ToggleLoadingScreen();
void ToggleHUD();
void ToggleBuildInstallCheckLookToCamera();
void ToggleBaseCampWorkerSanityDetail();
void TimeStopForBP();
void TeleportToSafePoint();
void TeleportToNearestPlayer();
void TeleportToNearestCamp();
void TeleportToLocationByClipboard();
void TeleportToLocation(float X, float Y, float Z);
void TeleportToLastLandingLocation();
void TeleportToDungeonEntranceRandom();
void TeleportToDungeonEntranceByRandomScattered();
void TeleportToDungeonEntranceByIndex(const int32 Index);
void TeleportToDungeonEntranceByDataLayer(const FName DataLayerName);
void TeleportToCurrentDungeonTreasureBox();
void TeleportToCurrentDungeonGoal();
void TeleportToBotLocation(int32 botIndex);
void TeleportToBotCamp(int32 botIndex);
void TeleportToBossTower(EPalBossType BossType);
void TeleportNearestPlayerToMe();
void StringToPlayerUID(FString Str);
void StopTimerDropItem();
void StopOtomoMovement();
void StopOtomoAI();
void StartWildPalCombat();
void StartTraceAllOption();
void StartDismantlingMode();
void StartBuildMode(const FName BuildObjectId);
void SpectatorOnForBP();
void SpectatorOn();
void SpectatorOffForBP();
void SpectatorOff();
void SpawnPalEggBreedFarm(const FName MonsterId, const float Range);
void SpawnMonsterForPlayer(const FName& CharacterID, int32 Num, int32 Level);
void SpawnMonster(const FName CharacterID, int32 Level);
void SleepAllEnemy();
void SkipCutscene();
void ShutdownRemoteServer();
void ShowTargetLocalPlayerEnemyList();
void ShowSpawnerInfo();
void ShowPlayers();
void ShowPlayerMoveSpeed();
void ShowPalEggStatus();
void ShowPalCount();
void ShowObjectNameGround();
void ShowObjectNameForward();
void ShowMovementMode();
void ShowMapObjectStatus();
void ShowMapObjectFoliageStatus();
void ShowMapObjectConnector();
void ShowLocalSaveData();
void ShowLaunchArguments();
void ShowInviteCode();
void ShowInvaderDeubgLog();
void ShowHateArrow();
void ShowFloorLocation();
void ShowDialog(FText Msg);
void ShowDefenseAttackTarget();
void ShowDefenseAttackableRange();
void ShowDebugWorkAssignTarget();
void ShowDebugWorkAssign();
void ShowDebugWanted();
void ShowDebugCrime();
void ShowCharacterStatus();
void ShowBuildObjectInstallCheck();
void ShowAlert(FText Msg);
void ShowAISound();
void ShowActionName();
void ShowActionAndStatus_ToServer();
void ShowActionAndStatus();
void SetWorldPartitionLoadParameter(float Range, bool bIsActivated);
void SetVoiceID(int32 VoiceID);
void SetSunLightShadowDistance(const float InDistance);
void SetSanityToBaseCampPal(const float Sanity);
void SetPlayerSP(int32 NewSP);
void SetPlayerHP(int32 NewHP);
void SetPlayerCameraBoomLengthRate(const float Rate);
void SetPassive_PlayerWeapon(FName firstPassive, FName secondPassive, FName
thirdPassive);
void SetPalWorldTimeScale(float Rate);
void SetPalWorldTime(int32 Hour);
void SetPalEggStatusRange(const float Range);
void SetPaldexComplete(bool IsComplete);
void SetOtomoPalWorkSpeedRank(int32 Rank);
void SetOtomoPalRank(int32 Rank);
void SetOtomoPalHPRank(int32 Rank);
void SetOtomoPalDefenceRank(int32 Rank);
void SetOtomoPalAttackRank(int32 Rank);
void SetMultiplayRestriction(bool bRestriction);
void SetMapObjectStatusRange(const float Range);
void SetLoadingSceneVisible(bool IsVisible);
void SetInventoryItemDurability(const float Percent);
void SetGameTime_NextNight_SecondsAgo(const int32 SecondsAgo);
void SetGameTime_NextNight();
void SetGameTime_NextDay_SecondsAgo(const int32 SecondsAgo);
void SetGameTime_NextDay();
void SetFPSForServer(float fps);
void SetForceLocationTeleport(bool bForceLocationTeleport);
void SetDisableInteractReticleTarget(bool bIsEnable);
void SetDebugRespawnPointForPlayer(class APalPlayerCharacter* Character,
FVector Location);
void SetDebugFullStomachDecreaseRate(const float Rate);
void SetCharacterName(FString Name);
void SetCharacterMakeColor(FColor Color);
void SetCharacterMakeAllRed();
void SetCharacterMakeAllNormal();
void SetCharacterMakeAllMin();
void SetCharacterMakeAllMax();
void SetCharacterMakeAllGreen();
void SetCharacterMakeAllBlue();
void SetBaseCampWorkerHpSingle(const float Percentage);
void SetBaseCampWorkerHp(const float Percentage);
void SetAlwaysGrantPassiveSkillMode(bool Flag);
void SetActivity(FString ConnStr, int32 maxPlayer, int32 currentPlayer);
void SendChatToBroadcast(FString Text);
void SaikyoGamePreset();
void RideIKEnable();
void RideIKDisable();
void RespawnPlayer();
void RerollCharacterMake();
void RequestLogTreasureBoxLocalPlayerAround();
void RequestFillSlotChestToInventory();
void RequestFillSlotChestFromInventory();
void RepairEquipment();
void RandomizePassive_PlayerWeapon();
void PrintInventoryDynamicItemLog();
void PrintGameTime();
void Ping(const FString Address);
void ParallelForUpdateActiveTiles();
void PalmiTargetEnemny();
void OrderBaseCampWorker(const EPalMapBaseCampWorkerOrderType OrderType);
void OpenTitleForBP();
void OpenTitle();
void OpenPrivateServerForBP();
void OpenPrivateServer();
void OpenMultiBattleMapForBP();
void OpenMultiBattleMap();
void OpenDefaultMap();
void OnPingComplete(class UPingIP* PingIP, FString Address, int32 TimeMS);
void NotDecreaseWeaponItem();
void NotConsumeMaterialsInCraft();
void NotConsumeMaterialsInBuild();
void MutekiForPlayer();
void MutekiForFriend();
void MutekiALL();
void ManyUNKO();
void LoginNative();
void LoginEOS();
void LogBaseCampInfo();
void KillPlayer();
void KillGuildFriend();
void KillBaseCampWorkerSingle();
void KillBaseCampWorker();
void KillAllFriend();
void KillAllEnemy();
void KickPlayer(FString PlayerUIdORSteamId, FText KickReason);
void JumpToClientStartLocation();
void JoinInviteCode(FString InviteCode);
void JoinClientPlayerToServerGuild();
bool IsShowCharacterStatus();
bool IsNotDecreaseWeaponItem();
bool IsNotConsumeMaterialsInBuild();
bool IsMutekiForPlayer();
bool IsMutekiForFriend();
bool IsMutekiALL();
bool IsIgnoreBuildRestrictionBaseCamp();
bool IsFixedSP();
bool IsDisableEnemyEyeSight();
bool IsCaptureSuccessAlways();
bool IsCaptureFailAlways();
void IsAllStreamingCompleted();
bool IsActionName();
void InvaderMarchRandom();
void InvaderMarch();
void InstallVirtualBaseCamp();
void InsightsTraceStopForServer();
void InsightsTraceStopForLocal();
void InsightsTraceStartForServer();
void InsightsTraceStartForLocal();
void InitInventory(const FName StaticItemId, const int32 Count);
void IgnoreRestrictedByItemsForPartnerSkill();
void IgnoreBuildRestrictionBaseCamp();
void HPOneAllCharacter();
void HideTutorialQuest_BP();
void HideTutorialQuest();
void GetRelic(int32 Count);
void GetPlanerPal();
void GetPalEgg(const FName CharacterID);
void GetItemWithPassiveSkill(FName StaticItemId, int32 Count, FName
PassiveSkillId);
void GetItemWithPassive(FName StaticItemId, int32 Count);
void GetItemToLoadoutWithPassive(FName StaticItemId, int32 Count);
void GetItemToLoadout(FName StaticItemId, int32 Count);
void GetItem(FName StaticItemId, int32 Count);
void GenerateCombiMonster();
void FullPowerForPlayer();
void ForceUpdateBaseCampWorkerEvent();
void ForceSpawnRarePal();
void ForceReportCriminal();
void ForceReloadPlayerParameter();
void ForceReleaseWanted();
void ForceLowerSpecSetting();
void ForceExitStageAllPlayer();
void ForceExitStage();
void ForceDisableTimerLight();
void ForceDisablePalMeshCollision();
void FootIKEnable();
void FootIKDisable();
void FixedUseEagleForGlider();
void FixedSP();
void FixedActionRandomSeed();
void ExitGuildPlayer(FString GuildName, class APalPlayerCharacter* Player);
void ExitGuildLocalPlayer(FString GuildName);
void EnterGuildPlayer(FString GuildName, class APalPlayerCharacter* Player);
void EnterGuildLocalPlayer(FString GuildName);
void EnterGroup(FString GroupName, FPalInstanceID IndividualId);
void EnableStatUnit();
void EnableStatPlayerInfo();
void EnableStatPalnet();
void EnableCommandToServer();
void EnableCollectServerPalCount();
void EasyGamePreset();
void DropItems(const FName StaticItemId, const int32 Num, const int32
DropCount);
void DropItemByTimer(const FName StaticItemId, const int32 Num, const float
Interval);
void DropItem(const FName StaticItemId, const int32 Num);
void DrawDebugRangeBaseCamp(const float LifeTime);
void DrawDebugLimitVolume(const EPalLimitVolumeFlag Flag, const float Range,
const float Duration);
void DisposeGuild(FString GuildName);
void DismantleBaseCampFirst();
void DismantleBaseCampByBaseCampId(const FGuid& BaseCampId);
void DisableScreenMessage();
void DisableEnemyEyeSight();
void DeleteWorldAndShutdownRemoteServer();
void DeletePlayerAndQuitGame();
void DebugWindow();
void DebugSaveWorldOptionData(FString WorldName);
void DebugSaveWorldData(FString saveName);
void DebugSaveLocalWorldData(FString saveName);
void DebugSaveFullWorldData(FString WorldName);
void DebugDeleteEnemyCampSaveData();
void DebugChangeAutoSaveTimespan(float saveSpan);
void DebugAutoSave();
void DebugAutoRun();
void CreateGuildWithAdmin(FString GuildName, const FGuid& AdminPlayerUId);
void CreateGuildAndEnterLocalPlayer(FString GuildName);
void CreateGuild(FString GuildName);
void CountPalCharacter();
void CopyWorldDirectoryName();
void CopyPlayerLocation();
void CommandToServer(const FString Command);
void CleatDebugInfoText();
void CheckFoliageChunkStatus(const bool bShowInstanceDetail, const bool
bShowGridDetail);
void ChangePassive_PlayerWeapon(int32 Index, FName SkillName);
void ChangeHUDScale(float Scale);
void CauseServerCrash();
void CauseEnsure();
void CauseCrash();
void CaptureSuccessAlways();
void CaptureNewMonster(const FName CharacterID);
void CaptureFailAlways();
void CaptureAllMonsters();
void CaptureAllEnemy();
void BuildNotConsumeMaterials();
void BuildDebugBaseCamp(FName Mode);
void BotOn();
void BotOff();
void ApplyDebugGameProgress(FName PresetName);
void AddTechnologyPoints(int32 AddPoints);
void AddPlayerExp(int32 addExp);
void AddPartyExp(int32 addExp);
void AddOneStatusPlayer();
void AddOneStatusOtomo();
void AddOneStatusEnemy();
void AddMoney(int64 addValue);
void AddMapObjectEffectVisualAround_Burn(const float Range);
void AddMapObjectEffectVisualAround(const float Range, const
EPalMapObjectVisualEffectType EffectType);
void AddGameTime_Minutes(const int32 Minutes);
void AddGameTime_Hours(const int32 Hours);
void AddExpForALLPlayer(int32 addExp);
void AddBossTechnologyPoints(int32 AddPoints);
void AddBaseCampEnergyAmount(const EPalEnergyType EnergyType, const float
Amount);
}; // Size: 0xC8
class UPalClimbingComponent : public UActorComponent

{
void StartClimb(const FHitResult& Result);

void ForceCancelClimb();
}; // Size: 0xA0
class UPalCombiMonsterParameter : public UObject

{
}; // Size: 0x28
class UPalComboBoxString : public UWidget

{
TArray<FString> DefaultOptions;
// 0x0150 (size: 0x10)
FString SelectedOption;
// 0x0160 (size: 0x10)
FComboBoxStyle WidgetStyle;
// 0x0170 (size: 0x660)
FTableRowStyle ItemStyle;
// 0x07D0 (size: 0xD50)
FMargin ContentPadding;
// 0x1520 (size: 0x10)
float MaxListHeight;
// 0x1530 (size: 0x4)
bool HasDownArrow;
// 0x1534 (size: 0x1)
bool EnableGamepadNavigationMode;
// 0x1535 (size: 0x1)
FSlateFontInfo Font;
// 0x1538 (size: 0x60)
FSlateColor ForegroundColor;
// 0x1598 (size: 0x14)
bool bIsFocusable;
// 0x15AC (size: 0x1)
FPalComboBoxStringOnGenerateWidgetEvent OnGenerateWidgetEvent;
// 0x15B0 (size: 0x10)
class UWidget* GenerateWidgetForString(FString Item);
FPalComboBoxStringOnGenerateTopWidgetEvent OnGenerateTopWidgetEvent;
// 0x15C0 (size: 0x10)
class UWidget* GenerateWidgetForString(FString Item);
FPalComboBoxStringOnSelectionChanged OnSelectionChanged;
// 0x15D0 (size: 0x10)
void OnSelectionChangedEvent(FString SelectedItem,
TEnumAsByte<ESelectInfo::Type> SelectionType);
FPalComboBoxStringOnOpening OnOpening;
// 0x15E0 (size: 0x10)
void OnOpeningEvent();
void SetSelectedOption(FString Option);

void SetSelectedIndex(const int32 Index);
bool RemoveOption(FString Option);
void RefreshOptions();
void OnSelectionChangedEvent__DelegateSignature(FString SelectedItem,
TEnumAsByte<ESelectInfo::Type> SelectionType);
void OnOpeningEvent__DelegateSignature();
bool IsOpen();
FString GetSelectedOption();
int32 GetSelectedIndex();
int32 GetOptionCount();
FString GetOptionAtIndex(int32 Index);
int32 FindOptionIndex(FString Option);
void ClearSelection();
void ClearOptions();
void AddOption(FString Option);
}; // Size: 0x1640
class UPalCommonBoundActionButton : public UCommonBoundActionButton

{
}; // Size: 0x1510
class UPalCommonQuestRewardGiver : public UPalQuestRewardGiver

{
FPalCommonQuestRewardData RewardData;
// 0x0028 (size: 0x58)
void SetCommonRewardData(FPalCommonQuestRewardData InRewardList);

}; // Size: 0x80
class UPalCommonScrollListBase : public UPalUserWidget

{
void MoveItem(const int32 Num, class UPalItemSlot* MoveItemSlot, const
FPalContainerId& TargetContainerId);
}; // Size: 0x408
class UPalCommonUIActionRouter : public UCommonUIActionRouterBase

{
}; // Size: 0x158
class UPalContainerBase : public UObject

{
FPalContainerBaseOnDisposeContainerDelegate OnDisposeContainerDelegate;
// 0x0028 (size: 0x10)
void DisposeContainerDelegate();
FPalContainerId ID;
// 0x0038 (size: 0x10)
// 0x0048 (size: 0x1)
bool IsEmpty();
FPalContainerId GetId();
void DisposeContainerDelegate__DelegateSignature();
}; // Size: 0x50
class UPalContainerIdUtility : public UBlueprintFunctionLibrary

{
FPalContainerId NoneContainerId();
bool IsNoneContainerId(const FPalContainerId& ContainerId);
bool BP_NotEqual(const FPalContainerId& A, const FPalContainerId& B);
bool BP_Equal(const FPalContainerId& A, const FPalContainerId& B);
}; // Size: 0x28
class UPalContainerUtility : public UObject

{
}; // Size: 0x28
class UPalCoopClimbPlayer : public UObject

{
class APalCharacter* Player;
// 0x0028 (size: 0x8)
class UPalAnimInstance* PlayerAnime;
// 0x0030 (size: 0x8)
TArray<EHumanBone> BoneChain;
// 0x0038 (size: 0x10)
int32 CurrentIndex;
// 0x0048 (size: 0x4)
FTransform TargetWorldTf;
// 0x0050 (size: 0x60)
float Progress;
// 0x00B0 (size: 0x4)
bool Complete;
// 0x00B4 (size: 0x1)
FPalCoopClimbPlayerStartStandAnimeDelegate StartStandAnimeDelegate;
// 0x00B8 (size: 0x10)
void StartStandAnimeDelegate();
FTransform UpdateTransform(FTransform Climber, float ProgressSpeed, float

LeapPosSpeed, float LeapRotateSpeed, float DeltaTime);
void StartStandAnimeDelegate__DelegateSignature();
void InitializeNode(EHumanBone EntryBone, class APalCharacter* PlayerCharacter,
FTransform Climber);
}; // Size: 0xD0
class UPalCoopSkillModuleAssignPassiveSkill : public UPalCoopSkillModuleBase

{
TArray<FPalCoopSkillModuleAssignPassiveSkillNames> AssignSkillNamesPerRank;
// 0x0038 (size: 0x10)
FName PassiveSkillAssignFlagName;
// 0x0048 (size: 0x8)
void RemovePassiveSkills();
void AssignPassiveSkills(const TArray<FPalDataTableRowName_PassiveSkillData>&
AssignSkillName);
void AssignPassiveSkill(const FName& SkillName);
}; // Size: 0x50
class UPalCoopSkillModuleBase : public UObject

{
EPalLogType ExecuteLog;
// 0x0028 (size: 0x1)
class APalCharacter* OwnerCharacter;
// 0x0030 (size: 0x8)
void Start();
void SetTrainerCoopFlag(bool IsCoop);
void OnTick(float DeltaTime);
void OnStartSkill();
void OnSkillOverheat();
void Initialize(class UPalPartnerSkillParameterComponent*
PartnerSkillComponent);
int32 GetOwnerRank();
void AddSkillLog();
void Abort();
}; // Size: 0x38
class UPalCoopSkillSearchBase : public UObject

{
TArray<float> SearchRangeMaxByRank;
// 0x0028 (size: 0x10)
TArray<float> ExtendRangePerSecByRank;
// 0x0038 (size: 0x10)
FVector SearchOrigin;
// 0x0048 (size: 0x18)
float SearchRangeMax;
// 0x0060 (size: 0x4)
float ExtendRangePerSec;
// 0x0064 (size: 0x4)
float ElapsedTime;
// 0x0068 (size: 0x4)
int32 SkillRank;
// 0x006C (size: 0x4)
FGuid CalledPlayerUId;
// 0x0070 (size: 0x10)
bool bIsRunning;
// 0x0080 (size: 0x1)
TArray<FPalCoopSkillSearchResultParameter> SearchResultParameters;
// 0x0088 (size: 0x10)
void Tick(float DeltaTime, class UPalCoopSkillSearchLocationRegister*

LocationRegister);
void Terminate();
void Start(const FVector& Origin, int32 Rank, const FGuid& RequestPlayerUId);
void OnRemoveLocationForCompass_BP(const FGuid& LocationId, class
UPalLocationBase* Location);
void OnRemoveLocationForCompass(const FGuid& LocationId, class
void OnAddedLocationForCompass_BP(const FGuid& LocationId, class
void OnAddedLocationForCompass(const FGuid& LocationId, class UPalLocationBase*
Location);
bool IsRunning();
bool IsFinished();
float GetSearchRangeMax();
float GetSearchRangeByRank(int32 Rank);
int32 GetRank();
FVector GetOrigin();
float GetExtendSearchRangePerSec();
float GetExtendRangePerSecByRank(int32 Rank);
float GetCurrentSearchRadius();
void End();
void ClearSearchResultParameters();
void AddSearchResultParameter(const FPalCoopSkillSearchResultParameter&
ResultParameter);
}; // Size: 0x98
class UPalCoopSkillSearchCharacter : public UPalCoopSkillSearchBase

{
void SearchMonsters(const FVector& Origin, float SearchRadius, const FGuid&

RequestPlayerUId);
}; // Size: 0x98
class UPalCoopSkillSearchDungeonPortal : public UPalCoopSkillSearchBase

{
void SearchDungeonPortal(const FVector& Origin, float SearchRadius, const

FGuid& RequestPlayerUId);
}; // Size: 0x98
class UPalCoopSkillSearchEffectController : public UObject

{
void Tick(float DeltaTime);

void Start(const FVector& Origin, float RadiusFrom, float RadiusTo, float
ExtRadiusPerSec);
bool IsRunning();
bool IsFinished();
void End();
}; // Size: 0x28
class UPalCoopSkillSearchLocationRegister : public UObject

{
TArray<FGuid> RegisteredLocationIds;
// 0x0028 (size: 0x10)
TMap<FGuid, float> RegisteredLocationElapsedSec;
// 0x0038 (size: 0x50)
float LocationDisplayTimeSec;
// 0x0088 (size: 0x4)
void UnregisterMapObjectLocationsFromCompass(const FGuid& guiid);

void RegisterMapObjectLocationsToCompass(const
FPalCoopSkillSearchResultParameter& ResultParameter);
}; // Size: 0xE0
class UPalCoopSkillSearchMapObject : public UPalCoopSkillSearchBase

{
void SearchMapObjects(const TArray<FName>& SearchMapObjIds, const FVector&

Origin, float SearchRadius, const FGuid& RequestPlayerUId);
}; // Size: 0x98
class UPalCoopSkillSearchSystem : public UObject

{
TSubclassOf<class UPalCoopSkillSearchEffectController> EffectControllerClass;
// 0x0030 (size: 0x8)
class UPalCoopSkillSearchLocationRegister* LocationRegister;
// 0x0038 (size: 0x8)
class UPalCoopSkillSearchEffectController* EffectController;
// 0x0040 (size: 0x8)
TArray<class UPalCoopSkillSearchBase*> SearchObjects;
// 0x0048 (size: 0x10)
void StartSearchEffect(const FPalCoopSkillSearchEffectParameter& EffectParam);

class UPalCoopSkillSearchBase* CreateSearchObject(TSubclassOf<class
UPalCoopSkillSearchBase> SearchClass);
}; // Size: 0x58
class UPalCryComponentBase : public UActorComponent

{
}; // Size: 0xA0
class UPalCustomPrimitiveWidget : public UPalUserWidget

{
class USlateBrushAsset* SlateBrush;
// 0x0408 (size: 0x8)
TArray<FPalUMGCustomVertexData> VertexData;
// 0x0410 (size: 0x10)
TArray<int32> vertexIndexes;
// 0x0420 (size: 0x10)
void UpdateVertexData(int32 Index, const FPalUMGCustomVertexData&

inVertexData);
void PushVertexData(const FPalUMGCustomVertexData& inVertexData);
void DrawVertexData(FPaintContext& Context);
}; // Size: 0x430
class UPalCutsceneComponent : public UActorComponent

{
FPalCutsceneComponentOnPlayCutsceneDelegate OnPlayCutsceneDelegate;
// 0x00A0 (size: 0x10)
void CutsceneDelegate();
FPalCutsceneComponentOnFinishCutsceneDelegate OnFinishCutsceneDelegate;
// 0x00B0 (size: 0x10)
void CutsceneFinishDelegate(bool bIsSkipped);
class APalCutsceneActor* CutsceneActor;
// 0x00C0 (size: 0x8)
class UPalHUDDispatchParameter_FadeWidget* FadeParam;
// 0x00D0 (size: 0x8)
void StopCutsceneToServer();
void StopCutscene();
void StartFadeOut();
class APalCutsceneActor* SpawnCutsceneActor(TSubclassOf<class
APalCutsceneActor> CutsceneActorClass, FVector Location, FRotator Rotation, class
AActor* Owner);
void PlayCutsceneToServer();
void PlayCutscene(class APalCutsceneActor* InCutsceneActor, bool
IsAutoDestroy);
void OnFinished();
void OnEndFadeOut();
bool IsPlayingCutscene();
void CutsceneFinishDelegate__DelegateSignature(bool bIsSkipped);
void CutsceneDelegate__DelegateSignature();
}; // Size: 0xE8
class UPalDamageDisplayCanvas : public UPalUserWidget

{
int32 CalcDisplayDamage(const FPalDamageInfo& DamageInfo, class AActor*

Defender, float& outSpecialDamageRate, int32& weakCount);
}; // Size: 0x408
class UPalDamageExplodeComponent : public UActorComponent

{
float ExplosionDelayTime;
// 0x00A8 (size: 0x4)
FPalDamageExplodeComponentOnDamageDelegate_Ex OnDamageDelegate_Ex;
// 0x00B0 (size: 0x10)
void OnDamageDelegate_Ex(FPalDamageInfo DamageInfo);
bool IsExploded;
// 0x00C0 (size: 0x1)
void SpawnExplosionActor_Delay(class AActor* Attacker, float DelayTime);

void SpawnExplosionActor(class AActor* Attacker);
void OnDamageDelegate_Ex__DelegateSignature(FPalDamageInfo DamageInfo);
void ForceExplode(class AActor* Attacker);
}; // Size: 0xC8
class UPalDamageInfoUtility : public UObject

{
float GetSpecialAttackRate(const FPalDamageInfo& DamageInfo, const

EPalSpecialAttackRateType Type);
}; // Size: 0x28
class UPalDamagePopUpManager : public UObject

{
FPalDamagePopUpManagerOnAddDamagePopupDelegate OnAddDamagePopupDelegate;
// 0x0028 (size: 0x10)
void AddDamagePopupDelegate(const FPalDamageInfo& DamageInfo, class AActor*
Defender);
void AddDamagePopupDelegate__DelegateSignature(const FPalDamageInfo&

DamageInfo, class AActor* Defender);
void AddDamagePopUp(const FPalDamageInfo& DamageInfo, class AActor* Defender);
}; // Size: 0x38
class UPalDamageReactionComponent : public UActorComponent

{
FPalDamageReactionComponentOnDamageDelegate OnDamageDelegate;
// 0x00A8 (size: 0x10)
void OnDamageDelegate(FPalDamageResult DamageResult);
FPalDamageReactionComponentOnDamageDelegate_Always OnDamageDelegate_Always;
// 0x00B8 (size: 0x10)
void OnDamageDelegate(FPalDamageResult DamageResult);
FPalDamageReactionComponentOnDeadDelegate OnDeadDelegate;
// 0x00C8 (size: 0x10)
void OnDeadDelegate(FPalDeadInfo DeadInfo);
FPalDamageReactionComponentOnDyingDeadEndDelegate OnDyingDeadEndDelegate;
// 0x00D8 (size: 0x10)
void OnDyingDeadEnd(class APalPlayerCharacter* PlayerCharacter);
FPalDamageReactionComponentOnMentalDamageDelegate OnMentalDamageDelegate;
// 0x00E8 (size: 0x10)
void OnMentalDamageDelegate(FPalDamageResult DamageResult);
FPalDamageReactionComponentOnSleepDelegate OnSleepDelegate;
// 0x00F8 (size: 0x10)
void OnSleepDelegate(int32 LastDamage);
FPalDamageReactionComponentOnDamageReactionDelegate OnDamageReactionDelegate;
// 0x0108 (size: 0x10)
void OnDamageReactionDelegate(FPalDamageRactionInfo ReactionInfo);
FPalDamageReactionComponentOnEachDamageReactionDelegate
OnEachDamageReactionDelegate; // 0x0118 (size: 0x10)
void OnEachDamageReactionDelegate(FPalEachDamageRactionInfo EachReactionInfo);
FPalDamageReactionComponentOnSlipDamageDelegate OnSlipDamageDelegate;
// 0x0128 (size: 0x10)
void OnSlipDamageDelegate(int32 Damage);
FPalDamageReactionComponentOnCaptureStartDelegate OnCaptureStartDelegate;
// 0x0138 (size: 0x10)
void OnCaptureStartDelegate();
FPalDamageReactionComponentOnNooseTrapDelegate OnNooseTrapDelegate;
// 0x0148 (size: 0x10)
void OnNooseTrapDelegate(class AActor* TrapActor, FVector FixLocation);
TSubclassOf<class UPalHitEffectSlot> DamageEffectSlotClass;
// 0x0158 (size: 0x8)
class UPalHitEffectSlot* EffectSlot;
// 0x0160 (size: 0x8)
TArray<float> RateList;
// 0x0168 (size: 0x10)
void SlipDamageAndBlowWhenDead(int32 Damage, FVector Velocity);

void SlipDamage(int32 Damage, bool ShieldIgnore);
void ProcessDeath_ToServer();
void ProcessDamage_ToServer(const FPalDamageInfo& Info);
void PopupDamageBySlipDamage_ToALL(int32 Damage);
void PlayEachDamageReaction(FPalEachDamageRactionInfo EachReactionInfo);
void PlayDamageReaction(FPalDamageRactionInfo ReactionInfo);
void PlayAddDamageMotion(EPalDamageAnimationReactionType reactionType);
void OnSlipDamageDelegate__DelegateSignature(int32 Damage);
void OnSleepDelegate__DelegateSignature(int32 LastDamage);
void OnNooseTrapDelegate__DelegateSignature(class AActor* TrapActor, FVector
FixLocation);
void OnMentalDamageDelegate__DelegateSignature(FPalDamageResult DamageResult);
void OnHitNooseTrap(class AActor* TrapActor, FVector FixLocation);
void OnEndDamageMotion(class UAnimMontage* Montage, bool bInterrupted);
void OnEachDamageReactionDelegate__DelegateSignature(FPalEachDamageRactionInfo
EachReactionInfo);
void OnDyingDeadEndDelegate_ToALL();
void OnDyingDeadEnd__DelegateSignature(class APalPlayerCharacter*
PlayerCharacter);
void OnDeadDelegate__DelegateSignature(FPalDeadInfo DeadInfo);
void OnDamageReactionDelegate__DelegateSignature(FPalDamageRactionInfo
ReactionInfo);
void OnDamageDelegate__DelegateSignature(FPalDamageResult DamageResult);
void OnCaptureStartDelegate__DelegateSignature();
void ForceDamageDelegateForCaptureBall(class AActor* Attacker);
void DeathDamage_ForSelfDestruct(FVector Velocity, EPalWazaID WazaID);
void CallOnDamageDelegateAlways(FPalDamageResult DamageResult);
void CallDeadDelegate_ToALL(FPalDeadInfo DeadInfo);
void ApplyDamageForMP(FPalDamageResult DamageResult);
void ApplyDamageForHP(FPalDamageResult DamageResult);
void ApplyDamageForDyingHP(FPalDamageResult DamageResult);
void AddDeadImplus(FPalDamageResult DamageResult);
}; // Size: 0x178
class UPalDamageText : public UPalUserWidget

{
FVector2D RandomPositionMin;
// 0x0408 (size: 0x10)
FVector2D RandomPositionMax;
// 0x0418 (size: 0x10)
}; // Size: 0x428
class UPalDataTableRowIdMapper : public UObject

{
TArray<class UDataTable*> DataTables;
// 0x0028 (size: 0x10)
TMap<FName, int32> RowNameHashMap;
// 0x0038 (size: 0x50)
}; // Size: 0x88
class UPalDatabaseCharacterParameter : public UObject

{
TMap<class FName, class TSubclassOf<UPalAIResponsePreset>> AIResponsePresetMap;
// 0x0028 (size: 0x50)
TMap<class FName, class TSubclassOf<UPalAISightResponsePreset>>
AISightResponsePresetMap; // 0x0078 (size: 0x50)
TSubclassOf<class UPalPettingPresset> PettingPressetClass;
// 0x00C8 (size: 0x8)
class UDataTable* PlayerParameterDataTable;
// 0x00D0 (size: 0x8)
class UDataTable* MonsterParameterDataTable;
// 0x00D8 (size: 0x8)
class UDataTable* HumanParameterDataTable;
// 0x00E0 (size: 0x8)
class UDataTable* DropItemDataTable;
// 0x00E8 (size: 0x8)
class UDataTable* MonsterNameDataTable;
// 0x00F0 (size: 0x8)
class UDataTable* HumanNameDataTable;
// 0x00F8 (size: 0x8)
class UDataTable* CharacterIconDataTable;
// 0x0100 (size: 0x8)
class UDataTable* BPClassDataTable;
// 0x0108 (size: 0x8)
class UDataTable* PartnerSkillDataTable;
// 0x0110 (size: 0x8)
class UDataTable* PalSizeParameterDataTable;
// 0x0118 (size: 0x8)
class UDataTable* PalCapturedCageDataTable;
// 0x0120 (size: 0x8)
class UDataTable* PalStatusEffectFoodDataTable;
// 0x0128 (size: 0x8)
class UDataTable* PalCombiUniqueDataTable;
// 0x0130 (size: 0x8)
TArray<float> TalentMagnificationList;
// 0x0140 (size: 0x10)
class UPalPettingPresset* PettingPressetInstance;
// 0x0150 (size: 0x8)
class UPalCombiMonsterParameter* CombiMonsterParameter;
// 0x0158 (size: 0x8)
void UpdateApplyDatabaseToIndividualParameter(class
UPalIndividualCharacterParameter* IndividualParameter);
bool SetupSaveParameter(const FName CharacterID, const int32 Level, const
FGuid& OwnerPlayerUId, FPalIndividualCharacterSaveParameter& outParameter);
int32 HigherLevelOtomoFromTrainer(const class UPalIndividualCharacterParameter*
IndividualCharacterParameter);
void GetWorkSuitabilityRank(FName RowName, TMap<EPalWorkSuitability, int32>&
WorkSuitabilities);
void GetWorkSuitabilityMaterialSubTypes(FName RowName,
TArray<EPalMapObjectMaterialSubType>& MaterialSubTypes);
void GetWorkSuitability(FName RowName, TArray<EPalWorkSuitability>&
WorkSuitabilities);
EPalWeaponType GetWeaponType(FName RowName);
bool GetWeaponEquip(FName RowName);
int32 GetViewingDistance_cm(FName RowName);
int32 GetViewingAngle_Degree(FName RowName);
EPalTribeID GetTribe(FName RowName);
int32 GetSupportBySaveParameter(const FPalIndividualCharacterSaveParameter&
SaveParameter);
int32 GetSupport(class UPalIndividualCharacterParameter* IndividualParameter);
EPalSizeType GetSize(FName RowName);
int32 GetShotAttackBySaveParameter(const FPalIndividualCharacterSaveParameter&
SaveParameter);
int32 GetShotAttack(const class UPalIndividualCharacterParameter*
int32 GetRarity(FName RowName);
float GetPriceRate(FName RowName);
void GetPrefixNameMsgID(const FName& CharacterID, FName& OutMsgID);
class UPalPettingPresset* GetPettingPreset();
void GetPassiveSkill(FName RowName, TArray<FName>& PassiveSkill);
void GetPartnerSkillMsgID(const FName& CharacterID, FName& OutMsgID);
EPalOrganizationType GetOrganizationType(FName RowName);
bool GetNocturnal(FName RowName);
int32 GetMeleeAttackBySaveParameter(const FPalIndividualCharacterSaveParameter&
SaveParameter);
int32 GetMeleeAttack(class UPalIndividualCharacterParameter*
void GetLocalizedCharacterName(const FName& CharacterID, FText& OutText);
bool GetIsTowerBoss(FName RowName);
bool GetIsPal(FName RowName);
bool GetIsBoss(FName RowName);
int32 GetHPBySaveParameter(const FPalIndividualCharacterSaveParameter&
SaveParameter);
int32 GetHP(class UPalIndividualCharacterParameter* IndividualParameter);
float GetHearingRate(FName RowName);
EPalGenusCategoryType GetGenusCategory(FName RowName);
int32 GetFoodAmount(FName RowName);
float GetExpRatio(FName RowName);
void GetElementType(FName RowName, EPalElementType& Element1, EPalElementType&
Element2);
bool GetDropItemData(const FName& CharacterID, const int32 Level,
FPalDropItemDatabaseRow& OutData);
int32 GetDefenseBySaveParameter(const FPalIndividualCharacterSaveParameter&
SaveParameter);
int32 GetDefense(const class UPalIndividualCharacterParameter*
TArray<FPalWorkSuitabilityInfo> GetCraftSpeeds(class
int32 GetCraftSpeedBySaveParameter(const FPalIndividualCharacterSaveParameter&
SaveParameter);
int32 GetCraftSpeed(class UPalIndividualCharacterParameter*
FSoftObjectPath GetCharacterIconTexturePath(const FName CharacterID);
TSoftObjectPtr<UTexture2D> GetCharacterIconTextureByTribeID(const EPalTribeID
TribeID);
TSoftObjectPtr<UTexture2D> GetCharacterIconTexture(const FName CharacterID);
float GetCaptureRateCorrect(FName RowName);
FName GetBPClassName(FName RowName);
TSoftClassPtr<APalCharacter> GetBPClass(FName RowName);
EPalBattleBGMType GetBattleBGM(FName RowName);
bool FindPalSizeParameter(EPalSizeType CharacterSize, FPalSizeParameterDataRow&
RowData);
int32 CalcCorrectedLevel(const int32 TrainerLevel, const int32
TargetCharacterLevel, const class UObject* WorldContextObject);
}; // Size: 0x160
class UPalDeadBodyManager : public UObject

{
TArray<class UPalIndividualCharacterHandle*> DeadPalList;
// 0x0028 (size: 0x10)
void GetDeadPalList(TArray<class UPalIndividualCharacterHandle*>& OutArray);

}; // Size: 0x38
class UPalDeathPenaltyManager : public UObject

{
float StageDeathPenaltyRayStartHeight;
// 0x0028 (size: 0x4)
float StageDeathPenaltyChestRadius;
// 0x002C (size: 0x4)
float StageDeathPenaltySpaceWidth;
// 0x0030 (size: 0x4)
float StageDeathPenaltySpaceDepth;
// 0x0034 (size: 0x4)
TMap<class FGuid, class FPalDeathPenaltyList> DeathPenaMap;
// 0x0038 (size: 0x50)
void DropDeathPenaltyChest(class APalPlayerCharacter* Player);
}; // Size: 0x88
class UPalDebugInfoGameInstanceSubsystem : public UGameInstanceSubsystem

{
class UFont* FontObject;
// 0x0038 (size: 0x8)
}; // Size: 0x40
class UPalDebugSetting : public UObject

{
bool bEnableCommandToServer;
// 0x0028 (size: 0x1)
EPalLanguageType EditorPlayTextLanguageType;
// 0x0029 (size: 0x1)
bool IsRequiredLoadPlayerSaveData;
// 0x002A (size: 0x1)
FString DefaultLoadPlayerSaveDataName;
// 0x0030 (size: 0x10)
bool IsRequiredLoadWorldSaveData;
// 0x0040 (size: 0x1)
FString DefaultLoadWorldSaveDataName;
// 0x0048 (size: 0x10)
bool bIsRequiredLoadLocalWorldSaveData;
// 0x0058 (size: 0x1)
TMap<int32, FGuid> EditorPlayerSaveDataOverwriteMap;
// 0x0060 (size: 0x50)
FString PlayerAutoSaveDataName;
// 0x00B0 (size: 0x10)
FString WorldAutoSaveDataName;
// 0x00C0 (size: 0x10)
bool bDontAutoSaveInMulti;
// 0x00D0 (size: 0x1)
FName EditorSaveDirectoryName;
// 0x00D4 (size: 0x8)
float autoSaveSpan;
// 0x00DC (size: 0x4)
bool autoSaveEnable;
// 0x00E0 (size: 0x1)
bool bAutoSetTruePalMainStats;
// 0x00E1 (size: 0x1)
FPalDataTableRowName_GameProgressPreset PlayerDefaultPreset;
// 0x00E4 (size: 0x8)
int32 PlayerLevel;
// 0x00EC (size: 0x4)
int32 ForceFixLevelForWildPal;
// 0x00F0 (size: 0x4)
int32 ForceFixTalent;
// 0x00F4 (size: 0x4)
TArray<FPalDebugOtomoPalInfo> DefaultOtomoPal;
// 0x00F8 (size: 0x10)
TArray<FPalDebugPalCaptureInfo> DefaultCapturePalInfos;
// 0x0108 (size: 0x10)
int32 DefaultCapturePalRandomNum;
// 0x0118 (size: 0x4)
TArray<FPalDebugItemCreateInfo> DefaultItem;
// 0x0120 (size: 0x10)
TArray<FPalDebugItemCreateInfo> DefaultLoadoutItem;
// 0x0130 (size: 0x10)
int32 PlayStart_PalWorldTime;
// 0x0140 (size: 0x4)
float DebugRate_PalWorldTime;
// 0x0144 (size: 0x4)
bool bIgnoreOverWeightMove;
// 0x0148 (size: 0x1)
bool bIsDisableReticleShoot;
// 0x0149 (size: 0x1)
bool bEquipDefaultWeapon;
// 0x014A (size: 0x1)
bool bGetAllBulletItems;
// 0x014B (size: 0x1)
bool bIgnoreItemDurabilityDecrease;
// 0x014C (size: 0x1)
bool bNotConsumeMaterialsInRepair;
// 0x014D (size: 0x1)
bool bIsMutekiALL;
// 0x014E (size: 0x1)
bool bIsMutekiForPlayer;
// 0x014F (size: 0x1)
bool bIsMutekiForFriend;
// 0x0150 (size: 0x1)
bool bDisableDeathPenalty;
// 0x0151 (size: 0x1)
bool bIgnoreRespawnTimer;
// 0x0152 (size: 0x1)
bool bIsDisableDyingCountdown;
// 0x0153 (size: 0x1)
bool bIsFixedSP;
// 0x0154 (size: 0x1)
bool bDisiablePlayerShield;
// 0x0155 (size: 0x1)
bool bIsFullPowerForPlayer;
// 0x0156 (size: 0x1)
bool bIsCaptureSuccessAlways;
// 0x0157 (size: 0x1)
bool bIsCaptureFailAlways_BounceBall;
// 0x0158 (size: 0x1)
bool bIsShowActionName;
// 0x0159 (size: 0x1)
bool bIsShowCharacterStatus;
// 0x015A (size: 0x1)
bool bIsShowCharacterTickInfo;
// 0x015B (size: 0x1)
bool bIsWazaCoolTimeFast;
// 0x015C (size: 0x1)
bool bIsShowUseRootMotion;
// 0x015D (size: 0x1)
bool bIsEnableClimbing;
// 0x015E (size: 0x1)
bool bIsDisableFallDamage;
// 0x015F (size: 0x1)
bool bIsShowPlayerFallHeight;
// 0x0160 (size: 0x1)
bool bIsShowGroundObjectName;
// 0x0161 (size: 0x1)
bool bIsShowForwardObjectName;
// 0x0162 (size: 0x1)
bool bDisableStatus_Darkness;
// 0x0163 (size: 0x1)
bool bIsIgnoreBuildRestrictionBaseCamp;
// 0x0164 (size: 0x1)
EPalMovementSpeedType ConfirmTransportItemBaseSpeedType;
// 0x0165 (size: 0x1)
float ConfirmTransportItemSpeedMultipleRate;
// 0x0168 (size: 0x4)
bool bNotConsumeMaterialsInBuild;
// 0x016C (size: 0x1)
float BuildRequiredWorkAmount;
// 0x0170 (size: 0x4)
bool bIsDisableEnemyEyeSight;
// 0x0174 (size: 0x1)
bool bIsEnableNPCDrawRaycastDebug;
// 0x0175 (size: 0x1)
bool bIsHideScreenMessage;
// 0x0176 (size: 0x1)
bool bIsHungerDisable;
// 0x0177 (size: 0x1)
bool bIsAllRecipeUnlock;
// 0x0178 (size: 0x1)
bool bNotDecreaseWeaponItem;
// 0x0179 (size: 0x1)
bool bNotRequiredBulletWhenReload;
// 0x017A (size: 0x1)
bool bShowReticleLocation;
// 0x017B (size: 0x1)
bool bShowAutoAimInfo;
// 0x017C (size: 0x1)
bool bIsEnableMouseAutoAim;
// 0x017D (size: 0x1)
float MouseSensitivityRate;
// 0x0180 (size: 0x4)
int32 CaptureFPS;
// 0x0184 (size: 0x4)
bool bIsDisableDropItem;
// 0x0188 (size: 0x1)
bool bShowDropItemHitEvent;
// 0x0189 (size: 0x1)
bool bPrintLogGroupsWhenGroupOperated;
// 0x018A (size: 0x1)
bool bIsSoundRangeVisual;
// 0x018B (size: 0x1)
bool bIsToggleHUDWhenEject;
// 0x018C (size: 0x1)
bool bIsLookAtDisable;
// 0x018D (size: 0x1)
bool bPalBoxInLevelBelongingToServerPlayer;
// 0x018E (size: 0x1)
bool bCreateGameInstanceViewActor;
// 0x018F (size: 0x1)
bool bIsFixedLightingControllerTime;
// 0x0190 (size: 0x1)
float LightingControllerTimeIfFixed;
// 0x0194 (size: 0x4)
bool bIsShowFloorLocation;
// 0x0198 (size: 0x1)
bool bIsShowGroundTilt;
// 0x0199 (size: 0x1)
bool bIsDisableShiftKey;
// 0x019A (size: 0x1)
bool IsSpawnAlwaysFromSpawner;
// 0x019B (size: 0x1)
bool IsDisableSpawner;
// 0x019C (size: 0x1)
float OverrideSpawnRadius;
// 0x01A0 (size: 0x4)
float OverrideDespawnRadius;
// 0x01A4 (size: 0x4)
bool bIsPlayerCompleteSTEALTH;
// 0x01A8 (size: 0x1)
bool bIsShowEnemyHate;
// 0x01A9 (size: 0x1)
bool bIsShowEnemyHateArrow;
// 0x01AA (size: 0x1)
bool bIsShowTargetLocalPlayerList;
// 0x01AB (size: 0x1)
bool bIsShowMovementMode;
// 0x01AC (size: 0x1)
bool bIsShowOrganization;
// 0x01AD (size: 0x1)
bool bCanAccessToOtherGuildMapObject;
// 0x01AE (size: 0x1)
bool bFirstBuildPalBox;
// 0x01AF (size: 0x1)
float WorkExtraRate;
// 0x01B0 (size: 0x4)
bool bIsDisableFootIK;
// 0x01B4 (size: 0x1)
bool bBuildInstallCheckLookToCamera;
// 0x01B5 (size: 0x1)
bool bBuildFXDebugLog;
// 0x01B6 (size: 0x1)
bool bDamageTextStack;
// 0x01B7 (size: 0x1)
bool bFootStepNotify_DebugDisplay;
// 0x01B8 (size: 0x1)
bool bSkipBossCutscene;
// 0x01B9 (size: 0x1)
bool bShowRangeDistributeExpAround;
// 0x01BA (size: 0x1)
bool bNotDropOtomoAtPlayerDeath;
// 0x01BB (size: 0x1)
bool bNotDropItemsAtPlayerDeath;
// 0x01BC (size: 0x1)
bool bEnableDebugMoveSpeed;
// 0x01BD (size: 0x1)
bool bForceToggleDash;
// 0x01BE (size: 0x1)
bool bDebugAutoRun;
// 0x01BF (size: 0x1)
bool bDrawPlayerInDoor;
// 0x01C0 (size: 0x1)
int32 PlayerPalStoragePage;
// 0x01C4 (size: 0x4)
bool ShowPlayerMoveSpeed;
// 0x01C8 (size: 0x1)
bool bSwimming_DebugDisplay;
// 0x01C9 (size: 0x1)
bool bSwimming_NoDecreaseSP;
// 0x01CA (size: 0x1)
bool bPartnerSkill_DebugDisplay;
// 0x01CB (size: 0x1)
bool bPartnerSkill_NoDecrease;
// 0x01CC (size: 0x1)
float PartnerSkill_CooldownSpeedRate;
// 0x01D0 (size: 0x4)
bool PartnerSkill_IgnoreRestrictedByItems;
// 0x01D4 (size: 0x1)
bool bNotConsumeMaterialsInCraft;
// 0x01D5 (size: 0x1)
bool bSelectableRecipeWhenNothingMaterials;
// 0x01D6 (size: 0x1)
bool bIgnoreWorkableElementType;
// 0x01D7 (size: 0x1)
bool bIgnoreWorkableGenusCategories;
// 0x01D8 (size: 0x1)
bool bShowDebugWorkAssign;
// 0x01D9 (size: 0x1)
bool bShowDebugWorkAssignTarget;
// 0x01DA (size: 0x1)
bool bForceRunInWork;
// 0x01DB (size: 0x1)
bool bContinueSpeedInTransportWork;
// 0x01DC (size: 0x1)
bool bNotInterruptTransportingWork;
// 0x01DD (size: 0x1)
bool bPrintLogWorkerEventDetail;
// 0x01DE (size: 0x1)
float BaseCampWorkerEventTriggerInterval;
// 0x01E0 (size: 0x4)
bool IgnoreBaseCampTask;
// 0x01E4 (size: 0x1)
bool bBaseCampSpawnLevelMax;
// 0x01E5 (size: 0x1)
bool bBaseCampWorkerSanityDetail;
// 0x01E6 (size: 0x1)
float BaseCampWorkerEatTime;
// 0x01E8 (size: 0x4)
bool bBaseCampShowCannotTransportTarget;
// 0x01EC (size: 0x1)
FPalArrowSettings BaseCampCannotTransportTargetArrowSettings;
// 0x01F0 (size: 0xC)
bool bBaseCampMoveModeTeleportForce;
// 0x01FC (size: 0x1)
int32 fallBackDefense;
// 0x0200 (size: 0x4)
bool bDebugLogWorldSecurity;
// 0x0204 (size: 0x1)
bool bDebugLogEnableCriminal;
// 0x0205 (size: 0x1)
bool bDebugLogEnableWanted;
// 0x0206 (size: 0x1)
bool bDebugLogEnableCriminalPlayer;
// 0x0207 (size: 0x1)
bool bShowDebugWantedSpawnerSphere;
// 0x0208 (size: 0x1)
bool bTransportGrantedMonsterToPalBox;
// 0x0209 (size: 0x1)
bool bInvaderDisable;
// 0x020A (size: 0x1)
float DebugSpawnWildPal_DistanceFromPlayer;
// 0x020C (size: 0x4)
EPalStatusID DebugAddStatus;
// 0x0210 (size: 0x1)
bool bIsDisplayDebug_PassiveSkill;
// 0x0211 (size: 0x1)
bool bShowPassiveSkillStatus;
// 0x0212 (size: 0x1)
float ShowPassiveSkillStatusRange;
// 0x0214 (size: 0x4)
bool bIgnorePalPassiveSkill;
// 0x0218 (size: 0x1)
TArray<FPalDataTableRowName_PassiveSkillData> PalPassiveSkillOverride;
// 0x0220 (size: 0x10)
bool bGrantPassiveSkillAlways;
// 0x0230 (size: 0x1)
TMap<class FPalDataTableRowName_PalMonsterData, class
FPalDebugAttachPassiveSkillInfo> PassiveSkill_AttachSkill; // 0x0238 (size: 0x50)
bool bPassiveSkill_CollectItem_10Sec;
// 0x0288 (size: 0x1)
bool bPassiveSkill_LifeSteal_DisplayRecoverHp;
// 0x0289 (size: 0x1)
bool bLogMapObjectFailedSpawn;
// 0x028A (size: 0x1)
bool bShowMapObjectStatus;
// 0x028B (size: 0x1)
bool bShowMapObjectFoliageStatus;
// 0x028C (size: 0x1)
float ShowMapObjectStatusRange;
// 0x0290 (size: 0x4)
bool bDisablePalFoliageComponentBeginPlay;
// 0x0294 (size: 0x1)
bool bShowMapObjectSpawnerStatus;
// 0x0295 (size: 0x1)
bool bDisableMapObjectEffect;
// 0x0296 (size: 0x1)
bool bDrawDetectMapObjectInDoor;
// 0x0297 (size: 0x1)
bool bCanDamageToMapObjectFromSameGroup;
// 0x0298 (size: 0x1)
int32 MapObjectHpOverride;
// 0x029C (size: 0x4)
float FoliageRespawnIntervalOverrideSeconds;
// 0x02A0 (size: 0x4)
bool bVisibleFoliageChunk;
// 0x02A4 (size: 0x1)
bool bShowPalEggStatus;
// 0x02A5 (size: 0x1)
float ShowPalEggStatusRange;
// 0x02A8 (size: 0x4)
bool bIsHideAllHUD;
// 0x02AC (size: 0x1)
bool bIsNowHUDHide;
// 0x02AD (size: 0x1)
bool bForceCreateDispatchParameterByHUDService;
// 0x02AE (size: 0x1)
bool bShowDebugMapIcon;
// 0x02AF (size: 0x1)
bool bIsHideUIForPV;
// 0x02B0 (size: 0x1)
bool bIsCompletePaldex;
// 0x02B1 (size: 0x1)
bool bUseFixedPositionPlayerUI;
// 0x02B2 (size: 0x1)
bool bForceShowHPGauge;
// 0x02B3 (size: 0x1)
bool bIsFixedRandomSeed;
// 0x02B4 (size: 0x1)
int32 actionRandomSeed;
// 0x02B8 (size: 0x4)
bool bAvailableBuildObjectInDevelop;
// 0x02BC (size: 0x1)
bool bShowBuildObjectInstallCheck;
// 0x02BD (size: 0x1)
TArray<EPalMapObjectOperationResult> IgnoreInstallErrors;
// 0x02C0 (size: 0x10)
bool bDrawDebugInstallConnection;
// 0x02D0 (size: 0x1)
bool bUseEagleForGlider;
// 0x02D1 (size: 0x1)
bool bEquipDefaultGlider;
// 0x02D2 (size: 0x1)
float ExtraHpRegenRateInSleepingBed;
// 0x02D4 (size: 0x4)
bool bForceDisableLamp;
// 0x02D8 (size: 0x1)
bool bForceDisableTimerLight;
// 0x02D9 (size: 0x1)
bool bForceDisableTickOptimization;
// 0x02DA (size: 0x1)
bool bForceDisableDamagePopup;
// 0x02DB (size: 0x1)
bool bIsShowTickOptimizationType;
// 0x02DC (size: 0x1)
bool bIgnoreFastTravelLock;
// 0x02DD (size: 0x1)
TMap<EPalAudioBus, float> AudioBusVolumes;
// 0x02E0 (size: 0x50)
TMap<class EPalAudioBus, class bool> AudioBusMute;
// 0x0330 (size: 0x50)
bool bIsShowPostAkEvent;
// 0x0380 (size: 0x1)
TSubclassOf<class APalSoundDebugModel> SoundDebugModelClass;
// 0x0388 (size: 0x8)
bool bIsMuteForPlayerSoundOnly;
// 0x0390 (size: 0x1)
bool bDisplayPlaySoundId;
// 0x0391 (size: 0x1)
bool bPlayFootStepSound;
// 0x0392 (size: 0x1)
TArray<FName> IgnoreSoundIds;
// 0x0398 (size: 0x10)
bool bIsSpawnFootStepEffect;
// 0x03A8 (size: 0x1)
bool bIsDisableCameraPitchLimit;
// 0x03A9 (size: 0x1)
bool bIsIgnoreNetworkVersionCompatible;
// 0x03AA (size: 0x1)
bool bIsUseClientOtomoSetting;
// 0x03AB (size: 0x1)
TArray<FPalDebugOtomoPalInfo> DefaultOtomoPalForClient;
// 0x03B0 (size: 0x10)
bool bIsForcedSynchronizedMapObject;
// 0x03C0 (size: 0x1)
bool bEnableCharacterCountInServer;
// 0x03C1 (size: 0x1)
bool bUseDedicatedServerOptimizeInListenServer;
// 0x03C2 (size: 0x1)
bool bIsDisableInitRandomCharacterMake;
// 0x03C3 (size: 0x1)
bool bForceSpawnTreasureBox;
// 0x03C4 (size: 0x1)
bool bForceSpawnEnemyCamp;
// 0x03C5 (size: 0x1)
bool bForceSpawnPalEgg;
// 0x03C6 (size: 0x1)
bool bForceSpawnRarePal;
// 0x03C7 (size: 0x1)
bool IgnoreAudio;
// 0x03C8 (size: 0x1)
bool bIsShowAudioSoundPlayer;
// 0x03C9 (size: 0x1)
bool bForceSpawnRandomIncident;
// 0x03CA (size: 0x1)
bool bForceDisableSpawnRandomIncident;
// 0x03CB (size: 0x1)
FString ForceSpawnRandomIncidentName;
// 0x03D0 (size: 0x10)
bool bShowRandomIncidentSpawnArea;
// 0x03E0 (size: 0x1)
bool bShowRandomIncidentEndArea;
// 0x03E1 (size: 0x1)
bool bShowRandomIncidentExcludeArea;
// 0x03E2 (size: 0x1)
bool bInvadeSetting_Override;
// 0x03E3 (size: 0x1)
float InvadeProbability_Override;
// 0x03E4 (size: 0x4)
int32 InvadeOccurablePlayerLevel_Override;
// 0x03E8 (size: 0x4)
FString ForceOccurInvaderName;
// 0x03F0 (size: 0x10)
EPalBiomeType Biome_Override;
// 0x0400 (size: 0x1)
int32 InvadeJudgmentInterval_Minutes_Override;
// 0x0404 (size: 0x4)
int32 InvadeCollTime_Max_Minutes_Override;
// 0x0408 (size: 0x4)
int32 InvadeCollTime_Min_Minutes_Override;
// 0x040C (size: 0x4)
int32 InvadeReturnTime_Minutes_Override;
// 0x0410 (size: 0x4)
int32 InvadeStartPoint_BaseCampRadius_Min_cm_Override;
// 0x0414 (size: 0x4)
int32 InvadeStartPoint_BaseCampRadius_Max_cm_Override;
// 0x0418 (size: 0x4)
float VisitorNPCProbability_Override;
// 0x041C (size: 0x4)
FString ForceOccurVisitorNPCName;
// 0x0420 (size: 0x10)
int32 VisitorNPCReturnTime_Minutes_Override;
// 0x0430 (size: 0x4)
bool bIsDisableCrossKeyQuickSwitch;
// 0x0434 (size: 0x1)
bool bIsEnableAirRolling;
// 0x0435 (size: 0x1)
bool bIsEnablePalWarp;
// 0x0436 (size: 0x1)
bool bDungeonDevelopFlag;
// 0x0437 (size: 0x1)
bool bIsDisableOptionWorldLoadConfig;
// 0x0438 (size: 0x1)
bool bIsShowNightSkipLog;
// 0x0439 (size: 0x1)
bool bIsApplyOptionWorldModePreset;
// 0x043A (size: 0x1)
bool bShowAnimRateScale;
// 0x043B (size: 0x1)
float ShowAnimRateScaleRange;
// 0x043C (size: 0x4)
bool bIsParallelForUpdateActiveTiles;
// 0x0440 (size: 0x1)
bool bIsDisablePlayerTeleportTimeout;
// 0x0441 (size: 0x1)
bool bUseMalePlayer;
// 0x0442 (size: 0x1)
bool bEnableLoadingScreen;
// 0x0443 (size: 0x1)
FPalDebugSettingOnLoadingScreenVisibilityChanged
OnLoadingScreenVisibilityChanged; // 0x0448 (size: 0x10)
void OnLoadingScreenVisibilityChangedDelegate(bool Visible);
bool bIsSkipCharacterMake;
// 0x0458 (size: 0x1)
bool bDrawHitCollision;
// 0x0459 (size: 0x1)
bool bDisableGrapplingCoolDown;
// 0x045A (size: 0x1)
bool bDrawGrapplingLine;
// 0x045B (size: 0x1)
bool bDrawGrapplingHitPoint;
// 0x045C (size: 0x1)
bool bDrawAmbientSoundLinePlayLocation;
// 0x045D (size: 0x1)
bool bDrawAmbientSoundActivateTrigger;
// 0x045E (size: 0x1)
bool bDrawDefenseAttackableRange;
// 0x045F (size: 0x1)
bool bShowDefenseAttackTarget;
// 0x0460 (size: 0x1)
float ShowDefenseRange;
// 0x0464 (size: 0x4)
float WorldPartitionLoadCheckRange;
// 0x0468 (size: 0x4)
bool WorldPartitionLoadActivatedCheck;
// 0x046C (size: 0x1)
bool bDisableInteractRecicleTarget;
// 0x046D (size: 0x1)
bool bShowStageDeathPenaltyLocation;
// 0x046E (size: 0x1)
bool bForceLocationTeleport;
// 0x046F (size: 0x1)
bool bShowInvaderDeubgLog;
// 0x0470 (size: 0x1)
}; // Size: 0x478
class UPalDebugWindowSetting : public UDataAsset

{
TArray<FString> PriorityFunctions;
// 0x0030 (size: 0x10)
}; // Size: 0x40
class UPalDefine : public UBlueprintFunctionLibrary

{
FGameplayTag UILayerTag_Modal();
FGameplayTag UILayerTag_Menu();
FGameplayTag UILayerTag_GameMenu7();
FGameplayTag UILayerTag_GameMenu();
FGameplayTag UILayerTag_Game();
FName TextId_UICommon_SystemMessageUnlockFastTravel();
FName TextId_UICommon_SystemErrorCantMoveNotOwned();
FName TextId_UICommon_LOG_NeedItemToOpenTreasureBox();
FName TextId_UICommon_LOG_ConsumeItem();
FName TextId_UICommon_InteractIndicator_InputPassword_CannotTry();
FName TextId_UICommon_InteractIndicator_ConsumeAndOpen();
FName TextId_UICommon_INFINITE();
FName TextId_UICommon_DISMANTLING_FAILED_PALBOX();
FName TextId_UICommon_DISMANTLING_CONFIRM_PALBOX();
FName TextId_UICommon_CONFIRM_DUNGEON_EXIT();
FName TextId_UICommon_CONFIRM_DUNGEON_ENTER();
FName StatusPointName_AddWorkSpeed();
FName StatusPointName_AddPower();
FName StatusPointName_AddMaxSP();
FName StatusPointName_AddMaxInventoryWeight();
FName StatusPointName_AddMaxHP();
FName StatusPointName_AddCaptureLevel();
FName StaticItemID_UnlockLantern();
FName StaticItemID_UnlockAutoMeal_Tier(int32 Num);
FName StaticItemID_Money();
FName Socket_Mouth();
FName Socket_JumpEffect();
FName Socket_EquipWeapon3();
FName Socket_BulletMuzzle();
FName Socket_BodyCenter();
FName NP_PlayerCenterPosition();
FName MS_HumanHeadName();
FName MS_HumanHairName();
FName MS_HumanEyeName();
FName MS_HumanClothName();
FName MS_HumanBrowName();
FName MS_HumanBodyName();
FName MP_TorsoNormalMinIntensityName();
FName MP_TorsoNormalMaxIntensityName();
FName MP_PalLitBaseColorName();
FName MP_LegNormalMinIntensityName();
FName MP_LegNormalMaxIntensityName();
FName MP_CharacterMakeSubsurfaceColorName();
FName MP_CharacterMakeBaseColorSaturationName();
FName MP_CharacterMakeBaseColorHueName();
FName MP_CharacterMakeBaseColorBrightnessName();
FName MP_ArmNormalMinIntensityName();
FName MP_ArmNormalMaxIntensityName();
FName FlagName_OverWeightInventory();
FName FlagName_DebugBotGuildName();
FName FlagName_CameraOffsetInLiftup();
FName DecreaseSanityRate_WorkHard();
FName DecreaseFullStomachRate_WorkHard();
FName DecreaseFullStomachRate_Work();
FName BS_TorsoArmMinName();
FName BS_TorsoArmMaxName();
FName BS_LegArmMinName();
FName BS_LegArmMaxName();
FName BS_BodyArmMinName();
FName BS_BodyArmMaxName();
FName ActionNotify_MiningImpactTiming();
FName ActionNotify_MiningEndTiming();
FName ActionBBKey_FeedItem();
}; // Size: 0x28
class UPalDialogParameterBase : public UPalHUDDispatchParameterBase

{
EPalDialogType DialogType;
// 0x0038 (size: 0x1)
FText Message;
// 0x0040 (size: 0x18)
FPalDialogParameterBaseCallback Callback;
// 0x0058 (size: 0x10)
void PalDialogBoolCallback(bool bResult);
FPalDialogParameterBaseCallbackWithParameter CallbackWithParameter;
// 0x0068 (size: 0x10)
void PalDialogCallback(bool bResult, class UPalDialogParameterBase* Parameter);
bool IsCloseWhenDamaged;
// 0x0078 (size: 0x1)
bool IsEnableShortcutConfirmInput;
// 0x0079 (size: 0x1)
void InvokeCallback(const bool bResult);

}; // Size: 0x80
class UPalDialogParameterDialog : public UPalDialogParameterBase
{
bool bDefaultNegative;
// 0x0080 (size: 0x1)
void SetParameters(const FText InMessage, const EPalDialogType InDialogType,

const bool bInNegativeDefault);
}; // Size: 0x88
class UPalDialogParameter_RequestJoinGuild : public UPalDialogParameterDialog

{
FGuid RequestPlayerUId;
// 0x0088 (size: 0x10)
FPalInstanceID RequestPlayerInstanceId;
// 0x0098 (size: 0x30)
FGuid TargetPlayerUId;
// 0x00C8 (size: 0x10)
FPalInstanceID TargetPlayerInstanceId;
// 0x00D8 (size: 0x30)
}; // Size: 0x108
class UPalDialogParameter_RequestMapObjectDismantle : public

UPalDialogParameterDialog
{
// 0x0088 (size: 0x10)
}; // Size: 0x98
class UPalDungeonDefines : public UObject

{
}; // Size: 0x28
class UPalDungeonInfoParameterUtility : public UObject

{
float CalcDisappearRemainSeconds(const class UObject* WorldContextObject, const

FPalDungeonInfoParameter& InParameter);
}; // Size: 0x28
class UPalDungeonInstanceModel : public UObject

{
FPalDungeonInstanceModelOnChangeInstanceStatusDelegate
OnChangeInstanceStatusDelegate; // 0x0060 (size: 0x10)
void ReturnSelfDelegate(class UPalDungeonInstanceModel* Self);
FGuid DungeonInstanceId;
// 0x0070 (size: 0x10)
// 0x0080 (size: 0x10)
FName DungeonSpawnAreaId;
// 0x0090 (size: 0x8)
FName DungeonLevelName;
// 0x0098 (size: 0x8)
FName OverrideDungeonNameTextId;
// 0x00A0 (size: 0x8)
FVector_NetQuantize RepFieldWarpPointLocation;
// 0x00A8 (size: 0x18)
FTransform FieldWarpPointTransform;
// 0x00C0 (size: 0x60)
FTransform StartPointTransform;
// 0x0120 (size: 0x60)
FTransform DeadItemDropTransform;
// 0x0180 (size: 0x60)
// 0x01E0 (size: 0x1)
FName EnemySpawner_Boss_RowName;
// 0x01E4 (size: 0x8)
TSoftClassPtr<APalNPCSpawnerBase> EnemySpawnerClass_Boss;
// 0x01F0 (size: 0x30)
FGameDateTime DisappearTimeAt;
// 0x0220 (size: 0x8)
int32 Level;
// 0x0228 (size: 0x4)
// 0x022C (size: 0x14)
TArray<FPalMapObjectSaveData> MapObjectSaveDataArray;
// 0x0240 (size: 0x10)
int32 ReservedDataLayerAssetIndex;
// 0x0250 (size: 0x4)
// 0x0258 (size: 0x8)
void ReturnSelfDelegate__DelegateSignature(class UPalDungeonInstanceModel*

Self);
void OnUpdateBossState();
void OnSpawnedCharacter_ServerInternal(class UPalIndividualCharacterHandle*
IndividualHandle);
void OnRep_DisappearTimeAt();
void OnRep_BossState();
void OnDeadBoss_ServerInternal(FPalDeadInfo DeadInfo);
void OnChangeInstanceStatus();
void OnCapturedBoss_ServerInternal(class APalCharacter* Character, class
APalCharacter* Attacker);
int32 GetLevel();
FName GetDungeonSpawnAreaId();
FText GetDungeonNameText();
FGameDateTime GetDisappearTimeAt();
EPalDungeonInstanceBossState GetBossState();
float CalcRemainSecondsBy(const class UObject* WorldContextObject, const
FGameDateTime& TimeAt);
float CalcDisappearRemainSeconds(const class UObject* WorldContextObject, const
FGameDateTime& InDisappearTimeAt);
}; // Size: 0x270
class UPalDungeonInstanceModelFixedDungeon : public UPalDungeonInstanceModel

{
FGameDateTime RespawnBossTimeAt;
// 0x0268 (size: 0x8)
FGameDateTime GetRespawnBossTimeAt();
}; // Size: 0x270
class UPalDungeonLevelDataAsset : public UDataAsset

{
FBox LevelBounds;
// 0x0030 (size: 0x38)
}; // Size: 0x68
class UPalDungeonSpawnerDataAsset : public UDataAsset

{
TArray<FName> SpawnerPatternNames;
// 0x0030 (size: 0x10)
}; // Size: 0x40
class UPalDungeonWorldSubsystem : public UPalWorldSubsystem

{
TMap<class FGuid, class FPalDungeonMarkerPointData> MarkerPointDataMap;
// 0x0080 (size: 0x50)
TMap<class FGuid, class UPalDungeonInstanceModel*> InstanceModelMap;
// 0x00D0 (size: 0x50)
FVector DungeonMargin;
// 0x0120 (size: 0x18)
float TickInterval;
// 0x0138 (size: 0x4)
TMap<class FName, class FPalDungeonDataLayerAssetSet> DataLayerAssetMap;
// 0x0140 (size: 0x50)
TArray<class APalDungeonPointMarker*> PointMarkersWaitSystemInitializeInServer;
// 0x0190 (size: 0x10)
bool bInitializedWithSaveData;
// 0x01A0 (size: 0x1)
bool TryGetDungeonInfo(const FPalStageInstanceId& StageInstanceId,

FPalDungeonInfoParameter& OutInfo);
FGuid Debug_GetDungeonInstanceIdByIndex(const int32 Index);
}; // Size: 0x1A8
class UPalDynamicArmorItemDataBase : public UPalDynamicItemDataBase

{
float Durability;
// 0x0070 (size: 0x4)
float MaxDurability;
// 0x0074 (size: 0x4)
float OldDurability;
// 0x0078 (size: 0x4)
// 0x0080 (size: 0x10)

void OnRep_Durability();
void DeleteAllPassive();
bool ChangePassiveSkill(int32 passiveIndex, FName SkillName);
bool AddPassiveSkill(FName SkillName);
}; // Size: 0xA8
class UPalDynamicItemDataBase : public UObject

{
FPalDynamicItemId ID;
// 0x0040 (size: 0x20)
FName StaticId;
// 0x0060 (size: 0x8)
FName GetStaticId();
FPalDynamicItemId GetId();
}; // Size: 0x68
class UPalDynamicItemDataManager : public UObject

{
FPalDynamicItemDataManagerOnCreateItemInServerDelegate
OnCreateItemInServerDelegate; // 0x0038 (size: 0x10)
void CreateItemDelegate(class UPalDynamicItemDataBase* CreatedItemData, const
FPalItemCreateParameter& CreateParameter);
TMap<class FPalDynamicItemId, class UPalDynamicItemDataBase*>
ItemDynamicDataMap; // 0x0048 (size: 0x50)
float DisposeReservedDynamicItemRemainingTime;
// 0x0098 (size: 0x4)
int32 DynamicItemDisposeReserveCount;
// 0x00B0 (size: 0x4)
TMap<class FGuid, class FPalDynamicItemDisposeWaitNotifyInfo>
DisposeDynamicItemIdRequestWaitInfoMap_ServerInternal; // 0x00B8 (size: 0x50)
}; // Size: 0x110
class UPalDynamicItemWorldSubsystem : public UPalWorldSubsystem

{
TMap<class FPalDynamicItemId, class UPalDynamicItemDataBase*>
DynamicItemDataMap_InServer; // 0x0090 (size: 0x50)
TMap<class FPalDynamicItemId, class FPalDynamicItemInfo>
WeakDynamicItemDataMap_InClient; // 0x00E0 (size: 0x50)
TArray<class UPalDynamicItemDataBase*> DynamicItemDataCache_InClient;
// 0x0130 (size: 0x10)
}; // Size: 0x140
class UPalDynamicPalEggItemDataBase : public UPalDynamicItemDataBase

{
FName CharacterID;
// 0x0068 (size: 0x8)
// 0x0070 (size: 0x218)
}; // Size: 0x288
class UPalDynamicWeaponItemDataBase : public UPalDynamicItemDataBase

{
float Durability;
// 0x0070 (size: 0x4)
float MaxDurability;
// 0x0074 (size: 0x4)
float OldDurability;
// 0x0078 (size: 0x4)
int32 RemainingBullets;
// 0x007C (size: 0x4)
// 0x0080 (size: 0x10)
int32 UseBullets(int32 useNum);

bool UseBullet();
void SetBulletsNum(int32 bulletsNum);
void OnRep_Durability();
bool IsEmptyMagazine();
int32 GetRemainingBulletsNum();
void DeleteAllPassive();
bool ChangePassiveSkill(int32 passiveIndex, FName SkillName);
bool AddPassiveSkill(FName SkillName);
}; // Size: 0xA8
class UPalEditorNpcMultiTalkDataUtility : public UBlueprintFunctionLibrary

{
}; // Size: 0x28
class UPalEditorSetting : public UObject

{
FSoftObjectPath ItemDataTableAssetPath;
// 0x0028 (size: 0x20)
FSoftObjectPath PalMonsterDataTableAssetPath;
// 0x0048 (size: 0x20)
FSoftObjectPath PalHumanDataTableAssetPath;
// 0x0068 (size: 0x20)
FSoftObjectPath MapObjectDataTableAssetPath;
// 0x0088 (size: 0x20)
FSoftObjectPath FarmCropDataTableAssetPath;
// 0x00A8 (size: 0x20)
FSoftObjectPath CrimeMasterDataTableAssetPath;
// 0x00C8 (size: 0x20)
FSoftObjectPath PassiveSkillDataTableAssetPath;
// 0x00E8 (size: 0x20)
FSoftObjectPath ItemProductDataTableAssetPath;
// 0x0108 (size: 0x20)
FSoftObjectPath NPCUniqueDataTableAssetPath;
// 0x0128 (size: 0x20)
FSoftObjectPath RecipeTechnologyDataTableAssetPath;
// 0x0148 (size: 0x20)
FSoftObjectPath BaseCampWorkerEventDataTableAssetPath;
// 0x0168 (size: 0x20)
FSoftObjectPath UIInputActionTableAssetPath;
// 0x0188 (size: 0x20)
FSoftObjectPath SoundIDTableAssetPath;
// 0x01A8 (size: 0x20)
FSoftObjectPath ItemShopCreateDataTableAssetPath;
// 0x01C8 (size: 0x20)
FSoftObjectPath ItemShopLotteryDataTableAssetPath;
// 0x01E8 (size: 0x20)
FSoftObjectPath PalShopCreateDataTableAssetPath;
// 0x0208 (size: 0x20)
FSoftObjectPath DungeonSpawnAreaDataTableAssetPath;
// 0x0228 (size: 0x20)
FSoftObjectPath FieldLotteryNameDataTableAssetPath;
// 0x0248 (size: 0x20)
FSoftObjectPath NoteDataTableAssetPath;
// 0x0268 (size: 0x20)
FSoftObjectPath GameProgressPresetTableAssetPath;
// 0x0288 (size: 0x20)
}; // Size: 0x2A8
class UPalEditorTalkTreeDataTable : public UObject
{
}; // Size: 0x28
class UPalEditorTalkTreeDataUtility : public UBlueprintFunctionLibrary

{
}; // Size: 0x28
class UPalEnergyTypeUtility : public UBlueprintFunctionLibrary

{
void CollectWorkableElementTypes(const EPalEnergyType EnergyType,

TArray<EPalElementType>& ElementTypes);
}; // Size: 0x28
class UPalEquipItemContainerUtility : public UBlueprintFunctionLibrary

{
}; // Size: 0x28
class UPalEquipWeaponShooterComponent : public UActorComponent

{
TMap<class EPalMonsterEquipWeaponSocketType, class FPalEquipWeaponInfo>
SpawnedWeaponInfoMap; // 0x00A0 (size: 0x50)
void SetWeapon_ForDebug_DirectBP(EPalMonsterEquipWeaponSocketType SocketType,

TSubclassOf<class APalMonsterEquipWeaponBase> WeaponActorClass);
void SetWeapon_ForDebug(EPalMonsterEquipWeaponSocketType SocketType, FName
ItemName);
void PullTrigger();
}; // Size: 0xF0
class UPalEventNotifyBase : public UObject

{
}; // Size: 0x28
class UPalEventNotifySystem : public UPalWorldSubsystem

{
TArray<class TSubclassOf<UPalEventNotifyBase>> EventNotifyClassArray;
// 0x0070 (size: 0x10)
TMap<class TSubclassOf<UPalEventNotifyBase>, class UPalEventNotifyBase*>
EventNotifyMap; // 0x0080 (size: 0x50)
class UPalEventNotifyBase* GetEventNotify(TSubclassOf<class

UPalEventNotifyBase> Class);
}; // Size: 0xD0
class UPalEventNotifySystem_Concrete : public UBlueprintFunctionLibrary

{
}; // Size: 0x28
class UPalEventNotify_Area : public UPalEventNotifyBase

{
FPalEventNotify_AreaOnNotifyEventBeginInvasionInServer
OnNotifyEventBeginInvasionInServer; // 0x0028 (size: 0x10)
void PalEventNotifyCharacterInvasionDelegate(class AActor* InvasionActor, const
FGuid& AreaInstanceId);
FPalEventNotify_AreaOnNotifyEventEndInvasionInServer
OnNotifyEventEndInvasionInServer; // 0x0038 (size: 0x10)
void PalEventNotifyCharacterInvasionDelegate(class AActor* InvasionActor, const
FGuid& AreaInstanceId);
void OnRegiterdArea_ServerInternal(class APalTriggerAreaBase* TriggerBase);

void OnEndAreaInvasion_ServerInternal(class AActor* HitActor, const FGuid&
AreaInstanceId);
void OnBeginAreaInvasion_ServerInternal(class AActor* HitActor, const FGuid&
AreaInstanceId);
class UPalEventNotify_Area* GetEventNotify_Area(const class UObject*
}; // Size: 0x48
class UPalEventNotify_Character : public UPalEventNotifyBase

{
FPalEventNotify_CharacterOnNotifyEventDamagedInServer
OnNotifyEventDamagedInServer; // 0x0028 (size: 0x10)
void PalEventNotifyCharacterDamagedDelegate(const FPalDamageResult&
DamageResult);
FPalEventNotify_CharacterOnNotifyEventDeadInServer OnNotifyEventDeadInServer;
// 0x0038 (size: 0x10)
void PalEventNotifyCharacterDeadDelegate(const FPalDeadInfo& DeadInfo);
void OnCharacterSpawned_ServerInternal(class UPalIndividualCharacterHandle*

CharacterHandle);
void OnCharacterDead_ServerInternal(FPalDeadInfo DeadInfo);
void OnCharacterDamaged_ServerInternal(FPalDamageResult DamageResult);
class UPalEventNotify_Character* GetEventNotify_Character(const class UObject*
}; // Size: 0x48
class UPalEventNotify_ItemContainer : public UPalEventNotifyBase

{
FPalEventNotify_ItemContainerOnNotifyEventMoveInServer
OnNotifyEventMoveInServer; // 0x0028 (size: 0x10)
void PalEventNotifyItemMoveDelegate(const FPalItemOperationInfo_Move&
EventInfo);
void OnItemOperationMove_ServerInternal(const
TArray<FPalItemOperationInfo_Move>& OperationInfoSet);
class UPalEventNotify_ItemContainer* GetEventNotify_Item(const class UObject*
}; // Size: 0x38
class UPalExpDatabase : public UObject

{
class UDataTable* ExpDataTable;
// 0x0028 (size: 0x8)
class UDataTable* PaldexBonusExpDataTable;
// 0x0030 (size: 0x8)
int32 GetTotalExp(int32 Level, bool IsPlayer);

int32 GetNextExp(int32 Level, bool IsPlayer);
int32 GetDropExp(int32 Level, FName RowName);
void DistributionExpValue_forPlayerParty_Server(int32 ExpValue, TArray<class
APalPlayerCharacter*> GiftPlayerList, bool isCallDelegate);
int32 CalcPaldexBonusExp(const FName CharacterID, int32 CaptureCount, class
APalPlayerState* captureOwnerState);
int32 CalcLevelFromTotalExp(int32 TotalEXP, bool IsPlayer);
void AddExpValue_forPlayerParty_Server(int32 ExpValue, TArray<class
APalPlayerCharacter*> GiftPlayerList, bool isCallDelegate);
void AddExp_forPlayerParty_TowerBoss(class UPalIndividualCharacterHandle*
DeadEnemyHandle, TArray<class APalPlayerCharacter*> GiftPlayerList, bool
isCallDelegate);
void AddExp_forBaseCamp(class UPalIndividualCharacterHandle* DeadEnemyHandle,
class UPalBaseCampModel* CampModel);
void AddExp_EnemyDeath(FPalDeadInfo DeadInfo);
}; // Size: 0x38
class UPalFacialComponent : public UActorComponent

{
bool bIsEnableEyeBlink;
// 0x00A0 (size: 0x1)
class UPalFacial_MainModule* MainModule;
// 0x00A8 (size: 0x8)
void SetUpTestMesh(class USkeletalMeshComponent* SkeletalMeshComponent);

void SetDisableNotify(bool Disable);
void SetDefaultLayer(EPalFacialEyeType Eye);
bool ExistFacialNotifyInMontage(class UAnimMontage* Montage);
bool ExistEyeNotifyInMontage(class UAnimMontage* Montage);
void ChangeMouth_ForMontageNotify(EPalFacialMouthType Mouth);
void ChangeEyeAndMouthMesh(EPalFacialEyeType Eye);
void ChangeEye_ForMontageNotify(EPalFacialEyeType Eye);
void ChangeDefaultFacial();
void Blink();
}; // Size: 0xC8
class UPalFacial_MainModule : public UObject

{
int32 EyeMaterialIndex;
// 0x0068 (size: 0x4)
int32 MouthMaterialIndex;
// 0x006C (size: 0x4)
int32 BrowMaterialIndex;
// 0x0070 (size: 0x4)
TMap<class EPalFacialEyeType, class FPalMorphSetting> MorphSetting_Eye;
// 0x00C8 (size: 0x50)
TMap<class EPalFacialMouthType, class FPalMorphSetting> MorphSetting_Mouth;
// 0x0118 (size: 0x50)
TMap<EPalFacialEyeType, float> BlendShape_TypeEyeWeight;
// 0x0170 (size: 0x50)
TMap<EPalFacialMouthType, float> BlendShape_TypeMouthWeight;
// 0x01C0 (size: 0x50)
TMap<FName, float> BlendShape_EyeWeight;
// 0x0210 (size: 0x50)
TMap<FName, float> BlendShape_MouthWeight;
// 0x0260 (size: 0x50)
void Setup_FacialModule(class USkeletalMeshComponent* SkeletalMeshComponent);

}; // Size: 0x2B0
class UPalFadeWidgetBase : public UPalUserWidget

{
}; // Size: 0x408
class UPalFirePointLightComponent : public UPointLightComponent

{
}; // Size: 0x420
class UPalFlyMeshHeightCtrlComponent : public UActorComponent
{
float FlingAdditionalHeight;
// 0x00A0 (size: 0x4)
float HighFlingAddtionalHeight;
// 0x00A4 (size: 0x4)
EPalFlyHeightType State;
// 0x00A8 (size: 0x1)
bool bIsHighFling;
// 0x00B4 (size: 0x1)
bool bIsHighFlingCache;
// 0x00B5 (size: 0x1)
class USkeletalMeshComponent* SK;
// 0x00B8 (size: 0x8)
void ToLand(float Duration);

void ToFly(float Duration);
void SetupMesh();
void OnRep_bIsHighFling();
void OnChangeBattleMode(bool bIsBattleMode);
bool IsFlying();
void HighFlingEnd_Server();
void HighFlingEnd_Implementation();
void HighFlingEnd();
float GetDefaultMeshLocationZ();
void Debug_ForceHighFlingEnd();
}; // Size: 0xE0
class UPalFoliageDamageReactionComponent : public UActorComponent

{
// 0x00B8 (size: 0x8)
}; // Size: 0xC0
class UPalFoliageGridModel : public UObject

{
TMap<class FName, class UPalMapObjectFoliageModel*> FoliageModelMapInServer;
// 0x0048 (size: 0x50)
TMap<class FName, class FPalFoliageGridInstanceMap> InstanceMapByComponentId;
// 0x0140 (size: 0x50)
TMap<class FVector, class FPalFoliageInstanceId> InstanceIdMapByLocation;
// 0x0190 (size: 0x50)
}; // Size: 0x1E0
class UPalFoliageISMComponent : public UFoliageInstancedStaticMeshComponent

{
}; // Size: 0x900
class UPalFoliageISMComponentBase : public UPalFoliageISMComponent

{
TMap<FVector, int32> InstanceIndexMapByLocation;
// 0x0900 (size: 0x50)
void SpawnInstance(class UPalFoliageInstance* Instance);

void OnRemoveInstance(const FName FoliageTypeId, class UPalFoliageInstance*
Instance);
void OnRegisterInstance(const FName FoliageTypeId, class UPalFoliageInstance*
Instance);
void OnReceiveDamageInClient(const FPalDamageInfo& DamageInfo);
void OnDisposeModel(class UPalMapObjectFoliageModel* Model);
void DespawnInstance(class UPalFoliageInstance* Instance);
}; // Size: 0x950
class UPalFoliageInstallDataAsset : public UDataAsset

{
TMap<class FName, class TSoftObjectPtr<UPalFoliageInstallDataAssetByIFA>>
InstallDataSetMap; // 0x0030 (size: 0x50)
}; // Size: 0x80
class UPalFoliageInstallDataAssetByIFA : public UDataAsset

{
TMap<class FName, class FPalFoliageInstallDataArray> InstallDataArrayMap;
// 0x0030 (size: 0x50)
}; // Size: 0x80
class UPalFoliageInstance : public UObject

{
TMap<int32, bool> DirtyMap;
// 0x0048 (size: 0x50)
// 0x00B8 (size: 0x10)
FName FoliageTypeId;
// 0x00C8 (size: 0x8)
int32 HP;
// 0x00D0 (size: 0x4)
bool bAlive;
// 0x00D4 (size: 0x1)
FPalFoliageInstanceTransform WorldTransform;
// 0x00D8 (size: 0x38)
FTransform WorldTransformCache;
// 0x0110 (size: 0x60)
FGameDateTime RespawnTimeAt;
// 0x0170 (size: 0x8)
void OnRep_WorldTransform();
void OnRep_Alive(bool bOldValue);
void FoliageInstanceDelegate__DelegateSignature(class UPalFoliageInstance*
Instance);
}; // Size: 0x180
class UPalFoliagePresetDataSet : public UDataAsset

{
TMap<class EPalFoliagePresetType, class FPalFoliagePresetData> Presets;
// 0x0030 (size: 0x50)
}; // Size: 0x80
class UPalFoliageType_InstancedStaticMesh : public UFoliageType_InstancedStaticMesh

{
EPalFoliagePresetType PresetType;
// 0x04F0 (size: 0x1)
}; // Size: 0x4F8
class UPalFollowingComponent : public UPathFollowingComponent
{
}; // Size: 0x2B8
class UPalFootIKComponent : public UActorComponent

{
bool bIsEnableFootIK;
// 0x00A0 (size: 0x1)
float MinMeshOffset;
// 0x00A4 (size: 0x4)
float FootIKInterpTime;
// 0x00A8 (size: 0x4)
TMap<class EPalFootType, class FFootIKSetting> FootIKSettings;
// 0x00B0 (size: 0x50)
float FootIKMeshOffset;
// 0x0100 (size: 0x4)
TMap<class EPalFootType, class FHitResult> FootGroundResult;
// 0x0108 (size: 0x50)
void SetFootIKDisable(FName flagName, bool bIsDisable);

bool IsEnableFootIK();
}; // Size: 0x1A8
class UPalFootStepEffectAssetBase : public UObject

{
TMap<class EPalLandingType, class FFootStepEffectInfo> FootStepEffectInfo;
// 0x0028 (size: 0x50)
TSoftObjectPtr<UNiagaraSystem> GetEffectObjectPtr(EPalLandingType LandingType,

TEnumAsByte<EPhysicalSurface> PhysicalSurface);
bool GetEffectInfo(EPalLandingType LandingType, FFootStepEffectInfo& OutVal);
}; // Size: 0x78
class UPalFunnelCharacterManager : public UPalWorldSubsystem

{
TMap<class FGuid, class FPalFunnelCharacterManagementInfo>
ManagedCharacterInfo; // 0x0070 (size: 0x50)
TMap<class FGuid, class FPalInstanceID> PickupTarget;
// 0x00C0 (size: 0x50)
void SpawnActorCallback(const FGuid& Guid, class AActor* Actor);

void SetFunnelCharacterActive(class APalFunnelCharacter* FunnelCharacter, bool
IsActive);
void InitializeForServer_BP();
void Initialize_BP();
class APalCharacter* GetOwnerCharacter(const class APalFunnelCharacter*
FunnelCharacter);
int32 GetIndexOfFunnelsWithinSameTrainer(class APalFunnelCharacter*
FunnelCharacter);
}; // Size: 0x110
class UPalFunnelSkillModule : public UObject

{
class APalFunnelCharacter* FunnelCharacter;
// 0x0028 (size: 0x8)
bool ShouldSetSkillAction();
void SetCharacter(class APalCharacter* Character);
void OnNotifyFinishSkillAction();
}; // Size: 0x30
class UPalFunnelSkillModuleCollectItem : public UPalFunnelSkillModule

{
TArray<float> SearchItemRange;
// 0x0030 (size: 0x10)
FGuid CollectItemId;
// 0x0040 (size: 0x10)
bool bShouldSetSkillAction;
// 0x0050 (size: 0x1)
TMap<class FGuid, class FPalFunnelSkillModuleCollectItemSearchInfo>
SearchItemInfoList; // 0x0058 (size: 0x50)
void SearchCollectableItem(float DeltaTime);

void Reset();
bool Pickup();
void ObserveCollectItem(float DeltaTime);
bool IsNearTargetLocation(FVector Location);
class APalMapObject* GetTargetObject();
bool GetTargetLocation(FVector& Location);
FGuid GetTargetId();
}; // Size: 0xA8
class UPalFunnelSkillModuleReticleTargetAttack : public UPalFunnelSkillModule

{
bool bShouldSetSkillAction;
// 0x0030 (size: 0x1)
float SearchRange;
// 0x0034 (size: 0x4)
float CoolTime;
// 0x003C (size: 0x4)
TWeakObjectPtr<class APalCharacter> ReticleTarget;
// 0x0040 (size: 0x8)
void Reset();
class APalCharacter* GetTarget();
}; // Size: 0x48
class UPalGameInstance : public UGameInstance

{
FPalGameInstanceOnCompletedCharacterMakeDelegate
OnCompletedCharacterMakeDelegate; // 0x01C0 (size: 0x10)
void OnCompletedCharacterMake();
FPalGameInstanceOnPawnLocalPlayerControllerChangedDelegates
OnPawnLocalPlayerControllerChangedDelegates; // 0x01D0 (size: 0x10)
void OnPawnLocalPlayerControllerChanged(class APawn* Pawn, class AController*
Controller);
bool bNetworkError;
// 0x01E0 (size: 0x1)
FString DisplayVersion;
// 0x01E8 (size: 0x10)
FString ErrorString;
// 0x0200 (size: 0x10)
FString InputPassword;
// 0x0210 (size: 0x10)
TArray<FString> BanList;
// 0x0220 (size: 0x10)
TSubclassOf<class UPalGameSetting> GameSettingClass;
// 0x03C0 (size: 0x8)
class UPalGameSetting* GameSetting;
// 0x03C8 (size: 0x8)
TSubclassOf<class UPalMasterDataTables> MasterDataTablesClass;
// 0x03D0 (size: 0x8)
class UPalMasterDataTables* MasterDataTables;
// 0x03D8 (size: 0x8)
TSubclassOf<class UPalMapObjectManager> MapObjectManagerClass;
// 0x03E0 (size: 0x8)
TSubclassOf<class UPalGroupManager> GroupManagerClass;
// 0x03E8 (size: 0x8)
TSubclassOf<class UPalCharacterManager> CharacterManagerClass;
// 0x03F0 (size: 0x8)
TSubclassOf<class UPalCharacterContainerManager>
CharacterContainerManagerClass; // 0x03F8 (size: 0x8)
class UPalCharacterContainerManager* CharacterContainerManager;
// 0x0400 (size: 0x8)
TSubclassOf<class UPalBaseCampManager> BaseCampManagerClass;
// 0x0408 (size: 0x8)
TSubclassOf<class UPalWorkProgressManager> WorkProgressManagerClass;
// 0x0410 (size: 0x8)
TSubclassOf<class UPalDamagePopUpManager> DamagePopUpManagerClass;
// 0x0418 (size: 0x8)
class UPalDamagePopUpManager* DamagePopUpManager;
// 0x0420 (size: 0x8)
TSubclassOf<class UPalItemContainerManager> ItemContainerManagerClass;
// 0x0428 (size: 0x8)
TSubclassOf<class UPalItemIDManager> ItemIDManagerClass;
// 0x0430 (size: 0x8)
class UPalItemIDManager* ItemIDManager;
// 0x0438 (size: 0x8)
TSubclassOf<class UPalWazaDatabase> WazaDatabaseClass;
// 0x0440 (size: 0x8)
class UPalWazaDatabase* WazaDatabase;
// 0x0448 (size: 0x8)
TSubclassOf<class UPalBattleManager> BattleManagerClass;
// 0x0450 (size: 0x8)
TSubclassOf<class UPalBossBattleManager> BossBattleManagerClass;
// 0x0458 (size: 0x8)
TSubclassOf<class UPalPlayerDataStorage> PlayerDataStorageClass;
// 0x0460 (size: 0x8)
class UPalPlayerDataStorage* PlayerDataStorage;
// 0x0468 (size: 0x8)
TSubclassOf<class UPalHUDService> HUDServiceClass;
// 0x0470 (size: 0x8)
class UPalHUDService* HUDService;
// 0x0478 (size: 0x8)
TSubclassOf<class UPalExpDatabase> ExpDatabaseClass;
// 0x0480 (size: 0x8)
class UPalExpDatabase* ExpDatabase;
// 0x0488 (size: 0x8)
TSubclassOf<class UPalDatabaseCharacterParameter>
DatabaseCharacterParameterClass; // 0x0490 (size: 0x8)
class UPalDatabaseCharacterParameter* DatabaseCharacterParameter;
// 0x0498 (size: 0x8)
TSubclassOf<class UPalAssetStreamableManager> AssetStreamableManagerClass;
// 0x04A0 (size: 0x8)
class UPalAssetStreamableManager* AssetStreamableManager;
// 0x04A8 (size: 0x8)
TSubclassOf<class UPalPassiveSkillManager> PassiveSkillManagerClass;
// 0x04B0 (size: 0x8)
class UPalPassiveSkillManager* PassiveSkillManager;
// 0x04B8 (size: 0x8)
TSubclassOf<class UPalDataTableRowIdMapper> DataTableRowIdMapperClass;
// 0x04C0 (size: 0x8)
class UPalDataTableRowIdMapper* DataTableRowIdMapper;
// 0x04C8 (size: 0x8)
TSubclassOf<class UPalDeadBodyManager> DeadBodyManagerClass;
// 0x04D0 (size: 0x8)
class UPalDeadBodyManager* DeadBodyManager;
// 0x04D8 (size: 0x8)
TSubclassOf<class UPalBulletCreator> BulletCreatorClass;
// 0x04E0 (size: 0x8)
class UPalBulletCreator* BulletCreator;
// 0x04E8 (size: 0x8)
TSubclassOf<class UPalPlayerManager> PlayerManagerClass;
// 0x04F0 (size: 0x8)
TSubclassOf<class UPalSaveGameManager> SaveGameManagerClass;
// 0x04F8 (size: 0x8)
class UPalSaveGameManager* SaveGameManager;
// 0x0500 (size: 0x8)
TSubclassOf<class UPalVisualEffectDataBase> VisualEffectDataBaseClass;
// 0x0508 (size: 0x8)
class UPalVisualEffectDataBase* VisualEffectDataBase;
// 0x0510 (size: 0x8)
TSubclassOf<class UPalEventNotifySystem> EventNotifySystemClass;
// 0x0518 (size: 0x8)
TSubclassOf<class UPalWorldSecuritySystem> WorldSecuritySystemClass;
// 0x0520 (size: 0x8)
TSubclassOf<class UPalLocationManager> LocationManagerClass;
// 0x0528 (size: 0x8)
TSubclassOf<class UPalNPCManager> NPCManagerClass;
// 0x0530 (size: 0x8)
class UPalNPCManager* NPCManager;
// 0x0538 (size: 0x8)
TSubclassOf<class UPalDeathPenaltyManager> DeathPenaltyManagerClass;
// 0x0540 (size: 0x8)
class UPalDeathPenaltyManager* DeathPenaltyManager;
// 0x0548 (size: 0x8)
TSubclassOf<class UPalCoopSkillSearchSystem> CoopSkillSearchSystemClass;
// 0x0550 (size: 0x8)
class UPalCoopSkillSearchSystem* CoopSkillSearchSystem;
// 0x0558 (size: 0x8)
TSubclassOf<class UPalCharacterImportanceManager>
CharacterImportanceManagerClass; // 0x0560 (size: 0x8)
class UPalCharacterImportanceManager* CharacterImportanceManager;
// 0x0568 (size: 0x8)
TSubclassOf<class UPalAudioSettingSystem> AudioSettingClass;
// 0x0570 (size: 0x8)
class UPalAudioSettingSystem* AudioSettingSystem;
// 0x0578 (size: 0x8)
TSubclassOf<class UPalCharacterParameterStorageSubsystem>
CharacterParameterStorageSubsystemClass; // 0x0580 (size: 0x8)
TSubclassOf<class UPalTutorialManager> TutorialManagerClass;
// 0x0588 (size: 0x8)
TSubclassOf<class UPalObjectCollector> ObjectCollectorClass;
// 0x0590 (size: 0x8)
TSubclassOf<class UPalActionDummyTargetManager> ActionDummyTargetManager;
// 0x0598 (size: 0x8)
TSubclassOf<class UPalLogManager> LogManagerClass;
// 0x05A0 (size: 0x8)
int32 revisionNum;
// 0x05A8 (size: 0x4)
FPalGameInstanceFxiedCharacterMakeDataDelegate FxiedCharacterMakeDataDelegate;
// 0x05B0 (size: 0x10)
void FxiedCharacterMakeData(const FPalPlayerDataCharacterMakeInfo& MakeInfo);
FPalGameInstanceFxiedCharacterNameDelegate FxiedCharacterNameDelegate;
// 0x05C0 (size: 0x10)
void FxiedCharacterName(FString Name);
TArray<TScriptInterface<IPalGameSystemNeedSync>> NeedWorldSyncSystems;
// 0x05D0 (size: 0x10)
TSubclassOf<class UPalPersistentSoundPlayer> TitleBGMPlayerClass;
// 0x0600 (size: 0x8)
class UPalPersistentSoundPlayer* TitleBGMPlayer;
// 0x0608 (size: 0x8)
FString SelectedWorldName;
// 0x0610 (size: 0x10)
FString SelectedWorldSaveDirectoryName;
// 0x0620 (size: 0x10)
bool bIsNewGame;
// 0x0630 (size: 0x1)
FPalOptionWorldSettings NewGameWorldSetting;
// 0x0638 (size: 0x128)
void ShowUIMultiplayRestriction(bool bOverrideChecking);

void ShowCharacterMakeScreen();
void SetupGameInit();
void SetNewWorldName(FString WorldName);
void SetIsNewGame();
bool SelectWorldSaveDirectoryName(FString WorldSaveDirectoryName);
bool SelectWorld(FString WorldName);
void OnPawnLocalPlayerControllerChanged__DelegateSignature(class APawn* Pawn,
class AController* Controller);
void OnInitializeCompleteSystem();
void OnCompletedJoinSession(bool IsSuccess, JoinSessionResultType Type);
void OnCompletedFindSessions(bool bIsSuccess, const
TArray<FBlueprintSessionResult>& Results, FString ErrorStr);
void OnCompletedCharacterMake__DelegateSignature();
void LoadingFinished();
bool IsPlayFromTitle();
bool IsNewGame();
void GoToDefaultMap();
FString GetSelectedWorldSaveDirectoryName();
FString GetSelectedWorldName();
void FxiedCharacterName__DelegateSignature(FString Name);
void FxiedCharacterMakeData__DelegateSignature(const
FPalPlayerDataCharacterMakeInfo& MakeInfo);
void CompleteInitCharacterMakeData();
void ClearNetworkError();
void CheckInvite();
void ApplicationHasReactivated();
void ApplicationHasEnteredForeground();
}; // Size: 0x760
class UPalGameLocalSettings : public UObject

{
// 0x0028 (size: 0x1C)
// 0x0044 (size: 0x1)
EPalOptionGraphicsLevel DefaultGraphicsLevel;
// 0x0045 (size: 0x1)
bool bRunedBenchMark;
// 0x0046 (size: 0x1)
bool bHasAppliedUserSetting;
// 0x0047 (size: 0x1)
FString DedicatedServerName;
// 0x0048 (size: 0x10)
// 0x0058 (size: 0x1)
UDLSSMode DLSSMode;
// 0x0059 (size: 0x1)
int32 GraphicsCommonQuality;
// 0x005C (size: 0x4)
bool RequireBenchMarkScalaBility();
}; // Size: 0x60
class UPalGameSetting : public UBlueprintFunctionLibrary

{
int32 CharacterMaxLevel;
// 0x0028 (size: 0x4)
int32 GuildCharacterMaxLevel;
// 0x002C (size: 0x4)
int32 OtomoLevelSyncAddMaxLevel;
// 0x0030 (size: 0x4)
EPalPlayerSprintStaminaDecreaseType PlayerSprintStaminaType;
// 0x0034 (size: 0x1)
int32 CharacterMaxRank;
// 0x0038 (size: 0x4)
int32 ConsumStamina_PalThrow;
// 0x003C (size: 0x4)
float ReturnOtomoPalCoolTime;
// 0x0040 (size: 0x4)
int32 OtomoSlotNum;
// 0x0044 (size: 0x4)
float OtomoWazaCoolDownSpeedRate;
// 0x0048 (size: 0x4)
float PlayerHPRateFromRespawn;
// 0x004C (size: 0x4)
float PlayerStomachRateFromRespawn;
// 0x0050 (size: 0x4)
float RarePal_AppearanceProbability;
// 0x0054 (size: 0x4)
float RarePal_LevelMultiply;
// 0x0058 (size: 0x4)
int32 BossOrRarePal_TalentMin;
// 0x005C (size: 0x4)
int32 CharacterRankUpRequiredNumDefault;
// 0x0060 (size: 0x4)
TMap<int32, int32> CharacterRankUpRequiredNumMap;
// 0x0068 (size: 0x50)
float NaturalUpdateSaveParameterInterval;
// 0x00B8 (size: 0x4)
float CharacterHUDDisplayRange;
// 0x00BC (size: 0x4)
float CharacterFedEatingTime;
// 0x00C0 (size: 0x4)
float CharacterStayingSecondsInSpa;
// 0x00C4 (size: 0x4)
int32 PalBoxPageNum;
// 0x00C8 (size: 0x4)
int32 PalBoxSlotNumInPage;
// 0x00CC (size: 0x4)
float PlayerBattleJudge_EnemyDistance;
// 0x00D0 (size: 0x4)
TMap<int32, float> BodyTemperature_SlipDamage_Percent;
// 0x00D8 (size: 0x50)
TMap<int32, float> BodyTemperature_StomachDecreaceRate;
// 0x0128 (size: 0x50)
TSoftObjectPtr<UNiagaraSystem> SleepFXDefault;
// 0x0178 (size: 0x30)
float LiftupCharacterThrownVelocityScalar;
// 0x01A8 (size: 0x4)
float LiftupCharacterClearCollisionDelayTime;
// 0x01AC (size: 0x4)
int32 NickNameMaxLength;
// 0x01B0 (size: 0x4)
float IntervalForPalAttackFromBall;
// 0x01B4 (size: 0x4)
bool CanShootRiderByFullRide;
// 0x01B8 (size: 0x1)
bool HitWazaAttackForMapObject;
// 0x01B9 (size: 0x1)
int32 KnockBack_MaxHpPercent;
// 0x01BC (size: 0x4)
float KnockBack_Power;
// 0x01C0 (size: 0x4)
float StunTime;
// 0x01C4 (size: 0x4)
float StepCooldownTime;
// 0x01C8 (size: 0x4)
float Stun_GunDamageRate;
// 0x01CC (size: 0x4)
bool IsEnableAutoReload;
// 0x01D0 (size: 0x1)
float DeadShootImpulseRate;
// 0x01D4 (size: 0x4)
float DeadShootImpulseMax;
// 0x01D8 (size: 0x4)
float OtomoDamageRate_Defense;
// 0x01DC (size: 0x4)
int32 DamageValueMin_MapObject;
// 0x01E0 (size: 0x4)
float DamageRate_WealPoint;
// 0x01E4 (size: 0x4)
float DamageRate_StrongPoint;
// 0x01E8 (size: 0x4)
float DamageRate_SleepHit;
// 0x01EC (size: 0x4)
float FinalDamageRate_Waza;
// 0x01F0 (size: 0x4)
float FinalDamageRate_Weapon;
// 0x01F4 (size: 0x4)
float FinalDamageRate_Mine;
// 0x01F8 (size: 0x4)
float FinalDamageRate_MapObject_Waza;
// 0x01FC (size: 0x4)
float FinalDamageRate_MapObject_Weapon;
// 0x0200 (size: 0x4)
float FinalDamageRate_MapObject_Mine;
// 0x0204 (size: 0x4)
float FoliageDefault_Defense;
// 0x0208 (size: 0x4)
float WazaAttackerLevelDamage_Power;
// 0x020C (size: 0x4)
float DamageRandomRate_Min;
// 0x0210 (size: 0x4)
float DamageRandomRate_Max;
// 0x0214 (size: 0x4)
float LevelDamageCorrect;
// 0x0218 (size: 0x4)
float LevelStatusAccumulateCorrect;
// 0x021C (size: 0x4)
float DamageElementMatchRate;
// 0x0220 (size: 0x4)
float MineAttack_DefensePower;
// 0x0224 (size: 0x4)
float StatusCalculate_LevelMultiply_HP;
// 0x0228 (size: 0x4)
int32 StatusCalculate_TribePlus_HP;
// 0x022C (size: 0x4)
int32 StatusCalculate_ConstPlus_HP;
// 0x0230 (size: 0x4)
float StatusCalculate_LevelMultiply_Attack;
// 0x0234 (size: 0x4)
int32 StatusCalculate_ConstPlus_Attack;
// 0x0238 (size: 0x4)
float StatusCalculate_LevelMultiply_Defense;
// 0x023C (size: 0x4)
int32 StatusCalculate_ConstPlus_Defense;
// 0x0240 (size: 0x4)
float StatusCalculate_TribeMultiply_CraftSpeed;
// 0x0244 (size: 0x4)
float StatusCalculate_GenkaiToppa_PerAdd;
// 0x0248 (size: 0x4)
float StatusCalculate_Talent_PerAdd;
// 0x024C (size: 0x4)
float BreakedWeaponDamageRate;
// 0x0250 (size: 0x4)
float BreakedArmorDefenseRate;
// 0x0254 (size: 0x4)
float ArmorDurabilityDamageDivide;
// 0x0258 (size: 0x4)
float ClimbingStamina_Move;
// 0x025C (size: 0x4)
float ClimbingStamina_Jump;
// 0x0260 (size: 0x4)
float RideWazaStaminaRate;
// 0x0264 (size: 0x4)
bool bIsEnableJumpPreliminary;
// 0x0268 (size: 0x1)
float JumpInterval;
// 0x026C (size: 0x4)
float FlyMaxHeight;
// 0x0270 (size: 0x4)
float FlyHover_SP;
// 0x0274 (size: 0x4)
float FlyHorizon_SP;
// 0x0278 (size: 0x4)
float FlyHorizon_Dash_SP;
// 0x027C (size: 0x4)
float FlyVertical_SP;
// 0x0280 (size: 0x4)
float AimingSpeedRateInRide;
// 0x0284 (size: 0x4)
float SlidingEndSpeed;
// 0x0288 (size: 0x4)
int32 JumpSP;
// 0x028C (size: 0x4)
int32 StepSP;
// 0x0290 (size: 0x4)
int32 MeleeAttackSP;
// 0x0294 (size: 0x4)
float SprintSP;
// 0x0298 (size: 0x4)
float GliderSP;
// 0x029C (size: 0x4)
float SwimmingFallWaitTimeSec;
// 0x02A0 (size: 0x4)
float Swimming_SP_Idle;
// 0x02A4 (size: 0x4)
float Swimming_SP_Swim;
// 0x02A8 (size: 0x4)
float Swimming_SP_DashSwim;
// 0x02AC (size: 0x4)
float FluidFriction;
// 0x02B0 (size: 0x4)
float OverWeightSpeedZero_AddPercent;
// 0x02B4 (size: 0x4)
float WalkableFloorAngleForDefault;
// 0x02B8 (size: 0x4)
float WalkableFloorAngleForRide;
// 0x02BC (size: 0x4)
bool IsEnableSpeedCollision;
// 0x02C0 (size: 0x1)
float CollisionDamageMinSpeed;
// 0x02C4 (size: 0x4)
float SpeedCollisionDamagePower;
// 0x02C8 (size: 0x4)
float CollisionDamageSpeedMultiplay;
// 0x02CC (size: 0x4)
float CollisionDamageWeightThreshold;
// 0x02D0 (size: 0x4)
float AutoHPRegene_Percent_perSecond;
// 0x02D4 (size: 0x4)
float AutoHPRegene_Percent_perSecond_Sleeping;
// 0x02D8 (size: 0x4)
float PosionHPDecrease_Percent_perSecond;
// 0x02DC (size: 0x4)
float Starvation_DecreaseHP_Percent_perSecond;
// 0x02E0 (size: 0x4)
float AutoSANRegene_Percent_perSecond_PalStorage;
// 0x02E4 (size: 0x4)
float StomachDecreace_perSecond_Monster;
// 0x02E8 (size: 0x4)
float StomachDecreace_perSecond_Player;
// 0x02EC (size: 0x4)
float StomachDecreace_AutoHealing;
// 0x02F0 (size: 0x4)
float StomachDecreace_WorkingRate;
// 0x02F4 (size: 0x4)
int32 HungerStart_StomachValue;
// 0x02F8 (size: 0x4)
int32 FullStomachPalStartEatFood;
// 0x02FC (size: 0x4)
float FullStomachCost_ByWazaUse_Base;
// 0x0300 (size: 0x4)
TMap<int32, float> FullStomachCost_ByWazaUse_RateMap;
// 0x0308 (size: 0x50)
float StomachDecreaceRate_GroundRide_Sprint;
// 0x0358 (size: 0x4)
float StomachDecreaceRate_WaterRide;
// 0x035C (size: 0x4)
float StomachDecreaceRate_WaterRide_Sprint;
// 0x0360 (size: 0x4)
float StomachDecreaceRate_FlyRide;
// 0x0364 (size: 0x4)
float StomachDecreaceRate_FlyRide_Sprint;
// 0x0368 (size: 0x4)
int32 RemainderOfLife_Second;
// 0x036C (size: 0x4)
float HpDecreaseRate_Drowning;
// 0x0370 (size: 0x4)
float PlayerShield_RecoverStartTime;
// 0x0374 (size: 0x4)
float PlayerShield_RecoverPercentPerSecond;
// 0x0378 (size: 0x4)
float StaminaRecover_PercentPerSecond;
// 0x037C (size: 0x4)
float ResuscitationTime;
// 0x0380 (size: 0x4)
int32 PlayerDeath_DropOtomoNum;
// 0x0384 (size: 0x4)
float PlayerDeath_DropOtomoRange;
// 0x0388 (size: 0x4)
int32 PlayerDeath_DropOtomoDisappearHours;
// 0x038C (size: 0x4)
float PlayerDyingDamagePerTime;
// 0x0390 (size: 0x4)
int32 ElementStatus_ResistanceInitialValue;
// 0x0394 (size: 0x4)
float ElementStatus_AutoDecreasePerSecond;
// 0x0398 (size: 0x4)
int32 ElementStatus_ResetResistanceSecond;
// 0x039C (size: 0x4)
int32 BuildExp;
// 0x03A0 (size: 0x4)
int32 CraftExp;
// 0x03A4 (size: 0x4)
int32 PickupItemOnLevelExp;
// 0x03A8 (size: 0x4)
int32 MapObjectDestroyProceedExp;
// 0x03AC (size: 0x4)
float MapObjectDistributeExpRange;
// 0x03B0 (size: 0x4)
TMap<int32, int32> OtomoExp_LevelDifferenceMap;
// 0x03B8 (size: 0x50)
int32 OtomoExp_HigherPlayerLevel;
// 0x0408 (size: 0x4)
int32 CaptureExpBonus_Tier1_TableReferenceNum;
// 0x040C (size: 0x4)
// 0x0410 (size: 0x4)
// 0x0414 (size: 0x4)
TArray<FPalDebugOtomoPalInfo> NewGameOtomoPalSet;
// 0x0418 (size: 0x10)
TMap<FName, int32> NewGameInventoryItemSet;
// 0x0428 (size: 0x50)
TMap<FName, int32> NewGameLoadoutItemSet;
// 0x0478 (size: 0x50)
FVector WorldHUDDisplayOffsetDefault;
// 0x04C8 (size: 0x18)
float WorldHUDDisplayRangeDefault;
// 0x04E0 (size: 0x4)
float WorldHUDDetailDisplayRange;
// 0x04E4 (size: 0x4)
TArray<FPalDataTableRowName_ItemData> FarmCropWaterItemIds;
// 0x04E8 (size: 0x10)
float FarmCropGrowupSpeedBySec;
// 0x04F8 (size: 0x4)
float FarmCropIncreaseRateByWaterFillRate;
// 0x04FC (size: 0x4)
FString MaxMoney;
// 0x0500 (size: 0x10)
int32 DefaultMoney;
// 0x0510 (size: 0x4)
float SneakAttackBackJudgeAngle_Degree;
// 0x0514 (size: 0x4)
float SneakAttack_PalMeleeWaza_AttackRate;
// 0x0518 (size: 0x4)
float AutoAimCameraMoveRate;
// 0x051C (size: 0x4)
float AutoAimCharacterMoveRate;
// 0x0520 (size: 0x4)
float AutoAimCameraAdsorptionSpeed;
// 0x0524 (size: 0x4)
float AutoAimLockOnScreenSpaceRate;
// 0x0528 (size: 0x4)
float ForceAutoAimTime;
// 0x052C (size: 0x4)
float SellItemRate;
// 0x0530 (size: 0x4)
float PalPriceConstantValueA;
// 0x0534 (size: 0x4)
float PalPriceConstantValueB;
// 0x0538 (size: 0x4)
float SellPalRate;
// 0x053C (size: 0x4)
float SearchRangeOnThrowedCharacterLanded;
// 0x0540 (size: 0x4)
float WorkCompleteReactionRangeFromPlayer;
// 0x0544 (size: 0x4)
int32 WorkerCollectResourceStackMaxNum;
// 0x0548 (size: 0x4)
EPalFacialEyeType FacialTypeHardWork;
// 0x054C (size: 0x1)
float Timeout_WorkerApproachToTarget;
// 0x0550 (size: 0x4)
float WaitTime_WorkRepairFailedFindPath;
// 0x0554 (size: 0x4)
float WorkerWaitingNotifyInterval;
// 0x0558 (size: 0x4)
float WarpCheckInterval;
// 0x055C (size: 0x4)
float WarpCheckMoveDistanceThreshold;
// 0x0560 (size: 0x4)
float WarpThreshold;
// 0x0564 (size: 0x4)
float AutoDecreaseHateValue_PercentMaxHP_PerSecond;
// 0x0568 (size: 0x4)
float HateDecreaseDamageRate;
// 0x056C (size: 0x4)
float Hate_ForceUp_HPRate_OtomoActive;
// 0x0570 (size: 0x4)
float Hate_ForceUp_HPRate_IncidentBattle;
// 0x0574 (size: 0x4)
float CombatEndDistance_BattleStartSelfPos_To_SelfPos;
// 0x0578 (size: 0x4)
float CombatEndDistance_BattleStartSelfPos_To_TargetPos;
// 0x057C (size: 0x4)
float CombatEndDistance_BattleStartSelfPos_To_TargetPos_AddFirstTargetDistance;
// 0x0580 (size: 0x4)
float NavigationAreaDivideExtents;
// 0x0584 (size: 0x4)
TArray<FPalNavigationUpdateFrequencySetting>
NavigationUpdateFrequencySettingsFromPlayer; // 0x0588 (size: 0x10)
float autoSaveSpan;
// 0x0598 (size: 0x4)
FName SaveDataName_WorldBaseInfo;
// 0x059C (size: 0x8)
FName SaveDataName_World;
// 0x05A4 (size: 0x8)
FName SaveDataName_PlayerDirectory;
// 0x05AC (size: 0x8)
FName SaveDataName_LocalData;
// 0x05B4 (size: 0x8)
FName SaveDataName_WorldOption;
// 0x05BC (size: 0x8)
TMap<EPalSupportedPlatformType, int32> MaxWorldDataNumMap;
// 0x05C8 (size: 0x50)
int32 PalWorldTime_GameStartHour;
// 0x0618 (size: 0x4)
int32 PalWorldMinutes_RealOneMinute;
// 0x061C (size: 0x4)
int32 NightStartHour;
// 0x0620 (size: 0x4)
int32 NightEndHour;
// 0x0624 (size: 0x4)
int32 PlayerMorningHour;
// 0x0628 (size: 0x4)
int32 PlayerSleepStartHour;
// 0x062C (size: 0x4)
int32 NightSkipWaitSecond;
// 0x0630 (size: 0x4)
float LocalPlayerAndOtomo_LightRangeScale;
// 0x0634 (size: 0x4)
FVector BuildBaseUnitGridDefinition;
// 0x0638 (size: 0x18)
float BuildSimulationVerticalAdjustRate;
// 0x0650 (size: 0x4)
float BuildSimulationVerticalMinLength;
// 0x0654 (size: 0x4)
float BuildSimulationFoundationFloatingAllowance;
// 0x0658 (size: 0x4)
TMap<class EPalBuildObjectInstallStrategy, class FVector>
BuildSimulationFoundationCheckCollisionScale; // 0x0660 (size: 0x50)
float BuildSimulationRoofHeightOffset;
// 0x06B0 (size: 0x4)
float BuildSimulationStairHeightOffset;
// 0x06B4 (size: 0x4)
float BuildSimulationLeanAngleMax;
// 0x06B8 (size: 0x4)
float BuildingProgressInterpolationSpeed;
// 0x06BC (size: 0x4)
int32 PlayerRecord_BuildingObjectMaxNum;
// 0x06C0 (size: 0x4)
float BuildingMaxZ;
// 0x06C4 (size: 0x4)
int32 BuildObj_HatchedPalCharacterLevel;
// 0x06C8 (size: 0x4)
float BuildObj_DamageScarecrowStartRecoveryTime;
// 0x06CC (size: 0x4)
float BaseCampAreaRange;
// 0x06D0 (size: 0x4)
float BaseCampPalFindWorkRange;
// 0x06D4 (size: 0x4)
float PalArriveToWorkLocationRange;
// 0x06D8 (size: 0x4)
float PalArriveToWorkLocationRangeZ;
// 0x06DC (size: 0x4)
float BaseCampNeighborMinimumDistance;
// 0x06E0 (size: 0x4)
float PalRotateSpeedToWork;
// 0x06E4 (size: 0x4)
float BaseCampFoliageWorkableRange;
// 0x06E8 (size: 0x4)
float BaseCampHungerApproachToPlayer;
// 0x06EC (size: 0x4)
float BaseCampHungerUnreachableObjectTimeoutRealSeconds;
// 0x06F0 (size: 0x4)
float HungerHUDDisplayRange;
// 0x06F4 (size: 0x4)
float WorkAmountBySecForPlayer;
// 0x06F8 (size: 0x4)
float BaseCampWorkerEventTriggerInterval;
// 0x06FC (size: 0x4)
float BaseCampWorkerEventTriggerProbability;
// 0x0700 (size: 0x4)
float BaseCampWorkerSanityWarningThreshold;
// 0x0704 (size: 0x4)
float BaseCampWorkerFinishEatingFullStomach;
// 0x0708 (size: 0x4)
float BaseCampWorkerFinishEatingSanity;
// 0x070C (size: 0x4)
int32 BaseCampWorkerFinishEatCount;
// 0x0710 (size: 0x4)
float BaseCampWorkerRecoverHungryTurnToTargetTimeout;
// 0x0714 (size: 0x4)
float BaseCampWorkerStartSleepHpPercentage;
// 0x0718 (size: 0x4)
float BaseCampWorkerSleepInPlaceRecoverSanityRate;
// 0x071C (size: 0x4)
float BaseCampWorkerDistancePickableItem;
// 0x0720 (size: 0x4)
TArray<EPalBaseCampItemContainerType> BaseCampBuildingItemContainerPriority;
// 0x0728 (size: 0x10)
float FoliageRespawnFailedExtraRangeOfBaseCamp;
// 0x0738 (size: 0x4)
float BaseCampPalCombatRange_AddCampRange;
// 0x073C (size: 0x4)
FFloatInterval BaseCampPalWalkTime_BeforeSleep;
// 0x0740 (size: 0x8)
float BaseCampTimeFinishBattleModeAfterEmptyEnemy;
// 0x0748 (size: 0x4)
EPalCharacterImportanceType BaseCampWorkerMoveModeChangeThreshold;
// 0x074C (size: 0x1)
int32 BaseCampWorkerDirectorTickForAssignWorkByCount;
// 0x0750 (size: 0x4)
float BaseCampWorkerLookToTargetWork;
// 0x0754 (size: 0x4)
float ReviveWorkAdditionalRange;
// 0x0758 (size: 0x4)
float WorkAroundRangeDefault;
// 0x075C (size: 0x4)
TArray<EPalWorkType> IssueNotifyWorkTypes;
// 0x0760 (size: 0x10)
float WorkAmountByManMonth;
// 0x0770 (size: 0x4)
float WorkNotifyDelayTime;
// 0x0774 (size: 0x4)
float WorkFinishDelayCallAddWorkNotifyDelayTime;
// 0x0778 (size: 0x4)
float WorkIgnitionTorchWaitTime;
// 0x077C (size: 0x4)
TMap<class EPalWorkAssignableCheckResult, class
EPalMonsterControllerBaseCampLogType> WorkAssignFailedLogTypeMap; // 0x0780 (size:
0x50)
float WorkTransportingSpeedRate;
// 0x07D0 (size: 0x4)
TArray<FPalDataTableRowName_ItemData> BaseCampNotTransportItemBlackList;
// 0x07D8 (size: 0x10)
float WorkTransportingDelayTimeDropItem;
// 0x07E8 (size: 0x4)
float BaseCampStopProvideEnergyInterval;
// 0x07EC (size: 0x4)
TMap<class EPalBaseCampPassiveEffectWorkHardType, class
FPalBaseCampPassiveEffectWorkHardInfo> BaseCampPassiveEffectWorkHardInfoMap; //
0x07F0 (size: 0x50)
float BaseCampWorkCollectionRestoreStashSeconds;
// 0x0840 (size: 0x4)
TArray<FPalWorkTypeSet> WorkTypeAssignPriorityOrder;
// 0x0848 (size: 0x10)
FPalWorkAssignDefineDataStaticSetting WorkAssignDefineData_Build;
// 0x0858 (size: 0x40)
FPalWorkAssignDefineDataStaticSetting WorkAssignDefineData_FoliageWork;
// 0x0898 (size: 0x40)
FPalWorkAssignDefineDataStaticSetting WorkAssignDefineData_ReviveCharacterWork;
// 0x08D8 (size: 0x40)
FPalWorkAssignDefineDataStaticSetting
WorkAssignDefineData_TransportItemInBaseCamp; // 0x0918 (size: 0x40)
FPalWorkAssignDefineDataStaticSetting
WorkAssignDefineData_RepairBuildObjectInBaseCamp; // 0x0958 (size: 0x40)
FPalWorkAssignDefineDataStaticSetting WorkAssignDefineData_BreedFarm;
// 0x0998 (size: 0x40)
FPalWorkAssignDefineDataStaticSetting WorkAssignDefineData_ExtinguishBurn;
// 0x09D8 (size: 0x40)
int32 WorkSuitabilityMaxRank;
// 0x0A18 (size: 0x4)
TMap<class EPalWorkSuitability, class FPalWorkSuitabilityDefineData>
WorkSuitabilityDefineDataMap; // 0x0A20 (size: 0x50)
FPalWorkSuitabilityCollectionDefineData WorkSuitabilityDefineData_Collection;
// 0x0A70 (size: 0x28)
FPalWorkSuitabilityDeforestDefineData WorkSuitabilityDefineData_Deforest;
// 0x0A98 (size: 0x28)
FPalWorkSuitabilityMiningDefineData WorkSuitabilityDefineData_Mining;
// 0x0AC0 (size: 0x28)
int32 DropItemWaitInsertMaxNumPerTick;
// 0x0AE8 (size: 0x4)
FPalDungeonMarkerPointSpawnParameter DungeonSpawnParameterDefault;
// 0x0AEC (size: 0x10)
float GamePad_NotAimCameraRotateSpeed_DegreePerSecond;
// 0x0AFC (size: 0x4)
float GamePad_AimCameraRotateSpeed_DegreePerSecond;
// 0x0B00 (size: 0x4)
float Mouse_NotAimCameraRotateSpeed;
// 0x0B04 (size: 0x4)
float Mouse_AimCameraRotateSpeed;
// 0x0B08 (size: 0x4)
float YawCameraMaxSpeedRate;
// 0x0B0C (size: 0x4)
float TimeForCameraMaxSpeed;
// 0x0B10 (size: 0x4)
float AimInterpInterval;
// 0x0B14 (size: 0x4)
int32 InvaderSelfDeleteAddTime;
// 0x0B18 (size: 0x4)
float InvadeProbability;
// 0x0B1C (size: 0x4)
int32 InvadeOccurablePlayerLevel;
// 0x0B20 (size: 0x4)
int32 InvadeJudgmentInterval_Minutes;
// 0x0B24 (size: 0x4)
int32 InvadeCollTime_Max_Minutes;
// 0x0B28 (size: 0x4)
int32 InvadeCollTime_Min_Minutes;
// 0x0B2C (size: 0x4)
int32 InvadeReturnTime_Minutes;
// 0x0B30 (size: 0x4)
int32 InvadeStartPoint_BaseCampRadius_Min_cm;
// 0x0B34 (size: 0x4)
int32 InvadeStartPoint_BaseCampRadius_Max_cm;
// 0x0B38 (size: 0x4)
float VisitorNPCProbability;
// 0x0B3C (size: 0x4)
int32 VisitorNPCReturnTime_Minutes;
// 0x0B40 (size: 0x4)
float RidingAimOpacity;
// 0x0B44 (size: 0x4)
float hideUITimeWhenNotConflict;
// 0x0B48 (size: 0x4)
float firstCapturedUIDisplayTime;
// 0x0B4C (size: 0x4)
float capturedUIDisplayTime;
// 0x0B50 (size: 0x4)
float firstActivatedOtomoInfoDisplayTime;
// 0x0B54 (size: 0x4)
float playerLevelUpUIDIsplayTime;
// 0x0B58 (size: 0x4)
float playerExpGaugeUIDisplayTime;
// 0x0B5C (size: 0x4)
float otomoExpGaugeUIDisplayTime;
// 0x0B60 (size: 0x4)
float npcGaugeDisplayDistance;
// 0x0B64 (size: 0x4)
float npcGaugeDisplayRange_CameraSight;
// 0x0B68 (size: 0x4)
float GuildMemberGaugeDisplayDIstance;
// 0x0B6C (size: 0x4)
float downPlayerLoupeDisplayDistance;
// 0x0B70 (size: 0x4)
float downPlayerGaugeDisplayRange_CameraSight;
// 0x0B74 (size: 0x4)
FVector2D ReticleOffsetRate;
// 0x0B78 (size: 0x10)
int32 lowHealthEffectParcent;
// 0x0B88 (size: 0x4)
TMap<EPalDamageTextType, int32> damageTextMargineMap;
// 0x0B90 (size: 0x50)
float DamageTextDisplayLength;
// 0x0BE0 (size: 0x4)
FVector2D damageTextMaxOffset;
// 0x0BE8 (size: 0x10)
float damageTextOffsetInterpolationLength;
// 0x0BF8 (size: 0x4)
TMap<EPalDamageTextType, float> damageTextScaleMap;
// 0x0C00 (size: 0x50)
FVector2D damageTextRandomOffset;
// 0x0C50 (size: 0x10)
int32 strongEnemyMarkLevel;
// 0x0C60 (size: 0x4)
float otomoInteractUIDisplayDistance;
// 0x0C64 (size: 0x4)
float enemyMarkUIMinScale;
// 0x0C68 (size: 0x4)
float enemyMarkScaleInterpolationLength;
// 0x0C6C (size: 0x4)
FVector2D npcHPGaugeGlobalOffset;
// 0x0C70 (size: 0x10)
float delayGaugeStartTime;
// 0x0C80 (size: 0x4)
float delayGaugeProgressPerSecond;
// 0x0C84 (size: 0x4)
float inventoryWeaponRangeMaxBorder;
// 0x0C88 (size: 0x4)
float inventoryWeaponStabilityMinBorder;
// 0x0C8C (size: 0x4)
float inventoryWeaponAccuracyMinBorder;
// 0x0C90 (size: 0x4)
float worldmapUIMaskClearSize;
// 0x0C94 (size: 0x4)
float worldmapUIFTMergeDistance;
// 0x0C98 (size: 0x4)
int32 worldmapUIMaxMarker;
// 0x0C9C (size: 0x4)
float NPCHPGaugeUpdateSpan;
// 0x0CA0 (size: 0x4)
float CaptureFailedUIDisplayTime;
// 0x0CA4 (size: 0x4)
TArray<FPalDataTableRowName_ItemData> CaptureSphereSortArray;
// 0x0CA8 (size: 0x10)
float OpenGameOverUITime;
// 0x0CB8 (size: 0x4)
float BlockRespawnTime;
// 0x0CBC (size: 0x4)
float InventoryWeightAlertRate;
// 0x0CC0 (size: 0x4)
float InventoryWeightGaugeDIsplayTime;
// 0x0CC4 (size: 0x4)
float OtomoLevelUpNoticeUIDisplayTime;
// 0x0CC8 (size: 0x4)
float OtomoMasteredWazaNoticeUIDisplayTime;
// 0x0CCC (size: 0x4)
float ProgressGaugeInterpolationSpeed;
// 0x0CD0 (size: 0x4)
float TeleportFadeInTime;
// 0x0CD4 (size: 0x4)
float TeleportFadeOutTime;
// 0x0CD8 (size: 0x4)
float PlayerTeleportTimeoutTime;
// 0x0CDC (size: 0x4)
TArray<float> PassiveSkillAppendNumWeights;
// 0x0CE0 (size: 0x10)
bool bIsEggLauncherExplosion;
// 0x0CF0 (size: 0x1)
float ThrowPalBattleRadius;
// 0x0CF4 (size: 0x4)
float ThrowPalWorkRadius;
// 0x0CF8 (size: 0x4)
float RopeHitPowe;
// 0x0CFC (size: 0x4)
float RopePullPower;
// 0x0D00 (size: 0x4)
float DefaultMaxInventoryWeight;
// 0x0D04 (size: 0x4)
float RaycastLengthForDetectIndoor;
// 0x0D08 (size: 0x4)
float MapObjectConnectAnyPlaceRaycastLength;
// 0x0D0C (size: 0x4)
float ShootingTargetRayCastDistance;
// 0x0D10 (size: 0x4)
TArray<float> CaptureJudgeRateArray;
// 0x0D18 (size: 0x10)
int32 CaptureBallBoundCountMax;
// 0x0D28 (size: 0x4)
TArray<FName> ExceptCapturedItemList;
// 0x0D30 (size: 0x10)
TMap<EPalCaptureSphereLevelType, int32> CaptureSphereLevelMap;
// 0x0D40 (size: 0x50)
TMap<EPalStatusID, float> CaptureRateAddByStatusMap;
// 0x0D90 (size: 0x50)
float IgnoreFirstCaptureFailedHPRate;
// 0x0DE0 (size: 0x4)
float CaptureRateAdd_ByLegHold;
// 0x0DE4 (size: 0x4)
float LongPressInterval;
// 0x0DE8 (size: 0x4)
float LongPressInterval_EnemyCampCage;
// 0x0DEC (size: 0x4)
float LongPressInterval_GetHatchedPal;
// 0x0DF0 (size: 0x4)
float CrouchLockAttenuation;
// 0x0DF4 (size: 0x4)
bool IsEnableCharacterWazaScale;
// 0x0DF8 (size: 0x1)
bool IsOverrideDamageAdditiveAnimation;
// 0x0DF9 (size: 0x1)
float BlinkInterval;
// 0x0DFC (size: 0x4)
float CrimeStateMaintainDurationBaseDefault;
// 0x0E00 (size: 0x4)
int32 technologyPointPerLevel;
// 0x0E04 (size: 0x4)
int32 bossTechnologyPointPerTowerBoss;
// 0x0E08 (size: 0x4)
int32 bossTechnologyPointPerNormalBoss;
// 0x0E0C (size: 0x4)
TArray<FPalDataTableRowName_RecipeTechnologyData> DefaultUnlockTechnology;
// 0x0E10 (size: 0x10)
int32 DefaultTechnologyPoint;
// 0x0E20 (size: 0x4)
int32 TechnologyPoint_UnlockFastTravel;
// 0x0E24 (size: 0x4)
float DecreaseSanity_DamagedMultiply;
// 0x0E28 (size: 0x4)
int32 FullStomachPercent_RecoverySanity;
// 0x0E2C (size: 0x4)
float RecoverySanity_FullStomach;
// 0x0E30 (size: 0x4)
float DecreaseSanity_Hunger;
// 0x0E34 (size: 0x4)
float DecreaseSanity_Starvation;
// 0x0E38 (size: 0x4)
bool Spawner_IsCheckLoadedWorldPartition;
// 0x0E3C (size: 0x1)
float SpawnerDisableDistanceCM_FromBaseCamp;
// 0x0E40 (size: 0x4)
float Spawner_DefaultSpawnRadius_S;
// 0x0E44 (size: 0x4)
float Spawner_DefaultSpawnRadius_M;
// 0x0E48 (size: 0x4)
float Spawner_DefaultSpawnRadius_L;
// 0x0E4C (size: 0x4)
float Spawner_DefaultSpawnRadius_NPC;
// 0x0E50 (size: 0x4)
float Spawner_DefaultDespawnDistance_S;
// 0x0E54 (size: 0x4)
float Spawner_DefaultDespawnDistance_M;
// 0x0E58 (size: 0x4)
float Spawner_DefaultDespawnDistance_L;
// 0x0E5C (size: 0x4)
float Spawner_DefaultDespawnDistance_NPC;
// 0x0E60 (size: 0x4)
class UDataTable* CharacterHeadMeshDataTable;
// 0x0E68 (size: 0x8)
class UDataTable* CharacterBodyMeshDataTable;
// 0x0E70 (size: 0x8)
class UDataTable* CharacterHairMeshDataTable;
// 0x0E78 (size: 0x8)
class UDataTable* CharacterEquipmentArmorMeshDataTable;
// 0x0E80 (size: 0x8)
class UDataTable* CharacterEyeMaterialDataTable;
// 0x0E88 (size: 0x8)
float CharacterMakeColorLimit_SV;
// 0x0E90 (size: 0x4)
bool IsAutoEquipMasteredWaza;
// 0x0E94 (size: 0x1)
bool ActiveUNKO;
// 0x0E95 (size: 0x1)
int32 MaxSpawnableDeathPenaltyChest;
// 0x0E98 (size: 0x4)
FName BuildObjectInstallStrategy_SinkAllowCollisionPresetName;
// 0x0E9C (size: 0x8)
float MapObjectShakeTimeOnDamaged;
// 0x0EA4 (size: 0x4)
FVector MapObjectShakeOffsetOnDamaged;
// 0x0EA8 (size: 0x18)
int32 MapObjectOutlineByReticleTargetting;
// 0x0EC0 (size: 0x4)
int32 MapObjectOutlineByInteractable;
// 0x0EC4 (size: 0x4)
FPalMapObjectRepairInfo MapObjectRepairInfo;
// 0x0EC8 (size: 0x10)
float FoliageExtentsXY;
// 0x0ED8 (size: 0x4)
int32 FoliageChunkSeparateScale;
// 0x0EDC (size: 0x4)
float MapObjectHPDisplayDistance;
// 0x0EE0 (size: 0x4)
float MapObjectHPDisplayTime;
// 0x0EE4 (size: 0x4)
float MapObjectGateLockTime;
// 0x0EE8 (size: 0x4)
bool bDirectObtainFromTreasureBox;
// 0x0EEC (size: 0x1)
float MapObjectEffectTriggerAccumulate_Burn;
// 0x0EF0 (size: 0x4)
float MapObjectEffect_Burn_DamageHpRate;
// 0x0EF4 (size: 0x4)
FVector MapObjectEffect_Burn_DamageAroundRange;
// 0x0EF8 (size: 0x18)
float MapObjectEffect_Burn_DamageAroundInterval;
// 0x0F10 (size: 0x4)
float MapObjectEffect_Burn_DamageAroundDamageValue;
// 0x0F14 (size: 0x4)
float MapObjectEffect_Burn_DamageAroundAccumulateValue;
// 0x0F18 (size: 0x4)
float MapObjectEffect_Burn_DamageAroundAccumulateValue_ForCharacter;
// 0x0F1C (size: 0x4)
int32 PasswordLockFailedMaxNum;
// 0x0F20 (size: 0x4)
float MapObjectItemChestCorruptionRateFromWorkSpeed;
// 0x0F24 (size: 0x4)
FPalOptimizeParameter RuntimeOptimizeParameter;
// 0x0F28 (size: 0x490)
TMap<int32, FPalWorldSecurityWantedPoliceSettingData>
WorldSecurityWantedPoliceSettingDataMap; // 0x13B8 (size: 0x50)
TMap<int32, FPalWorldSecurityWantedPoliceSettingData>
WorldSecurityWantedPoliceSettingDataMapForDS; // 0x1408 (size: 0x50)
int32 StatusPointPerLevel;
// 0x1458 (size: 0x4)
float AddMaxHPPerStatusPoint;
// 0x145C (size: 0x4)
float AddMaxSPPerStatusPoint;
// 0x1460 (size: 0x4)
float AddPowerPerStatusPoint;
// 0x1464 (size: 0x4)
float AddMaxInventoryWeightPerStatusPoint;
// 0x1468 (size: 0x4)
float AddCaptureLevelPerStatusPoint;
// 0x146C (size: 0x4)
float AddWorkSpeedPerStatusPoint;
// 0x1470 (size: 0x4)
float AddMaxHPPerHPRank;
// 0x1474 (size: 0x4)
float AddAttackPerAttackRank;
// 0x1478 (size: 0x4)
float AddDefencePerDefenceRank;
// 0x147C (size: 0x4)
float AddWorkSpeedPerWorkSpeedRank;
// 0x1480 (size: 0x4)
TArray<float> Combi_TalentInheritNum;
// 0x1488 (size: 0x10)
TArray<float> Combi_PassiveInheritNum;
// 0x1498 (size: 0x10)
TArray<float> Combi_PassiveRandomAddNum;
// 0x14A8 (size: 0x10)
TArray<FPalEggRankInfo> PalEggRankInfoArray;
// 0x14B8 (size: 0x10)
TMap<class EPalElementType, class FPalDataTableRowName_MapObjectData>
PalEggMapObjectIdMap; // 0x14C8 (size: 0x50)
TMap<int32, float> PalEggHatchingSpeedRateByTemperature;
// 0x1518 (size: 0x50)
class UFont* DebugInfoFont;
// 0x1568 (size: 0x8)
int32 MaxGuildNameLength;
// 0x1570 (size: 0x4)
float JoinGuildRequestInteractLongPushTime;
// 0x1574 (size: 0x4)
float TutorialMinDisplayTime;
// 0x1578 (size: 0x4)
float TutorialDisplayTime;
// 0x157C (size: 0x4)
TMap<EPalUIRewardDisplayType, float> CommonRewardDisplayTime;
// 0x1580 (size: 0x50)
float DeadBodyDestroySecond;
// 0x15D0 (size: 0x4)
float EnemyCampRespawnCoolTime;
// 0x15D4 (size: 0x4)
float EnemyCampDespawnDelayTime;
// 0x15D8 (size: 0x4)
float PalBoxReviveTime;
// 0x15DC (size: 0x4)
float AfterNPCTalkDelayTime_Interact;
// 0x15E0 (size: 0x4)
float MinSprintThreshold;
// 0x15E4 (size: 0x4)
float MaxSprintThreshold;
// 0x15E8 (size: 0x4)
float MinHPGaugeDisplayTime;
// 0x15EC (size: 0x4)
class UDataTable* SoundSourceDataTable;
// 0x15F0 (size: 0x8)
TMap<class EPalPlatformType, class TSubclassOf<UPalOptimizeParameterSetting>>
OptimizeParameterSettingClass; // 0x15F8 (size: 0x50)
bool TryGetWorkSuitabilityDefineData(const EPalWorkSuitability WorkSuitability,

FPalWorkSuitabilityDefineData& outDefineData);
bool IsSoundMuteable(FName RowName);
float GetWeakScale(int32 weakCount);
int32 GetSoundRadius_cm(FName RowName);
class UPalOptionSubsystem* GetOptionSubsystem(const class UObject*
void GetMiningRankDefineData(int32 MiningRank, FPalMiningRankDefineData&
outDefineData);
float GetMiningDamageRate(int32 MiningRank);
float GetEnemyMarkScale(const FVector& targetPosition, const FVector&
selfPosition);
void GetDeforestRankDefineData(int32 DeforestRank, FPalDeforestRankDefineData&
outDefineData);
float GetDeforestDamageRate(int32 DeforestRank);
float GetCollectionDropNumRate(int32 CollectionRank);
float GetCaptureRateByStatus_ForGameSettingBP(const class AActor* TargetPal);
int32 GetCaptureLevelBySphereType(EPalCaptureSphereLevelType SphereType);
float CalcCaptureRate(float captureItemLevel, const class
UPalIndividualCharacterHandle* targetHandle, const class
UPalIndividualCharacterHandle* throwCharacterHandle);
}; // Size: 0x1648
class UPalGameStateReplicatorBase : public UObject
{
}; // Size: 0x28
class UPalGameSystemInitManagerComponent : public UGameStateComponent

{
TArray<FPalGameSystemInitSequenceSet> InitSequences;
// 0x00E0 (size: 0x10)
int32 CurrentSequenceIndex;
// 0x00F0 (size: 0x4)
void OnChangeProcessState(class UPalGameSystemInitProcessHandle*

ChangedProcessHandle);
void OnChangeProcessProgressRate(class UPalGameSystemInitProcessHandle*
ChangedProcessHandle);
}; // Size: 0xF8
class UPalGameSystemInitProcessHandle : public UObject

{
TArray<class UPalGameSystemInitProcessHandle*> ChildProcessHandles;
// 0x0050 (size: 0x10)
}; // Size: 0x68
class UPalGameSystemInitSequenceBase : public UObject

{
TArray<class UPalGameSystemInitProcessHandle*> ProcessHandles;
// 0x0028 (size: 0x10)
}; // Size: 0x38
class UPalGameSystemInitSequence_ApplyWorldSaveData : public

UPalGameSystemInitSequenceBase
{
}; // Size: 0x38
class UPalGameSystemInitSequence_CreateSystemForDedicatedServer : public

{
}; // Size: 0x38
class UPalGameSystemInitSequence_InitializeWorld : public

{
}; // Size: 0x38
class UPalGameSystemInitSequence_InitializeWorldAfterAppliedSaveData : public

{
}; // Size: 0x38
class UPalGameSystemInitSequence_MapObjectRegistration : public

{
}; // Size: 0x38
class UPalGameSystemInitSequence_ReadyWorldSaveData : public

{
}; // Size: 0x38
class UPalGameSystemInitSequence_StartAutoSave_WorldAndLocal : public

{
}; // Size: 0x38
class UPalGameSystemInitSequence_StartAutoSave_WorldOnly : public

{
}; // Size: 0x38
class UPalGameSystemInitSequence_WaitForLocalNetworkTransmitter : public

{
}; // Size: 0x38
class UPalGameSystemInitSequence_WaitForLocalPlayerStateSetup : public

{
}; // Size: 0x38
class UPalGameSystemInitSequence_WaitForWorldSystemInit : public

{
}; // Size: 0x38
class UPalGameViewportClient : public UCommonGameViewportClient

{
}; // Size: 0x3E0
class UPalGameWorldSettings : public UObject

{
FPalOptionWorldSettings OptionSettings;
// 0x0028 (size: 0x128)
}; // Size: 0x150
class UPalGaugeInterpolationCalculatorUtility : public UBlueprintFunctionLibrary

{
void TickGaugeInterpolation(const class UObject* WorldContextObject,

FPalGaugeInterpolationCalculator& Target, const float DeltaTime);
void SetGaugeInterpolationTargetValue(FPalGaugeInterpolationCalculator& Target,
const float TargetValue);
}; // Size: 0x28
class UPalGetWorldUObject : public UObject

{
}; // Size: 0x28
class UPalGliderComponent : public UActorComponent

{
FPalGliderComponentOnStartGlidingDelegate OnStartGlidingDelegate;
// 0x00A0 (size: 0x10)
FPalGliderComponentOnEndGlidingDelegate OnEndGlidingDelegate;
// 0x00B0 (size: 0x10)
TArray<FPalGliderPalInfo> GliderPalInfos;
// 0x00C0 (size: 0x10)
class APalGliderObject* CurrentGlider;
// 0x00D0 (size: 0x8)
TSoftClassPtr<APalGliderObject> CurrentGliderSoftClass;
// 0x00D8 (size: 0x30)
TSubclassOf<class APalGliderObject> CurrentGliderClass;
// 0x0108 (size: 0x8)
bool bIsGliding;
// 0x0110 (size: 0x1)
TryGetGliderIndividualHandleFromOtomoHolder();
void StopGliderSound(const FPalDataTableRowName_SoundID& ID);
void StartGliding_ToServer();
void StartGliding();
void SetCurrentGliderSoftClass_ToServer(const TSoftClassPtr<APalGliderObject>&
gliderSoftClass);
void PlayGliderSound(const FPalDataTableRowName_SoundID& ID, const
FPalSoundOptions& Option);
void OnUpdateOtomoHolderSlot(int32 SlotIndex, class
UPalIndividualCharacterHandle* LastHandle);
void OnUpdateOtomoHolderInitialized(class APalCharacter* Character);
void OnUpdateIndividualActor(class UPalIndividualCharacterHandle* Handle);
void OnUpdateEquipmentSlot(class UPalItemSlot* itemSlot,
void OnStartGliding__DelegateSignature();
void OnRep_IsGliding();
void OnRep_CurrentGliderSoftClass();
void OnInitializeGlider();
void OnEndGliding__DelegateSignature();
void OnDeadGliderPal(FPalDeadInfo DeadInfo);
void OnCompleteOwnerInitialize();
void OnChangeMovementMode(class UPalCharacterMovementComponent* Component,
TEnumAsByte<EMovementMode> prevMode, TEnumAsByte<EMovementMode> newMode,
NewCustomMode);
void OnChangeGliderVisibility(bool bIsVisibility);
bool IsGliding();
bool IsEquipGlider();
bool HasGliderPal();
TArray<FName> GetAllGliderPalNames();
void EndGliding_ToServer();
void EndGliding();
bool CanGliding();
bool CanEndGliding();
void CancelGliding();
}; // Size: 0x118
class UPalGroupBase : public UObject

{
FPalGroupBaseOnChangedGroupName OnChangedGroupName;
// 0x0030 (size: 0x10)
void ChangedGroupNameDelegate(FString NewGroupName);
FPalGroupBaseOnEnterCharacterDelegate OnEnterCharacterDelegate;
// 0x0040 (size: 0x10)
void IndividualHandleDelegate(class UPalIndividualCharacterHandle*
IndividualHandle);
FPalGroupBaseOnExitCharacterDelegate OnExitCharacterDelegate;
// 0x0050 (size: 0x10)
void IndividualHandleDelegate(class UPalIndividualCharacterHandle*
IndividualHandle);
FGuid ID;
// 0x0060 (size: 0x10)
FString GroupName;
// 0x0070 (size: 0x10)
TArray<FPalInstanceID> IndividualCharacterHandleIds;
// 0x0080 (size: 0x10)
void OnUpdateIndividualActor(class UPalIndividualCharacterHandle*

CharacterHandle);
void OnRep_GroupName();
void IndividualHandleDelegate__DelegateSignature(class
FGuid GetId();
FString GetGroupName();
void ChangedGroupNameDelegate__DelegateSignature(FString NewGroupName);
}; // Size: 0x98
class UPalGroupDefine : public UObject

{
}; // Size: 0x28
class UPalGroupGuild : public UPalGroupGuildBase

{
FPalFastGuildPlayerInfoRepInfoArray PlayerInfoRepInfoArray;
// 0x0130 (size: 0x148)
FGuid AdminPlayerUId;
// 0x0278 (size: 0x10)
void OnChangedGuildMemberNickName(class UPalIndividualCharacterParameter*

Parameter, FString NickName);
}; // Size: 0x288
class UPalGroupGuildBase : public UPalGroupOrganization

{
class UPalGuildPalStorage* PalStorage;
// 0x00F0 (size: 0x8)
TArray<FGuid> MapObjectInstanceIds_BaseCampPoint;
// 0x00F8 (size: 0x10)
int32 BaseCampLevel;
// 0x0108 (size: 0x4)
TWeakObjectPtr<class APalGuildInfo> WeakGuildInfo;
// 0x010C (size: 0x8)
FString GuildName;
// 0x0118 (size: 0x10)
bool bAllPlayerNotOnlineAndAlreadyReset;
// 0x0128 (size: 0x1)
void UpdatedGuildNameDelegate__DelegateSignature(FString NewGuildName);

void ReturnSelfDelegate__DelegateSignature(class UPalGroupGuildBase* Self);
EPalGroupOperationResult RequestDismantleBaseCamp(const FGuid& BaseCampId);
void OnRep_Guildname();
void OnRep_BaseCampLevel(int32 OldValue);
void OnDeletePlayerAccount_ServerInternal(class UPalPlayerAccount*
DeleteAccount);
void NotifyPlayerInfoDelegate__DelegateSignature(const class
UPalGroupGuildBase* Self, const FGuid& PlayerUId, const FPalGuildPlayerInfo&
PlayerInfo);
FString GetGuildName();
int32 GetBaseCampMaxNumInGuild();
int32 GetBaseCampLevel();
}; // Size: 0x130
class UPalGroupIndependentGuild : public UPalGroupGuildBase

{
FGuid PlayerUId;
// 0x0130 (size: 0x10)
FPalGuildPlayerInfo PlayerInfo;
// 0x0140 (size: 0x20)
}; // Size: 0x160
class UPalGroupManager : public UPalWorldSubsystem

{
TMap<class FGuid, class UPalGroupBase*> GroupMap;
// 0x0078 (size: 0x50)
TMap<class FGuid, class UPalGroupGuildBase*> GuildMap;
// 0x00C8 (size: 0x50)
TMap<class EPalOrganizationType, class EPalGroupType>
StaticOrganizationGroupTypeMap; // 0x0118 (size: 0x50)
TMap<class EPalOrganizationType, class FGuid> StaticOrganizationGroupIdMap;
// 0x0168 (size: 0x50)
bool TryGetGuildName(const FGuid& GroupID, FString& OutGuildName);

bool TryGetGroupName(const FGuid& GroupID, FString& OutGroupName);
bool IsExistGroup(FString GroupName);
FGuid GetOrganizationGroupId(const class UObject* WorldContextObject, const
EPalOrganizationType OrganizationType);
void Debug_RequestNewGroup(FPalGroupCreateParameter CreateParam,
FDebug_RequestNewGroupCallback Callback);
void Debug_RequestExitGroup(const FPalInstanceID& IndividualId,
FDebug_RequestExitGroupCallback Callback);
void Debug_RequestEnterGroup(const FPalInstanceID& IndividualId, const FGuid&
GroupID, FDebug_RequestEnterGroupCallback Callback);
void Debug_RequestDisposeGroup(const FGuid& GroupID,
FDebug_RequestDisposeGroupCallback Callback);
class UPalGroupBase* Debug_GetFirstGroupByType(const EPalGroupType Type);
}; // Size: 0x1C8
class UPalGroupNeutral : public UPalGroupBase

{
}; // Size: 0x98
class UPalGroupOperationResultUtility : public UObject

{
}; // Size: 0x28
class UPalGroupOrganization : public UPalGroupBase

{
EPalOrganizationType OrganizationType;
// 0x00A0 (size: 0x1)
TArray<FGuid> BaseCampIds;
// 0x00A8 (size: 0x10)
void OnDead(FPalDeadInfo DeadInfo);

}; // Size: 0xB8
class UPalGroupUtility : public UBlueprintFunctionLibrary

{
EPalOrganizationType GetOrganizationTypeByIndividualId(const class UObject*

WorldContextObject, const FPalInstanceID& IndividualId);
EPalOrganizationType GetOrganizationTypeByIndividualHandle(const class UObject*
WorldContextObject, class UPalIndividualCharacterHandle* IndividualHandle);
class UPalGroupGuildBase* GetLocalPlayerGuild(const class UObject*
FGuid GetGroupIdByIndividualId(const class UObject* WorldContextObject, const
}; // Size: 0x28
class UPalGuildJoinRequestResultUtility : public UObject

{
}; // Size: 0x28
class UPalGuildPalStorage : public UObject

{
void OnNotifiedRemovedCharacterFromPalBoxInServer(class
void OnNotifiedObtainCharacterInServer(class UPalIndividualCharacterHandle*
Handle);
}; // Size: 0x38
class UPalGuildPlayerInfoUtility : public UBlueprintFunctionLibrary

{
bool IsValid(const FPalGuildPlayerInfo& PlayerInfo);

}; // Size: 0x28
class UPalHUDDispatchParame_JoinGameInputCode : public UPalHUDDispatchParameterBase

{
EPalUIJoinGameInputCodeType InputCodeType;
// 0x0038 (size: 0x1)
FPalUIServerDisplayData TargetServerDisplayInfo;
// 0x0040 (size: 0x1A0)
}; // Size: 0x1E0
class UPalHUDDispatchParameterBase : public UObject

{
FPalHUDDispatchParameterBaseOnClose OnClose;
// 0x0028 (size: 0x10)
void BeginDestroyDelegate(class UPalHUDDispatchParameterBase* Param);
}; // Size: 0x38
class UPalHUDDispatchParameter_Authentication : public

UPalHUDDispatchParameter_MapObject
{
bool IsAuthentication;
// 0x0040 (size: 0x1)
}; // Size: 0x48
class UPalHUDDispatchParameter_BaseCampTask : public UPalHUDDispatchParameterBase

{
FGuid TargetBaseCampId;
// 0x0038 (size: 0x10)
}; // Size: 0x48
class UPalHUDDispatchParameter_CharacterDisplay : public

UPalHUDDispatchParameterBase
{
class UPalMapObjectDisplayCharacterModel* Model;
// 0x0038 (size: 0x8)
}; // Size: 0x40
class UPalHUDDispatchParameter_CharacterMake : public UPalHUDDispatchParameterBase

{
bool bIsNewGame;
// 0x0038 (size: 0x1)
}; // Size: 0x40
class UPalHUDDispatchParameter_CharacterRankUp : public

{
class UPalMapObjectRankUpCharacterModel* ConcreteModel;
// 0x0038 (size: 0x8)
}; // Size: 0x40
class UPalHUDDispatchParameter_CharacterStatusOperator : public

{
void GetCharacterStatusOperationResultText(const class UObject*

WorldContextObject, const EPalCharacterStatusOperationResult Type, FText& OutText);
void BindReceiveRequestResultDelegate(const class UObject* WorldContextObject,
FBindReceiveRequestResultDelegateDelegate Delegate);
}; // Size: 0x38
class UPalHUDDispatchParameter_ConvertItem : public UPalHUDDispatchParameterBase

{
class UPalMapObjectConvertItemModel* ConvertItemModel;
// 0x0038 (size: 0x8)
}; // Size: 0x40
class UPalHUDDispatchParameter_CutsceneOverlay : public

{
class UPalCutsceneComponent* CutsceneComponent;
// 0x0038 (size: 0x8)
}; // Size: 0x40
class UPalHUDDispatchParameter_FadeWidget : public UPalHUDDispatchParameterBase
{
EPalFadeWidgetType FadeWidgetType;
// 0x0038 (size: 0x1)
FLinearColor CustomColor;
// 0x003C (size: 0x10)
float FadeInTime;
// 0x004C (size: 0x4)
float FadeOutTime;
// 0x0050 (size: 0x4)
FPalHUDDispatchParameter_FadeWidgetOnStartFadeIn OnStartFadeIn;
// 0x0058 (size: 0x10)
void FadeWidgetDelegate();
FPalHUDDispatchParameter_FadeWidgetOnEndFadeIn OnEndFadeIn;
// 0x0068 (size: 0x10)
FPalHUDDispatchParameter_FadeWidgetOnStartFadeOut OnStartFadeOut;
// 0x0078 (size: 0x10)
FPalHUDDispatchParameter_FadeWidgetOnEndFadeOut OnEndFadeOut;
// 0x0088 (size: 0x10)
}; // Size: 0x98
class UPalHUDDispatchParameter_HatchingEgg : public UPalHUDDispatchParameterBase

{
class UPalMapObjectHatchingEggModel* HatchingEggModel;
// 0x0038 (size: 0x8)
}; // Size: 0x40
class UPalHUDDispatchParameter_HungerIcon : public UPalHUDDispatchParameterBase

{
bool IsExistFood;
// 0x0038 (size: 0x1)
FGuid BelongGroupId;
// 0x003C (size: 0x10)
}; // Size: 0x50
class UPalHUDDispatchParameter_Invader : public UPalHUDDispatchParameterBase

{
TSoftObjectPtr<APalCharacter> ParentCharacter;
// 0x0038 (size: 0x30)
}; // Size: 0x68
class UPalHUDDispatchParameter_ItemShop : public UPalHUDDispatchParameterBase

{
class UPalShopBase* Shop;
// 0x0038 (size: 0x8)
}; // Size: 0x40
class UPalHUDDispatchParameter_MapObject : public UPalHUDDispatchParameterBase

{
class UPalMapObjectConcreteModelBase* MapObjectConcreteModel;
// 0x0038 (size: 0x8)
}; // Size: 0x40
class UPalHUDDispatchParameter_MapObjectEnergyModule : public

{
class UPalMapObjectEnergyModule* EnergyModule;
// 0x0038 (size: 0x8)
}; // Size: 0x40
class UPalHUDDispatchParameter_MonsterDetail : public UPalHUDDispatchParameterBase

{
// 0x0038 (size: 0x8)
}; // Size: 0x40
class UPalHUDDispatchParameter_PalBox : public UPalHUDDispatchParameterBase

{
FGuid BaseCampId;
// 0x0038 (size: 0x10)
}; // Size: 0x48
class UPalHUDDispatchParameter_PalShop : public UPalHUDDispatchParameterBase

{
class UPalShopBase* Shop;
// 0x0038 (size: 0x8)
}; // Size: 0x40
class UPalHUDDispatchParameter_RecoverOtomo : public UPalHUDDispatchParameterBase

{
class UPalMapObjectRecoverOtomoModel* RecoverOtomoModel;
// 0x0038 (size: 0x8)
}; // Size: 0x40
class UPalHUDDispatchParameter_RepairBench : public UPalHUDDispatchParameterBase

{
class UPalMapObjectRepairItemModel* Model;
// 0x0038 (size: 0x8)
}; // Size: 0x40
class UPalHUDDispatchParameter_SelectItemInventory : public

{
FText TitleText;
// 0x0038 (size: 0x18)
TArray<EPalPlayerInventoryType> showInventoryTypes;
// 0x0050 (size: 0x10)
TArray<EPalItemTypeA> showItemTypesA;
// 0x0060 (size: 0x10)
TArray<EPalItemTypeB> showItemTypesB;
// 0x0070 (size: 0x10)
bool shouldSelectNum;
// 0x0080 (size: 0x1)
FPalHUDDispatchParameter_SelectItemInventoryCallback Callback;
// 0x0084 (size: 0x10)
void PalSelectedItemPlayerInventoryDelegate(const FPalItemSlotId& itemSlotId,
const int32 itemNum);
void InvokeCallback(const FPalItemSlotId& itemSlotId, const int32 itemNum);

}; // Size: 0x98
class UPalHUDDispatchParameter_Signboard : public

UPalHUDDispatchParameter_MapObject
{
FString InText;
// 0x0040 (size: 0x10)
FString OutText;
// 0x0050 (size: 0x10)
FPalHUDDispatchParameter_SignboardOnUpdateTextDelegate OnUpdateTextDelegate;
// 0x0060 (size: 0x10)
void UpdateTextDelegate(FString TextValue);
}; // Size: 0x70
class UPalHUDDispatchParameter_WorkerRadialMenu : public

{
// 0x0038 (size: 0x8)
EPalWorkerRadialMenuResult ResultType;
// 0x0040 (size: 0x1)
}; // Size: 0x48
class UPalHUDDispatchParameter_WorldMap : public UPalHUDDispatchParameterBase

{
bool CanFastTravel;
// 0x0038 (size: 0x1)
bool ForRespawn;
// 0x0039 (size: 0x1)
bool IsInitSelect;
// 0x003A (size: 0x1)
}; // Size: 0x40
class UPalHUDDispatchParameter_WorldSetting : public UPalHUDDispatchParameterBase

{
bool IsNewWorld;
// 0x0038 (size: 0x1)
FString WorldSaveDirectoryName;
// 0x0040 (size: 0x10)
FString WorldName;
// 0x0050 (size: 0x10)
}; // Size: 0x60
class UPalHUDLayout : public UPalActivatableWidget

{
TSoftClassPtr<UCommonActivatableWidget> EscapeMenuClass;
// 0x03D0 (size: 0x30)
}; // Size: 0x400
class UPalHUDService : public UObject
{
FPalHUDServiceOnPushedStackableUI OnPushedStackableUI;
// 0x0030 (size: 0x10)
void OnPushedStackableUI(const FGuid& pushedWidgetID);
FPalHUDServiceOnSuccessedCapturePal OnSuccessedCapturePal;
// 0x0040 (size: 0x10)
void OnSuccessedCapturePal(const FPalUIPalCaptureInfo& CaptureInfo);
FPalHUDServiceOnApplicationActivationStateChanged
OnApplicationActivationStateChanged; // 0x0050 (size: 0x10)
void OnApplicationActivationStateChangedDelegate(bool bIsFocused);
FPalHUDServiceOnInvalidatePlayerInputGuard OnInvalidatePlayerInputGuard;
// 0x0060 (size: 0x10)
void InvalidatePlayerInputGuard();
FUITransientData TransientData;
// 0x0070 (size: 0x14)
TScriptInterface<class IPalHUDServiceProviderInterface> ServiceProvider;
// 0x0088 (size: 0x10)
void StartFadeOut(EPalFadeWidgetLayerType LayerType);

void StartFadeIn(EPalFadeWidgetLayerType LayerType, class
UPalHUDDispatchParameter_FadeWidget* FadeParameter);
FGuid ShowCommonUI(const EPalWidgetBlueprintType WBPType, class
void ShowCommonReward(const FPalUICommonRewardDisplayData& RewardDisplayData);
void ShowCommonItemInfo(const FPalUICommonItemInfoDisplayData& DisplayData);
void SetHUDLayerHideFlag(const FGameplayTag& LayerTagName, const FName&
HideReasonName, bool IsHide);
void RemoveWorldHUDFromWidgetId(const FGuid& ID);
void RemoveWorldHUD(const FGuid& ID);
void RemoveHUD(const FGuid& ID);
FGuid Push(TSubclassOf<class UPalUserWidgetStackableUI> WidgetClass, class
void OnSuccessedCapturePal__DelegateSignature(const FPalUIPalCaptureInfo&
CaptureInfo);
void OnPushedStackableUI__DelegateSignature(const FGuid& pushedWidgetID);
void OnApplicationActivationStateChangedDelegate__DelegateSignature(bool
bIsFocused);
void InvokeFunction_Int32(const FName FunctionName, int32 Value);
void InvokeFunction_FName(const FName FunctionName, FName Value);
void InvokeFunction(const FName FunctionName);
void InvalidatePlayerInputGuard__DelegateSignature();
void HideCommonItemInfo();
class UPalUILiftSlotModel* GetLiftSlotModel();
void DeactivateFocusCursor();
class UPalHUDDispatchParameterBase* CreateDispatchParameterForK2Node(const
class UObject* WorldContextObject, TSubclassOf<class UPalHUDDispatchParameterBase>
ParameterClass);
void CloseOwnerStackableUI(const class UObject* InObject);
void CloseOverlayUIAll();
void Close(const FGuid& ID);
FGuid AddWorldHUD(FPalWorldHUDParameter Parameter);
FGuid AddHUD(TSubclassOf<class UPalUserWidget> WidgetClass, const
EPalHUDWidgetPriority Priority, class UPalHUDDispatchParameterBase* Parameter);
void ActivatePlayerInputGuard();
void ActivateFocusCursor(class UWidget* TargetWidget);
}; // Size: 0x98
class UPalHate : public UObject

{
TMap<FPalInstanceID, float> HateMap;
// 0x0028 (size: 0x50)
FTimerHandle HateTimerHandle;
// 0x0078 (size: 0x8)
void SelfDeathEvent(FPalDeadInfo DeadInfo);

void ForceHateUp_ForActiveAndAttackOtomoPal(const class AActor* OtomoPal);
class AActor* FindMostHateTarget();
void DamageEvent(FPalDamageResult DamageResult);
void ChangeHate(const class AActor* Attacker, float PlusHateValue);
void AttackSuccessEvent(FPalDamageResult DamageResult);
}; // Size: 0x80
class UPalHeadUpDisplayComponent : public UActorComponent

{
float HeadUpOffset;
// 0x00A0 (size: 0x4)
void UpdateInvaderHUD();
void ShowInvaderHUD();
void OnUpdatePossessItem(class UPalCharacterParameterComponent* Parameter);
void OnUpdateOwnerCharacterGroupId(const FGuid& GroupID);
}; // Size: 0xD8
class UPalHeatSourceBoxComponent : public UBoxComponent

{
bool DefaultActive;
// 0x0578 (size: 0x1)
class UPalHeatSourceModule* HeatSourceModule;
// 0x0580 (size: 0x8)
void SetActiveHeatSource(bool NextIsActive);

class UPalHeatSourceModule* GetModule();
}; // Size: 0x590
class UPalHeatSourceModule : public UObject

{
TArray<TWeakObjectPtr<AActor>> PlayerList;
// 0x0028 (size: 0x10)
TArray<TWeakObjectPtr<AActor>> ActorList;
// 0x0038 (size: 0x10)
bool IsActive;
// 0x0048 (size: 0x1)
FName UnieqName;
// 0x004C (size: 0x8)
FPalHeatSourceInfo HeatSourceInfo;
// 0x0054 (size: 0x8)
void SetActivate(bool Active);

void RemovePlayer(class AActor* Player);
void RemoveActor(class AActor* Actor);
void InitializeHeatSource(FName SourceName, FPalHeatSourceInfo Info, bool
DefaultActive);
void AddPlayer(class AActor* Player);
void AddActor(class AActor* Actor);
}; // Size: 0x60
class UPalHeatSourceSphereComponent : public USphereComponent

{
bool DefaultActive;
// 0x0560 (size: 0x1)
class UPalHeatSourceModule* HeatSourceModule;
// 0x0568 (size: 0x8)
void SetActiveHeatSource(bool NextIsActive);

class UPalHeatSourceModule* GetModule();
}; // Size: 0x570
class UPalHiddenBoxComponent : public UBoxComponent

{

}; // Size: 0x580
class UPalHiddenCapsuleComponent : public UCapsuleComponent

{

}; // Size: 0x560
class UPalHitEffectSlot : public UObject

{
void PlayHitEffect(const FPalDamageInfo& Info);

void Initialize();
}; // Size: 0x28
class UPalHitFilter : public UObject

{
int32 MaxHitNum;
// 0x0030 (size: 0x4)
float HitInterval;
// 0x0034 (size: 0x4)
TSubclassOf<class UPalHitLocationCalculator> HitLocationCalculator;
// 0x0038 (size: 0x8)
bool bIsIntersectionCollision;
// 0x0040 (size: 0x1)
int32 IntersectionNum;
// 0x0044 (size: 0x4)
FPalHitFilterOnHitDelegate OnHitDelegate;
// 0x0048 (size: 0x10)
void OnHitDelegate(class UPrimitiveComponent* MyHitComponent, class AActor*
OtherHitActor, class UPrimitiveComponent* OtherHitComponent, const TArray<int32>&
FoliageIndex, FVector HitLocation, int32 HitCount);
FPalHitFilterOnOverlapEndDelegate OnOverlapEndDelegate;
// 0x0058 (size: 0x10)
void OverlapEndDelegate(class UPrimitiveComponent* MyHitComponent, class
AActor* OtherHitActor, class UPrimitiveComponent* OtherHitComponent);
void UnbindPrimitiveComponent(class UPrimitiveComponent* Component);

void SetIntersectionNum(int32 Num);
void SetAttacker(class AActor* Attacker);
void ResetFilter();
void OverlapEndDelegate__DelegateSignature(class UPrimitiveComponent*
MyHitComponent, class AActor* OtherHitActor, class UPrimitiveComponent*
OtherHitComponent);
void OnHitDelegate__DelegateSignature(class UPrimitiveComponent*
MyHitComponent, class AActor* OtherHitActor, class UPrimitiveComponent*
OtherHitComponent, const TArray<int32>& FoliageIndex, FVector HitLocation, int32
HitCount);
void OnEndOverlap(class UPrimitiveComponent* OverlappedComp, class AActor*
Other, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex);
void OnBeginOverlap(class UPrimitiveComponent* HitComp, class AActor*
bFromSweep, const FHitResult& Hit);
void BindPrimitiveComponent(class UPrimitiveComponent* Component);
}; // Size: 0x158
class UPalHitLocationCalculator : public UObject

{
FVector CalcLocation(class UPrimitiveComponent* MyHitComponent, class

UPrimitiveComponent* OtherHitComponent);
}; // Size: 0x28
class UPalIncidentBase : public UObject

{
FPalIncidentExecutionSettings ExecSettings;
// 0x0028 (size: 0x1)
FPalIncidentIdParameter IdParameter;
// 0x0030 (size: 0x38)
class UPalIncidentBase* ParentIncident;
// 0x0068 (size: 0x8)
class UPalIncidentDynamicParameter* DynamicParameter;
// 0x0070 (size: 0x8)
FPalIncidentSystemFunctionAccessor FunctionAccessor;
// 0x0080 (size: 0xC0)
bool bForceStop;
// 0x0140 (size: 0x1)
class UObject* OccuredObject;
// 0x0148 (size: 0x8)
class UObject* OwnerObject;
// 0x0150 (size: 0x8)
EPalIncidentState ExecState;
// 0x0158 (size: 0x1)

void SetDynamicParameter(class UPalIncidentDynamicParameter* Parameter);
int32 RequestConsumeInventoryItem(class UPalPlayerInventoryData* InventoryData,
FName ItemId, int32 ConsumeNum);
void OnGenerated();
void OnForceStop();
void OnEnd();
void OnChildInitialized(class UPalIncidentBase* Child);
void OnCanceled();
void OnBegin();
bool IsInitialized();
bool IsExecuting();
bool IsCompleted();
bool IsCanceled();
bool HasOption(const FName& Option);
class UPalIncidentBase* GetRootIncident();
class UPalIncidentBase* GetParentIncident();
class UObject* GetOwner();
class UObject* GetOccuredObject();
FName GetIncidentType();
FName GetIncidentId();
class UPalIncidentDynamicParameter* GetDynamicParameter();
TArray<FName> GetArgs();
FName GetArg(int32 Index);
void ForceStop();
void Finish();
void DropItem(FName ItemId, int32 DropNum, FVector SpawnLocation, FVector
ReleaseDirection);
}; // Size: 0x160
class UPalIncidentDynamicParameter : public UObject

{
class AActor* Other;
// 0x0028 (size: 0x8)
}; // Size: 0x30
class UPalIncidentDynamicParameterInvader : public UPalIncidentDynamicParameter

{
// 0x0030 (size: 0x10)
}; // Size: 0x40
class UPalIncidentDynamicParameterRandom : public UPalIncidentDynamicParameter

{
FName SettingName;
// 0x0030 (size: 0x8)
int32 PlayerId;
// 0x0038 (size: 0x4)
}; // Size: 0x40
class UPalIncidentDynamicParameterTalk : public UPalIncidentDynamicParameter

{
EPalIncidentTalkType TalkType;
// 0x0030 (size: 0x1)
FName TalkId;
// 0x0034 (size: 0x8)
FName RequestItem;
// 0x003C (size: 0x8)
int32 RequestItemNum;
// 0x0044 (size: 0x4)
bool IsRequestSucceed;
// 0x0048 (size: 0x1)
}; // Size: 0x50
class UPalIncidentList : public UPalIncidentBase

{
TArray<FName> FirstIncidentIds;
// 0x0160 (size: 0x10)
TArray<class UPalIncidentBase*> WaitingIncidents;
// 0x0170 (size: 0x10)
class UPalIncidentBase* CurrentIncident;
// 0x0180 (size: 0x8)
TArray<class UPalIncidentBase*> CompletedIncidents;
// 0x0188 (size: 0x10)
int32 ProgressCount;
// 0x0198 (size: 0x4)
void OnIncidentProgressed(class UPalIncidentBase* PrevIncident, class

UPalIncidentBase* NextIncident, int32 ProcessCount);
void OnAllIncidentsCompleted();
void InsertIncidentToTop(const FName& ID);
void InsertIncidentsToTop(const TArray<FName>& IDs);
void AddIncidents(const TArray<FName>& IDs);
void AddIncident(const FName& ID);
}; // Size: 0x1A0
class UPalIncidentNotifyListener : public UObject

{
FPalIncidentNotifyListenerOnIncidentStateNotifyDelegate
OnIncidentStateNotifyDelegate; // 0x0028 (size: 0x10)
void IncidentStateNotifyDelegate(class UPalIncidentNotifyListener* Listener,
EPalIncidentState IncidentState, const FPalIncidentNotifyParameter& Parameter);
class UObject* FilterOccuredObject;
// 0x0038 (size: 0x8)
class UObject* FilterOwnerObject;
// 0x0040 (size: 0x8)
TArray<FName> FilterIncidentIds;
// 0x0048 (size: 0x10)
TArray<FName> FilterIncidentTypes;
// 0x0058 (size: 0x10)
void UnregisterFromIncidentSystem();
void RegisterToIncidentSystemWithFilterOwner(class UObject* FilterOwner);
void RegisterToIncidentSystemWithFilterOccuredOwner(class UObject*
FilterOccured, class UObject* FilterOwner);
void RegisterToIncidentSystemWithFilterOccured(class UObject* FilterOccured);
void RegisterToIncidentSystemWithFilterIdsOwner(const TArray<FName>& FilterIds,
class UObject* FilterOwner);
void RegisterToIncidentSystemWithFilterIdsOccuredOwner(const TArray<FName>&
FilterIds, class UObject* FilterOccured, class UObject* FilterOwner);
void RegisterToIncidentSystemWithFilterIdsOccured(const TArray<FName>&
FilterIds, class UObject* FilterOccured);
void RegisterToIncidentSystemWithFilterIds(const TArray<FName>& FilterIds);
void RegisterToIncidentSystemWithFilterIdOwner(FName FilterId, class UObject*
FilterOwner);
void RegisterToIncidentSystemWithFilterIdOccuredOwner(FName FilterId, class
UObject* FilterOccured, class UObject* FilterOwner);
void RegisterToIncidentSystemWithFilterIdOccured(FName FilterId, class UObject*
FilterOccured);
void RegisterToIncidentSystemWithFilterId(FName FilterId);
void RegisterToIncidentSystem();
void OnIncidentStateNotify(class UPalIncidentNotifyListener* Listener,
EPalIncidentState IncidentState, const FPalIncidentNotifyParameter& Parameter);
void IncidentStateNotifyDelegate__DelegateSignature(class
UPalIncidentNotifyListener* Listener, EPalIncidentState IncidentState, const
FPalIncidentNotifyParameter& Parameter);
}; // Size: 0x68
class UPalIncidentSystem : public UPalWorldSubsystem

{
TArray<FName> ResidentIncidentList;
// 0x0070 (size: 0x10)
TMap<class FName, class TSubclassOf<UPalIncidentBase>> IncidentClassMap;
// 0x0080 (size: 0x50)
class UDataTable* IncidentParameterDataTable;
// 0x00D0 (size: 0x8)
FPalIncidentSystemOnIncidentStateNotifyDelegate OnIncidentStateNotifyDelegate;
// 0x00D8 (size: 0x10)
void IncidentStateNotify(EPalIncidentState IncidentState, const
TArray<class UPalIncidentBase*> WaitingIncidents;
// 0x00E8 (size: 0x10)
TArray<class UPalIncidentBase*> ExecuteIncidents;
// 0x00F8 (size: 0x10)
TArray<class UPalIncidentBase*> ResidentIncidents;
// 0x0108 (size: 0x10)
TArray<class UPalIncidentNotifyListener*> Listeners;
// 0x0118 (size: 0x10)
class UPalIncidentList* RequestIncidents(const TArray<FName>& Incidents, class

UObject* OccuredObject, class UObject* OwnerObject, class
UPalIncidentDynamicParameter* Parameter);
class UPalIncidentBase* RequestIncident(FName IncidentId, class UObject*
OccuredObject, class UObject* OwnerObject, class UPalIncidentDynamicParameter*
Parameter);
void NotifyIncidentState(EPalIncidentState NotifyType, const
bool IsIncidentBeginAllowed(class UPalIncidentBase* Incident);
void IncidentStateNotify__DelegateSignature(EPalIncidentState IncidentState,
const FPalIncidentNotifyParameter& Parameter);
class UPalIncidentBase* GenerateIncident(FPalIncidentInitializeParameter&
InitializeParam);
void ForceStopByOwner(class UObject* OwnerObject);
void ForceStopByOccuredObject(class UObject* OccuredObject);
void ForceStopByIncidentType(FName IncidentType);
void ForceStopByIncidentId(FName IncidentId);
}; // Size: 0x1F0
class UPalIndividualCharacterContainer : public UPalContainerBase

{
FPalIndividualCharacterContainerOnUpdateContentsDelegate
OnUpdateContentsDelegate; // 0x0050 (size: 0x10)
void UpdateContentsDelegate(class UPalIndividualCharacterContainer* Container);
FPalIndividualCharacterContainerOnUpdateSlotsDelegate OnUpdateSlotsDelegate;
// 0x0060 (size: 0x10)
void UpdateContentsDelegate(class UPalIndividualCharacterContainer* Container);
TArray<class UPalIndividualCharacterSlot*> SlotArray;
// 0x0080 (size: 0x10)
void UpdateContentsDelegate__DelegateSignature(class
UPalIndividualCharacterContainer* Container);
void OnRep_Slots();
int32 Num();
TArray<class UPalIndividualCharacterSlot*> GetSlots();
class UPalIndividualCharacterSlot* Get(const int32 Index);
class UPalIndividualCharacterSlot* FindEmptySlot();
class UPalIndividualCharacterSlot* FindByHandle(class
}; // Size: 0x90
class UPalIndividualCharacterHandle : public UObject

{
FPalIndividualCharacterHandleOnUpdateIndividualActorDelegate
OnUpdateIndividualActorDelegate; // 0x0028 (size: 0x10)
void UpdateIndividualActorDelegate(class UPalIndividualCharacterHandle*
Handle);
FPalInstanceID ID;
// 0x0038 (size: 0x30)
void UpdateIndividualActorDelegate__DelegateSignature(class
class APalCharacter* TryGetPhantomActor(int32 PhantomId);
class UPalIndividualCharacterParameter* TryGetIndividualParameter();
class APalCharacter* TryGetIndividualActor();
int32 GetPhantomIDByActor(class APalCharacter* Character);
FPalInstanceID GetIndividualID();
}; // Size: 0x68
class UPalIndividualCharacterHandleReference : public UPalIndividualCharacterHandle

{
}; // Size: 0x68
class UPalIndividualCharacterParameter : public UObject

{
FPalIndividualCharacterParameterOnUpdateLevelDelegate OnUpdateLevelDelegate;
// 0x0028 (size: 0x10)
void UpdateLevelDelegate(int32 addLevel, int32 nowLevel);
FPalIndividualCharacterParameterOnUpdateRankDelegate OnUpdateRankDelegate;
// 0x0038 (size: 0x10)
void UpdateRankDelegate(int32 nowRank, int32 oldRank);
FPalIndividualCharacterParameterOnAddExpDelegate OnAddExpDelegate;
// 0x0048 (size: 0x10)
void AddExpDelegate(int32 addExp, int32 nowExp);
FPalIndividualCharacterParameterOnUpdateHPDelegate OnUpdateHPDelegate;
// 0x0058 (size: 0x10)
void UpdateHPDelegate(FFixedPoint64 nowHP, FFixedPoint64 nowMaxHP);
FPalIndividualCharacterParameterOnUpdateSPDelegate OnUpdateSPDelegate;
// 0x0068 (size: 0x10)
void UpdateSPDelegate(FFixedPoint64 nowSP, FFixedPoint64 nowMaxSP, bool
isOverHeated);
FPalIndividualCharacterParameterOnUpdateFullStomachDelegate
OnUpdateFullStomachDelegate; // 0x0078 (size: 0x10)
void UpdateFullStomachDelegate(float Current, float Last);
FPalIndividualCharacterParameterOnUpdateHungerTypeDelegate
OnUpdateHungerTypeDelegate; // 0x0088 (size: 0x10)
void UpdateHungerTypeDelegate(EPalStatusHungerType Current,
EPalStatusHungerType Last);
FPalIndividualCharacterParameterOnUpdateNickNameDelegate
OnUpdateNickNameDelegate; // 0x0098 (size: 0x10)
void UpdateNickNameDelegate(FString newNickName);
FPalIndividualCharacterParameterOnUpdateNickNameWithParameterDelegate
OnUpdateNickNameWithParameterDelegate; // 0x00A8 (size: 0x10)
void UpdateNickNameWithParameterDelegate(class
UPalIndividualCharacterParameter* IndividualParameter, FString newNickName);
FPalIndividualCharacterParameterOnUpdateShieldMaxHPDelegate
OnUpdateShieldMaxHPDelegate; // 0x00B8 (size: 0x10)
void UpdateShieldMaxHPDelegate(FFixedPoint64 nowShieldMaxHP);
FPalIndividualCharacterParameterOnUpdateShieldHPDelegate
OnUpdateShieldHPDelegate; // 0x00C8 (size: 0x10)
void UpdateShieldHPDelegate(FFixedPoint64 nowShieldMaxHP, FFixedPoint64
nowShieldHP);
FPalIndividualCharacterParameterOnShieldDamageDelegate OnShieldDamageDelegate;
// 0x00D8 (size: 0x10)
void ShieldDamageDelegate(int32 Damage, bool IsShieldBroken);
FPalIndividualCharacterParameterOnUpdateSanityDelegate OnUpdateSanityDelegate;
// 0x00E8 (size: 0x10)
void UpdateSanityDelegate(float nowSanity, float oldSanity);
FPalIndividualCharacterParameterOnUpdateUnusedStatusPoint
OnUpdateUnusedStatusPoint; // 0x00F8 (size: 0x10)
void UpdateUnusedStatusPointDelegate(int32 UnusedPoint);
FPalIndividualCharacterParameterOnUpdateStatusPointDelegate
OnUpdateStatusPointDelegate; // 0x0108 (size: 0x10)
void UpdateStatusPointDelegate(FName StatusName, int32 prevPoint, int32
newPoint);
FPalIndividualCharacterParameterOnChangeBuffDelegate OnChangeBuffDelegate;
// 0x0118 (size: 0x10)
void ChangeBuffStatusDelegate();
FPalIndividualCharacterParameterOnConditionChangedDelegate
OnConditionChangedDelegate; // 0x0128 (size: 0x10)
void ConditionChangedDelegate();
FPalIndividualCharacterParameterOnWorkSuitabilityChangedDelegate
OnWorkSuitabilityChangedDelegate; // 0x0138 (size: 0x10)
void WorkSuitabilityChangedDelegate();
FPalIndividualCharacterParameterOnGotStatusPointListChangedDelegate
OnGotStatusPointListChangedDelegate; // 0x0148 (size: 0x10)
void GotStatusPointListChangedDelegate();
FPalIndividualCharacterParameterOnStatusRankChangedDelegate
OnStatusRankChangedDelegate; // 0x0158 (size: 0x10)
void StatusRankChangedDelegate();
FPalIndividualCharacterParameterOnInvaderTargetChanged OnInvaderTargetChanged;
// 0x0168 (size: 0x10)
void InvaderTargetChangedDelegate();
FPalIndividualCharacterParameterOnTriedConsumeFoodDelegate
OnTriedConsumeFoodDelegate; // 0x0178 (size: 0x10)
void TriedConsumeFoodDelegate();
FPalIndividualCharacterParameterOnUpdateGroupIdDelegate
OnUpdateGroupIdDelegate; // 0x0188 (size: 0x10)
void UpdateGroupIdDelegate(const FGuid& NewGroupId);
FPalIndividualCharacterParameterOnUpdateReviveTimerDelegate
OnUpdateReviveTimerDelegate; // 0x0198 (size: 0x10)
void UpdateReviveTimerDelegate(float NowReviveTimer);
FPalIndividualCharacterParameterOnEndMedicalBedDelegate
OnEndMedicalBedDelegate; // 0x01A8 (size: 0x10)
void EndMedicalBedDelegate();
FPalIndividualCharacterParameterOnRevivedDelegate OnRevivedDelegate;
// 0x01B8 (size: 0x10)
void OnRevivedDelegate(class UPalIndividualCharacterParameter*
FPalIndividualCharacterParameterOnDeadBodyDelegate OnDeadBodyDelegate;
// 0x01C8 (size: 0x10)
void DeadBodyDelegate(class UPalIndividualCharacterHandle* IndividualHandle);
class APalCharacter* IndividualActor;
// 0x01D8 (size: 0x8)
// 0x01E0 (size: 0x30)
TMap<int32, APalCharacter*> PhantomActorMap;
// 0x0210 (size: 0x50)
TArray<FPalPhantomReplicateInfo> PhantomActorReplicateArray;
// 0x0260 (size: 0x10)
// 0x0270 (size: 0x218)
FPalIndividualCharacterParameterOnAddEquipWazaDelegate OnAddEquipWazaDelegate;
// 0x0490 (size: 0x10)
void AddEquipWazaDelegate(EPalWazaID WazaID);
FPalIndividualCharacterParameterOnChangeEquipWazaDelegate
OnChangeEquipWazaDelegate; // 0x04A0 (size: 0x10)
void ChangeEquipWazaDelegate(class UPalIndividualCharacterParameter*
FPalIndividualCharacterParameterOnChangeMasteredWazaDelegate
OnChangeMasteredWazaDelegate; // 0x04B0 (size: 0x10)
void ChangeMasteredWazaDelegate(class UPalIndividualCharacterParameter*
IndividualParameter, EPalWazaID WazaID);
FFlagContainer DisableNaturalHealing;
// 0x0520 (size: 0x50)
FFloatContainer AdditionalNatureHealingRate;
// 0x0570 (size: 0x10)
FPalIndividualCharacterSaveParameter SaveParameterMirror;
// 0x0580 (size: 0x218)
class UPalItemContainer* EquipItemContainer;
// 0x0798 (size: 0x8)
FGuid BaseCampId;
// 0x07A0 (size: 0x10)
FString Debug_CurrentAIActionName;
// 0x07B0 (size: 0x10)
void WorkSuitabilityChangedDelegate__DelegateSignature();
void UseItemInSlot(const FPalItemSlotIdAndNum SlotIdAndNum);
void UpdateUnusedStatusPointDelegate__DelegateSignature(int32 UnusedPoint);
void UpdateStatusPointDelegate__DelegateSignature(FName StatusName, int32
prevPoint, int32 newPoint);
void UpdateSPDelegate__DelegateSignature(FFixedPoint64 nowSP, FFixedPoint64
nowMaxSP, bool isOverHeated);
void UpdateShieldMaxHPDelegate__DelegateSignature(FFixedPoint64
nowShieldMaxHP);
void UpdateShieldHPDelegate__DelegateSignature(FFixedPoint64 nowShieldMaxHP,
FFixedPoint64 nowShieldHP);
void UpdateSanityDelegate__DelegateSignature(float nowSanity, float oldSanity);
void UpdateReviveTimerDelegate__DelegateSignature(float NowReviveTimer);
void UpdateRankDelegate__DelegateSignature(int32 nowRank, int32 oldRank);
void UpdateNickNameWithParameterDelegate__DelegateSignature(class
UPalIndividualCharacterParameter* IndividualParameter, FString newNickName);
void UpdateNickNameDelegate__DelegateSignature(FString newNickName);
void UpdateLevelDelegate__DelegateSignature(int32 addLevel, int32 nowLevel);
void UpdateHungerTypeDelegate__DelegateSignature(EPalStatusHungerType Current,
EPalStatusHungerType Last);
void UpdateHPDelegate__DelegateSignature(FFixedPoint64 nowHP, FFixedPoint64
nowMaxHP);
void UpdateGroupIdDelegate__DelegateSignature(const FGuid& NewGroupId);
void UpdateFullStomachDelegate__DelegateSignature(float Current, float Last);
bool TryFindEatItem(const FPalContainerId& ContainerId, int32& SlotIndex);
void TriedConsumeFoodDelegate__DelegateSignature();
void StoreIndividualActorInfoToSaveParameter();
void StatusRankChangedDelegate__DelegateSignature();
void StartRemainderOfLifeTimer();
void StartRecuperatingInMedicalBed();
void ShieldDamageDelegate__DelegateSignature(int32 Damage, bool
IsShieldBroken);
void SetStatusPoint(FName StatusName, int32 Point);
void SetShieldMaxHP(FFixedPoint64 NextSheildMaxHP);
void SetShieldHP(FFixedPoint64 NextSheildHP);
void SetPhysicalHealth(EPalStatusPhysicalHealthType PhysicalHealth);
void SetNoFallDamageHeightLastJumpedLocation();
void SetLastJumpedLocation(FVector Location);
void SetInvaderData(EPalInvaderType InvaderType, const FGuid InBaseCampId);
void SetDisableNaturalHealing(FName Key, bool Disable);
void SetDecreaseFullStomachRates(const FName Name, float Rate);
void ResetLastJumpedLocation();
void RemoveDecreaseFullStomachRates(const FName Name);
void PartyPalMealInventoryFood();
void OnRevivedDelegate__DelegateSignature(class
void OnRep_SaveParameter();
void OnRep_PhantomActorReplicateArray();
void OnRep_IndividualActor();
void NaturalUpdateSaveParameter(const EPalCharacterNaturalUpdateType Type);
bool IsSleeping();
bool IsRarePal();
bool IsNoFallDamageLastJumpedLocation();
bool IsNocturnal();
bool IsLevelMax();
bool IsHPFullRecovered();
void InvaderTargetChangedDelegate__DelegateSignature();
float HungerParameterRate();
bool HasWorkSuitabilityRank(const EPalWorkSuitability InWorkSuitability, const
int32 SuitabilityRank);
bool HasWorkSuitability(const EPalWorkSuitability InWorkSuitability);
bool HasMasteredWaza(EPalWazaID WazaID);
bool HasGenusCategory(EPalGenusCategoryType Category);
void GotStatusPointListChangedDelegate__DelegateSignature();
int32 GetWorkSuitabilityRankWithCharacterRank(const EPalWorkSuitability
WorkSuitability);
TMap<EPalWorkSuitability, int32> GetWorkSuitabilityRanksWithCharacterRank();
int32 GetWorkSuitabilityRank(const EPalWorkSuitability InWorkSuitability);
int32 GetWorkSpeedRank();
EPalBaseCampWorkerSickType GetWorkerSick();
int32 GetUnusedStatusPoint();
EPalTribeID GetTribeID();
void GetStatusPointList(TArray<FPalGotStatusPoint>& OutPointList);
int32 GetStatusPoint(FName StatusName);
int32 GetShotAttack_withBuff();
int32 GetShotAttack();
FFixedPoint64 GetShieldMaxHP();
FFixedPoint64 GetShieldHP();
FPalIndividualCharacterSaveParameter GetSaveParameter();
float GetSanityValue();
float GetSanityRate();
float GetRatePassiveSkill(EPalPassiveSkillEffectType EffectType);
float GetRatePartnerSkill(EPalPassiveSkillEffectType EffectType);
int32 GetRank();
EPalStatusPhysicalHealthType GetPhysicalHealth();
int32 GetPalSoulRank();
void GetNickname(FString& outName);
int32 GetMeleeAttack_withBuff();
int32 GetMeleeAttack();
float GetMaxSanityValue();
FFixedPoint64 GetMaxHP_withBuff();
int32 GetMaxHP();
float GetMaxFullStomach();
TArray<EPalWazaID> GetMasteredWaza();
int32 GetLevel();
FVector GetLastJumpedLocation();
EPalStatusHungerType GetHungerType();
int32 GetHPRank();
FFixedPoint64 GetHP();
FGuid GetGroupId();
EPalGenderType GetGenderType();
float GetFullStomachRate();
float GetFullStomachDecreasingRate();
float GetFullStomach();
float GetFoodStatusRate(EPalFoodStatusEffectType EffectType);
int32 GetExp();
TArray<EPalWazaID> GetEquipWaza();
FPalContainerId GetEquipItemContainerId();
FPalIndividualCharacterEquipItemContainerHandler
GetEquipItemContainerHandler();
float GetEffectFoodTimeRate();
FName GetEffectFoodName();
int32 GetDefense_withBuff();
int32 GetDefense();
int32 GetDefenceRank();
EPalWorkSuitability GetCurrentWorkSuitability();
float GetCraftSpeedSickRate();
int32 GetCraftSpeedByWorkSuitability(const EPalWorkSuitability
WorkSuitability);
float GetCraftSpeedBuffRate();
int32 GetCraftSpeed_withBuff_WorkSuitability(const EPalWorkSuitability
Suitability);
int32 GetCraftSpeed_withBuff();
int32 GetCraftSpeed();
TSoftClassPtr<APalCharacter> GetCharacterClass();
EPalBaseCampWorkerEventType GetBaseCampWorkerEventType();
int32 GetAttackRank();
float GetAffectSanityValue();
void FullRecoveryHP();
void EndRecuperatingInMedicalBed();
void EndMedicalBedDelegate__DelegateSignature();
void DecrementUnusedStatusPoint();
void DecreaseShieldHPByDamage(int32 Damage);
void DeadBodyDelegate__DelegateSignature(class UPalIndividualCharacterHandle*
IndividualHandle);
void ConditionChangedDelegate__DelegateSignature();
void ClearEquipWaza();
void ChangeMasteredWazaDelegate__DelegateSignature(class
UPalIndividualCharacterParameter* IndividualParameter, EPalWazaID WazaID);
void ChangeEquipWazaDelegate__DelegateSignature(class
void ChangeBuffStatusDelegate__DelegateSignature();
void AddPassiveSkill(FName AddSkill, FName OverrideSkill);
void AddHP(FFixedPoint64 PlusHP);
void AddExpDelegate__DelegateSignature(int32 addExp, int32 nowExp);
void AddEquipWazaDelegate__DelegateSignature(EPalWazaID WazaID);
void AddEquipWaza(EPalWazaID WazaID);
}; // Size: 0x7C0
class UPalIndividualCharacterParameterUtility : public UBlueprintFunctionLibrary

{
int32 CraftSpeedWorkSuitability(const EPalWorkSuitability WorkSuitability,

class UPalIndividualCharacterParameter* Parameter);
int32 CraftSpeed(class UPalIndividualCharacterParameter* Parameter);
}; // Size: 0x28
class UPalIndividualCharacterReferenceSlot : public UPalIndividualCharacterSlot

{
FPalIndividualCharacterReferenceSlotOnUpdateSlotReferenceHandleDelegate
OnUpdateSlotReferenceHandleDelegate; // 0x00B8 (size: 0x10)
void UpdateSlotReferenceHandleDelegate(class
UPalIndividualCharacterReferenceSlot* Slot, FPalInstanceID LastIndividualId);
// 0x00C8 (size: 0x30)
}; // Size: 0xF8
class UPalIndividualCharacterSaveParameterObject : public UObject

{
// 0x0028 (size: 0x218)
}; // Size: 0x240
class UPalIndividualCharacterSaveParameterUtility : public UObject

{
bool IsValid(const FPalIndividualCharacterSaveParameter& SaveParameter);

}; // Size: 0x28
class UPalIndividualCharacterSlot : public UObject

{
FPalIndividualCharacterSlotOnUpdateSlotHandleDelegate
OnUpdateSlotHandleDelegate; // 0x0030 (size: 0x10)
void UpdateSlotHandleDelegate(class UPalIndividualCharacterSlot* Slot, class
FPalIndividualCharacterSlotOnUpdateSlotLockDelegate OnUpdateSlotLockDelegate;
// 0x0040 (size: 0x10)
void UpdateSlotLockDelegate(class UPalIndividualCharacterSlot* Slot);
class UPalIndividualCharacterHandle* Handle;
// 0x0050 (size: 0x8)
FPalInstanceID ReplicateHandleID;
// 0x0058 (size: 0x30)
// 0x0090 (size: 0x10)
int32 SlotIndex;
// 0x00A0 (size: 0x4)
FGuid LockPlayerUId;
// 0x00A4 (size: 0x10)
EPalTribeID PermissionTribeID;
// 0x00B4 (size: 0x1)
bool bIsReplicateCharacterParameter;
// 0x00B5 (size: 0x1)
void UpdateSlotLockDelegate__DelegateSignature(class
UPalIndividualCharacterSlot* Slot);
void UpdateSlotHandleDelegate__DelegateSignature(class
UPalIndividualCharacterSlot* Slot, class UPalIndividualCharacterHandle*
LastHandle);
void Setup(const int32 InSlotIndex, const FPalContainerId& InContainerId);
void OnRep_LockPlayerUId();
void OnRep_HandleID();
bool IsLocked();
bool IsEmpty();
int32 GetSlotIndex();
FPalCharacterSlotId GetSlotId();
FGuid GetLockPlayerUId();
class UPalIndividualCharacterHandle* GetHandle();
bool CanSetHandle(class UPalIndividualCharacterHandle* InHandle);
}; // Size: 0xB8
class UPalIndividualCharacterSlotsObserver : public UObject

{
FPalIndividualCharacterSlotsObserverOnUpdateContainerDelegate
OnUpdateContainerDelegate; // 0x0028 (size: 0x10)
void UpdateContainerDelegate();
void UpdateContainerDelegate__DelegateSignature();
void OnUpdateSlot(class UPalIndividualCharacterSlot* Slot, class
void OnUpdateContainerSlots(class UPalIndividualCharacterContainer* Container);
void OnUpdateContainerSize(class UPalIndividualCharacterContainer* Container);
void OnUpdateContainer(class UPalIndividualCharacterContainer* Container);
}; // Size: 0x60
class UPalInsideBaseCampCheckComponent : public UActorComponent

{
FPalInsideBaseCampCheckComponentOnEnterBaseCampDelegate
OnEnterBaseCampDelegate; // 0x00A0 (size: 0x10)
void OnEnterBaseCampDelegate(class UPalBaseCampModel* Model);
FPalInsideBaseCampCheckComponentOnLeaveBaseCampDelegate
OnLeaveBaseCampDelegate; // 0x00B0 (size: 0x10)
void OnLeaveBaseCampDelegate();
FGuid NowInsideBaseCampID;
// 0x00C0 (size: 0x10)
void OnLeaveBaseCampDelegate__DelegateSignature();
void OnEnterBaseCampDelegate__DelegateSignature(class UPalBaseCampModel*
Model);
bool IsInsideBaseCamp();
class UPalBaseCampModel* GetInsideBaseCampModel();
FGuid GetInsideBaseCampID();
}; // Size: 0xD0
class UPalInteractComponent : public UActorComponent
{
FPalInteractComponentOnStartInteractiveObjectDelegate
OnStartInteractiveObjectDelegate; // 0x00A0 (size: 0x10)
void StartInteractiveObjectDelegate(TScriptInterface<class
FPalInteractComponentOnEndInteractiveObjectDelegate
OnEndInteractiveObjectDelegate; // 0x00B0 (size: 0x10)
void EndInteractiveObjectDelegate();
FPalInteractComponentOnUpdateInteractiveObjectDelegate
OnUpdateInteractiveObjectDelegate; // 0x00C0 (size: 0x10)
void UpdateInteractiveObjectDelegate(TScriptInterface<class
TArray<TScriptInterface<IPalInteractiveObjectComponentInterface>>
InteractiveObjects; // 0x00D0 (size: 0x10)
TScriptInterface<class IPalInteractiveObjectComponentInterface>
TargetInteractiveObject; // 0x00E0 (size: 0x10)
TScriptInterface<class IPalInteractiveObjectComponentInterface>
LastInteractingObject; // 0x00F0 (size: 0x10)
FFlagContainer InteractDisableFlags;
// 0x0140 (size: 0x50)
void UpdateInteractiveObjectDelegate__DelegateSignature(TScriptInterface<class
void TerminateInteract();
void StartTriggerInteract(EPalInteractiveObjectActionType ActionType);
void StartInteractiveObjectDelegate__DelegateSignature(TScriptInterface<class
void SetEnableInteractByFlagName(const FName& flagName, const bool bEnable,
const bool bTerminateInteractIfDisable);
void SetEnableInteract(const bool bEnable, const bool
bTerminateInteractIfDisable);
void OnEnableInteract(TScriptInterface<class
bool IsInteracting();
bool IsEnableInteract();
void EndTriggerInteract(EPalInteractiveObjectActionType ActionType);
void EndInteractiveObjectDelegate__DelegateSignature();
}; // Size: 0x190
class UPalInteractDelegates : public UObject

{
FPalInteractDelegatesOnEnableTriggerInteract OnEnableTriggerInteract;
// 0x0028 (size: 0x10)
void InteractSelfDelegate(TScriptInterface<class
FPalInteractDelegatesOnInteractBegin OnInteractBegin;
// 0x0038 (size: 0x10)
void InteractDelegate(class AActor* Other, TScriptInterface<class
FPalInteractDelegatesOnInteractEnd OnInteractEnd;
// 0x0048 (size: 0x10)
void InteractDelegate(class AActor* Other, TScriptInterface<class
FPalInteractDelegatesOnInteracting OnInteracting;
// 0x0058 (size: 0x10)
void InteractingDelegate(float DeltaTime);
FPalInteractDelegatesOnTriggerInteract OnTriggerInteract;
// 0x0068 (size: 0x10)
void InteractTriggerDelegate(class AActor* Other,
FPalInteractDelegatesOnStartTriggerInteract OnStartTriggerInteract;
// 0x0078 (size: 0x10)
FPalInteractDelegatesOnEndTriggerInteract OnEndTriggerInteract;
// 0x0088 (size: 0x10)
FPalInteractDelegatesOnTriggeringInteract OnTriggeringInteract;
// 0x0098 (size: 0x10)
void InteractTriggeringDelegate(class AActor* Other,
EPalInteractiveObjectIndicatorType IndicatorType, float DeltaTime);
}; // Size: 0xA8
class UPalInteractableSphereComponentNative : public

UPalInteractiveObjectSphereComponent
{
}; // Size: 0x5D0
class UPalInteractiveObjectActionInfoUtility : public UObject

{
EPalInteractiveObjectIndicatorType GetIndicatorType(const
FPalInteractiveObjectActionInfoSet& ActionInfo, const
EPalInteractiveObjectActionType ActionType);
FPalInteractiveObjectActionBy CreateSituationInfo(const class UObject*
}; // Size: 0x28
class UPalInteractiveObjectBoxComponent : public UBoxComponent

{
class UPalInteractDelegates* InteractDelegates;
// 0x0588 (size: 0x8)
bool bIsEnableTriggerInteract;
// 0x0590 (size: 0x1)
bool bIsImplementedTriggerInteract;
// 0x0591 (size: 0x1)
bool bIsEnableInteractingTick;
// 0x0592 (size: 0x1)
bool bIsEnableInteractingTickInClientOnly;
// 0x0593 (size: 0x1)
FComponentReference IndicatorOriginRef;
// 0x0598 (size: 0x28)
bool bIsAdjustIndicatorLocationZForPlayer;
// 0x05C0 (size: 0x1)
TScriptInterface<class IPalInteractiveObjectIndicatorInterface>
IndicatorInterface; // 0x05C8 (size: 0x10)
FPalInteractiveObjectBoxComponentOnCreateInteractDelegatesDelegate
OnCreateInteractDelegatesDelegate; // 0x05D8 (size: 0x10)
void OnCreateInteractDelegatesMultiCast(class UPalInteractDelegates*
InteractDelegates);
void SetForceDisableInteract();
void OnCreateInteractsDelegates__DelegateSignature(class UPalInteractDelegates*
InteractDelegates);
void OnCreateInteractDelegatesMultiCast__DelegateSignature(class
UPalInteractDelegates* InteractDelegates);
void
CallOrRegisterOnCreateInteractDelegates(FCallOrRegisterOnCreateInteractDelegatesDel
egate Delegate);
}; // Size: 0x5F0
class UPalInteractiveObjectCapsuleComponent : public UCapsuleComponent

{
// 0x0570 (size: 0x8)
// 0x0578 (size: 0x1)
// 0x0579 (size: 0x1)
// 0x057A (size: 0x1)
// 0x057B (size: 0x1)
// 0x0580 (size: 0x28)
bool bIsAdjustIndicatorLocationZForPlayer;
// 0x05A8 (size: 0x1)
IndicatorInterface; // 0x05B0 (size: 0x10)
FPalInteractiveObjectCapsuleComponentOnCreateInteractDelegatesDelegate
OnCreateInteractDelegatesDelegate; // 0x05C0 (size: 0x10)
InteractDelegates);
InteractDelegates);
void
egate Delegate);
}; // Size: 0x5D0
class UPalInteractiveObjectComponentUtility : public UObject

{
}; // Size: 0x28
class UPalInteractiveObjectIndicatorTypeUtility : public UObject

{
FText ToText(const class UObject* WorldObjectContext, const

EPalInteractiveObjectIndicatorType Type);
}; // Size: 0x28
class UPalInteractiveObjectSphereComponent : public USphereComponent

{
// 0x0570 (size: 0x8)
// 0x0578 (size: 0x1)
// 0x0579 (size: 0x1)
// 0x057A (size: 0x1)
// 0x057B (size: 0x1)
// 0x0580 (size: 0x28)
IndicatorInterface; // 0x05A8 (size: 0x10)
FPalInteractiveObjectSphereComponentOnCreateInteractDelegatesDelegate
OnCreateInteractDelegatesDelegate; // 0x05B8 (size: 0x10)
InteractDelegates);
InteractDelegates);
void
egate Delegate);
}; // Size: 0x5D0
class UPalInvaderBaseCampObserver : public UObject

{
class UPalBaseCampModel* TargetBaseCamp;
// 0x0028 (size: 0x8)
// 0x0030 (size: 0x10)
bool bIsInvading;
// 0x0040 (size: 0x1)
bool bIsCoolTime;
// 0x0041 (size: 0x1)
float CoolTimeFinish;
// 0x0044 (size: 0x4)
float CoolTimeElapsed;
// 0x0048 (size: 0x4)
float PlayerInBaseCampTimer;
// 0x004C (size: 0x4)
}; // Size: 0x50
class UPalInvaderIncidentBase : public UPalIncidentBase

{
// 0x0160 (size: 0x1)
class UDataTable* InvaderDataTable;
// 0x0168 (size: 0x8)
TSubclassOf<class APalAIController> MonsterAIControllerClass;
// 0x0170 (size: 0x8)
TSubclassOf<class APalAIController> EnemyAIControllerClass;
// 0x0178 (size: 0x8)
TArray<FPalInvaderSpawnCharacterParameter> InvaderMember;
// 0x0180 (size: 0x10)
TArray<class APalAIController*> MemberController;
// 0x0190 (size: 0x10)
FName ChosenInvaderDataRowName;
// 0x01A0 (size: 0x8)
FGuid GroupGuid;
// 0x01A8 (size: 0x10)
bool bCanExecute;
// 0x01B8 (size: 0x1)
// 0x01C0 (size: 0x8)
TMap<class FPalInstanceID, class FGuid> LocationMap;
// 0x01C8 (size: 0x50)
void StartInvader();
void SpawnMemberCharacters(FVector StartLocation);
bool SelectInvaders(int32 Grade, EPalBiomeType Biome,
TArray<FPalInvaderSpawnCharacterParameter>& OutInvaderMember);
void RemoveGroupCharacter(class UPalIndividualCharacterHandle*
RemoveIndividualHandle);
void OnStartInvade();
void OnInvaderArrived();
void OnEndInvade();
bool IsGroupCharacter(class UPalIndividualCharacterHandle* IndividualHandle);
int32 GetVisitorNPCReturnTimeMinutes();
class UPalBaseCampModel* GetTargetCampModel();
bool GetInvaderStartPoint(FVector& Result);
int32 GetInvadeReturnTimeMinutes();
void GetChosenInvaderGroupName(FText& OutText);
int32 GetCandidateStartLocations(TArray<FVector>& Result);
void GetBroadcastParameter(FPalIncidentBroadcastParameter& outParameter);
int32 GetAliveInvaderNum();
void EndInvadeByTimelimit();
AddIndividualHandle, EPalCharacterLocationType LocationType);
}; // Size: 0x220
class UPalInvaderManager : public UPalWorldSubsystem

{
FPalInvaderManagerSpawnDummyNavInvokerDelegate SpawnDummyNavInvokerDelegate;
// 0x0080 (size: 0x10)
class AActor* SpawnDummyNavInvokerDelegate(FTransform Transform);
FPalInvaderManagerOnInvaderStartDelegate OnInvaderStartDelegate;
// 0x0090 (size: 0x10)
void InvaderStartDelegate(const FPalIncidentBroadcastParameter& Parameter);
FPalInvaderManagerOnInvaderEndDelegate OnInvaderEndDelegate;
// 0x00A0 (size: 0x10)
void InvaderEndDelegate(const FPalIncidentBroadcastParameter& Parameter);
FPalInvaderManagerOnInvaderArrivedDelegate OnInvaderArrivedDelegate;
// 0x00B0 (size: 0x10)
void InvaderOnArrivedDelegate(const FPalIncidentBroadcastParameter& Parameter);
TMap<class FGuid, class FPalInvaderStartPointInfo> InvadeStartLocationList;
// 0x00C0 (size: 0x50)
TMap<class FGuid, class UPalInvaderBaseCampObserver*> Observers;
// 0x0110 (size: 0x50)
TMap<class FGuid, class UPalInvaderIncidentBase*> Incidents;
// 0x0160 (size: 0x50)
FGuid StartInvaderLogId;
// 0x01B0 (size: 0x10)
void VisitorTravelTest();
void VisitorTravelLog(EPalLogType logType);
void StartInvaderMarchRandom();
void StartInvaderMarchAll();
class AActor* SpawnDummyNavInvokerDelegate__DelegateSignature(FTransform
Transform);
class AActor* SpawnDummyNavInvoker(const FTransform& Transform);
class UPalInvaderIncidentBase* RequestIncidentVisitorNPC_BP(class UObject*
OccuredBaseCamp, class UPalIncidentDynamicParameterInvader* Parameter);
bool RequestIncidentVisitorNPC(const FGuid& Guid, class
UPalInvaderBaseCampObserver* Observer);
class UPalInvaderIncidentBase* RequestIncidentInvaderEnemy_BP(class UObject*
OccuredBaseCamp, class UPalIncidentDynamicParameterInvader* Parameter);
bool RequestIncidentInvaderEnemy(const FGuid& Guid, class
UPalInvaderBaseCampObserver* Observer);
void RemoveInvaderIncident(class UPalIncidentBase* Incident);
void InvaderStartDelegate__DelegateSignature(const
FPalIncidentBroadcastParameter& Parameter);
void InvaderOnArrivedDelegate__DelegateSignature(const
void InvaderEndDelegate__DelegateSignature(const
}; // Size: 0x1C0
class UPalItemContainer : public UPalContainerBase

{
FPalItemContainerOnUpdateContentsDelegate OnUpdateContentsDelegate;
// 0x0050 (size: 0x10)
void UpdateContentsDelegate(class UPalItemContainer* Container);
TArray<class UPalItemSlot*> ItemSlotArray;
// 0x0060 (size: 0x10)
// 0x0070 (size: 0x30)
float CorruptionMultiplier;
// 0x00A0 (size: 0x4)
void UpdateContentsDelegate__DelegateSignature(class UPalItemContainer*

Container);
void OnUpdateSlotContent(class UPalItemSlot* Slot);
void OnRep_Permission();
void OnRep_ItemSlotArray();
int32 Num();
FPalItemPermission GetPermission();
int32 GetItemStackCount(const FName StaticItemId);
class UPalItemSlot* Get(const int32 Index);
}; // Size: 0xA8
class UPalItemContainerManager : public UPalWorldSubsystem

{
FPalItemContainerManagerOnItemOperationMoveDelegate
OnItemOperationMoveDelegate; // 0x0080 (size: 0x10)
void ItemOperationMoveDelegate(const TArray<FPalItemOperationInfo_Move>&
OperationInfoSet);
TMap<class FPalContainerId, class UPalItemContainer*>
ItemContainerMap_InServer; // 0x0090 (size: 0x50)
TMap<class FPalContainerId, class FPalItemContainerBelongInfo>
ItemContainerBelongInfo; // 0x0130 (size: 0x50)
bool TryGetSlot(const FPalItemSlotId& SlotID, class UPalItemSlot*& Slot);

bool TryGetContainer(const FPalContainerId& ContainerId, class
UPalItemContainer*& Container);
void ItemOperationMoveDelegate__DelegateSignature(const
TArray<FPalItemOperationInfo_Move>& OperationInfoSet);
FGuid GetGroupIdByItemSlotId(const class UObject* WorldContextObject, const
FPalItemSlotId& SlotID);
FGuid GetGroupIdByItemContainerId(const class UObject* WorldContextObject,
const FPalContainerId& ContainerId);
class UPalItemContainer* GetContainer(const FPalContainerId& ContainerId);
}; // Size: 0x190
class UPalItemContainerMultiHelper : public UObject

{
FPalItemContainerMultiHelperOnUpdateContentDelegate OnUpdateContentDelegate;
// 0x0028 (size: 0x10)
void UpdateContentDelegate(class UPalItemContainerMultiHelper* Self);
TArray<class UPalItemContainer*> Containers;
// 0x0038 (size: 0x10)
void UpdateContentDelegate__DelegateSignature(class
UPalItemContainerMultiHelper* Self);
void OnUpdateContainerContent(class UPalItemContainer* Container);
void OnRep_Containers();
bool IsExistItems(const TArray<FPalStaticItemIdAndNum>& StaticItemInfos);
void FindByStaticItemIds(const TArray<FName>& StaticItemIds,
TArray<FPalStaticItemIdAndNum>& StaticItemInfos);
void FindByStaticItemId(const FName StaticItemId, FPalStaticItemIdAndNum&
StaticItemInfo);
}; // Size: 0x48
class UPalItemFlowSplineComponent : public USplineComponent

{
float ItemSpawnInterval;
// 0x0638 (size: 0x4)
float FlowSpeedRate;
// 0x063C (size: 0x4)
FFloatCounter FlowingItemSpawnTimer;
// 0x0640 (size: 0x8)
TSubclassOf<class AActor> ItemVisualBlueprintClass;
// 0x0648 (size: 0x8)
TArray<FPalItemFlowInSplineInfo> FlowingItemInfos;
// 0x0650 (size: 0x10)
void UpdateTargetItem(const FName InStaticItemId);

void UpdateIsFlowing(const bool bOn);
}; // Size: 0x660
class UPalItemIDManager : public UObject

{
class UPalStaticItemDataAsset* StaticItemDataAsset;
// 0x0028 (size: 0x8)
FPalDataTableRowName_ItemData WoodItemRowName;
// 0x0030 (size: 0x8)
FPalDataTableRowName_ItemData EggItemRowName;
// 0x0038 (size: 0x8)
FPalDataTableRowName_ItemData PalUpgradeStoneItemRowName;
// 0x0040 (size: 0x8)
FPalDataTableRowName_ItemData MoneyItemRowName;
// 0x0048 (size: 0x8)
class UPalStaticItemDataTable* StaticItemDataTable;
// 0x0050 (size: 0x8)
FName GetStaticItemIdPalEgg(const class UObject* WorldContextObject, const

FName CharacterID);
class UPalStaticItemDataBase* GetStaticItemData(const FName StaticItemId);
FPalItemData GetItemData(const FPalItemId& ItemId);
}; // Size: 0x58
class UPalItemInventoryBase : public UObject

{
}; // Size: 0x28
class UPalItemOperationResultUtility : public UObject

{
}; // Size: 0x28
class UPalItemSelectorComponent : public UActorComponent

{
FPalItemSelectorComponentOnChangeSelectedIndex OnChangeSelectedIndex;
// 0x00A0 (size: 0x10)
void ChangeSelectedIndexDelegate(EPalPlayerInventoryType inventoryType, int32
Index);
TMap<class EPalPlayerInventoryType, class FPalPlayerInventorySelectData>
itemSelectDataMap; // 0x00B0 (size: 0x50)
void SelectPrevItem(EPalPlayerInventoryType targetInventory);

void SelectNextItem(EPalPlayerInventoryType targetInventory);
void SelectItem(EPalPlayerInventoryType targetInventory, int32 Index);
bool RemoveTargetInventoryType(EPalPlayerInventoryType targetInventoryType);
class UPalItemSlot* GetNowSelectedItemSlot(EPalPlayerInventoryType
targetInventory);
int32 GetNowSelectedIndex(EPalPlayerInventoryType targetInventory);
class UPalItemContainer* GetContainer(EPalPlayerInventoryType targetInventory);
void ChangeSelectedIndexDelegate__DelegateSignature(EPalPlayerInventoryType
inventoryType, int32 Index);
bool AddTargetInventoryType(EPalPlayerInventoryType targetInventoryType);
}; // Size: 0x100
class UPalItemSlot : public UObject

{
FPalItemSlotOnUpdateSlotContentDelegate OnUpdateSlotContentDelegate;
// 0x0028 (size: 0x10)
void UpdateSlotContentDelegate(class UPalItemSlot* Slot);
FPalItemSlotOnLiftedSlotContentDelegate OnLiftedSlotContentDelegate;
// 0x0038 (size: 0x10)
void LiftedSlotContentDelegate(const int32 LiftItemNum);
FPalItemSlotOnFinishLiftedContentDelegate OnFinishLiftedContentDelegate;
// 0x0048 (size: 0x10)
void FinishLiftedContentDelegate();
FPalItemSlotOnUpdateSlotContentDurabilityDelegate
OnUpdateSlotContentDurabilityDelegate; // 0x0058 (size: 0x10)
void UpdateSlotContentDurabilityDelegate(float OldDurability, float
NewDurability);
FPalItemSlotOnUpdateSlotCorruptionDelegate OnUpdateSlotCorruptionDelegate;
// 0x0068 (size: 0x10)
void UpdateSlotContentDelegate(class UPalItemSlot* Slot);
TMap<int32, bool> DirtyMap;
// 0x0078 (size: 0x50)
int32 SlotIndex;
// 0x00C8 (size: 0x4)
// 0x00CC (size: 0x10)
FPalItemId ItemId;
// 0x00DC (size: 0x28)
int32 StackCount;
// 0x0104 (size: 0x4)
float CorruptionProgressValue;
// 0x0108 (size: 0x4)
// 0x0110 (size: 0x30)
// 0x0140 (size: 0x8)
FPalItemId LastItemId_Client;
// 0x0158 (size: 0x28)
void UpdateSlotContentDurabilityDelegate__DelegateSignature(float
OldDurability, float NewDurability);
void UpdateSlotContentDelegate__DelegateSignature(class UPalItemSlot* Slot);
bool TryGetStaticItemData(class UPalStaticItemDataBase*& OutStaticItemData);
bool TryGetDynamicItemData(class UPalDynamicItemDataBase*& OutDynamicItemData);
void OnUpdateSlotContentDurability(float OldDurability, float NewDurability);
void OnRep_StackCount();
void OnRep_Permission();
void OnRep_ItemId();
void OnRep_DynamicItemData();
void OnRep_CorruptionProgressValue();
void LiftedSlotContentDelegate__DelegateSignature(const int32 LiftItemNum);
bool IsMaxStack();
bool IsEmpty();
int32 GetStackCount();
FPalItemSlotId GetSlotId();
FPalItemPermission GetPermission();
FPalItemId GetItemId();
FText GetCorruptionRemainTimeText();
float GetCorruptionProgressRate();
void FinishLiftedContentDelegate__DelegateSignature();
}; // Size: 0x180
class UPalItemUtility : public UBlueprintFunctionLibrary

{
bool TryGetItemVisualBlueprintClass(const class UObject* WorldContextObject,

const FName StaticItemId, TSoftClassPtr<AActor>& VisualBlueprintClass);
void RestoreWithItem(const class UObject* WorldContextObject, FName
staticItemName, class UPalIndividualCharacterParameter* targetParameter);
void MaterialInfos(const FPalItemRecipe& Recipe,
TArray<FPalStaticItemIdAndNum>& MaterialInfos);
bool IsValid(const FPalItemRecipe& Recipe);
bool IsStatusPointResetItem(const class UPalStaticItemDataBase* ItemData);
bool IsRepairableItem(class UObject* WorldContextObject, const FPalItemId&
TargetItemId);
bool IsEmpty(const FPalItemAndNum& ItemInfo);
int32 GetRecipeMaterialKindCount(const FPalItemRecipe& Recipe);
class UPalItemSlot* CreateLocalItemSlot(class UObject* WorldContextObject,
const FName StaticItemId, const int32 Stack);
void CollectLocalPlayerControllableItemInfos(const class UObject*
WorldContextObject, TArray<FName> StaticItemIds, TArray<FPalStaticItemIdAndNum>&
OutItemInfos, const bool bIncludeInRangeBaseCamp);
bool CanUseHealItem(const class UObject* WorldContextObject, FName
staticItemName, class UPalIndividualCharacterParameter* targetParameter);
}; // Size: 0x28
class UPalLandingTypeUtility : public UBlueprintFunctionLibrary

{
bool IsRollStep(EPalLandingType T);

bool IsJumpLanding(EPalLandingType T);
bool IsFootStep(EPalLandingType T);
}; // Size: 0x28
class UPalLavaBoxComponent : public UBoxComponent

{

}; // Size: 0x580
class UPalLawUtility : public UBlueprintFunctionLibrary

{
bool IsEqualsGroupIndividualIdAndSlotIds(const class UObject*

WorldContextObject, const FPalInstanceID& IndividualId, const
TArray<FPalItemSlotId>& SlotIds, const bool IgnoreNoBelongSlot);
bool ExistOtherGroupFromSlotIds(const class UObject* WorldContextObject, const
FPalInstanceID& IndividualId, const TArray<FPalItemSlotId>& SlotIds, const bool
IgnoreNoBelongSlot, FGuid& OutGroupId);
}; // Size: 0x28
class UPalLevelObjectInterfaceUtility : public UObject

{
FGuid BP_GetLevelObjectInstanceId(TScriptInterface<class
IPalLevelObjectInterface> Target);
}; // Size: 0x28
class UPalLimitVolumeBoxComponent : public UBoxComponent

{
int32 LimitFlags;
// 0x0580 (size: 0x4)
}; // Size: 0x590
class UPalLimitVolumeSphereComponent : public USphereComponent

{
int32 LimitFlags;
// 0x0568 (size: 0x4)
}; // Size: 0x570
class UPalLoadingScreenWidgetBase : public UPalUserWidget

{
}; // Size: 0x408
class UPalLoadoutSelectorComponent : public UPalItemSelectorComponent

{
TSoftClassPtr<APalWeaponBase> ThrowOtomoPalWeaponClass;
// 0x0100 (size: 0x30)
TSubclassOf<class APalWeaponBase> DummyBallWeaponClass;
// 0x0130 (size: 0x8)
FPalLoadoutSelectorComponentOnEquipmentItemDelegate OnEquipmentItemDelegate;
// 0x0138 (size: 0x10)
void EquipmentItem(EPalPlayerInventoryType inventoryType, int32 Index);
FPalLoadoutSelectorComponentOnRemoveItemDelegate OnRemoveItemDelegate;
// 0x0148 (size: 0x10)
void RemoveItem(EPalPlayerInventoryType inventoryType, int32 Index);
EPalPlayerInventoryType primaryTargetInventoryType;
// 0x0158 (size: 0x1)
int32 currentItemSlotIndex;
// 0x015C (size: 0x4)
FName NowEquipBallItemID;
// 0x0160 (size: 0x8)
class APalWeaponBase* ThrowOtomoPalWeapon;
// 0x0168 (size: 0x8)
TArray<class APalWeaponBase*> spawnedWeaponsArray;
// 0x0170 (size: 0x10)
TMap<class FName, class APalWeaponBase*> spawnedBallMap;
// 0x0180 (size: 0x50)
class APalWeaponBase* DummyBall;
// 0x01D0 (size: 0x8)
EPalPlayerInventoryType replicatedPrimaryTargetInventoryType;
// 0x01D8 (size: 0x1)
int32 replicatedCurrentItemSlotIndex;
// 0x01DC (size: 0x4)
void TryEquipNowSelectedWeapon_ToAll();
bool TryEquipNowSelectedWeapon();
void SetWeaponLoadoutIndex_Internal(int32 Index);
void SetWeaponLoadoutIndex(int32 Index);
void SetupItemContainer();
void SetBallLoadoutIndex_Internal(int32 Index);
void SetBallLoadoutIndex(int32 Index);
void RequestChangeNowEquipBallItemID_ToServer(FName NextBallID);
void RemoveItem__DelegateSignature(EPalPlayerInventoryType inventoryType, int32
Index);
void OnUpdateWeaponLoadoutSlot(class UPalItemSlot* itemSlot);
void OnUpdateInventorySlot(class UPalItemSlot* itemSlot);
void OnRep_PrimaryTargetInventoryType();
void OnRep_CurrentItemSlotIndex();
void OnRemoveEquipItem(EPalPlayerInventoryType inventoryType, int32 Index);
void OnEquipItem(EPalPlayerInventoryType inventoryType, int32 Index);
EPalPlayerInventoryType GetPrimaryInventoryType();
void GetNowEquipedBallItemID(FName& OutBallItemID);
void EquipmentItem__DelegateSignature(EPalPlayerInventoryType inventoryType,
int32 Index);
void CheckRespawnWeaponActor(TArray<FPalLoadoutSynchronalizedData> synchroData,
TArray<class APalWeaponBase*> WeaponActorList, EPalPlayerInventoryType
inventoryType);
void ChangeWeaponByReplicated();
void ChangePrimiryInventoryType(EPalPlayerInventoryType targetInventory);
void ChangePrevWeaponLoadout_Internal();
void ChangePrevWeaponLoadout();
void ChangePrevBallLoadout_Internal();
void ChangePrevBallLoadout();
void ChangeNextWeaponLoadout_Internal();
void ChangeNextWeaponLoadout();
void ChangeNextBallLoadout_Internal();
void ChangeNextBallLoadout();
void AttachSpawnOtomoPalThrowWeapon_ToServer(int32 issuerID, bool IsAttach,
bool ShouldEquipDummyWeapon);
void AttachSpawnOtomoPalThrowWeapon_ToAll(int32 issuerID, bool IsAttach, bool
ShouldEquipDummyWeapon);
}; // Size: 0x240
class UPalLocalPlayer : public UCommonLocalPlayer

{
}; // Size: 0x2E8
class UPalLocalWorldSaveGame : public USaveGame

{
int32 Version;
// 0x0028 (size: 0x4)
FPalLocalSaveData SaveData;
// 0x0030 (size: 0x2E0)
}; // Size: 0x310
class UPalLocationBase : public UObject

{
FGuid CalledPlayerUId;
// 0x0028 (size: 0x10)
FGuid ID;
// 0x0038 (size: 0x10)
bool bShouldDisplay;
// 0x0048 (size: 0x1)
bool bShowInMap;
// 0x0049 (size: 0x1)
bool bShowInCompass;
// 0x004A (size: 0x1)
bool ShouldDisplay();
class UPalLocationPoint* LocationPoint();
bool IsShowInMap();
bool IsShowInCompass();
bool IsRequestedPlayer(const FGuid& LocalPlayerUId);
EPalLocationType GetType();
}; // Size: 0x50
class UPalLocationCreateParameter : public UObject

{
}; // Size: 0x50
class UPalLocationManager : public UPalWorldSubsystem

{
FPalLocationManagerOnAddedLocation OnAddedLocation;
// 0x0070 (size: 0x10)
void LocationDelegate(const FGuid& LocationId, class UPalLocationBase*
Location);
FPalLocationManagerOnRemoveLocation OnRemoveLocation;
// 0x0080 (size: 0x10)
Location);
FPalLocationManagerOnAddedLocationForCompass OnAddedLocationForCompass;
// 0x0090 (size: 0x10)
Location);
FPalLocationManagerOnRemoveLocationForCompass OnRemoveLocationForCompass;
// 0x00A0 (size: 0x10)
Location);
TMap<class FGuid, class UPalLocationBase*> LocationMap;
// 0x00B0 (size: 0x50)
TArray<class UPalLocationPoint_Custom*> CustomLocations;
// 0x0100 (size: 0x10)
void RemoveLocalCustomLocation(const FGuid& LocationId);

void LocationDelegate__DelegateSignature(const FGuid& LocationId, class
class UPalLocationPoint* GetLocationPoint(const FGuid& ID);
TMap<class FGuid, class UPalLocationBase*> GetLocationMap();
class UPalLocationBase* GetLocation(const FGuid& ID);
int32 GetLocalCustomLocationCount();
FGuid AddLocalCustomLocation(FVector IconLocation, int32 IconType);
}; // Size: 0x118
class UPalLocationPoint : public UPalLocationBase

{
bool IsEnableFastTravel();
void InvokeFastTravel();
float GetRotationZ();
FQuat GetRotation();
void GetLocationAndRotationZ(FVector& OutLocation, float& OutRotationZ);
FVector GetLocation();
}; // Size: 0x50
class UPalLocationPointBaseCamp : public UPalLocationPointStatic

{
FGuid BaseCampId;
// 0x0070 (size: 0x10)
bool bIsAvailable;
// 0x0080 (size: 0x1)
void SetAvailable();
void OnDisposeTarget(class UPalBaseCampModel* Model);
bool IsSameGuildWithPlayer(FGuid PlayerUId);
}; // Size: 0x88
class UPalLocationPointCreateParameter_BaseCamp : public

UPalLocationPointStaticCreateParameter
{
}; // Size: 0x80
class UPalLocationPointCreateParameter_BossTower : public

{
}; // Size: 0x78
class UPalLocationPointCreateParameter_Character : public

UPalLocationCreateParameter
{
}; // Size: 0x98
class UPalLocationPointCreateParameter_CustomMarker : public

{
}; // Size: 0x88
class UPalLocationPointCreateParameter_DroppedCharacter : public

{
}; // Size: 0x90
class UPalLocationPointCreateParameter_DroppedChest : public

{
}; // Size: 0x80
class UPalLocationPointCreateParameter_DungeonPortal : public

{
}; // Size: 0x70
class UPalLocationPointCreateParameter_FastTravel : public

{
}; // Size: 0x90
class UPalLocationPointCreateParameter_MapObject : public

UPalLocationCreateParameter
{
}; // Size: 0x60
class UPalLocationPointCreateParameter_Respawn : public

{
}; // Size: 0x78
class UPalLocationPointDungeonPortal : public UPalLocationPointStatic
{
}; // Size: 0x70
class UPalLocationPointFastTravel : public UPalLocationPointStatic

{
FGuid LocationId;
// 0x0070 (size: 0x10)
bool ShouldUnlockFlag;
// 0x0080 (size: 0x1)
FName FastTravelPointID;
// 0x0084 (size: 0x8)
}; // Size: 0x90
class UPalLocationPointStatic : public UPalLocationPoint

{
FVector Location;
// 0x0050 (size: 0x18)
float RotationZ;
// 0x0068 (size: 0x4)
}; // Size: 0x70
class UPalLocationPointStaticCreateParameter : public UPalLocationCreateParameter

{
}; // Size: 0x70
class UPalLocationPoint_BossTower : public UPalLocationPointStatic

{
// 0x0070 (size: 0x8)
class APalBossTower* GetBossTower();

}; // Size: 0x78
class UPalLocationPoint_Character : public UPalLocationPoint

{
// 0x0050 (size: 0x30)
EPalCharacterLocationType CharacterLocationType;
// 0x0080 (size: 0x1)
// 0x0084 (size: 0x10)
FName CharacterID;
// 0x0094 (size: 0x8)
void OnDestroyedTarget(class AActor* Target);

void OnDeadTarget(FPalDeadInfo Info);
EPalCharacterLocationType GetCharacterLocationType();
}; // Size: 0xA0
class UPalLocationPoint_Custom : public UPalLocationPointStatic

{
FPalLocationPoint_CustomOnIconTypeChanged OnIconTypeChanged;
// 0x0070 (size: 0x10)
void OnIconTypeChangedDelegate(int32 NewType);
void SetIconType(int32 Index);
void OnIconTypeChangedDelegate__DelegateSignature(int32 NewType);
FGuid GetOwnerPlayerId();
int32 GetIconType();
}; // Size: 0x98
class UPalLocationPoint_DroppedCharacter : public UPalLocationPointStatic

{
FGuid MapObjectConcreteModelId;
// 0x0070 (size: 0x10)
// 0x0080 (size: 0x10)
FGuid GetOwnerPlayerUId();
class UPalMapObjectPickableCharacterModelBase* GetMapObjectConcreteModel();
}; // Size: 0x90
class UPalLocationPoint_DroppedChest : public UPalLocationPointStatic

{
// 0x0070 (size: 0x10)
FGuid GetOwnerPlayerUId();
}; // Size: 0x80
class UPalLocationPoint_MapObject : public UPalLocationPoint

{
FGuid MapObjectModelId;
// 0x0050 (size: 0x10)
FVector InitialLocationCache;
// 0x0060 (size: 0x18)
void OnDisposeTarget(class UPalMapObjectModel* Model, const

bool GetMapObjectName(FName& MapObjectName);
}; // Size: 0x78
class UPalLocationPoint_Respawn : public UPalLocationPointStatic

{
FName RespawnPointID;
// 0x0070 (size: 0x8)
}; // Size: 0x78
class UPalLocationReplicator : public UPalGameStateReplicatorBase

{
FFastPalLocationRepInfoArray RepInfoArray;
// 0x0028 (size: 0x148)
}; // Size: 0x1C0
class UPalLogManager : public UPalWorldSubsystem

{
float normalLogDisplayTime;
// 0x0070 (size: 0x4)
float importantLogDisplayTime;
// 0x0074 (size: 0x4)
float veryImportantLogDisplayTime;
// 0x0078 (size: 0x4)
TMap<class FGuid, class FPalLogDataSet> veryImportantLogMap;
// 0x0080 (size: 0x50)
TSubclassOf<class UPalStaticLogCollector> staticLogCollectorClass;
// 0x00D0 (size: 0x8)
class UPalStaticLogCollector* staticLogCollector;
// 0x00D8 (size: 0x8)
FPalLogManagerOnAddedNormalLogDelegate OnAddedNormalLogDelegate;
// 0x00E0 (size: 0x10)
void AddedNormalLogDelegate(const FText& LogText, const FPalLogAdditionalData&
logAdditionalData);
FPalLogManagerOnAddedImportantLogDelegate OnAddedImportantLogDelegate;
// 0x00F0 (size: 0x10)
void AddedImportantLogDelegate(const FText& LogText, const
FPalLogAdditionalData& logAdditionalData);
FPalLogManagerOnAddedVeryImportantLogDelegate OnAddedVeryImportantLogDelegate;
// 0x0100 (size: 0x10)
void AddedVeryImportantLogDelegate(const FGuid& logId, const FText& LogText,
const FPalLogAdditionalData& logAdditionalData);
FPalLogManagerOnRemovedVeryImportantLogDelegate
OnRemovedVeryImportantLogDelegate; // 0x0110 (size: 0x10)
void RemovedVeryImportantLogDelegate(const FGuid& logId);
bool RemoveVeryImportantLog(const FGuid& targetLogId);

void RemovedVeryImportantLogDelegate__DelegateSignature(const FGuid& logId);
FGuid AddLog(EPalLogPriority logPriority, const FText& LogText, const
void AddedVeryImportantLogDelegate__DelegateSignature(const FGuid& logId, const
FText& LogText, const FPalLogAdditionalData& logAdditionalData);
void AddedNormalLogDelegate__DelegateSignature(const FText& LogText, const
void AddedImportantLogDelegate__DelegateSignature(const FText& LogText, const
}; // Size: 0x120
class UPalLogUtility : public UBlueprintFunctionLibrary

{
void SetTextureToAdditionalDataFromStaticItemIDs(const class UObject*

WorldContextObject, FPalLogAdditionalData& targetData, const TArray<FName>&
StaticItemIds);
void SetTextureToAdditionalDataFromStaticItemID(const class UObject*
WorldContextObject, FPalLogAdditionalData& targetData, const FName& StaticItemId);
void SetTextureToAdditionalDataFromHandles(const class UObject*
WorldContextObject, FPalLogAdditionalData& targetData, const TArray<class
UPalIndividualCharacterHandle*>& targetHandles);
void SetTextureToAdditionalDataFromHandle(const class UObject*
WorldContextObject, FPalLogAdditionalData& targetData, const class
UPalIndividualCharacterHandle* targetHandle);
void SetTextureToAdditionalDataFromCharacterID(const class UObject*
WorldContextObject, FPalLogAdditionalData& targetData, const FName CharacterID);
void CreateLogText(const class UObject* WorldContextObject, EPalLogType
logType, FText& OutText);
FText CreateItemGetLogText(const class UObject* WorldContextObject, const
FPalStaticItemIdAndNum& ItemIDAndNum);
void AddWorkerStartWorking_ProductResource_Mining(const class UObject*
WorldContextObject, const class UPalIndividualCharacterHandle* workerHandle, const
FName MapObjectId);
void AddWorkerStartWorking_ProductResource_Deforest(const class UObject*
WorldContextObject, const class UPalIndividualCharacterHandle* workerHandle);
void AddWorkerStartWorking_CollectResource(const class UObject*
WorldContextObject, const class UPalIndividualCharacterHandle* workerHandle, const
FName StaticItemId);
void AddWorkerStartWorking(const class UObject* WorldContextObject, const class
UPalIndividualCharacterHandle* workerHandle, const EPalWorkType WorkType);
void AddWorkerStartRepairing(const class UObject* WorldContextObject, const
class UPalIndividualCharacterHandle* workerHandle, const FName&
buildedMapObjectName);
void AddWorkerStartBuilding(const class UObject* WorldContextObject, const
void AddWorkerCompleteItemConvertLog(const class UObject* WorldContextObject,
const class UPalIndividualCharacterHandle* workerHandle, const FPalItemId& ItemId,
const int32 Num);
void AddWorkerCompleteBuildLog(const class UObject* WorldContextObject, const
void AddSkillLog(const class UObject* WorldContextObject, EPalLogType logType,
const FPalLogInfo_Skill& Info);
void AddItemGetLog(const class UObject* WorldContextObject, const
FPalStaticItemIdAndNum& ItemIDAndNum);
void AddDropPalLog(const class UObject* WorldContextObject, const
FPalLogInfo_DropPal& LogInfo);
}; // Size: 0x28
class UPalLogWidget : public UPalUserWidget

{
}; // Size: 0x408
class UPalLogWidgetBase : public UPalUserWidget

{
float destroyTime;
// 0x0408 (size: 0x4)
float ElapsedTime;
// 0x040C (size: 0x4)
EPalLogWidgetState logState;
// 0x0410 (size: 0x1)
FPalStaticItemIdAndNum ItemIDAndNum;
// 0x0414 (size: 0xC)
void StartDisplayLog(float inDestroyTime);

void SetState(EPalLogWidgetState ChangeState);
void SetLogText(const FText& InText);
void SetAdditionalData(const FPalLogAdditionalData& inAdditionalData);
void RequestOutAnime();
void RequestInAnime();
}; // Size: 0x420
class UPalLoginPlayer : public UObject

{
FPalLoginPlayerOnNotifyObtainNewInServerDelegate
OnNotifyObtainNewInServerDelegate; // 0x0028 (size: 0x10)
void NotifyCharacterDelegate(class UPalIndividualCharacterHandle* Handle);
FPalLoginPlayerOnNotifyRemovedFromPalBoxInServerDelegate
OnNotifyRemovedFromPalBoxInServerDelegate; // 0x0038 (size: 0x10)
void NotifyCharacterDelegate(class UPalIndividualCharacterHandle* Handle);
FGuid PlayerUId;
// 0x0048 (size: 0x10)
FVector RegisteredRespawnLocation;
// 0x0058 (size: 0x18)
}; // Size: 0x70
class UPalLongPressObject : public UObject

{
void ReleaseCallback();
void PressCallback();
void LongPressCallback();
}; // Size: 0x180
class UPalLookAtComponent : public UActorComponent

{
FVector LookAtTargetLocation;
// 0x00A0 (size: 0x18)
FVector LookAtTargetLocation_forActor;
// 0x00B8 (size: 0x18)
class AActor* LookAtTargetActor;
// 0x00D0 (size: 0x8)
FVector LookAtTargetLocation_Interpolated;
// 0x00D8 (size: 0x18)
FName LookAtTargetBoneName;
// 0x00F0 (size: 0x8)
float LookAtInInterpTime;
// 0x00F8 (size: 0x4)
float LookAtOutInterpTime;
// 0x00FC (size: 0x4)
bool bIsEnableLookAt;
// 0x0100 (size: 0x1)
FFlagContainer LookAtDisableFlag;
// 0x0108 (size: 0x50)
float InterpolatedSpeed;
// 0x0158 (size: 0x4)
bool bIsShowDebugImage;
// 0x015C (size: 0x1)
void StopLookAt(float interpTime);

void StartLookAtForActor(class AActor* Actor, FName BoneName, float
interpTime);
void StartLookAt(FVector LookAtTarget, float interpTime);
void SetLookAtDisable(FName flagName, bool bIsDisable);
void OnChangeShootState(bool IsAim, bool IsShooting);
bool IsEnableLookAt();
FVector GetLookAtTarget();
float GetLookAtOutInterpTime();
float GetLookAtInInterpTime();
}; // Size: 0x160
class UPalMapBaseCampWorkerOrderTypeUtility : public UBlueprintFunctionLibrary

{
bool IsBattleOrderType(const EPalMapBaseCampWorkerOrderType OrderType);

}; // Size: 0x28
class UPalMapObjectAmusementModel : public UPalMapObjectConcreteModelBase

{
FPalMapObjectAmusementModelOnUpdateCharacterDelegate OnUpdateCharacterDelegate;
// 0x0240 (size: 0x10)
void SimpleDelegate(class UPalMapObjectAmusementModel* Model);
class UPalIndividualCharacterHandle* HealingCharacterHandle;
// 0x0250 (size: 0x8)
FVector HealingLocationOffset;
// 0x0258 (size: 0x18)
// 0x0270 (size: 0x4)
TSubclassOf<class UPalAIActionBase> AIActionClass;
// 0x0278 (size: 0x8)
void SimpleDelegate__DelegateSignature(class UPalMapObjectAmusementModel*

Model);
void OnFinishHealingAction(class UPalAIActionBase* action);
class UPalIndividualCharacterHandle* GetHealingHandle();
void ClearCharacterHandle();
}; // Size: 0x280
class UPalMapObjectAmusementParameterComponent : public UActorComponent

{
// 0x00A0 (size: 0x4)
TSubclassOf<class UPalAIActionBase> AIActionClass;
// 0x00A8 (size: 0x8)
}; // Size: 0xB0
class UPalMapObjectBaseCampPassiveEffectModel : public

UPalMapObjectConcreteModelBase
{
}; // Size: 0x218
class UPalMapObjectBaseCampPassiveEffectParameterComponentBase : public

UActorComponent
{
}; // Size: 0xA0
class UPalMapObjectBaseCampPassiveEffectWorkHardParameterComponent : public

UPalMapObjectBaseCampPassiveEffectParameterComponentBase
{
}; // Size: 0xA0
class UPalMapObjectBaseCampPassiveEffectWorkSpeedParameterComponent : public

UPalMapObjectBaseCampPassiveEffectParameterComponentBase
{
int32 AffectMaxNum;
// 0x00A0 (size: 0x4)
EPalWorkSuitability TargetWorkSuitability;
// 0x00A4 (size: 0x1)
float WorkSpeedAdditionalRate;
// 0x00A8 (size: 0x4)
}; // Size: 0xB0
class UPalMapObjectBaseCampPassiveWorkHardModel : public

UPalMapObjectBaseCampPassiveEffectModel
{
void RequestUpdateWorkHardType_ServerInternal(const int32 RequestPlayerId,
const int32 TypeInt);
void RequestUpdateWorkHardType(const EPalBaseCampPassiveEffectWorkHardType
Type);
class UPalBaseCampPassiveEffect_WorkHard* GetPassiveEffectWorkHard();
}; // Size: 0x218
class UPalMapObjectBaseCampPoint : public UPalMapObjectConcreteModelBase

{
TSubclassOf<class UPalUserWidgetOverlayUI> PalBoxWiget;
// 0x0218 (size: 0x8)
TSubclassOf<class UPalUserWidgetOverlayUI> CampTaskWiget;
// 0x0220 (size: 0x8)
FGuid BaseCampId;
// 0x0228 (size: 0x10)
}; // Size: 0x238
class UPalMapObjectBaseCampWorkerDirectorModel : public

{
FPalMapObjectBaseCampWorkerDirectorModelOnNotifiedChangeBaseCampBattleTypeDelegate
OnNotifiedChangeBaseCampBattleTypeDelegate; // 0x0218 (size: 0x10)
void ReturnSelfDelegate(class UPalMapObjectBaseCampWorkerDirectorModel* Model);
EPalBaseCampWorkerDirectionBattleType BaseCampBattleTypeForClientRead;
// 0x0228 (size: 0x1)
UPalMapObjectBaseCampWorkerDirectorModel* Model);
void RequestUpdateBaseCampBattleType_ServerInternal(const int32
RequestPlayerId, const int32 BattleTypeInt);
void OnRep_BaseCampBattleTypeForClientRead();
void NotifyChangeBaseCampBattleType_ClientInternal();
}; // Size: 0x230
class UPalMapObjectBreedFarmModel : public UPalMapObjectConcreteModelBase

{
FPalMapObjectBreedFarmModelOnUpdateBreedProgress OnUpdateBreedProgress;
// 0x0218 (size: 0x10)
void OnBreedProgressChangedDelegate(float CurrentProgress, float MaxProgress);
TArray<FGuid> SpawnedEggInstanceIds;
// 0x0228 (size: 0x10)
int32 ExistPalEggMaxNum;
// 0x0238 (size: 0x4)
float BreedRequiredRealTime;
// 0x023C (size: 0x4)
float BreedProgressTime;
// 0x0240 (size: 0x4)
TArray<FPalInstanceID> LastProceedWorkerIndividualIds;
// 0x0248 (size: 0x10)
TArray<FName> TargetBreedItemIds;
// 0x0258 (size: 0x10)
void OnUpdateAssignedCharacter(class UPalWorkBase* Work);

void OnRep_UpdateBreedProgress();
void OnBreedProgressChangedDelegate__DelegateSignature(float CurrentProgress,
float MaxProgress);
void GetBreedProgress(float& NowProgress, float& MaxProgress);
bool CanProceedBreeding();
EPalItemOperationResult CanConsumeBreedItem(FPalItemSlotIdAndNum&
ConsumableItem);
}; // Size: 0x268
class UPalMapObjectBreedFarmParameterComponent : public UActorComponent

{
float BreedRequiredRealTime;
// 0x00A0 (size: 0x4)
int32 ExistPalEggMaxNum;
// 0x00A4 (size: 0x4)
int32 SlotNum;
// 0x00A8 (size: 0x4)
TArray<FPalDataTableRowName_ItemData> TargetItemIds;
// 0x00B0 (size: 0x10)
}; // Size: 0xC0
class UPalMapObjectCharacterContainerModule : public

UPalMapObjectConcreteModelModuleBase
{
class UPalIndividualCharacterContainer* TargetContainer;
// 0x0030 (size: 0x8)
bool TryGetContainer(class UPalIndividualCharacterContainer*& OutContainer);

void OnRep_TargetContainer();
bool IsCompleteSetup();
FPalContainerId GetContainerId();
class UPalIndividualCharacterContainer* GetContainer();
}; // Size: 0x38
class UPalMapObjectCharacterStatusOperatorModel : public

{
}; // Size: 0x218
class UPalMapObjectCollectResourceParameterComponent : public UActorComponent

{
int32 SlotNum;
// 0x00A0 (size: 0x4)
TArray<FPalDataTableRowName_ItemData> TargetItemIds;
// 0x00A8 (size: 0x10)
float AdditionalRangeOutOfBaseCamp;
// 0x00B8 (size: 0x4)
}; // Size: 0xC0
class UPalMapObjectConcreteModelBase : public UObject

{
FPalMapObjectConcreteModelBaseOnAvailableDelegate OnAvailableDelegate;
// 0x0030 (size: 0x10)
void SimpleDelegate(class UPalMapObjectConcreteModelBase* Model);
FPalMapObjectConcreteModelBaseOnNotAvailableDelegate OnNotAvailableDelegate;
// 0x0040 (size: 0x10)
void SimpleDelegate(class UPalMapObjectConcreteModelBase* Model);
TMap<class UClass*, class
FPalMapObjectConcreteModelBaseOnSpawnedReadyModuleDelegateMap>
OnSpawnedReadyModuleDelegateMap; // 0x0050 (size: 0x50)
FGuid InstanceId;
// 0x00A0 (size: 0x10)
// 0x00B0 (size: 0x10)
bool bDisposed;
// 0x00C0 (size: 0x1)
FPalFastMapObjectModuleRepInfoArray ModuleRepInfoArray;
// 0x00C8 (size: 0x148)
class UPalMapObjectWorkeeModule* WorkeeModuleCache;
// 0x0210 (size: 0x8)
FName TryGetMapObjectId();
void SimpleDelegate__DelegateSignature(class UPalMapObjectConcreteModelBase*
Model);
IndicatorType);
void OnTriggeringInteract(class AActor* Other,
EPalInteractiveObjectIndicatorType IndicatorType, const float DeltaTime);
void OnStartTriggerInteract(class AActor* Other,
void OnRep_ModuleArray();
void OnEndTriggerInteract(class AActor* Other,
class UPalMapObjectWorkeeModule* GetWorkeeModule();
FTransform GetTransform();
class UPalMapObjectSwitchModule* GetSwitchModule();
class UPalMapObjectPasswordLockModule* GetPasswordLockModule();
void GetMapObjectLocation(FVector& outVector);
class UPalMapObjectItemContainerModule* GetItemContainerModule();
FGuid GetInstanceId();
class UPalMapObjectEnergyModule* GetEnergyModule();
class UPalMapObjectCharacterContainerModule* GetCharacterContainerModule();
class UPalBaseCampModel* GetBaseCampModelBelongTo();
void CallOrRegisterOnReadyModule(const EPalMapObjectConcreteModelModuleType
ModuleType, FCallOrRegisterOnReadyModuleDelegate Delegate);
}; // Size: 0x218
class UPalMapObjectConcreteModelModuleBase : public UObject

{
bool bTriggeredOnSpawnedReady;
// 0x0028 (size: 0x1)
}; // Size: 0x30
class UPalMapObjectConvertItemModel : public UPalMapObjectConcreteModelBase

{
FPalMapObjectConvertItemModelOnUpdateRecipeDelegate OnUpdateRecipeDelegate;
// 0x0238 (size: 0x10)
void UpdateRecipeDelegate(class UPalMapObjectConvertItemModel* Model);
FPalMapObjectConvertItemModelOnFinishConvertDelegate OnFinishConvertDelegate;
// 0x0248 (size: 0x10)
void FinishConvertDelegate(class UPalMapObjectConvertItemModel* Model);
FPalMapObjectConvertItemModelOnRecieveUpdateRecipeRequestResultDelegate
OnRecieveUpdateRecipeRequestResultDelegate; // 0x0258 (size: 0x10)
void
RecieveUpdateRecipeRequestResultDelegate(EPalMapObjectConvertItemModelRequestResult
Result);
FPalMapObjectConvertItemModelOnUpdateSettingDelegate OnUpdateSettingDelegate;
// 0x0268 (size: 0x10)
void UpdateSettingDelegate(class UPalMapObjectConvertItemModel* Model);
FName CurrentRecipeId;
// 0x0278 (size: 0x8)
int32 RequestedProductNum;
// 0x0280 (size: 0x4)
int32 RemainProductNum;
// 0x0284 (size: 0x4)
bool bIsWorkable;
// 0x0288 (size: 0x1)
TArray<FName> RecipeIds;
// 0x0290 (size: 0x10)
// 0x02A0 (size: 0x4)
int32 CurrentRecipeRequestPlayerId;
// 0x02A4 (size: 0x4)
TArray<EPalItemTypeA> TargetTypesA;
// 0x02A8 (size: 0x10)
TArray<EPalItemTypeB> TargetTypesB;
// 0x02B8 (size: 0x10)
int32 TargetRankMax;
// 0x02C8 (size: 0x4)
bool IsPickUpInteractable;
// 0x02CC (size: 0x1)
void UpdateSettingDelegate__DelegateSignature(class
UPalMapObjectConvertItemModel* Model);
void UpdateRecipeDelegate__DelegateSignature(class
void RequestUpdateRecipe(const FName RecipeID, const int32 ProductNum);
void RequestChangeRecipe_ServerInternal(const int32 RequestPlayerId, const
FPalNetArchive& Archive);
void RequestCancel();
void
RecieveUpdateRecipeRequestResultDelegate__DelegateSignature(EPalMapObjectConvertIte
mModelRequestResult Result);
void ReceivedPickProductResult(class UPalItemSlot* Slot);
void OnUpdateEnergyModuleState(class UPalMapObjectEnergyModule* EnergyModule);
void OnUpdateContainerContentInServer(class UPalItemContainer* Container);
void OnStartWorkAnyone_ServerInternal(class UPalWorkBase* Work, const
FPalInstanceID& WorkerIndividualId);
void OnRep_RequestedProductNum();
void OnRep_RemainProductNum();
void OnRep_IsWorkable();
void OnRep_CurrentRecipeId();
void OnEndWorkAnyone_ServerInternal(class UPalWorkBase* Work, const
FPalInstanceID& WorkerIndividualId);
bool IsTransportToStorage();
bool IsProductNumInfinite(const int32 ProductNum);
class UPalItemSlot* GetSlotInjectableMaterial(const FName StaticItemId);
int32 GetSlotIndexProductOut();
TArray<int32> GetSlotIndexesMaterialInput();
int32 GetRemainCreateNum();
TArray<FName> GetRecipes();
class UPalItemSlot* GetProductSlot();
FName GetCurrentRecipeId();
FPalItemRecipe GetCurrentRecipe();
void FinishConvertDelegate__DelegateSignature(class
float CalcRequiredAmount(const float BaseRequiredAmount);
void AddConvertItemResultLog(const FPalNetArchive& Archive);
}; // Size: 0x2D0
class UPalMapObjectDamageReactionComponent : public UActorComponent

{
// 0x00A8 (size: 0x8)
}; // Size: 0xB0
class UPalMapObjectDamagedScarecrowModel : public UPalMapObjectConcreteModelBase

{
float ProgressTimeStartAtDamaged;
// 0x0218 (size: 0x4)
void OnDamage_ServerInternal(class UPalMapObjectModel* Model, const

FPalDamageInfo& DamageInfo, const int32 LastHp);
}; // Size: 0x220
class UPalMapObjectDeathDroppedCharacterModel : public

UPalMapObjectPickableCharacterModelBase
{
FPalMapObjectDeathDroppedCharacterModelOnNotifiedGuildUpdateInClientDelegate
OnNotifiedGuildUpdateInClientDelegate; // 0x0458 (size: 0x10)
void ReturnSelfDelegate(class UPalMapObjectDeathDroppedCharacterModel* Model);
// 0x0468 (size: 0x10)
UPalMapObjectDeathDroppedCharacterModel* Model);
void OnChangedPlayerInfoInLocalPlayerGuild_ClientInternal(class
APalPlayerState* LocalPlayerState);
bool IsSameGuildInLocalPlayer();
}; // Size: 0x478
class UPalMapObjectDeathPenaltyStorageModel : public UPalMapObjectItemStorageModel

{
FPalMapObjectDeathPenaltyStorageModelOnNotifiedGuildUpdateInClientDelegate
OnNotifiedGuildUpdateInClientDelegate; // 0x0220 (size: 0x10)
void ReturnSelfDelegate(class UPalMapObjectDeathPenaltyStorageModel* Model);
// 0x0230 (size: 0x10)
FGuid LocationId;
// 0x0240 (size: 0x10)
UPalMapObjectDeathPenaltyStorageModel* Model);
void OnChangedPlayerInfoInLocalPlayerGuild_ClientInternal(class
APalPlayerState* LocalPlayerState);
bool IsSameGuildInLocalPlayer();
}; // Size: 0x250
class UPalMapObjectDefenseBulletLauncherModel : public

UPalMapObjectDefenseModelBase
{
TWeakObjectPtr<class APalMapObject> WeakLauncherControlMapObject;
// 0x0218 (size: 0x8)
TWeakObjectPtr<class APalStationaryWeaponBase> WeakWeapon;
// 0x0220 (size: 0x8)
int32 remainingBulletsNum;
// 0x0228 (size: 0x4)
int32 MagazineSize;
// 0x022C (size: 0x4)
FName BulletItemName;
// 0x0230 (size: 0x8)
void UseBullet();
void TurnToTarget(const class AActor* TargetActor, float DeltaTime);
bool TryGetWeapon(class APalStationaryWeaponBase*& OutWeapon);
void SetOwnerCharacter(const class APalCharacter* OwnerCharacter);
void SetEnableTrigger(bool EnableTrigger);
void ReloadBullets(int32 ReloadBulletsNum);
int32 GetRemainingBulletsNum();
int32 GetMagazineSize();
FName GetBulletName();
float GetAttackableDistance();
float GetAttackableAngle();
bool CanAvailable();
}; // Size: 0x238
class UPalMapObjectDefenseModelBase : public UPalMapObjectConcreteModelBase

{
bool TryGetLauncherControlMapObject(class APalMapObject*& OutMapObject);

FVector GetLocation();
EPalMapObjectDefenseType GetDefenseType();
}; // Size: 0x218
class UPalMapObjectDefenseWaitModel : public UPalMapObjectDefenseModelBase

{
TWeakObjectPtr<class APalMapObject> WeakLauncherControlMapObject;
// 0x0218 (size: 0x8)
}; // Size: 0x220
class UPalMapObjectDisplayCharacterModel : public UPalMapObjectConcreteModelBase

{
float RecoverAmountBySec;
// 0x0218 (size: 0x4)
FTransform CharacterSpawnLocalTransform;
// 0x0220 (size: 0x60)
// 0x0280 (size: 0x8)
TSubclassOf<class UPalUserWidgetOverlayUI> MenuUIWidgetClass;
// 0x0288 (size: 0x8)
class UPalIndividualCharacterSlotsObserver* CharacterSlotsObserver;
// 0x0290 (size: 0x8)
void TryMoveToDisplayCage(class UPalIndividualCharacterSlot* fromSlot);

void OnUpdateCharacterContainer_ServerInternal();
void OnSpawnedPhantomCharacter_ServerInternal(FPalInstanceID IndividualId,
const int32 PhantomId);
bool GetDisplaySlots(TArray<class UPalIndividualCharacterSlot*>& Slots);
}; // Size: 0x2F0
class UPalMapObjectDisplayCharacterParameterComponent : public UActorComponent
{
int32 SlotNum;
// 0x00A0 (size: 0x4)
// 0x00A4 (size: 0x4)
FTransform CharacterSpawnLocalTransform;
// 0x00B0 (size: 0x60)
// 0x0110 (size: 0x8)
// 0x0118 (size: 0x8)
}; // Size: 0x120
class UPalMapObjectDoorModel : public UPalMapObjectConcreteModelBase

{
void RequestTrigger_ServerInternal(const int32 RequestPlayerId, const int32

ToStateInt);
}; // Size: 0x218
class UPalMapObjectDropItemModel : public UPalMapObjectPickableItemModelBase

{
FPalItemId ItemId;
// 0x0248 (size: 0x28)
FVector ReleaseDirection;
// 0x0270 (size: 0x18)
bool bEnableInteract;
// 0x0288 (size: 0x1)
void OnUpdateItemContainerContentInServer(class UPalItemContainer* Container);

void OnInteracting(float DeltaTime);
void OnEnableTriggerInteract(TScriptInterface<class
}; // Size: 0x298
class UPalMapObjectDropItemParameterComponent : public UActorComponent

{
TArray<FPalMapObjectDropItemData> DropItems;
// 0x00A0 (size: 0x10)
}; // Size: 0xB0
class UPalMapObjectEnergyModule : public UPalMapObjectConcreteModelModuleBase

{
FPalMapObjectEnergyModuleOnUpdateCurrentStateDelegate
OnUpdateCurrentStateDelegate; // 0x0030 (size: 0x10)
void ReturnSelfMulticastDelegate(class UPalMapObjectEnergyModule* Module);
// 0x0040 (size: 0x1)
// 0x0044 (size: 0x4)
float CurrentConsumeEnergySpeed;
// 0x0048 (size: 0x4)
EPalMapObjectEnergyModuleStatusType CurrentState;
// 0x004C (size: 0x1)
bool bRequiredConsumeEnergy;
// 0x004D (size: 0x1)
FGuid StatusHUDId;
// 0x0050 (size: 0x10)
void ReturnSelfMulticastDelegate__DelegateSignature(class
UPalMapObjectEnergyModule* Module);
void RemoveHUD();
bool IsRequiredEnergy();
EPalEnergyType GetEnergyType();
EPalMapObjectEnergyModuleStatusType GetCurrentState();
float GetCurrentConsumeEnergySpeed();
float GetConsumeEnergySpeed();
bool CanConsumeEnergy();
}; // Size: 0x68
class UPalMapObjectFarmBlockV2Model : public UPalMapObjectConcreteModelBase

{
FPalMapObjectFarmBlockV2ModelOnUpdateStateDelegate OnUpdateStateDelegate;
// 0x0220 (size: 0x10)
void UpdateStateDelegate(EPalFarmCropState LastState, EPalFarmCropState
NextState);
FReactivePropertyFloat CropProgressRate;
// 0x0230 (size: 0x18)
FReactivePropertyFloat WaterStackRate;
// 0x0248 (size: 0x18)
class UPalMapObjectFarmBlockV2ModelStateBehaviourMachine*
StateBehaviourMachine; // 0x0260 (size: 0x8)
FName CurrentCropDataId;
// 0x0268 (size: 0x8)
EPalFarmCropState CurrentState;
// 0x0270 (size: 0x1)
float CropProgressRateValue;
// 0x0274 (size: 0x4)
float WaterStackRateValue;
// 0x0278 (size: 0x4)
void UpdateStateDelegate__DelegateSignature(EPalFarmCropState LastState,

EPalFarmCropState NextState);
void OnUpdateWaterStackRate(const float UpdatedRate);
void OnUpdateCropProgressRate(const float ProgressRate);
void OnRep_WaterStackRateValue();
void OnRep_CropProgressRateValue();
void NotifySimpleDelegate__DelegateSignature();
EPalFarmCropState GetCurrentState();
FName GetCurrentCropDataId();
}; // Size: 0x280
class UPalMapObjectFarmBlockV2ModelStateBehaviourBase : public

UPalStateMachineStateBase
{
}; // Size: 0x30
class UPalMapObjectFarmBlockV2ModelStateBehaviourGrowup : public

UPalMapObjectFarmBlockV2ModelStateBehaviourBase
{
}; // Size: 0x48
class UPalMapObjectFarmBlockV2ModelStateBehaviourHarvestable : public

{
void UpdateHarvestProgressRateDelegate__DelegateSignature(float ProgressRate);

void OnWorkStarted(class UPalWorkBase* Work, const FPalInstanceID&
IndividualId);
void OnProgressWork(class UPalWorkProgress* WorkProgress);
}; // Size: 0x48
class UPalMapObjectFarmBlockV2ModelStateBehaviourMachine : public UPalStateMachine

{
class UPalMapObjectFarmBlockV2ModelStateBehaviourBase*
CurrentStateBehaviourCache; // 0x0088 (size: 0x8)
}; // Size: 0x98
class UPalMapObjectFarmBlockV2ModelStateBehaviourSeeding : public

{
void UpdateProgressRateDelegate__DelegateSignature(float ProgressRate);

void OnProgressWork(class UPalWorkProgress* WorkProgress);
}; // Size: 0x40
class UPalMapObjectFarmBlockV2ModelStateBehaviourWatering : public

{
void UpdateWaterStackRateDelegate__DelegateSignature(float WaterStackRate);

void OnProgressWorkInServer(class UPalWorkProgress* WorkProgress);
}; // Size: 0x40
class UPalMapObjectFarmCropDataUtility : public UBlueprintFunctionLibrary

{
void MaterialInfos(const FPalMapObjectFarmCropData& Data,

TArray<FPalStaticItemIdAndNum>& MaterialInfos);
bool IsValid(FPalMapObjectFarmCropData& Data);
}; // Size: 0x28
class UPalMapObjectFastTravelPointModel : public UPalMapObjectConcreteModelBase

{
FGuid LocationInstanceId;
// 0x0218 (size: 0x10)
}; // Size: 0x228
class UPalMapObjectFoliage : public UObject

{
class UPalFoliagePresetDataSet* PresetDataSet;
// 0x0028 (size: 0x8)
TMap<class FName, class UPalFoliageType_InstancedStaticMesh*>
UsedPalFoliageTypeMap; // 0x0030 (size: 0x50)
TSet<EPalFoliagePresetType> LoadedPresetTypeSet;
// 0x0080 (size: 0x50)
int32 GridSize;
// 0x00D0 (size: 0x4)
TMap<class FPalCellCoord, class UPalFoliageGridModel*> GridModelMap;
// 0x00D8 (size: 0x50)
}; // Size: 0x130
class UPalMapObjectFoliageModel : public UObject

{
FPalMapObjectFoliageModelOnRespawn OnRespawn;
// 0x0028 (size: 0x10)
void InstanceDelegate(class UPalFoliageInstance* Instance);
FPalMapObjectFoliageModelOnDamage OnDamage;
// 0x0038 (size: 0x10)
void InstanceDamageDelegate(class UPalFoliageInstance* Instance, const int32
DamageValue);
FPalMapObjectFoliageModelOnDestroy OnDestroy;
// 0x0048 (size: 0x10)
void InstanceDelegate(class UPalFoliageInstance* Instance);
FPalMapObjectFoliageModelOnUpdatedRequiredTickInServer
OnUpdatedRequiredTickInServer; // 0x0058 (size: 0x10)
void ReturnSelfDelegate(class UPalMapObjectFoliageModel* Self);
FPalMapObjectFoliageModelOnDisposeModelDelegate OnDisposeModelDelegate;
// 0x0068 (size: 0x10)
void ReturnSelfDelegate(class UPalMapObjectFoliageModel* Self);
FName ModelId;
// 0x0078 (size: 0x8)
TMap<class FPalFoliageInstanceId, class UPalFoliageInstance*> InstanceMap;
// 0x0080 (size: 0x50)
FPalCellCoord CellCoord;
// 0x0120 (size: 0x18)
EPalFoliagePresetType FoliagePresetType;
// 0x0138 (size: 0x1)
void ReturnSelfDelegate__DelegateSignature(class UPalMapObjectFoliageModel*

Self);
void RespawnInstance(class UPalFoliageInstance* Instance);
void OnDestroyInstance(class UPalFoliageInstance* Instance);
void InstanceDelegate__DelegateSignature(class UPalFoliageInstance* Instance);
void InstanceDamageDelegate__DelegateSignature(class UPalFoliageInstance*
Instance, const int32 DamageValue);
}; // Size: 0x140
class UPalMapObjectFoodBoxParameterComponent : public UActorComponent

{
// 0x00A0 (size: 0x4)
}; // Size: 0xA8
class UPalMapObjectGateModel : public UPalMapObjectConcreteModelBase

{
FGameDateTime UnlockDateTime;
// 0x0218 (size: 0x8)
TMap<class FPalInstanceID, class
TWeakObjectPtr<UPalIndividualCharacterParameter>>
WeakInteractingCharacterParameters; // 0x0220 (size: 0x50)
void RequestTrigger_ServerInternal(const int32 RequestPlayerId, const int32

ToStateInt);
}; // Size: 0x270
class UPalMapObjectGenerateEnergyModel : public UPalMapObjectConcreteModelBase

{
FPalMapObjectGenerateEnergyModelOnUpdateStoredEnergyAmountDelegate
OnUpdateStoredEnergyAmountDelegate; // 0x0220 (size: 0x10)
void UpdateEnergyAmountDelegate(class UPalMapObjectGenerateEnergyModel* Model);
// 0x0230 (size: 0x1)
// 0x0234 (size: 0x4)
// 0x0238 (size: 0x4)
float StoredEnergyAmount;
// 0x023C (size: 0x4)
// 0x0240 (size: 0x4)
void UpdateEnergyAmountDelegate__DelegateSignature(class
UPalMapObjectGenerateEnergyModel* Model);
void OnUpdateAssignedCharacter_ServerInternal(class UPalWorkBase* Work);
void OnRep_StoredEnergyAmount();
float GetStoredEnergyAmount();
float GetMaxEnergyStorage();
EPalEnergyType GetEnergyType();
}; // Size: 0x248
class UPalMapObjectGenerateEnergyParameterComponent : public UActorComponent

{
EPalEnergyType GenerateEnergyType;
// 0x00A0 (size: 0x1)
// 0x00A4 (size: 0x4)
// 0x00A8 (size: 0x4)
}; // Size: 0xB0
class UPalMapObjectHPWorldHUDParameter : public UPalHUDDispatchParameterBase

{
class APalMapObject* MapObject;
// 0x0038 (size: 0x8)
}; // Size: 0x40
class UPalMapObjectHatchingEggModel : public UPalMapObjectConcreteModelBase

{
FPalMapObjectHatchingEggModelOnUpdateHatchedCharacterDelegate
OnUpdateHatchedCharacterDelegate; // 0x0220 (size: 0x10)
void UpdateHatchedCharacterDelegate(class UPalMapObjectHatchingEggModel*
Model);
FPalMapObjectHatchingEggModelOnUpdateHatchTemperaturDelegate
OnUpdateHatchTemperaturDelegate; // 0x0230 (size: 0x10)
void UpdateHatchTemperatureDelegate(int32 Temperature);
FPalIndividualCharacterSaveParameter HatchedCharacterSaveParameter;
// 0x0240 (size: 0x218)
bool bWorkable;
// 0x0458 (size: 0x1)
// 0x0460 (size: 0x8)
int32 CurrentPalEggTemperatureDiff;
// 0x0468 (size: 0x4)
void UpdateWorkAmountBySec(const float NewWorkAmountBySec);

void UpdateHatchTemperatureDelegate__DelegateSignature(int32 Temperature);
void UpdateHatchedCharacterDelegate__DelegateSignature(class
UPalMapObjectHatchingEggModel* Model);
void SetTemperatureDiff(int32 TemperatureDiff);
void OnRep_HatchTemperatureDiff();
void OnRep_HatchedCharacterSaveParameter();
void ObtainHatchedCharacter_ServerInternal(const int32 RequestPlayerId);
int32 GetTemperatureDiff();
bool GetPalEggRankInfo(FPalEggRankInfo& OutPalEggRankInfo);
}; // Size: 0x470
class UPalMapObjectHatchingEggParameterComponent : public UActorComponent

{
// 0x00A0 (size: 0x4)
// 0x00A8 (size: 0x8)
float GetDefaultAutoWorkAmountBySec();
}; // Size: 0xB0
class UPalMapObjectHeatSourceModel : public UPalMapObjectConcreteModelBase

{
void OnUpdateEnergyModuleState_ServerInternal(class UPalMapObjectEnergyModule*

EnergyModule);
}; // Size: 0x218
class UPalMapObjectInteractRestrictTypeUtility : public UBlueprintFunctionLibrary

{
}; // Size: 0x28
class UPalMapObjectItemChestModel : public UPalMapObjectItemStorageModel

{
void OnUpdateLocalPlayerPasswordLockInfo(const
FPalMapObjectPasswordLockPlayerInfo& OldLocalPlayerInfo, const
FPalMapObjectPasswordLockPlayerInfo& NewLocalPlayerInfo);
}; // Size: 0x228
class UPalMapObjectItemChestParameterComponent : public UActorComponent

{
int32 SlotNum;
// 0x00A0 (size: 0x4)
// 0x00A8 (size: 0x10)
// 0x00B8 (size: 0x10)
// 0x00C8 (size: 0x1)
bool bAutoDestroyIfEmpty;
// 0x00C9 (size: 0x1)
// 0x00CC (size: 0x4)
}; // Size: 0xD0
class UPalMapObjectItemChest_AffectCorruption : public UPalMapObjectItemChestModel

{
}; // Size: 0x228
class UPalMapObjectItemContainerModule : public

{
class UPalItemContainer* TargetContainer;
// 0x0040 (size: 0x8)
bool bDropItemAtDisposed;
// 0x0048 (size: 0x1)
TArray<FPalMapObjectItemContainerModuleSlotIndexes> SlotAttributeIndexes;
// 0x0050 (size: 0x10)
TArray<EPalMapObjectItemContainerSlotAttribute> AllSlotAttribute;
// 0x0060 (size: 0x10)
EPalContainerUsageType UsageType;
// 0x00F0 (size: 0x1)
void UpdateContentsMulticastDelegate__DelegateSignature(class
UPalMapObjectItemContainerModule* Module);
void UpdateContentsDelegate__DelegateSignature(class
UPalMapObjectItemContainerModule* Module);
void UnbindUpdateContents(FUnbindUpdateContentsDelegate Delegate);
bool TryGetContainer(class UPalItemContainer*& OutContainer);
void RequestSortContainer_ServerInternal();
void RequestSortContainer();
void OnUpdateContents(class UPalItemContainer* Container);
class UPalItemContainer* GetContainer();
void BindUpdateContents(FBindUpdateContentsDelegate Delegate);
}; // Size: 0x100
class UPalMapObjectItemConverterParameterComponent : public UActorComponent

{
// 0x00A0 (size: 0x10)
// 0x00B0 (size: 0x10)
int32 TargetRankMax;
// 0x00C0 (size: 0x4)
// 0x00C4 (size: 0x4)
// 0x00C8 (size: 0x4)
}; // Size: 0xD0
class UPalMapObjectItemDropOnDamagModel : public UPalMapObjectConcreteModelBase

{
TArray<FPalItemAndNum> DropItemInfos;
// 0x0230 (size: 0x10)

}; // Size: 0x240
class UPalMapObjectItemSimpleProductParameterComponent : public UActorComponent

{
FPalDataTableRowName_ItemProductData ItemProductId;
// 0x00A0 (size: 0x8)
int32 SlotNum;
// 0x00A8 (size: 0x4)
// 0x00AC (size: 0x4)
bool bIsGainExp;
// 0x00B0 (size: 0x1)
}; // Size: 0xB8
class UPalMapObjectItemStorageModel : public UPalMapObjectConcreteModelBase

{
bool bAutoDestroyIfEmpty;
// 0x0218 (size: 0x1)
void RequestSortContainer();
}; // Size: 0x220
class UPalMapObjectLampModel : public UPalMapObjectConcreteModelBase

{

}; // Size: 0x218
class UPalMapObjectLocationComponent : public UActorComponent

{
FGuid LocationId;
// 0x00A0 (size: 0x10)
void SetLocationId();
}; // Size: 0xB0
class UPalMapObjectManager : public UPalWorldSubsystem

{
FPalMapObjectManagerOnCreateMapObjectModelInServerDelegate
OnCreateMapObjectModelInServerDelegate; // 0x00B8 (size: 0x10)
void MapObjectModelWithVectorDelegate(class UPalMapObjectModel* MapObjectModel,
const FVector& Vector);
FPalMapObjectManagerOnRepMapObjectModelDelegate OnRepMapObjectModelDelegate;
// 0x00C8 (size: 0x10)
void MapObjectModelDynamicDelegate(class UPalMapObjectModel* MapObjectModel);
FPalMapObjectManagerOnSpawnedMapObjectModelByInServerDelegate
OnSpawnedMapObjectModelByInServerDelegate; // 0x00D8 (size: 0x10)
void MapObjectModelSpawnedByDelegate(class UPalMapObjectModel* MapObjectModel,
class UPalMapObjectModelInitializeExtraParameterSpawnedBy* SpawnedBy);
TArray<TScriptInterface<IPalBuildObjectSpawnValidationCheckInterface>>
BuildSpawnValidationCheckers; // 0x0110 (size: 0x10)
class UDataTable* BuildObjectDataTable;
// 0x0120 (size: 0x8)
class UDataTable* BuildObjectNameTable;
// 0x0128 (size: 0x8)
class UDataTable* BuildObjectDescTable;
// 0x0130 (size: 0x8)
class UDataTable* MapObjectAssignTable;
// 0x0138 (size: 0x8)
FBuildingSurfaceMaterialSet BuildingSurfaceMaterialSet;
// 0x0140 (size: 0x38)
class UPalFoliagePresetDataSet* FoliagePresetDataSet;
// 0x0178 (size: 0x8)
TSubclassOf<class APalFoliageModelChunk> FoliageModelChunkClass;
// 0x0180 (size: 0x8)
int32 FoliageGridSize;
// 0x0188 (size: 0x4)
class UPalMapObjectFoliage* Foliage;
// 0x0190 (size: 0x8)
class UPalBuildOperator* BuildOperator;
// 0x0198 (size: 0x8)
class UPalMapObjectWorldDisposer* WorldDisposerForServer;
// 0x01A0 (size: 0x8)
TMap<class FGuid, class UPalMapObjectModel*> MapObjectModelMapForServer;
// 0x01A8 (size: 0x50)
TMap<class FGuid, class UPalMapObjectConcreteModelBase*>
MapObjectConcreteModelMapForServer; // 0x01F8 (size: 0x50)
TMap<class FName, class FPalMapObjectModelStaticData>
MapObjectModelStaticDataCacheMap; // 0x0338 (size: 0x50)
FPalMapObjectStaticData StaticData;
// 0x0388 (size: 0x48)
FName DropItemMapObjectId;
// 0x03D0 (size: 0x8)
FName BuildObjectId_PalStorage;
// 0x03D8 (size: 0x8)
TArray<TEnumAsByte<EObjectTypeQuery>> SearchObjectTypes;
// 0x03E0 (size: 0x10)
TMap<class EPalMapObjectDestroyFXType, class UNiagaraSystem*> DestroyEffectMap;
// 0x03F8 (size: 0x50)
FName MapObjectDestroyFXUserParamName_BoxSize;
// 0x0448 (size: 0x8)
FName MapObjectDestroyFXUserParamName_BoxSurfaceArea;
// 0x0450 (size: 0x8)
class UNiagaraSystem* BuildStartEffect;
// 0x0458 (size: 0x8)
class UNiagaraSystem* BuildCompleteEffect;
// 0x0460 (size: 0x8)
FName BuildFXUserParamName_BoxCenter;
// 0x0468 (size: 0x8)
FName BuildFXUserParamName_BoxSize;
// 0x0470 (size: 0x8)
FName BuildFXUserParamName_BoxSurfaceArea;
// 0x0478 (size: 0x8)
class UAkAudioEvent* BuildCompleteSE;
// 0x0480 (size: 0x8)
class UNiagaraSystem* RepairEffect;
// 0x0488 (size: 0x8)
class UNiagaraSystem* DamageEffect;
// 0x0490 (size: 0x8)
FName DamageFXUserParamName_Alpha;
// 0x0498 (size: 0x8)
FName DamageFXUserParamName_Rate;
// 0x04A0 (size: 0x8)
FName DamageFXUserParamName_Scale;
// 0x04A8 (size: 0x8)
FName DamageFXUserParamName_RadiusScale;
// 0x04B0 (size: 0x8)
FName DamageFXUserParamName_AddRate;
// 0x04B8 (size: 0x8)
FName DamageFXUserParamName_EndAlpha;
// 0x04C0 (size: 0x8)
float DamageParam_MaxRate;
// 0x04C8 (size: 0x4)
float DamageParam_MaxAddRate;
// 0x04CC (size: 0x4)
float DamageParam_MaxScale;
// 0x04D0 (size: 0x4)
float DamageParam_MaxRadiusScale;
// 0x04D4 (size: 0x4)
float DamageParam_RadiusScaleMultiplier;
// 0x04D8 (size: 0x4)
float DamageFX_StartHPRate;
// 0x04DC (size: 0x4)
float DamageFX_DefaultBoundsSphereRadius;
// 0x04E0 (size: 0x4)
FVector DamageFX_SpanwLocationOffset;
// 0x04E8 (size: 0x18)
float DamageFX_EndFadeTime;
// 0x0500 (size: 0x4)
float DropItemSpawnLocationFromActorBounds;
// 0x0504 (size: 0x4)
float DropItemSpawnDirectionZ;
// 0x0508 (size: 0x4)
FVector FoliageDropItemSpawnOffset;
// 0x0510 (size: 0x18)
FVector DropItemReleaseDirectionRelative;
// 0x0528 (size: 0x18)
FVector FoliageDestroyFXExtentsDefault;
// 0x0540 (size: 0x18)
TSubclassOf<class UPalHitEffectSlot> HitEffectSlotClass;
// 0x0558 (size: 0x8)
TMap<class EPalMapObjectChangeMeshFXType, class UNiagaraSystem*>
ChangeMeshEffectMap; // 0x0560 (size: 0x50)
FPalMapObjectVisualEffectAssets VisualEffectAssets;
// 0x05B0 (size: 0x50)
TMap<class EPalMapObjectTreasureGradeType, class FPalDataTableRowName_ItemData>
TreasureBoxOpenRequiredItemMap; // 0x0600 (size: 0x50)
TMap<class FGuid, class UPalMapObjectModel*> MapObjectModelHandlingMap;
// 0x0650 (size: 0x50)
TArray<class APalMapObject*> LevelMapObjectsToRegister;
// 0x06B0 (size: 0x10)
class APalTestMapObjectRegistrationToManager* Registrator;
// 0x06C0 (size: 0x8)
TMap<class FGuid, class UPalMapObjectSpawnRequestHandler*>
SpawnRequestHandlerMap; // 0x06D0 (size: 0x50)
int32 InDoorCheckProcessIndex_AnyThread;
// 0x0768 (size: 0x4)
int32 InDoorCheckMaxNumPerFrame_AnyThread;
// 0x076C (size: 0x4)
TArray<class APalMapObjectSpawnerBase*> SpawnedSpawners;
// 0x0770 (size: 0x10)
TArray<TWeakObjectPtr<UObject>> SkeletalLODComponentArrayExec;
// 0x0780 (size: 0x10)
TArray<TWeakObjectPtr<UObject>> SkeletalLODComponentArrayWait;
// 0x0790 (size: 0x10)
TArray<TWeakObjectPtr<UObject>> PointLightComponents;
// 0x07A8 (size: 0x10)
void UpdateSkeletalMeshComponentForLOD(int32 InExecuteCount);

void UpdatePointLightComponentForCulling();
void UnResisterSkeletalMeshComponentForLOD(class UObject* InComponent);
void UnResisterPointLightComponent(class UObject* InComponent);
void ResisterSkeletalMeshComponentForLOD(class UObject* InComponent);
void ResisterPointLightComponent(class UObject* InComponent);
void RequestDismantleObject_OnResponseDialog(const bool bResult, class
UPalDialogParameterBase* DialogParameter);
void RecalcPointLightOverlap();
void MapObjectModelWithVectorDelegate__DelegateSignature(class
UPalMapObjectModel* MapObjectModel, const FVector& Vector);
void MapObjectModelSpawnedByDelegate__DelegateSignature(class
UPalMapObjectModel* MapObjectModel, class
UPalMapObjectModelInitializeExtraParameterSpawnedBy* SpawnedBy);
void MapObjectModelInterfaceDelegate__DelegateSignature(TScriptInterface<class
IPalMapObjectModelInterface> MapObjectModel);
void MapObjectModelDynamicDelegate__DelegateSignature(class UPalMapObjectModel*
MapObjectModel);
class UPalMapObjectFoliage* GetFoliage();
class UPalBuildOperator* GetBuildOperator();
class UPalMapObjectModel* FindModel(const FGuid& InstanceId);
class UPalMapObjectConcreteModelBase* FindConcreteModel(const FGuid&
InstanceId);
}; // Size: 0x7B8
class UPalMapObjectMedicalPalBedModel : public UPalMapObjectConcreteModelBase

{
FPalMapObjectMedicalPalBedModelOnUpdateSleepingCharacterDelegate
OnUpdateSleepingCharacterDelegate; // 0x0240 (size: 0x10)
void SimpleDelegate(class UPalMapObjectMedicalPalBedModel* Model);
class UPalIndividualCharacterHandle* SleepingCharacterHandle;
// 0x0250 (size: 0x8)
FVector SleepLocationOffset;
// 0x0258 (size: 0x18)
FVector RemovedSleepLocationOffset;
// 0x0270 (size: 0x18)
float AdditionalHealingRate;
// 0x0288 (size: 0x4)
// 0x028C (size: 0x4)
void SimpleDelegate__DelegateSignature(class UPalMapObjectMedicalPalBedModel*

Model);
void OnFinishSleepAction(class UPalAIActionBase* action);
class UPalIndividualCharacterHandle* GetSleepingHandle();
void ClearSleepingCharacterHandle();
}; // Size: 0x290
class UPalMapObjectMedicalPalBedParameterComponent : public UActorComponent

{
float AdditionalHealingRate;
// 0x00A0 (size: 0x4)
// 0x00A4 (size: 0x4)
}; // Size: 0xA8
class UPalMapObjectModel : public UObject

{
FPalMapObjectModelOnDamageInServerDelegate OnDamageInServerDelegate;
// 0x0038 (size: 0x10)
void PalMapObjectDamageWithLastDelegate(class UPalMapObjectModel* Model, const
FPalDamageInfo& DamageInfo, int32 LastHp);
FPalMapObjectModelOnDamageDelegate OnDamageDelegate;
// 0x0048 (size: 0x10)
void PalMapObjectDamageDelegate(class UPalMapObjectModel* Model, const
FPalDamageInfo& DamageInfo);
FPalMapObjectModelOnUpdateHp OnUpdateHp;
// 0x0058 (size: 0x10)
void MapObjectModelDelegate(class UPalMapObjectModel* Model);
FPalMapObjectModelOnDestroyDelegate OnDestroyDelegate;
// 0x0068 (size: 0x10)
FPalMapObjectModelOnDisposeDelegateInServer OnDisposeDelegateInServer;
// 0x0078 (size: 0x10)
void MapObjectModelDisposeDelegate(class UPalMapObjectModel* Model, const
FPalMapObjectModelOnUpdatedEnableTickDelegate OnUpdatedEnableTickDelegate;
// 0x0088 (size: 0x10)
FPalMapObjectModelOnUpdateBaseCampIdBelongToInServerDelegate
OnUpdateBaseCampIdBelongToInServerDelegate; // 0x0098 (size: 0x10)
FPalMapObjectModelOnUpdateGroupIdBelongToInServerDelegate
OnUpdateGroupIdBelongToInServerDelegate; // 0x00A8 (size: 0x10)
FPalMapObjectModelOnRepBuildPlayerUIdDelegate_Client
OnRepBuildPlayerUIdDelegate_Client; // 0x00B8 (size: 0x10)
FGuid InstanceId;
// 0x00F8 (size: 0x10)
FName MapObjectMasterDataId;
// 0x0108 (size: 0x8)
// 0x0110 (size: 0x80)
FBox MeshBoxBounds;
// 0x0190 (size: 0x38)
FGuid ConcreteModelInstanceId;
// 0x01C8 (size: 0x10)
class UPalMapObjectConcreteModelBase* ConcreteModel;
// 0x01D8 (size: 0x8)
FGuid BaseCampIdBelongTo;
// 0x01E0 (size: 0x10)
FGuid GroupIdBelongTo;
// 0x01F0 (size: 0x10)
// 0x0200 (size: 0x8)
// 0x0208 (size: 0x8)
// 0x0210 (size: 0x1)
FPalMapObjectStatusValue HP;
// 0x0214 (size: 0x8)
FTransform InitialTransformCache;
// 0x0220 (size: 0x60)
class UPalMapObjectModelConnectorBase* Connector;
// 0x0280 (size: 0x8)
class UPalMapObjectModelEffect* Effect;
// 0x0288 (size: 0x8)
FGuid RepairWorkId;
// 0x0290 (size: 0x10)
FGuid OwnerSpawnerLevelObjectInstanceId;
// 0x02A0 (size: 0x10)
FGuid OwnerInstanceId;
// 0x02B0 (size: 0x10)
FGuid BuildPlayerUId;
// 0x02C0 (size: 0x10)
bool bInDoor;
// 0x02D0 (size: 0x1)
EPalMapObjectInteractRestrictType InteractRestrictType;
// 0x02D1 (size: 0x1)
FGameDateTime CreatedAt;
// 0x02D8 (size: 0x8)
float DeteriorationDamage;
// 0x02E4 (size: 0x4)
float DeteriorationTotalDamage;
// 0x02E8 (size: 0x4)
bool bIgnoredSave;
// 0x02EC (size: 0x1)
FGuid DungeonInstanceIdBelongTo;
// 0x02F0 (size: 0x10)
FPalStageInstanceId StageInstanceIdBelongTo;
// 0x0300 (size: 0x14)
FFlagContainer TickFlagContainer;
// 0x0318 (size: 0x50)
void RequestRepairByPlayer_ToServer_ServerInternal(const FGuid&

RequestPlayerUId);
void OnUpdateBuildProcess_ServerInternal(class UPalBuildProcess*
TargetBuildProcess);
void OnUnassignWorkRepairBuildObject(class UPalWorkBase* Work, const
IndicatorType);
void OnTriggeringInteract(class AActor* Other,
EPalInteractiveObjectIndicatorType IndicatorType, float DeltaTime);
void OnStartTriggerInteract(class AActor* Other,
void OnRep_Effect();
void OnRep_ConcreteModel();
void OnRep_BuildPlayerUId();
void OnEndTriggerInteract(class AActor* Other,
void OnAssignWorkRepairBuildObject(class UPalWorkBase* Work, const
bool IsDamaged();
FPalMapObjectStatusValue GetHP();
}; // Size: 0x370
class UPalMapObjectModelConnectorAttach : public UPalMapObjectModelConnectorBase

{
}; // Size: 0x48
class UPalMapObjectModelConnectorAttachToCeil : public

UPalMapObjectModelConnectorAttach
{
}; // Size: 0x48
class UPalMapObjectModelConnectorAttachToWall : public

UPalMapObjectModelConnectorAttach
{
}; // Size: 0x48
class UPalMapObjectModelConnectorBase : public UObject

{
int32 SupportedLevel;
// 0x0028 (size: 0x4)
FPalMapObjectModelConnectInfo ConnectInfoAnyPlace;
// 0x0030 (size: 0x18)
}; // Size: 0x48
class UPalMapObjectModelConnectorFoundation : public

UPalMapObjectModelConnectorBase
{
FPalMapObjectModelConnectInfo FrontConnectInfo;
// 0x0048 (size: 0x18)
FPalMapObjectModelConnectInfo BackConnectInfo;
// 0x0060 (size: 0x18)
FPalMapObjectModelConnectInfo LeftConnectInfo;
// 0x0078 (size: 0x18)
FPalMapObjectModelConnectInfo RightConnectInfo;
// 0x0090 (size: 0x18)
}; // Size: 0xA8
class UPalMapObjectModelConnectorRoof : public UPalMapObjectModelConnectorBase

{
FPalMapObjectModelConnectInfo FrontConnectInfo;
// 0x0048 (size: 0x18)
FPalMapObjectModelConnectInfo BackConnectInfo;
// 0x0060 (size: 0x18)
FPalMapObjectModelConnectInfo LeftConnectInfo;
// 0x0078 (size: 0x18)
FPalMapObjectModelConnectInfo RightConnectInfo;
// 0x0090 (size: 0x18)
}; // Size: 0xA8
class UPalMapObjectModelConnectorStair : public UPalMapObjectModelConnectorBase

{
FPalMapObjectModelConnectInfo UpConnectInfo;
// 0x0048 (size: 0x18)
FPalMapObjectModelConnectInfo DownConnectInfo;
// 0x0060 (size: 0x18)
}; // Size: 0x78
class UPalMapObjectModelConnectorWallV2 : public UPalMapObjectModelConnectorBase

{
FPalMapObjectModelConnectInfo UpConnectInfo;
// 0x0048 (size: 0x18)
FPalMapObjectModelConnectInfo DownConnectInfo;
// 0x0060 (size: 0x18)
}; // Size: 0x78
class UPalMapObjectModelEffect : public UObject

{
FPalFastMapObjectModelEffectRepInfoArray RepInfoArray;
// 0x0048 (size: 0x148)
}; // Size: 0x198
class UPalMapObjectModelEffectBase : public UObject

{
}; // Size: 0x40
class UPalMapObjectModelEffectGrantParameterBase : public UObject

{
class UPalMapObjectModel* OwnerModel;
// 0x0028 (size: 0x8)
}; // Size: 0x30
class UPalMapObjectModelEffectGrantParameter_AccumulateTrigger : public

UPalMapObjectModelEffectGrantParameterBase
{
float Value;
// 0x0030 (size: 0x4)
}; // Size: 0x38
class UPalMapObjectModelEffectGrantParameter_Burn : public

UPalMapObjectModelEffectGrantParameter_AccumulateTrigger
{
}; // Size: 0x38
class UPalMapObjectModelEffect_AccumulateTrigger : public

UPalMapObjectModelEffectBase
{
float AccumulateValue;
// 0x0050 (size: 0x4)
}; // Size: 0x58
class UPalMapObjectModelEffect_Burn : public

UPalMapObjectModelEffect_AccumulateTrigger
{
bool bBurning;
// 0x0058 (size: 0x1)
float PersistenceValue;
// 0x005C (size: 0x4)
class APalHitCollisionBox* HitCollisionBox;
// 0x0060 (size: 0x8)
void OnRep_Burning(bool bLastValue);

void OnHitCollisionBox(class UPrimitiveComponent* MyHitComponent, class AActor*
OtherHitActor, class UPrimitiveComponent* OtherHitComponent, const TArray<int32>&
FoliageIndex, FVector HitLocation, int32 HitCount);
}; // Size: 0x68
class UPalMapObjectModelInitializeExtraParameterBase : public UObject

{
}; // Size: 0x28
class UPalMapObjectModelInitializeExtraParameterBuild : public

UPalMapObjectModelInitializeExtraParameterBase
{
float BuildWorkAmount;
// 0x0028 (size: 0x4)
}; // Size: 0x30
class UPalMapObjectModelInitializeExtraParameterByPlayerUId : public

{
FGuid ByPlayerUId;
// 0x0028 (size: 0x10)
}; // Size: 0x38
class UPalMapObjectModelInitializeExtraParameterDropItem : public

{
FPalContainerId TempContainerID;
// 0x0028 (size: 0x10)
FVector ReleaseDirection;
// 0x0038 (size: 0x18)
bool bAutoPickup;
// 0x0050 (size: 0x1)
}; // Size: 0x58
class UPalMapObjectModelInitializeExtraParameterInitialCharacter : public

{
FPalIndividualCharacterSaveParameter CharacterSaveParameter;
// 0x0028 (size: 0x218)
}; // Size: 0x240
class UPalMapObjectModelInitializeExtraParameterInitialItem : public

{
// 0x0028 (size: 0x10)
}; // Size: 0x38
class UPalMapObjectModelInitializeExtraParameterInteract : public
{
EPalMapObjectInteractRestrictType RestrictType;
// 0x0028 (size: 0x1)
}; // Size: 0x30
class UPalMapObjectModelInitializeExtraParameterItem : public

{
// 0x0028 (size: 0x10)
}; // Size: 0x38
class UPalMapObjectModelInitializeExtraParameterItemContainerAttribute : public

{
TArray<EPalMapObjectItemContainerSlotAttribute> AllSlotAttribute;
// 0x0028 (size: 0x10)
}; // Size: 0x38
class UPalMapObjectModelInitializeExtraParameterItemDropObject : public

{
// 0x0028 (size: 0x10)
}; // Size: 0x38
class UPalMapObjectModelInitializeExtraParameterNote : public

{
FName NoteRowName;
// 0x0028 (size: 0x8)
}; // Size: 0x30
class UPalMapObjectModelInitializeExtraParameterPalEgg : public

{
FName CharacterID;
// 0x0028 (size: 0x8)
}; // Size: 0x30
class UPalMapObjectModelInitializeExtraParameterSpawnedBy : public

{
FGuid ByMapObjectModelInstanceId;
// 0x0028 (size: 0x10)
}; // Size: 0x38
class UPalMapObjectModelInitializeExtraParameterSpawner : public

{
FGuid OwnerSpawnerLevelObjectInstanceId;
// 0x0028 (size: 0x10)
FPalStageInstanceId OwnerSpawnerStageInstanceId;
// 0x0038 (size: 0x14)
}; // Size: 0x50
class UPalMapObjectModelInitializeExtraParameterTreasureBox : public

{
EPalMapObjectTreasureGradeType GradeType;
// 0x0028 (size: 0x1)
}; // Size: 0x30
class UPalMapObjectMonsterFarmModel : public UPalMapObjectConcreteModelBase

{
}; // Size: 0x218
class UPalMapObjectMonsterFarmParameterComponent : public UActorComponent

{
FFloatInterval ActionIntervalSeconds;
// 0x00A0 (size: 0x8)
}; // Size: 0xA8
class UPalMapObjectNoteObjectParameterComponent : public UActorComponent

{
FPalDataTableRowName_NoteData NoteRowName;
// 0x00A0 (size: 0x8)
}; // Size: 0xA8
class UPalMapObjectOperationResultUtility : public UObject

{
}; // Size: 0x28
class UPalMapObjectPalEggModel : public UPalMapObjectPickupItemOnLevelModel

{
}; // Size: 0x250
class UPalMapObjectPalFoodBoxModel : public UPalMapObjectConcreteModelBase

{
}; // Size: 0x220
class UPalMapObjectPalStorageModel : public UPalMapObjectConcreteModelBase

{
FPalMapObjectPalStorageModelOnSpawnedCharacterDelegate
OnSpawnedCharacterDelegate; // 0x0218 (size: 0x10)
void SpawnedCharacterDelegate(FPalInstanceID IndividualId, int32 PhantomId);
TArray<FPalInstanceID> SpawnedIndividualIds;
// 0x02F0 (size: 0x10)
void SpawnedCharacterDelegate__DelegateSignature(FPalInstanceID IndividualId,

int32 PhantomId);
void OnUpdateGuildPalStorage_ServerInternal(class UPalBaseCampModel*
BaseCampModel, class UPalGuildPalStorage* GuildPalStorage);
void OnTriggerInteract_BP(class AActor* Other,
void OnSpawnedPhantomCharacter(FPalInstanceID IndividualId, int32 PhantomId);
void OnOverlapEndCageWalls(class UPrimitiveComponent* OverlappedComp, class
void OnOverlapBeginCageWalls(class UPrimitiveComponent* OverlappedComp, class
void OnDroppedCharacterToPhantom(FPalInstanceID IndividualId, int32 PhantomId);
void OnAddGuildPalStorage_ServerInternal(class UPalIndividualCharacterHandle*
NewCharacter);
}; // Size: 0x300
class UPalMapObjectPasswordLockModule : public UPalMapObjectConcreteModelModuleBase

{
FPalMapObjectPasswordLockModuleOnUpdateLockStateDelegate
OnUpdateLockStateDelegate; // 0x0030 (size: 0x10)
void ReturnSelfMulticastDelegate(class UPalMapObjectPasswordLockModule*
Module);
FPalMapObjectPasswordLockModuleOnAuthenticationResultNotifyDelegate
OnAuthenticationResultNotifyDelegate; // 0x0070 (size: 0x10)
void NotifyAuthenticationResultDelegate(bool passed);
EPalMapObjectPasswordLockState LockState;
// 0x0080 (size: 0x1)
FString Password;
// 0x0088 (size: 0x10)
TArray<FPalMapObjectPasswordLockPlayerInfo> PlayerInfos;
// 0x0098 (size: 0x10)
int32 TryAuthenticateMaxNum;
// 0x00A8 (size: 0x4)
UPalMapObjectPasswordLockModule* Module);
void ReturnSelfAndPasswordMulticastDelegate__DelegateSignature(class
UPalMapObjectPasswordLockModule* Module, FString Password);
void ReturnPlayerInfoDelegate__DelegateSignature(const
FPalMapObjectPasswordLockPlayerInfo& OldLocalPlayerInfo, const
FPalMapObjectPasswordLockPlayerInfo& NewLocalPlayerInfo);
void RequestUpdateUnlock_ServerInternal(const int32 RequestPlayerId);
void RequestUpdatePassword_ServerInternal(const int32 RequestPlayerId, const
void RequestUpdatePassword(FString NewPassword);
void RequestUpdateLock(const EPalMapObjectPasswordLockState NewLockState);
void RequestOpenUIPasswordSetting();
void RequestAuthenticate_ServerInternal(const int32 RequestPlayerId, const
void RequestAuthenticate(FString InputPassword);
void OpenMenuSecuritySetting();
void OnRep_PlayerInfos(const TArray<FPalMapObjectPasswordLockPlayerInfo>&
OldValue);
void NotifyAuthenticationResultDelegate__DelegateSignature(bool passed);
void NotifyAuthenticationResult(const bool passed);
EPalMapObjectPasswordLockState GetLockState();
bool CanTryAuthenticateByPlayer(const FGuid& RequestPlayerUId);
}; // Size: 0xB0
class UPalMapObjectPickableCharacterModelBase : public

{
FPalCharacterStoredParameterId StoredParameterId;
// 0x0218 (size: 0x10)
FPalIndividualCharacterSaveParameter ForRead_CharacterSaveParameter;
// 0x0228 (size: 0x218)
FGuid LocationId;
// 0x0440 (size: 0x10)
void RequestPickup_ServerInternal(const int32 RequestPlayerId);

void RequestPickup();
void OnRemovedStoredCharacter_ServerInternal(const
FPalCharacterStoredParameterId& RemovedID);
void OnDisappearTimeAt();
FPalIndividualCharacterSaveParameter GetCharacterSaveParameter();
}; // Size: 0x458
class UPalMapObjectPickableItemModelBase : public UPalMapObjectConcreteModelBase

{
bool bAutoPickedUp;
// 0x0230 (size: 0x1)
FTimerHandle RemovePickupGuardTimerHandle;
// 0x0238 (size: 0x8)
void RequestPickup_ServerInternal(const int32 RequestPlayerId);

void RequestPickup();
void OnTimer_RemovePickupGuard();
TArray<FPalItemAndNum> CreatePickupItemInfo();
}; // Size: 0x240
class UPalMapObjectPickupItemOnLevelModel : public

UPalMapObjectPickableItemModelBase
{
FName VisualStaticItemId;
// 0x0248 (size: 0x8)
void OnUpdateItemContainerContents(class UPalItemContainer* Container);

FName GetVisualStaticItemId();
}; // Size: 0x250
class UPalMapObjectPickupItemPalEggParameterComponent : public

UPalMapObjectPickupItemParameterComponent
{
FPalMapObjectPickupItemPalEggData PalEggData;
// 0x00B0 (size: 0x8)
}; // Size: 0xB8
class UPalMapObjectPickupItemParameterComponent : public

UPalMapObjectPickupItemParameterComponentBase
{
TArray<FPalMapObjectPickupItemData> DropItems;
// 0x00A0 (size: 0x10)
}; // Size: 0xB0
class UPalMapObjectPickupItemParameterComponentBase : public UActorComponent

{
}; // Size: 0xA0
class UPalMapObjectPlayerBedModel : public UPalMapObjectConcreteModelBase

{
FVector RespawnLocationOffset;
// 0x0218 (size: 0x18)
bool bHasAuthority;
// 0x0230 (size: 0x1)
class ACharacter* SleepingCharacter;
// 0x0238 (size: 0x8)
class UPalAction_SleepPlayerBed* SleepPlayerBedAction;
// 0x0240 (size: 0x8)
void RequestTriggerSleepPlayerBed_ToServer(const int32 RequestPlayerId);

void RequestTriggerGetupPlayerBed_ToServer(const int32 RequestPlayerId);
void ReceiveTriggerSleepPlayerBedSuccess(const int32 RequestPlayerId);
void ReceiveTriggerGetupPlayerBedSuccess(const int32 RequestPlayerId);
void PutPlayerToSleep(class UPalIndividualCharacterHandle* CharacterHandle);
void OnPlayerActionBegin(const class UPalActionBase* ActionBase);
void OnGetupTrigger();
void OnEndSleep();
void OnDispose(class UPalMapObjectModel* MapObjectModel, const
void OnDamagePlayer(FPalDamageResult DamageResult);
void BP_OnTriggerInteract_SleepPlayerBed(class AActor* Other,
}; // Size: 0x248
class UPalMapObjectPlayerRecordModule : public UPalMapObjectConcreteModelModuleBase

{
FPalMapObjectPlayerRecordModuleOnUpdatePlayerRecordBoolValDelegate
OnUpdatePlayerRecordBoolValDelegate; // 0x0030 (size: 0x10)
void MulticastBoolValDelegate(class UPalMapObjectPlayerRecordModule* Module,
const FName Key, const bool Value);
FPalMapObjectPlayerRecordModuleOnUpdatePlayerRecordIntValDelegate
OnUpdatePlayerRecordIntValDelegate; // 0x0040 (size: 0x10)
void MulticastIntValDelegate(class UPalMapObjectPlayerRecordModule* Module,
const FName Key, const int32 Value);
FName TargetKey;
// 0x0070 (size: 0x8)
void OnUpdatePlayerRecordIntVal(const FName Key, const int32 Value);

void OnUpdatePlayerRecordBoolVal(const FName Key, const bool Value);
void OnCompleteSyncPlayerFromServer_InClient(class APalPlayerState*
LocalPlayerState);
void MulticastIntValDelegate__DelegateSignature(class
UPalMapObjectPlayerRecordModule* Module, const FName Key, const int32 Value);
void MulticastBoolValDelegate__DelegateSignature(class
UPalMapObjectPlayerRecordModule* Module, const FName Key, const bool Value);
}; // Size: 0x78
class UPalMapObjectProductItemModel : public UPalMapObjectConcreteModelBase

{
FPalMapObjectProductItemModelOnFinishProductOneLoopDelegate
OnFinishProductOneLoopDelegate; // 0x0220 (size: 0x10)
void SimpleDelegate(class UPalMapObjectProductItemModel* Model);
bool bIsWorkable;
// 0x0230 (size: 0x1)
FName ProductItemId;
// 0x0234 (size: 0x8)
// 0x023C (size: 0x4)
void SimpleDelegate__DelegateSignature(class UPalMapObjectProductItemModel*

Model);
FName GetProductItemId();
class UPalItemContainer* GetItemContainer();
float CalcRequiredAmount(const float BaseRequiredAmount);
}; // Size: 0x240
class UPalMapObjectRankUpCharacterModel : public UPalMapObjectConcreteModelBase

{
FPalMapObjectRankUpCharacterModelOnReceiveRequestResultDelegate
OnReceiveRequestResultDelegate; // 0x0218 (size: 0x10)
void PalMapObjectRankUpCharacterResultDelegate(const
EPalMapObjectRankUpCharacterResult Result);
// 0x0228 (size: 0x10)
// 0x0238 (size: 0x8)
void RequestRankup_ServerInternal(const int32 RequestPlayerId, const

void ReceiveOperationResult(const int32 ResultInt);
}; // Size: 0x240
class UPalMapObjectRecoverOtomoModel : public UPalMapObjectConcreteModelBase

{
// 0x0220 (size: 0x4)
// 0x0228 (size: 0x8)
void StoreAllOtomo_ServerInternal(const int32 RequestPlayerId);

void RequestRecoverAllOtomo_ServerInternal(const int32 RequestPlayerId);
void OnUpdateCharacterContainer(class UPalIndividualCharacterContainer*
Container);
void ObtainAll_ServerInternal(const int32 RequestPlayerId);
}; // Size: 0x230
class UPalMapObjectRecoverOtomoParameterComponent : public UActorComponent

{
int32 SlotNum;
// 0x00A0 (size: 0x4)
// 0x00A4 (size: 0x4)
// 0x00A8 (size: 0x8)
}; // Size: 0xB0
class UPalMapObjectRepairItemModel : public UPalMapObjectConcreteModelBase

{
float RequiredRepairItemRate;
// 0x0228 (size: 0x4)
TSubclassOf<class UPalUserWidgetOverlayUI> WidgetClass;
// 0x0230 (size: 0x8)
void RequestRepairItem(const TArray<FPalItemSlotId>& TargetItemSlotIdArray);

void RepairItem_ServerInternal(const int32 RequestPlayerId, const
void OnNotifyRepairResult__DelegateSignature(bool IsSuccess);
void NotifyRepairResult(bool IsSuccess);
void GetRequiredMaterials(const TArray<FPalItemId>& TargetRepairItemIdArray,
TArray<FPalStaticItemIdAndNum>& OutRequiredMaterials);
}; // Size: 0x238
class UPalMapObjectRepairItemParameterComponent : public UActorComponent

{
float RequiredRepairItemPercent;
// 0x00A0 (size: 0x4)
}; // Size: 0xA8
class UPalMapObjectRespawnPointModel : public UPalMapObjectConcreteModelBase

{
FGuid LocationId;
// 0x0218 (size: 0x10)
}; // Size: 0x228
class UPalMapObjectShippingItemModel : public UPalMapObjectConcreteModelBase

{
TArray<int32> ShippingHours;
// 0x0218 (size: 0x10)
void OnChangeTimeHoursInServer();
}; // Size: 0x228
class UPalMapObjectShippingItemParameterComponent : public UActorComponent

{
int32 SlotNum;
// 0x00A0 (size: 0x4)
TArray<int32> ShippingHours;
// 0x00A8 (size: 0x10)
}; // Size: 0xB8
class UPalMapObjectSignboardModel : public UPalMapObjectConcreteModelBase

{
FPalMapObjectSignboardModelOnUpdateSignboardTextDelegate
OnUpdateSignboardTextDelegate; // 0x0218 (size: 0x10)
void UpdateSignboardTextDelegate(FString TextValue);
// 0x0228 (size: 0x8)
FString SignboardText;
// 0x0230 (size: 0x10)
bool bIsEditing;
// 0x0240 (size: 0x1)
void UpdateSignboardTextDelegate__DelegateSignature(FString TextValue);

void RequestUpdateText(const int32 RequestPlayerId, const FPalNetArchive&
Archive);
void RequestEditText(const int32 RequestPlayerId, const bool IsEditing);
void OnUpdateText(FString Text);
void OnRep_Text();
void OnOpenEdit();
FString GetSignboardText();
}; // Size: 0x248
class UPalMapObjectSignboardParameterComponent : public UActorComponent
{
// 0x00A0 (size: 0x8)
}; // Size: 0xA8
class UPalMapObjectSpawnRequestHandler : public UObject

{
FPalMapObjectModelInitializeExtraParameters ExtraParameters;
// 0x0090 (size: 0x28)
}; // Size: 0xD0
class UPalMapObjectSpawnerDamageReactionComponent : public UActorComponent

{
bool bDropItemOnDamaged;
// 0x00A8 (size: 0x1)
// 0x00B0 (size: 0x8)
}; // Size: 0xB8
class UPalMapObjectSpawnerMultiItemLocationComponent : public UStaticMeshComponent

{
}; // Size: 0x5F0
class UPalMapObjectStatusObserverModule : public

{
FPalMapObjectStatusObserverModuleOnDamageInServerDelegate
OnDamageInServerDelegate; // 0x0030 (size: 0x10)
void PalMapObjectDamageWithLastDelegate(class UPalMapObjectModel* Model, const
FPalDamageInfo& DamageInfo, int32 LastHp);

}; // Size: 0x40
class UPalMapObjectSwitchModule : public UPalMapObjectConcreteModelModuleBase

{
FPalMapObjectSwitchModuleOnUpdateSwitchStateDelegate
OnUpdateSwitchStateDelegate; // 0x0030 (size: 0x10)
void ReturnSelfMulticastDelegate(class UPalMapObjectSwitchModule* Module);
EPalMapObjectSwitchState SwitchState;
// 0x0040 (size: 0x1)
UPalMapObjectSwitchModule* Module);
void OnRep_SwitchState();
EPalMapObjectSwitchState GetSwitchState();
}; // Size: 0x48
class UPalMapObjectSwitchOnInWorking : public UPalMapObjectConcreteModelBase

{

}; // Size: 0x218
class UPalMapObjectTestFunctionModel : public UPalMapObjectConcreteModelBase
{
void RequestCountUpSIngle_ServerInternal(const int32 RequestPlayerId);

void RequestCountUp_ServerInternal(const int32 RequestPlayerId, const int32
IncrementNum);
void RequestCountUp(const int32 IncrementNum);
void OnRecieveCountUp(const int32 ReflectedCounter);
}; // Size: 0x220
class UPalMapObjectTestGlobalContainerModel : public UPalMapObjectConcreteModelBase

{
void WatchContainer();
void Swap(const int32 ASlotIndex, const int32 BSlotIndex);
void ProduceWithSlotWithConsume(const FName StaticItemId, const int32 Num,
const int32 SlotIndex, const int32 ConsumeSlotIndex, const int32 ConsumeNum);
void ProduceWithSlot(const FName StaticItemId, const int32 Num, const int32
SlotIndex);
void Produce(const FName StaticItemId, const int32 Num);
void OpenContainerUI();
void Move(const int32 Num, const int32 ToSlotIndex, const int32 FromSlotIndex);
void Dispose(const int32 SlotIndex, const int32 Num);
void CloseContainerUI();
}; // Size: 0x218
class UPalMapObjectTestItemDestroyedDropModel : public

{
TArray<FPalItemAndNum> DropItemInfos;
// 0x0218 (size: 0x10)
void OnDestroy_ServerInternal(class UPalMapObjectModel* Model);

}; // Size: 0x228
class UPalMapObjectTorchModel : public UPalMapObjectConcreteModelBase

{
int32 IgnitionMinutes;
// 0x0218 (size: 0x4)
FGameDateTime ExtinctionDateTime;
// 0x0220 (size: 0x8)
void RequestTriggerIgnition_ToServer(const int32 RequestPlayerId);

void OnWorkBootUp_ServerInternal(class UPalWorkBootUp* Work);
}; // Size: 0x228
class UPalMapObjectTorchParameterComponent : public UActorComponent

{
int32 IgnitionMinutes;
// 0x00A0 (size: 0x4)
}; // Size: 0xA8
class UPalMapObjectTreasureBoxModel : public UPalMapObjectConcreteModelBase

{
EPalMapObjectTreasureGradeType TreasureGradeType;
// 0x0228 (size: 0x1)
FVector DropItemLocalLocation;
// 0x0230 (size: 0x18)
bool bOpened;
// 0x0248 (size: 0x1)
void RequestOpen_ServerInternal(const int32 RequestPlayerId);

void ReceiveOpenSuccess_ClientInternal(const FPalNetArchive& Archive);
void ReceiveOpenFailed_ClientInternal(const FPalNetArchive& Archive);
EPalMapObjectTreasureGradeType GetTreasureGradeType();
void Debug_ReceiveObtainInfo_ClientInternal(const FPalNetArchive& Archive);
TArray<FPalItemAndNum> CreateItemInfo();
}; // Size: 0x250
class UPalMapObjectUtility : public UBlueprintFunctionLibrary

{
bool TryGetItemVisualModelStaticMesh(TSubclassOf<class AActor> actorClass,

class UStaticMesh*& OutStaticMesh, FTransform& OutComponentTransform, FVector&
OutCenterOfMass, class UMaterialInterface*& OutMaterialInterface);
EPalMapObjectOperationResult ToMapObjectOperationResult(const int32
ResultIntValue);
EPalMapObjectOperationResult SelectPriorityResult(EPalMapObjectOperationResult
Result1, EPalMapObjectOperationResult Result2);
FString MapObjectOperationResultToString(const EPalMapObjectOperationResult
Result);
bool IsContainsCollisionProfiles(const class UPrimitiveComponent* Component,
const TArray<FName>& CollisionProfiles);
}; // Size: 0x28
class UPalMapObjectVisualEffectComponent : public UActorComponent

{
TMap<class EPalMapObjectVisualEffectType, class
FPalMapObjectVisualEffectInstanceSet> SpawnedEffectMap; // 0x00A0 (size: 0x50)
void UpdateVisualByEffect(class UPalMapObjectModelEffectBase* Effect);

void OnRemoveEffect(class UPalMapObjectModel* Model, class
UPalMapObjectModelEffectBase* Effect);
void OnGrantedEffect(class UPalMapObjectModel* Model, class
UPalMapObjectModelEffectBase* Effect);
}; // Size: 0xF0
class UPalMapObjectWorkeeModule : public UPalMapObjectConcreteModelModuleBase

{
class UPalWorkBase* TargetWork;
// 0x0030 (size: 0x8)
void OnRep_TargetWork();
class UPalWorkProgress* GetWorkProgress();
}; // Size: 0x38
class UPalMapObjectWorldDisposer : public UObject

{
TArray<class UPalMapObjectWorldDisposerBase*> WorldDisposers;
// 0x0028 (size: 0x10)
}; // Size: 0x38
class UPalMapObjectWorldDisposerBase : public UObject

{
}; // Size: 0x30
class UPalMapObjectWorldDisposer_DropItem : public UPalMapObjectWorldDisposerBase
{
TMap<class EPalDropItemType, class FPalMapObjectWorldDropItemInfoSet>
DropItemInfoSetMap; // 0x0040 (size: 0x50)
void OnRestoreMapObject_ServerInternal(class UPalMapObjectModel* Model);

void OnCreateMapObject_ServerInternal(class UPalMapObjectModel* SpawnedModel,
const FVector& SpawnLocation);
}; // Size: 0x90
class UPalMasterDataTableAccessBase : public UObject

{
class UDataTable* DataTable;
// 0x0028 (size: 0x8)
TArray<FName> GetRowNames();
}; // Size: 0x30
class UPalMasterDataTableAccess_BaseCampLevelData : public

UPalMasterDataTableAccessBase
{
int32 GetMaxLevel();
FPalBaseCampLevelMasterData GetLevelInfo(int32 Level);
}; // Size: 0x38
class UPalMasterDataTableAccess_BuildObjectData : public

{
void BPExec_FindRowByMapObjectId(FName MapObjectId, EPalMasterDataExecPinType&

ExecType, FPalBuildObjectData& OutData);
void BPExec_FindRow(FName RowName, EPalMasterDataExecPinType& ExecType,
FPalBuildObjectData& OutData);
FPalBuildObjectData BP_FindRowByMapObjectId(FName MapObjectId, FName&
OutRowName, bool& bResult);
FPalBuildObjectData BP_FindRow(FName RowName, bool& bResult);
}; // Size: 0x30
class UPalMasterDataTableAccess_BuildObjectIconData : public

{

FPalBuildObjectIconData& OutData);
FPalBuildObjectIconData BP_FindRow(FName RowName, bool& bResult);
}; // Size: 0x30
class UPalMasterDataTableAccess_CharacterUpgradeData : public

{
int32 GetMaxRank();
}; // Size: 0x38
class UPalMasterDataTableAccess_DungeonEnemySpawnerData : public

{
}; // Size: 0x30
class UPalMasterDataTableAccess_DungeonItemLotteryData : public

{
}; // Size: 0x30
class UPalMasterDataTableAccess_DungeonLevelData : public

{
}; // Size: 0x30
class UPalMasterDataTableAccess_DungeonSpawnAreaData : public

{
FPalDungeonSpawnAreaData BP_FindRow(FName RowName, bool& bResult);

}; // Size: 0x30
class UPalMasterDataTableAccess_FarmCropData : public UPalMasterDataTableAccessBase

{
void BPExec_FindRowByCropItemId(FName CropItemId, EPalMasterDataExecPinType&

ExecType, FPalMapObjectFarmCropData& OutData);
FPalMapObjectFarmCropData& OutData);
FPalMapObjectFarmCropData BP_FindRowByCropItemId(FName CropItemId, bool&
bResult);
FPalMapObjectFarmCropData BP_FindRow(FName RowName, bool& bResult);
}; // Size: 0x30
class UPalMasterDataTableAccess_FieldLotteryNameData : public

{
}; // Size: 0x30
class UPalMasterDataTableAccess_ItemLotteryData : public

{
}; // Size: 0x30
class UPalMasterDataTableAccess_ItemProductData : public

{
}; // Size: 0x30
class UPalMasterDataTableAccess_ItemRecipe : public UPalMasterDataTableAccessBase

{

FPalItemRecipe& OutData);
FPalItemRecipe BP_FindRow(FName RowName, bool& bResult);
}; // Size: 0x30
class UPalMasterDataTableAccess_ItemShop : public UPalMasterDataTableAccessBase

{
}; // Size: 0x30
class UPalMasterDataTableAccess_ItemShopLottery : public

{
}; // Size: 0x30
class UPalMasterDataTableAccess_LocalizeText : public UPalMasterDataTableAccessBase

{
FText FindRow(FName RowName);

}; // Size: 0x30
class UPalMasterDataTableAccess_MapObjectMasterData : public

{

FPalMapObjectMasterData& OutData);
FPalMapObjectMasterData BP_FindRow(FName RowName, bool& bResult);
}; // Size: 0x30
class UPalMasterDataTableAccess_PalShop : public UPalMasterDataTableAccessBase

{
}; // Size: 0x30
class UPalMasterDataTableAccess_PlayerStatusRankData : public

{
int32 GetMaxRank();
}; // Size: 0x38
class UPalMasterDataTableAccess_UIInputActionData : public

{
}; // Size: 0x30
class UPalMasterDataTableAccess_WildSpawnerData : public

{
}; // Size: 0x30
class UPalMasterDataTables : public UObject

{
class UDataTable* WildSpawnerDataTable;
// 0x0028 (size: 0x8)
class UPalMasterDataTableAccess_WildSpawnerData* Access_WildSpawnerDataTable;
// 0x0030 (size: 0x8)
class UDataTable* ItemRecipeDataTable;
// 0x0038 (size: 0x8)
class UPalMasterDataTableAccess_ItemRecipe* Access_ItemRecipeDataTable;
// 0x0040 (size: 0x8)
class UDataTable* FarmCropDataTable;
// 0x0048 (size: 0x8)
class UPalMasterDataTableAccess_FarmCropData* Access_FarmCropDataTable;
// 0x0050 (size: 0x8)
class UDataTable* MapObjectDataTable;
// 0x0058 (size: 0x8)
class UPalMasterDataTableAccess_MapObjectMasterData* Access_MapObjectDataTable;
// 0x0060 (size: 0x8)
class UDataTable* BuildObjectDataTable;
// 0x0068 (size: 0x8)
class UPalMasterDataTableAccess_BuildObjectData* Access_BuildObjectDataTable;
// 0x0070 (size: 0x8)
class UDataTable* BuildObjectIconDataTable;
// 0x0078 (size: 0x8)
class UPalMasterDataTableAccess_BuildObjectIconData*
Access_BuildObjectIconDataTable; // 0x0080 (size: 0x8)
class UDataTable* ItemProductDataTable;
// 0x0088 (size: 0x8)
class UPalMasterDataTableAccess_ItemProductData* Access_ItemProductDataTable;
// 0x0090 (size: 0x8)
class UDataTable* BaseCampLevelDataTable;
// 0x0098 (size: 0x8)
class UPalMasterDataTableAccess_BaseCampLevelData*
Access_BaseCampLevelDataTable; // 0x00A0 (size: 0x8)
class UDataTable* DungeonSpawnAreaDataTable;
// 0x00A8 (size: 0x8)
class UPalMasterDataTableAccess_DungeonSpawnAreaData*
Access_DungeonSpawnAreaDataTable; // 0x00B0 (size: 0x8)
class UDataTable* DungeonLevelDataTable;
// 0x00B8 (size: 0x8)
class UPalMasterDataTableAccess_DungeonLevelData* Access_DungeonLevelDataTable;
// 0x00C0 (size: 0x8)
class UDataTable* DungeonEnemySpawnerDataTable;
// 0x00C8 (size: 0x8)
class UPalMasterDataTableAccess_DungeonEnemySpawnerData*
Access_DungeonEnemySpawnerDataTable; // 0x00D0 (size: 0x8)
class UDataTable* DungeonItemLotteryDataTable;
// 0x00D8 (size: 0x8)
class UPalMasterDataTableAccess_DungeonItemLotteryData*
Access_DungeonItemLotteryDataTable; // 0x00E0 (size: 0x8)
class UDataTable* FieldLotteryNameDataTable;
// 0x00E8 (size: 0x8)
class UPalMasterDataTableAccess_FieldLotteryNameData*
Access_FieldLotteryNameDataTable; // 0x00F0 (size: 0x8)
class UDataTable* ItemLotteryDataTable;
// 0x00F8 (size: 0x8)
class UPalMasterDataTableAccess_ItemLotteryData* Access_ItemLotteryDataTable;
// 0x0100 (size: 0x8)
class UDataTable* PlayerStatusRankDataTable;
// 0x0108 (size: 0x8)
class UPalMasterDataTableAccess_PlayerStatusRankData*
Access_PlayerStatusRankDataTable; // 0x0110 (size: 0x8)
class UDataTable* CharacterUpgradeDataTable;
// 0x0118 (size: 0x8)
class UPalMasterDataTableAccess_CharacterUpgradeData*
Access_CharacterUpgradeDataTable; // 0x0120 (size: 0x8)
class UPalNoteDataAsset* NoteDataAsset;
// 0x0128 (size: 0x8)
class UPalNoteDataAsset* HelpGuideDataAsset;
// 0x0130 (size: 0x8)
TMap<class EPalLocalizeTextCategory, class UDataTable*>
LocalizeTextDataTableMap; // 0x0138 (size: 0x50)
TMap<class EPalLocalizeTextCategory, class
UPalMasterDataTableAccess_LocalizeText*> Access_LocalizeTextDataTables; // 0x0188
(size: 0x50)
class UDataTable* UIInputActionDataTable;
// 0x01D8 (size: 0x8)
class UPalMasterDataTableAccess_UIInputActionData*
Access_UIInputActionDataTable; // 0x01E0 (size: 0x8)
FPalTechnologyDataSet technologyDataSet;
// 0x01E8 (size: 0x18)
class UDataTable* worldMapDataTable;
// 0x0200 (size: 0x8)
class UDataTable* ItemShopLotteryDataTable;
// 0x0208 (size: 0x8)
class UPalMasterDataTableAccess_ItemShopLottery*
Access_ItemShopLotteryDataTable; // 0x0210 (size: 0x8)
class UDataTable* ItemShopDataTable;
// 0x0218 (size: 0x8)
class UPalMasterDataTableAccess_ItemShop* Access_ItemShopDataTable;
// 0x0220 (size: 0x8)
class UDataTable* PalShopDataTable;
// 0x0228 (size: 0x8)
class UPalMasterDataTableAccess_PalShop* Access_PalShopDataTable;
// 0x0230 (size: 0x8)
}; // Size: 0x238
class UPalMasterDataTablesUtility : public UBlueprintFunctionLibrary

{
class UPalMasterDataTableAccess_WildSpawnerData*
GetWildSpawnerDataTableAccess(const class UObject* WorldContextObject);
class UDataTable* GetWildSpawnerDataTable(const class UObject*
class UPalMasterDataTableAccess_UIInputActionData*
GetUIInputActionDataTableAccess(const class UObject* WorldContextObject);
class UDataTable* GetUIInputActionDataTable(const class UObject*
class UPalMasterDataTableAccess_PlayerStatusRankData*
GetPlayerStatusRankDataTableAccess(const class UObject* WorldContextObject);
class UDataTable* GetPlayerStatusRankDataTable(const class UObject*
class UPalMasterDataTableAccess_PalShop* GetPalShopDataTableAccess(const class
UObject* WorldContextObject);
class UDataTable* GetPalShopDataTable(const class UObject* WorldContextObject);
class UPalNoteDataAsset* GetNoteDataAsset(const class UObject*
class UPalMasterDataTableAccess_MapObjectMasterData*
GetMapObjectDataTableAccess(const class UObject* WorldContextObject);
class UDataTable* GetMapObjectDataTable(const class UObject*
FText GetLocalizedText(const class UObject* WorldContextObject,
EPalLocalizeTextCategory TextCategory, FName TextId);
class UPalMasterDataTableAccess_ItemShopLottery*
GetItemShopLotteryDataTableAccess(const class UObject* WorldContextObject);
class UDataTable* GetItemShopLotteryDataTable(const class UObject*
class UPalMasterDataTableAccess_ItemShop* GetItemShopDataTableAccess(const
class UObject* WorldContextObject);
class UDataTable* GetItemShopDataTable(const class UObject*
class UPalMasterDataTableAccess_ItemRecipe* GetItemRecipeDataTableAccess(const
class UDataTable* GetItemRecipeDataTable(const class UObject*
class UPalMasterDataTableAccess_ItemLotteryData*
GetItemLotteryDataTableAccess(const class UObject* WorldContextObject);
class UDataTable* GetItemLotteryDataTable(const class UObject*
class UPalNoteDataAsset* GetHelpGuideDataAsset(const class UObject*
class UPalMasterDataTableAccess_FieldLotteryNameData*
GetFieldLotteryNameDataTableAccess(const class UObject* WorldContextObject);
class UDataTable* GetFieldLotteryNameDataTable(const class UObject*
class UPalMasterDataTableAccess_FarmCropData* GetFarmCropDataTableAccess(const
class UDataTable* GetFarmCropDataTable(const class UObject*
class UPalMasterDataTableAccess_DungeonSpawnAreaData*
GetDungeonSpawnAreaDataTableAccess(const class UObject* WorldContextObject);
class UDataTable* GetDungeonSpawnAreaDataTable(const class UObject*
class UPalMasterDataTableAccess_DungeonLevelData*
GetDungeonLevelDataTableAccess(const class UObject* WorldContextObject);
class UDataTable* GetDungeonLevelDataTable(const class UObject*
class UPalMasterDataTableAccess_DungeonItemLotteryData*
GetDungeonItemLotteryDataTableAccess(const class UObject* WorldContextObject);
class UDataTable* GetDungeonItemLotteryDataTable(const class UObject*
class UPalMasterDataTableAccess_DungeonEnemySpawnerData*
GetDungeonEnemySpawnerDataTableAccess(const class UObject* WorldContextObject);
class UDataTable* GetDungeonEnemySpawnerDataTable(const class UObject*
class UPalMasterDataTableAccess_CharacterUpgradeData*
GetCharacterUpgradeDataTableAccess(const class UObject* WorldContextObject);
class UDataTable* GetCharacterUpgradeDataTable(const class UObject*
class UPalMasterDataTableAccess_BuildObjectIconData*
GetBuildObjectIconDataTableAccess(const class UObject* WorldContextObject);
class UDataTable* GetBuildObjectIconDataTable(const class UObject*
class UPalMasterDataTableAccess_BuildObjectData*
GetBuildObjectDataTableAccess(const class UObject* WorldContextObject);
class UDataTable* GetBuildObjectDataTable(const class UObject*
class UPalMasterDataTableAccess_BaseCampLevelData*
GetBaseCampLevelDataTableAccess(const class UObject* WorldContextObject);
class UDataTable* GetBaseCampLevelDataTable(const class UObject*
}; // Size: 0x28
class UPalMoneyData : public UObject

{
FPalMoneyDataOnUpdatedMoneyDelegate OnUpdatedMoneyDelegate;
// 0x0028 (size: 0x10)
void UpdatedMoneyDelegate(int64 NowMoney);
FPalMoneyDataOnAddMoneyDelegate OnAddMoneyDelegate;
// 0x0038 (size: 0x10)
void AddMoneyDelegate(int64 OldMoney, int64 AddMoney);
class UPalPlayerInventoryData* parentInventoryData;
// 0x0048 (size: 0x8)
void UpdatedMoneyDelegate__DelegateSignature(int64 NowMoney);

void OnUpdateInventorylContainer(class UPalItemContainer* Container);
int64 GetNowMoney();
void AddMoneyDelegate__DelegateSignature(int64 OldMoney, int64 AddMoney);
}; // Size: 0x58
class UPalMonsterControllerBaseCampLogTypeUtility : public

UBlueprintFunctionLibrary
{
}; // Size: 0x28
class UPalMonsterControllerBaseCampUtility : public UBlueprintFunctionLibrary

{
FPalMonsterControllerBaseCampHungryParameter SetHungryParameterToDefault(const
class UObject* WorldObjectContext, FPalMonsterControllerBaseCampHungryParameter
Parameter);
}; // Size: 0x28
class UPalNPCAIWeaponHandle : public UObject

{
FPalNPCAIWeaponHandleOnInitializeEnd OnInitializeEnd;
// 0x0028 (size: 0x10)
void OnInitializeEnd();
TMap<class EPalWeaponType, class FPalNPCWeaponCombatInfo> CombatAIParamMap;
// 0x0038 (size: 0x50)
class AActor* ShooterHuman;
// 0x0088 (size: 0x8)
void UnequipWeapon();
void TerminateNPCWeapon();
void ShootOneBullet();
void ShootBurstBullet(float PullSecond);
void ReleaseTrigger();
void OnInitializeEnd__DelegateSignature();
bool IsTargetInConeShap();
bool IsNear_NearRange(class AActor* TargetActor, float NearRangePlusOffset);
bool IsNear_FarRange(class AActor* TargetActor, float FarRangePlusOffset);
bool IsMagazineEmpty();
bool IsEndInitialize();
void InitializeNPCWeapon(class APalWeaponBase* WeaponActor);
bool GetUseSideDashMovement();
float GetShootInterval();
int32 GetRemainingBullet();
float GetReloadTime();
float GetRandomMoveTimeMin();
int32 GetMaxShootCount();
bool GetIsMeleeAttackWithGun();
TSubclassOf<class UPalStateMachineStateBase> GetFireStateClass();
TSubclassOf<class UPalAIActionBase> GetCombatClass();
void FullReload();
void EquipWeapon();
void DecreaseBullet();
void AimToTarget(class AActor* TargetActor, bool Aim, float DeltaTime);
}; // Size: 0xE0
class UPalNPCInteractCondition : public UObject

{
void SetResult(bool bResult);

}; // Size: 0x40
class UPalNPCInteractConditionFunctions : public UObject

{
class UObject* Owner;
// 0x0028 (size: 0x8)
void SetOwner(class UObject* Owner);

class UObject* GetOwner();
}; // Size: 0x30
class UPalNPCInteractionComponent : public UActorComponent

{
class UDataTable* NPCInteractionDataTable;
// 0x00A8 (size: 0x8)
class UDataTable* NPCInteractConditionConstValDataTable;
// 0x00B0 (size: 0x8)
TSubclassOf<class UPalNPCInteractConditionFunctions> ConditionFunctionClass;
// 0x00B8 (size: 0x8)
TMap<class FName, class EPalIncidentTalkType> TalkTypeMap;
// 0x00D0 (size: 0x50)
TMap<class FName, class UPalNPCInteractCondition*> InteractConditions;
// 0x0120 (size: 0x50)
class UPalNPCInteractConditionFunctions* ConditionFunctions;
// 0x0170 (size: 0x8)

IndicatorType);
void Initialize();
void EndTalk(class APalPlayerCharacter* TalkPlayer);
void DebugInteractConditionString(FString testText);
void BeginPlay();
}; // Size: 0x178
class UPalNPCInteractionDataTableUtility : public UBlueprintFunctionLibrary

{
void GetJSONStringByInteractionDataTable(FString& OutString, const TMap<class

FName, class FPalNPCInteractionDataTableRow>& DataRows);
}; // Size: 0x28
class UPalNPCManager : public UObject

{
TSubclassOf<class UNavigationQueryFilter> AIOnNavMeshFilterClass;
// 0x0030 (size: 0x8)
TMap<class UPalIndividualCharacterHandle*, class FPalNPCManagerCallbackMap>
CallbackMap; // 0x0038 (size: 0x50)
TMap<class UPalIndividualCharacterHandle*, class FPalNPCSpawnInfo>
SpawnInfoMap; // 0x0088 (size: 0x50)
class UPalWildPalDrinkWaterSpotProvider* DrinkWaterSpotProvider;
// 0x00D8 (size: 0x8)
TMap<class FName, class bool> RespawnDisableFlag;
// 0x00E0 (size: 0x50)
TSubclassOf<class APalAIController> NPCAIControllerBaseClass;
// 0x0180 (size: 0x8)
class UDataTable* UniqueNPCDataTable;
// 0x0188 (size: 0x8)
class UDataTable* NPCOneTalkDataTable;
// 0x0190 (size: 0x8)
class UDataTable* NPCMultiTalkDataTable;
// 0x0198 (size: 0x8)
TMap<class EPalNPCTalkUIType, class UDataTable*> TalkDataTableMap;
// 0x01A0 (size: 0x50)
TMap<class FName, class EPalNPCTalkUIType> NPCNameTalkTypeMap;
// 0x01F0 (size: 0x50)
void SpawNPCCallback(FPalInstanceID ID);

class UPalIndividualCharacterHandle* SpawnNPCForServer(FPalNPCSpawnInfo
SpawnInfo, FSpawnNPCForServerSpawnCallback spawnCallback);
void SetEnemyCampStatus(FName KeyName, FPalEnemyCampStatus EnemyCampStatus);
void RemoveGroupWhenDestoryActor(class AActor* DestoryActor);
void NPCSpawnCallback__DelegateSignature(FPalInstanceID ID);
bool IsTalkable(class APalCharacter* Character);
EPalNPCTalkUIType GetTalkUIType(class APalCharacter* Character);
class UDataTable* GetNPCTalkDTFromTalkUIType(EPalNPCTalkUIType TalkUIType);
class UDataTable* GetNPCOneTalkDTFromTalkId(FName TalkId);
class UDataTable* GetNPCOneTalkDTFromCharacter(class APalCharacter* Character);
TSubclassOf<class UPalNPCMultiTalkHandle> GetNPCMultiTalkClassFromTalkId(FName
TalkId);
TSubclassOf<class UPalNPCMultiTalkHandle> GetNPCMultiTalkClass(class
class UDataTable* GetNPCCharacterTalkDT(FName CharacterID);
FPalEnemyCampStatus GetEnemyCampStatus(FName KeyName);
class UPalWildPalDrinkWaterSpotProvider* GetDrinkWaterSpotProvider();
FName GetCharacterIDFromCharacterIDAndUniqueNPCID(FName CharacterID, FName
UniqueNPCID);
void AllResetBossRespawnFlag();
}; // Size: 0x240
class UPalNPCMultiTalkHandle : public UObject

{
FName TalkId;
// 0x0028 (size: 0x8)
void OnFinishOneTalk();
void IncrementTalkCountRecord();
FName GetTalkId();
class UDataTable* GetTalkData(const FName& inTalkID);
class UPalPlayerDataStorage* GetPlayerDataStorage();
class UPalPlayerLocalRecordData* GetLocalRecordData();
int32 GetCurrentTalkCount();
}; // Size: 0x30
class UPalNPCTalkComponent : public UActorComponent

{
bool IsTalking;
// 0x00A0 (size: 0x1)
FPalNPCTalkComponentOnTalkStartDelegate OnTalkStartDelegate;
// 0x00A8 (size: 0x10)
void TalkStartDelegate(class AActor* SelfActor, class AActor* TargetActor);
FPalNPCTalkComponentOnTalkEndDelegate OnTalkEndDelegate;
// 0x00B8 (size: 0x10)
void TalkEndDelegate(class AActor* SelfActor, class AActor* TargetActor);
void TriggerStartTalk(class AActor* Other, EPalInteractiveObjectIndicatorType

IndicatorType);
void TriggerEndTalk(class AActor* Other);
void TalkStartDelegate__DelegateSignature(class AActor* SelfActor, class
AActor* TargetActor);
void TalkEndDelegate__DelegateSignature(class AActor* SelfActor, class AActor*
TargetActor);
void StartTalk(class AActor* Other);
bool HasTalkData(class APalCharacter* TalkCharacter);
bool GetIsTalking();
}; // Size: 0xC8
class UPalNPCTalkSystem : public UObject

{
class UPalTalkWidgetParameter* talkWidgetParameter;
// 0x0030 (size: 0x8)
class UPalTalkWindowWidgetBase* talkWidget;
// 0x0038 (size: 0x8)
FPalNPCTalkData nowExecutedTalkData;
// 0x0040 (size: 0x58)
int32 nowTalkDataIndex;
// 0x0098 (size: 0x4)
FName nowTalkDataSeqenceName;
// 0x009C (size: 0x8)
TArray<FName> defaultYesNoChoiceText;
// 0x00A8 (size: 0x10)
class UFunction* targetFunc;
// 0x00B8 (size: 0x8)
class UDataTable* FuncParam;
// 0x00C0 (size: 0x8)
EPalNPCTalkCustomFunctionResult CustomFuncResult;
// 0x00C8 (size: 0x1)
int32 CustomFuncChoseIndex;
// 0x00CC (size: 0x4)
void SetCustomFunctionResult_Implementation(EPalNPCTalkCustomFunctionResult
Result);
void SetCustomFunctionChoseIndex_Implementation(int32 Index);
EPalNPCTalkProceedResult Proceed();
void Initialize(class UPalTalkWidgetParameter* InParameter, class
UPalTalkWindowWidgetBase* inTalkWidget);
bool ChangeSeqence(FName targetSeqenceName);
bool CallCustomFunc();
void AddArgument_Implementation(FString Key, const FText& Text);
}; // Size: 0xD0
class UPalNPCWeaponGenerator : public UObject

{
TMap<class EPalWeaponType, class FName> WeaponIDMap;
// 0x0028 (size: 0x50)
FPalContainerId WeaponContainerId;
// 0x0078 (size: 0x10)
class APalWeaponBase* WeaponActorBP;
// 0x0088 (size: 0x8)
bool IsDefaultEquipWeapon;
// 0x0090 (size: 0x1)
void OnSpawnEvent(class APalWeaponBase* WeaponActor);

void GenerateWeapn(EPalWeaponType WeaponType, bool IsDefaultEquip);
}; // Size: 0x98
class UPalNavArea_HighObstacle : public UNavArea

{
}; // Size: 0x48
class UPalNavigationInvokerComponent : public UNavigationInvokerComponent

{
bool bIsAutoActivateInvoker;
// 0x00B0 (size: 0x1)
bool bIsWaitWorldPartition;
// 0x00B1 (size: 0x1)
FIntPoint AreaBelongTo;
// 0x00B4 (size: 0x8)
FFlagContainer IsDisableInvorkerFlag;
// 0x00C0 (size: 0x50)
void SetDisableInvorkerFlag(FName flagName, bool isDisable);

bool IsDisableInvorker();
void ActivateInvoker();
}; // Size: 0x110
class UPalNavigationSystemV1 : public UNavigationSystemV1

{
int32 UpdateInvokerCounter;
// 0x1580 (size: 0x4)
}; // Size: 0x1588
class UPalNetArchiveObject : public UObject

{
}; // Size: 0x28
class UPalNetworkBaseCampComponent : public UActorComponent

{
void RequestModule_Server_void(const FGuid& BaseCampId, const

EPalBaseCampModuleType ModuleType, const FName FunctionName);
void RequestModule_Server_int32(const FGuid& BaseCampId, const
EPalBaseCampModuleType ModuleType, const FName FunctionName, int32 Value);
void RequestModule_Server_FVector(const FGuid& BaseCampId, const
EPalBaseCampModuleType ModuleType, const FName FunctionName, FVector Value);
void RequestModule_Server_FPalNetArchive(const FGuid& BaseCampId, const
EPalBaseCampModuleType ModuleType, const FName FunctionName, FPalNetArchive Value);
void RequestModule_Server_bool(const FGuid& BaseCampId, const
EPalBaseCampModuleType ModuleType, const FName FunctionName, bool Value);
void Request_Server_void(const FGuid& BaseCampId, const FName FunctionName);
void Request_Server_int32(const FGuid& BaseCampId, const FName FunctionName,
int32 Value);
void Request_Server_FVector(const FGuid& BaseCampId, const FName FunctionName,
FVector Value);
void Request_Server_FPalNetArchive(const FGuid& BaseCampId, const FName
FunctionName, FPalNetArchive Value);
void Request_Server_bool(const FGuid& BaseCampId, const FName FunctionName,
bool Value);
void NotifyModule_RequestClient_void(const FGuid& BaseCampId, const
void NotifyModule_RequestClient_int32(const FGuid& BaseCampId, const
void NotifyModule_RequestClient_FVector(const FGuid& BaseCampId, const
void NotifyModule_RequestClient_FPalNetArchive(const FGuid& BaseCampId, const
void NotifyModule_RequestClient_bool(const FGuid& BaseCampId, const
void NotifyModule_Multicast_void(const FGuid& BaseCampId, const
void NotifyModule_Multicast_int32(const FGuid& BaseCampId, const
void NotifyModule_Multicast_FVector(const FGuid& BaseCampId, const
void NotifyModule_Multicast_FPalNetArchive(const FGuid& BaseCampId, const
void NotifyModule_Multicast_bool(const FGuid& BaseCampId, const
void Notify_RequestClient_void(const FGuid& BaseCampId, const FName
FunctionName);
void Notify_RequestClient_int32(const FGuid& BaseCampId, const FName
FunctionName, int32 Value);
void Notify_RequestClient_FVector(const FGuid& BaseCampId, const FName
FunctionName, FVector Value);
void Notify_RequestClient_FPalNetArchive(const FGuid& BaseCampId, const FName
void Notify_RequestClient_bool(const FGuid& BaseCampId, const FName
FunctionName, bool Value);
void Notify_Multicast_void(const FGuid& BaseCampId, const FName FunctionName);
void Notify_Multicast_int32(const FGuid& BaseCampId, const FName FunctionName,
int32 Value);
void Notify_Multicast_FVector(const FGuid& BaseCampId, const FName
void Notify_Multicast_FPalNetArchive(const FGuid& BaseCampId, const FName
void Notify_Multicast_bool(const FGuid& BaseCampId, const FName FunctionName,
bool Value);
void BroadcastBaseCampWorkerLog_Server(EPalLogType DisplayLogType, const
FPalInstanceID& WorkerCharacterInstanceId, const FName& EventDataID);
void BroadcastBaseCampLog_Server(const FPalMonsterControllerBaseCampLogContent&
LogContent);
void AddBaseCampWorkerLog_Client(EPalLogType DisplayLogType, const
FPalInstanceID& WorkerCharacterInstanceId, const FName& EventDataID);
void AddBaseCampLog_Client(const FPalMonsterControllerBaseCampLogContent&
LogContent);
}; // Size: 0xA0
class UPalNetworkBossBattleComponent : public UActorComponent

{
void UnlockAchievement_ToClient(EPalBossType BossType);

void RequestBossBattleStart_ToServer(EPalBossType BossType, class
APalPlayerCharacter* StartPlayer);
void RequestBossBattleStart_ToClient(bool IsSuccess, EPalBossType BossType,
const FPalStageInstanceId StageInstanceId, const TArray<class
APalPlayerCharacter*>& JoinPlayers);
void RequestBossBattleEntry_ToServer(EPalBossType BossType, class
APalPlayerCharacter* EntryPlayer);
void RemovePlayerFromRoom_ToClient(EPalBossType BossType, class
APalPlayerCharacter* DeadPlayer);
void NoticeSequenceEnd_ToServer(EPalBossType BossType, class
APalPlayerCharacter* Player);
void CombatResult_ToClient(EPalBossType BossType, EPalBossBattleCombatResult
CombatResult);
void ChangeSequence_ToClient(EPalBossType BossType, EPalBossBattleSequenceType
NextSequence);
}; // Size: 0xA0
class UPalNetworkCharacterComponent : public UActorComponent

{
void RequestReflectAction_ToServer(class APalCharacter* Character);

void ReflectAction_ToClient(class APalCharacter* Character,
FActionDynamicParameter Param, TSubclassOf<class UPalActionBase> actionClass);
void NotifyTalkStart_ToServer(class APalPlayerCharacter* TalkPlayer, class
APalCharacter* TargetNPC);
void NotifyTalkEnd_ToServer(class APalPlayerCharacter* TalkPlayer, class
APalCharacter* TargetNPC);
}; // Size: 0xA0
class UPalNetworkCharacterContainerComponent : public UActorComponent

{
TMap<class FGuid, class FPalNetworkCharacterContainerParameter>
ContainerParamMap; // 0x00A0 (size: 0x50)
void RequestUnlockSlot_ToServer(const FGuid& RequestID, const

FPalCharacterSlotId& SlotID);
void RequestSwap_ToServer_Rep(const FPalCharacterSlotId& SlotIdA, const
FPalCharacterSlotId& SlotIdB);
void RequestSortContainer_ToServer(const FPalContainerId& ContainerId, const
EPalCharacterContainerSortType SortType);
void RequestEmptySlot_ToServer_Rep(const FPalCharacterSlotId& SlotID);
void RequestAddToContainer_ToServer_Rep(const FPalContainerId& ContainerId,
void RecieveUnlockSlot_ToRequestClient(const FGuid& RequestID, const
EPalCharacterContainerOperationResult Result);
void RecieveUnlockSlot_ToClient(const FPalCharacterSlotId& SlotID);
}; // Size: 0xF0
class UPalNetworkCharacterStatusOperationComponent : public UActorComponent

{
FPalNetworkCharacterStatusOperationComponentOnReceiveRequestResultDelegate
OnReceiveRequestResultDelegate; // 0x00A0 (size: 0x10)
void PalCharacterStatusOperationResultDelegate(const
EPalCharacterStatusOperationResult Result);
void RequestReviveCharacterFromDying_ToServer(class APalCharacter* Character);

void RequestReviveCharacterFromDying(class APalCharacter* Character);
void RequestPlayerStatusUp_ToServer(const int32 ToRank);
void RequestPlayerStatusClear_ToServer();
void RequestPlayerRankClear();
void RequestPlayerRankAdd(const int32 ToRank);
void RequestOtomoStatusPointClearAll_ToServer(const FPalInstanceID&
IndividualId);
void RequestOtomoStatusPointClearAll(const class UPalIndividualCharacterHandle*
IndividualHandle);
void RequestOtomoStatusPointClear_ToServer(const FPalInstanceID& IndividualId,
const EPalCharacterStatusOperationName StatusName);
void RequestOtomoStatusPointClear(const class UPalIndividualCharacterHandle*
IndividualHandle, const EPalCharacterStatusOperationName StatusName);
void RequestOtomoStatusPointAdd_ToServer(const FPalInstanceID& IndividualId,
const EPalCharacterStatusOperationName StatusName, const int32 ToRank);
void RequestOtomoStatusPointAdd(const class UPalIndividualCharacterHandle*
IndividualHandle, const EPalCharacterStatusOperationName StatusName, const int32
ToRank);
void ReceiveOperationResult_ToClient(const EPalCharacterStatusOperationResult
Result);
class UPalNetworkCharacterStatusOperationComponent*
NetCharacterStatusOperation(const class UObject* WorldContextObject);
}; // Size: 0xB0
class UPalNetworkComponentUtility : public UObject

{
}; // Size: 0x28
class UPalNetworkGroupComponent : public UActorComponent

{
void RequestJoinGuildRequestForPlayer_ToServer(const FGuid& RequestPlayerUId,

const FGuid& TargetPlayerUId);
void RequestJoinGuildForPlayer_ToServer(const FGuid& RequestPlayerUId, const
FGuid& TargetPlayerUId);
void RequestExitGuild_ToServer(const FGuid& TargetPlayerUId);
void RequestChangeGuildName_ToServer(const FGuid& GroupID, FString
NewGuildName);
void RequestChangeGuildAdmin_ToServer(const FGuid& RequestPlayerUId, const
FGuid& TargetPlayerUId);
void NotifyJoinGuildRequestResult_ToServer(const FGuid& RequestPlayerUId, const
FGuid& NotifyTargetPlayerUId, EPalGuildJoinRequestResult ResultType);
}; // Size: 0xA0
class UPalNetworkIndividualComponent : public UActorComponent

{
void UpdateCharacterParameter_ToServer(const FPalInstanceID& ID, const

FPalNetArchive& parameterArchive, FGuid Guid);
void UpdateCharacterParameter_ToAll(const FPalInstanceID& ID, const
FPalNetArchive& parameterArchive, FGuid Guid);
void UpdateCharacterNickName_ToServer(const FPalInstanceID& ID, FString
newNickName);
void SpawnPhantomActor_ToServer(FPalInstanceID ID, FNetworkActorSpawnParameters
SpawnParameter, FGuid Guid);
void SpawnPhantomActor_ToALL(FPalInstanceID ID, int32 PhantomId, class AActor*
Actor, FGuid Guid);
void SpawnPhantomActor_SyncCheck(FPalInstanceID ID, int32 PhantomId, FGuid
Guid);
void SpawnIndividualActor_ToServer(FPalInstanceID ID,
FNetworkActorSpawnParameters SpawnParameter, FGuid Guid);
void SpawnIndividualActor_ToALL(FPalInstanceID ID, class AActor* Actor, FGuid
Guid);
void SpawnIndividualActor_SyncCheck(FPalInstanceID ID, FGuid Guid);
void SetWorkerSick_ToServer(const FPalInstanceID& ID,
EPalBaseCampWorkerSickType SickType);
void ResetStatusPoint_ToServer(const FPalInstanceID& ID);
void ReplaceEquipWaza_ToServer(const FPalInstanceID& ID, const EPalWazaID
OldWaza, const EPalWazaID NewWaza);
void RemoveHighPriorityList_ToServer(const FPalInstanceID& ID, class
APalCharacter* TargetPlayer);
void RemoveEquipWaza_ToServer(const FPalInstanceID& ID, const EPalWazaID
TargetWaza);
void RaiseToMainActor_ToServer(FPalInstanceID ID, int32 PhantomId, FGuid Guid);
void RaiseToMainActor_ToALL(FPalInstanceID ID, int32 PhantomId, FGuid Guid);
void EatItem_ToServer(const FPalInstanceID& ID, const class
UPalStaticConsumeItemData* ItemData, const int32 Num);
void DropToPhantomActor_ToServer(FPalInstanceID ID, FGuid Guid);
void DropToPhantomActor_ToALL(FPalInstanceID ID, int32 PhantomId, FGuid Guid);
void DespawnPhantomActor_ToServer(FPalInstanceID ID, int32 PhantomId, FGuid
Guid);
void DespawnPhantomActor_ToALL(FPalInstanceID ID, int32 PhantomId, FGuid Guid);
void DespawnPhantomActor_SyncCheck(FPalInstanceID ID, int32 PhantomId, FGuid
Guid);
void DespawnIndividualActor_ToServer(FPalInstanceID ID, FGuid Guid);
void DespawnIndividualActor_ToALL(FPalInstanceID ID, FGuid Guid);
void DespawnIndividualActor_SyncCheck(FPalInstanceID ID, FGuid Guid);
void CreateIndividualID_ToServer(FPalIndividualCharacterSaveParameter
initParameter, FGuid Guid, int32 RequestPlayerId);
void CreateIndividualID_ToALL(FPalIndividualCharacterSaveParameter
initParameter, FPalInstanceID ID, FGuid Guid);
void CreateIndividualID_SyncCheck(FPalInstanceID ID, FGuid Guid);
void CreateFixedIndividualID_ToServer(FPalInstanceID ID,
FPalIndividualCharacterSaveParameter initParameter, FGuid Guid, int32
RequestPlayerId);
void BroadcastChangeOwnerCharacter_ToAll(FPalInstanceID ID, const FGuid&
PlayerUId, FDateTime OwnedTime);
void AddPlayerCharacterStatusPoint_ToServer(const FPalInstanceID& ID, const
TArray<FPalGotStatusPoint>& AddStatusPointArray);
void AddMasteredWaza_ToServer(const FPalInstanceID& ID, EPalWazaID WazaID);
void AddHighPriorityList_ToServer(const FPalInstanceID& ID, class
APalCharacter* TargetPlayer);
void AddEquipWaza_ToServer(const FPalInstanceID& ID, const EPalWazaID NewWaza);
}; // Size: 0x208
class UPalNetworkInvaderComponent : public UActorComponent

{
void OnInvaderStart(const FPalIncidentBroadcastParameter& Parameter);

void OnInvaderEnd(const FPalIncidentBroadcastParameter& Parameter);
void OnInvaderArrived(const FPalIncidentBroadcastParameter& Parameter);
}; // Size: 0xA0
class UPalNetworkItemComponent : public UActorComponent

{
TMap<class FGuid, class FPalNetworkDynamicItemParameter> DynamicItemParamMap;
// 0x00A0 (size: 0x50)
TMap<class FGuid, class FPalNetworkContainerParameter> ContainerParamMap;
// 0x00F0 (size: 0x50)
TMap<class FGuid, class FPalNetworkItemOperationParameter>
ItemOperationParamMap; // 0x0140 (size: 0x50)
TMap<class FGuid, class FPalNetworkParameter> OperationParamMap;
// 0x0190 (size: 0x50)
void RequestSwap_ToServer(const FGuid& RequestID, const FPalItemAndSlot& SlotA,

const FPalItemPermission& APermission, const FPalItemAndSlot& SlotB, const
FPalItemPermission& BPermission);
void RequestProduceWithSlot_ToServer(const FGuid& RequestID, const
FPalStaticItemIdAndNum& ProductData, const FPalItemAndSlot& To, const
FPalNetArchive& CreateParamArchive);
void RequestProduce_ToServer(const FGuid& RequestID, const
FPalStaticItemIdAndNum& ProductData, const FPalContainerId& ContainerId, const
FPalNetArchive& CreateParamArchive);
void RequestMoveToContainer_ToServer(const FGuid& RequestID, const FPalItemId&
ItemId, const FPalContainerId& ToContainerId, const FPalItemPermission&
ToPermission, const TArray<FPalSlotItemAndNum>& Froms);
void RequestMove_ToServer(const FGuid& RequestID, const FPalItemId& ItemId,
const FPalItemAndSlot& To, const FPalItemPermission& ToPermission, const
TArray<FPalSlotItemAndNum>& Froms);
void RequestDrop_ToServer(const TArray<FPalItemSlotIdAndNum>&
DropSlotAndNumArray, const FVector& DropLocation, bool IsAutoPickup);
void RequestDispose_ToServer(const FGuid& RequestID, const FPalSlotItemAndNum&
SlotInfo);
void ReceiveProduceWithSlotResult_ToRequestClient(const FGuid& RequestID, const
EPalItemOperationResult Result);
void ReceiveProduceResult_ToRequestClient(const FGuid& RequestID, const
EPalItemOperationResult Result);
}; // Size: 0x1E0
class UPalNetworkMapObjectComponent : public UActorComponent

{
TMap<class FGuid, class FPalNetworkMapObjectSpawnRequestParameter>
MapObjectSpawnRequestParameterMap; // 0x00A0 (size: 0x50)
TMap<class FGuid, class UPalMapObjectSpawnRequestHandler*>
SpawnRequestHandlerMap; // 0x00F0 (size: 0x50)
void RequestSpawnMapObject_ToServer(const FGuid& RequestID, const FName

MapObjectId, const FVector& Location, const FQuat& Rotation, const
TArray<FPalNetArchive>& ExtraParameterArchives);
void RequestRepair_ToServer(const FGuid& InstanceId);
void RequestDismantleObject_ToServer(const FGuid& InstanceId);
void RequestDamageMapObjectSpawner_ToServer(class APalMapObjectSpawnerBase*
TargetSpawnerActor, const FPalDamageInfo& DamageInfo);
void RequestDamageMapObject_ToServer(const FGuid& InstanceId, const
FPalDamageInfo& Info);
void RequestDamageFoliage_ToServer(const FPalCellCoord& CellCoord, const FName
ModelId, const TArray<FPalFoliageInstanceId>& InstanceIds, const FPalDamageInfo&
DamageInfo);
void RequestConcreteModelModule_Server_void(const FGuid&
ConcreteModelInstanceId, const EPalMapObjectConcreteModelModuleType ModuleType,
const FName FunctionName);
void RequestConcreteModelModule_Server_int32(const FGuid&
const FName FunctionName, int32 Value);
void RequestConcreteModelModule_Server_FVector(const FGuid&
const FName FunctionName, FVector Value);
void RequestConcreteModelModule_Server_FPalNetArchive(const FGuid&
const FName FunctionName, FPalNetArchive Value);
void RequestConcreteModelModule_Server_bool(const FGuid&
const FName FunctionName, bool Value);
void RequestConcreteModel_void(const FGuid& ConcreteModelInstanceId, const
FName FunctionName);
void RequestConcreteModel_Server_void(const FGuid& ConcreteModelInstanceId,
void RequestConcreteModel_Server_int32(const FGuid& ConcreteModelInstanceId,
void RequestConcreteModel_Server_FVector(const FGuid& ConcreteModelInstanceId,
void RequestConcreteModel_Server_FPalNetArchive(const FGuid&
ConcreteModelInstanceId, const FName FunctionName, FPalNetArchive Value);
void RequestConcreteModel_Server_bool(const FGuid& ConcreteModelInstanceId,
void RequestConcreteModel_int32(const FGuid& ConcreteModelInstanceId, const
FName FunctionName, int32 Value);
void RequestConcreteModel_FVector(const FGuid& ConcreteModelInstanceId, const
FName FunctionName, FVector Value);
void RequestConcreteModel_FPalNetArchive(const FGuid& ConcreteModelInstanceId,
void RequestConcreteModel_bool(const FGuid& ConcreteModelInstanceId, const
FName FunctionName, bool Value);
void RequestBuildCancel_ToServer(const FGuid& InstanceId);
void RecieveDestroyMapObject_Multicast(const FGuid& InstanceId);
void RecieveDamageMapObject_ToClient(const FGuid& InstanceId, const
FPalDamageInfo& Info, const int32 DamagedHp);
void ReceiveUpdateHp_ToClient(const FGuid& InstanceId, const int32 UpdatedHp);
void ReceiveDismantleObjectResult_ToClient(const EPalMapObjectOperationResult
Result, const FGuid& InstanceId);
void NotifyReceivePickupResultSuccess_ToClient(const FPalNetArchive&
PickupItemArchive, class UPalMapObjectPickableItemModelBase* Model, bool
IsAllPickup);
void NotifyReceivePickupResultFailed_ToClient(class
UPalMapObjectPickableItemModelBase* Model);
void NotifyConcreteModelModule_RequestClient_void(const FGuid&
void NotifyConcreteModelModule_RequestClient_int32(const FGuid&
void NotifyConcreteModelModule_RequestClient_FVector(const FGuid&
void NotifyConcreteModelModule_RequestClient_FPalNetArchive(const FGuid&
void NotifyConcreteModelModule_RequestClient_bool(const FGuid&
void NotifyConcreteModelModule_Multicast_void(const FGuid&
void NotifyConcreteModelModule_Multicast_int32(const FGuid&
void NotifyConcreteModelModule_Multicast_FVector(const FGuid&
void NotifyConcreteModelModule_Multicast_FPalNetArchive(const FGuid&
void NotifyConcreteModelModule_Multicast_bool(const FGuid&
void NotifyConcreteModel_ToRequestClient_void(const FGuid&
ConcreteModelInstanceId, const int32 RequestPlayerId, const FName FunctionName);
void NotifyConcreteModel_ToRequestClient_int32(const FGuid&
ConcreteModelInstanceId, const int32 RequestPlayerId, const FName FunctionName,
int32 Value);
void NotifyConcreteModel_ToRequestClient_FVector(const FGuid&
FVector Value);
void NotifyConcreteModel_ToRequestClient_FPalNetArchive(const FGuid&
FPalNetArchive Value);
void NotifyConcreteModel_ToRequestClient_bool(const FGuid&
bool Value);
void NotifyConcreteModel_ToMulticast_void(const FGuid& ConcreteModelInstanceId,
void NotifyConcreteModel_ToMulticast_int32(const FGuid&
ConcreteModelInstanceId, const FName FunctionName, int32 Value);
void NotifyConcreteModel_ToMulticast_FVector(const FGuid&
ConcreteModelInstanceId, const FName FunctionName, FVector Value);
void NotifyConcreteModel_ToMulticast_FPalNetArchive(const FGuid&
void NotifyConcreteModel_ToMulticast_bool(const FGuid& ConcreteModelInstanceId,
void NotifyConcreteModel_RequestClient_void(const FGuid&
ConcreteModelInstanceId, const FName FunctionName);
void NotifyConcreteModel_RequestClient_int32(const FGuid&
ConcreteModelInstanceId, const FName FunctionName, int32 Value);
void NotifyConcreteModel_RequestClient_FVector(const FGuid&
void NotifyConcreteModel_RequestClient_FPalNetArchive(const FGuid&
void NotifyConcreteModel_RequestClient_bool(const FGuid&
ConcreteModelInstanceId, const FName FunctionName, bool Value);
void NotifyConcreteModel_Multicast_void(const FGuid& ConcreteModelInstanceId,
void NotifyConcreteModel_Multicast_int32(const FGuid& ConcreteModelInstanceId,
void NotifyConcreteModel_Multicast_FVector(const FGuid&
void NotifyConcreteModel_Multicast_FPalNetArchive(const FGuid&
void NotifyConcreteModel_Multicast_bool(const FGuid& ConcreteModelInstanceId,
}; // Size: 0x140
class UPalNetworkMulticastGateComponent : public UActorComponent

{
void SendToServer_void(int32 ID, class UObject* Instance, FName FunctionName);

void SendToServer_object(int32 ID, class UObject* Instance, FName FunctionName,
class UObject* Value);
void SendToServer_int32(int32 ID, class UObject* Instance, FName FunctionName,
int32 Value);
void SendToServer_FVector(int32 ID, class UObject* Instance, FName
void SendToServer_FPalNetArchive(int32 ID, class UObject* Instance, FName
void SendToServer_FPalInstanceID(int32 ID, class UObject* Instance, FName
FunctionName, FPalInstanceID Value);
void SendToServer_float(int32 ID, class UObject* Instance, FName FunctionName,
float Value);
void SendToServer_FGuid(int32 ID, class UObject* Instance, FName FunctionName,
FGuid Value);
void SendToServer_bool(int32 ID, class UObject* Instance, FName FunctionName,
bool Value);
void SendToALL_void(int32 ID, class UObject* Instance, FName FunctionName);
void SendToALL_object(int32 ID, class UObject* Instance, FName FunctionName,
class UObject* Value);
void SendToALL_int32(int32 ID, class UObject* Instance, FName FunctionName,
int32 Value);
void SendToALL_FVector(int32 ID, class UObject* Instance, FName FunctionName,
FVector Value);
void SendToALL_FPalNetArchive(int32 ID, class UObject* Instance, FName
void SendToALL_FPalInstanceID(int32 ID, class UObject* Instance, FName
FunctionName, FPalInstanceID Value);
void SendToALL_float(int32 ID, class UObject* Instance, FName FunctionName,
float Value);
void SendToALL_FGuid(int32 ID, class UObject* Instance, FName FunctionName,
FGuid Value);
void SendToALL_bool(int32 ID, class UObject* Instance, FName FunctionName, bool
Value);
void SendInternal_void(class UObject* Instance, FName FunctionName);
void SendInternal_object(class UObject* Instance, FName FunctionName, class
UObject* Value);
void SendInternal_int32(class UObject* Instance, FName FunctionName, int32
Value);
void SendInternal_FVector(class UObject* Instance, FName FunctionName, FVector
Value);
void SendInternal_FPalNetArchive(class UObject* Instance, FName FunctionName,
void SendInternal_FPalInstanceID(class UObject* Instance, FName FunctionName,
FPalInstanceID Value);
void SendInternal_float(class UObject* Instance, FName FunctionName, float
Value);
void SendInternal_FGuid(class UObject* Instance, FName FunctionName, FGuid
Value);
void SendInternal_bool(class UObject* Instance, FName FunctionName, bool
Value);
void Send_void(class UObject* Instance, FName FunctionName);
void Send_object(class UObject* Instance, FName FunctionName, class UObject*
Value);
void Send_int32(class UObject* Instance, FName FunctionName, int32 Value);
void Send_FVector(class UObject* Instance, FName FunctionName, FVector Value);
void Send_FPalNetArchive(class UObject* Instance, FName FunctionName,
void Send_FPalInstanceID(class UObject* Instance, FName FunctionName,
FPalInstanceID Value);
void Send_float(class UObject* Instance, FName FunctionName, float Value);
void Send_FGuid(class UObject* Instance, FName FunctionName, FGuid Value);
void Send_bool(class UObject* Instance, FName FunctionName, bool Value);
}; // Size: 0xA0
class UPalNetworkPlayerComponent : public UActorComponent

{
void ShowBossDefeatRewardUI_ToClient(int32 TechPoint, bool AfterTeleport, int32

DelayTime);
void SetCurrentSelectPalSphereIndex_ToServer(int32 NextIndex, class
UPalLoadoutSelectorComponent* LoadoutSelector);
void RequestUnlockTechnology_ToServer(const FName& UnlockTechnologyName);
void RequestTrashItemFromInventoryDropSlot_ToServer();
void RequestSortInventory_ToServer();
void RequestMoveItemToInventoryFromSlot(class UPalItemSlot* fromSlot, bool
IsTryEquip);
void RequestMoveItemToInventoryFromContainer(class UPalItemContainer*
fromContainer, bool IsTryEquip);
void RequestExitStage_ToServer();
void RequestEnterStage_ToServer(const FPalStageInstanceId& StageInstanceId);
void RequestDropOtomoPal_ToServer(const int32 OtomoIndex);
void RequestDropItemFromInventoryDropSlot_ToServer();
void RequestChangeVoiceID_ToServer(int32 NewVoiceID);
void RequestAddTechnolgyPointByItem_ToServer(const FPalItemSlotId&
ConsumeItemSlotID);
void RequestAddTechnolgyPoint_ToServer(const int32 AddPoint);
void RequestAddItem_ToServer(const FName StaticItemId, const int32 Count, bool
isAssignPassive);
void RegisterRespawnLocation_ToServer(const FGuid& PlayerUId, const FVector&
Location);
void ReceiveExitStageRequestResult_ToRequestClient(const EPalStageRequestResult
Result);
void ReceiveEnterStageRequestResult_ToRequestClient(const FPalStageInstanceId&
StageInstanceId, const EPalStageRequestResult Result);
void NotifyStartCrime_ToClient(FGuid CrimeInstanceId);
void NotifyReportCriminal_ToClient(class UPalIndividualCharacterHandle*
CriminalHandle, const TArray<FName>& CrimeIds);
void NotifyReleaseWanted_ToClient(class UPalIndividualCharacterHandle*
CriminalHandle);
void NotifyEndCrime_ToClient(FGuid CrimeInstanceId);
void LoadoutSelectorRemoveEquipItem(class UPalLoadoutSelectorComponent*
LoadoutSelector);
void LoadoutSelectorEquipItem(class UPalLoadoutSelectorComponent*
LoadoutSelector, EPalPlayerInventoryType inventoryType, int32 Index);
void Dev_RequestTeleportToDungeonEntranceByIndex_ToServer(const int32 Index);
void Dev_RequestTeleportToDungeonEntranceByDataLayer_ToServer(const FName
DataLayerName);
void Dev_RequestTeleportToCurrentDungeonTreasureBox_ToServer();
void Dev_RequestTeleportToCurrentDungeonGoal_ToServer();
void Dev_RequestTeleportToBossTower_ToServer(EPalBossType BossType);
}; // Size: 0xA0
class UPalNetworkPlayerStateComponent : public UActorComponent

{
TMap<class FGuid, class FPalNetworkPlayerObtainClientParameter>
ObtainClientParamMap; // 0x00A0 (size: 0x50)
}; // Size: 0xF0
class UPalNetworkShopComponent : public UActorComponent

{
void SetupShopDataForActor_ToServer(class AActor* VenderActor);

void RequestSellPals_ToServer(const FGuid& RequestPlayerUId, const FGuid&
ShopID, const TArray<FPalCharacterSlotId>& SellPalSlotIDArray);
void RequestSellItems_ToServer(const FGuid& RequestPlayerUId, const FGuid&
ShopID, const TArray<FPalItemSlotIdAndNum>& SellItemSlotIDArray);
void RequestCollectDroppedPalProductData(const FGuid& RequestPlayerUId, const
int32 MaxCollectNum);
void RequestBuyProduct_ToServer(const FPalInstanceID& RequestPlayerInstanceId,
const FGuid& ShopID, const FGuid& ProductId, int32 BuyNum);
void RequestBuyLostPal_ToServer(const FGuid& RequestPlayerUId, const
FPalCharacterStoredParameterId& StoredParameterId);
void RemoveShopData_ToServer(const FGuid& RemoveShopID);
void RecieveBuyResult_ToClient(EPalShopBuyResultType ResultType);
void ReceiveDroppedPalProductData_ToClient(const
TArray<FPalDroppedPalProductDataForShop>& CollectedData);
}; // Size: 0xA0
class UPalNetworkTimeComponent : public UActorComponent

{
void PreNightSkip_ToClient();
void NightSkip_ToClient();
}; // Size: 0xA0
class UPalNetworkWorkProgressComponent : public UActorComponent

{
void RequestStartPlayerWork_ToServer(const FGuid& RequestID, const FGuid&

WorkProgressId);
void RequestEndPlayerWork_ToServer(const FGuid& WorkId);
void ReceiveStartPlayerWork_ToRequestClient(const FGuid& RequestID, const
EPalWorkRequestResult Result);
void AddCompleteBuildWorkLog(const FPalNetArchive& Archive);
}; // Size: 0xF0
class UPalNetworkWorldSecurityComponent : public UActorComponent

{
}; // Size: 0xA0
class UPalNiagaraDataInterfaceSoundPlayer : public UNiagaraDataInterface

{
class UAkAudioEvent* AkEvent;
// 0x0038 (size: 0x8)
float FadeOutDuration;
// 0x0040 (size: 0x4)
}; // Size: 0x48
class UPalNoteData : public UObject

{
FName TextId_Description;
// 0x0028 (size: 0x8)
// 0x0030 (size: 0x30)
}; // Size: 0x60
class UPalNoteDataAsset : public UDataAsset

{
TMap<class FName, class UPalNoteData*> NoteDataMap;
// 0x0030 (size: 0x50)
class UPalNoteData* Find(const FName ID);

}; // Size: 0x80
class UPalObjectCollector : public UPalWorldSubsystem

{
TArray<class APalCharacter*> PalCharacter_All;
// 0x00D0 (size: 0x10)
TArray<class APalCharacter*> PalCharacter_NPC;
// 0x00E0 (size: 0x10)
TArray<class APalCharacter*> PalCharacter_Player;
// 0x00F0 (size: 0x10)
TArray<class APalMapObjectSpawnerBase*> MapObject_SpawnerBase;
// 0x0100 (size: 0x10)
TMap<class APalCharacter*, class FPalCharacterList>
NearestCharacter_FromPlayer; // 0x0110 (size: 0x50)
TArray<class APalMapObjectSpawnerBase*> NearestSpawnerBase;
// 0x0160 (size: 0x10)
TMap<class APalCharacter*, class FPalCharacterList>
CalculationNearestCharacter_FromPlayer; // 0x0170 (size: 0x50)
TArray<class APalMapObjectSpawnerBase*> CalculationNearSpawnerBase_FromPlayer;
// 0x01C0 (size: 0x10)
TArray<FVector> BaseCampLocationList;
// 0x01D0 (size: 0x10)
bool bIsUpdateBaseCamp;
// 0x01E0 (size: 0x1)
TArray<class APalMapObjectSpawnerBase*>
CalculationNearSpawnerBase_FromBaseCamp; // 0x01E8 (size: 0x10)
float NearStartDistanceForSpawnerBase;
// 0x01F8 (size: 0x4)
float NearEndDistanceForSpawnerBase;
// 0x01FC (size: 0x4)
float NearDistanceForSpawnerBaseFromBaseCamp;
// 0x0200 (size: 0x4)
}; // Size: 0x208
class UPalObjectReplicatorComponent : public UActorComponent

{
TArray<class UObject*> ReplicateObject;
// 0x00A0 (size: 0x10)
}; // Size: 0xB0
class UPalOnlineSubsystemSteam : public UObject

{
}; // Size: 0x28
class UPalOptimizeParameterSetting : public UObject

{
FPalOptimizeParameter Parameter;
// 0x0028 (size: 0x490)
}; // Size: 0x4B8
class UPalOptionReplicator : public UPalGameStateReplicatorBase

{
FPalOptionWorldSettings OptionWorldSettings;
// 0x0028 (size: 0x128)
void OnRep_OptionWorldSettings();
}; // Size: 0x150
class UPalOptionSaveGame : public USaveGame

{
FPalOptionSaveData OptionSaveData;
// 0x0028 (size: 0x180)
}; // Size: 0x1A8
class UPalOptionSubsystem : public UPalWorldSubsystem
{
FPalOptionSubsystemOnChangeKeyboardDelegate OnChangeKeyboardDelegate;
// 0x0070 (size: 0x10)
void OnChangeKeyboardDelegate(const FPalOptionKeyboardSettings& PrevSettings,
const FPalOptionKeyboardSettings& NewSettings);
FPalOptionSubsystemOnChangePadDelegate OnChangePadDelegate;
// 0x0080 (size: 0x10)
void OnChangePadDelegate(const FPalOptionPadSettings& PrevSettings, const
FPalOptionPadSettings& NewSettings);
FPalOptionSubsystemOnChangeGraphicsDelegate OnChangeGraphicsDelegate;
// 0x0090 (size: 0x10)
void OnChangeGraphicsDelegate(const FPalOptionGraphicsSettings& PrevSettings,
const FPalOptionGraphicsSettings& NewSettings);
FPalOptionSubsystemOnChangeWorldSettingsDelegate OnChangeWorldSettingsDelegate;
// 0x00A0 (size: 0x10)
void OnChangeWorldSettingsDelegate(const FPalOptionWorldSettings& PrevSettings,
const FPalOptionWorldSettings& NewSettings);
FPalOptionSubsystemOnChangeKeyConfigDelegate OnChangeKeyConfigDelegate;
// 0x00B0 (size: 0x10)
void OnChangeKeyConfigDelegate(const FPalKeyConfigSettings& PrevSettings, const
FPalKeyConfigSettings& NewSettings);
FPalOptionSubsystemOnChangeScreenRatioDelegate OnChangeScreenRatioDelegate;
// 0x00C0 (size: 0x10)
void OnChangeScreenRatioDelegate(float newRatio);
FPalOptionWorldStaticSettings OptionWorldStaticSettings;
// 0x00D0 (size: 0xF0)
FPalOptionLocalStaticSettings OptionLocalStaticSettings;
// 0x01C0 (size: 0x40)
FPalOptionWorldSettings OptionWorldSettings;
// 0x0200 (size: 0x128)
FPalOptionWorldSettings OptionWorldSettingsCache;
// 0x0328 (size: 0x128)
FPalOptionGraphicsSettings GraphicsSettings;
// 0x0450 (size: 0x54)
// 0x04A4 (size: 0x1C)
FPalOptionCommonSettings CommonSettings;
// 0x04C0 (size: 0x20)
FPalOptionKeyboardSettings KeyboardSettings;
// 0x04E0 (size: 0x10)
FPalOptionPadSettings PadSettings;
// 0x04F0 (size: 0x18)
FPalKeyConfigSettings KeyConfigSettings;
// 0x0508 (size: 0xC0)
float BaseFov;
// 0x05E8 (size: 0x4)
FString Namespace;
// 0x0600 (size: 0x10)
class UDataTable* OptionWorldPresetTable;
// 0x0618 (size: 0x8)
class UDataTable* OptionWorldModePresetTable;
// 0x0620 (size: 0x8)
class UDataTable* OptionGraphicsPresetTable;
// 0x0628 (size: 0x8)
TSubclassOf<class APalPlayerCharacter> PalPlayerCharacterClass;
// 0x0630 (size: 0x8)
void SetPadSettings(const FPalOptionPadSettings& InPadSettings);

void SetOptionWorldSettings(const FPalOptionWorldSettings&
InOptionWorldSettings);
void SetKeyConfigSettings(const FPalKeyConfigSettings& InKeyConfigSettings);
void SetKeyboardSettings(const FPalOptionKeyboardSettings& InKeyboardSettings);
void SetGraphicsSettings(const FPalOptionGraphicsSettings& InGraphicsSettings);
void SetCommonSettings(const FPalOptionCommonSettings& InCommonSettings);
void SetAudioSettings(const FPalOptionAudioSettings& InAudioSettings);
void SaveLocalSettings();
void RefreshBanList();
void OnCompletedGetBanlist(FString ResponseBody, bool bResponseOK, int32
ResponseCode);
void OnChangeWorldSettingsDelegate__DelegateSignature(const
FPalOptionWorldSettings& PrevSettings, const FPalOptionWorldSettings& NewSettings);
void OnChangeScreenRatioDelegate__DelegateSignature(float newRatio);
void OnChangePadDelegate__DelegateSignature(const FPalOptionPadSettings&
PrevSettings, const FPalOptionPadSettings& NewSettings);
void OnChangeKeyConfigDelegate__DelegateSignature(const FPalKeyConfigSettings&
PrevSettings, const FPalKeyConfigSettings& NewSettings);
void OnChangeKeyboardDelegate__DelegateSignature(const
FPalOptionKeyboardSettings& PrevSettings, const FPalOptionKeyboardSettings&
NewSettings);
void OnChangeGraphicsDelegate__DelegateSignature(const
FPalOptionGraphicsSettings& PrevSettings, const FPalOptionGraphicsSettings&
NewSettings);
void GetSupportScreenSizes(TArray<FIntPoint>& SupportResolutions,
TEnumAsByte<EWindowMode::Type> WindowMode);
FPalOptionPadSettings GetPadSettings();
FPalOptionWorldStaticSettings GetOptionWorldStaticSettings();
FPalOptionWorldSettings GetOptionWorldSettings();
FPalOptionLocalStaticSettings GetOptionLocalStaticSettings();
FPalKeyConfigSettings GetKeyConfigSettings();
FPalOptionKeyboardSettings GetKeyboardSettings();
FPalOptionGraphicsSettings GetGraphicsSettings();
FIntPoint GetGameResolution();
FPalOptionCommonSettings GetCommonSettings();
FPalOptionAudioSettings GetAudioSettings();
void ApplyWorldSettings();
void ApplyWorldPreset(FPalOptionWorldSettings& OutSettings,
EPalOptionWorldDifficulty Difficulty);
void ApplyWorldModePreset(FPalOptionWorldSettings& OutSettings, bool bIsPvP);
void ApplyGraphicsPresetByBenchMark(FPalOptionGraphicsSettings& OutSettings);
void ApplyGraphicsPreset(FPalOptionGraphicsSettings& OutSettings,
EPalOptionGraphicsLevel GraphicsLevel);
}; // Size: 0x640
class UPalOtomoAttackStopJudgeByBall : public UObject

{
bool IsProhibitAttack;
// 0x0028 (size: 0x1)
}; // Size: 0x30
class UPalOtomoAttackStopJudgeByBallList : public UObject

{
TMap<class FGuid, class UPalOtomoAttackStopJudgeByBall*> JudgeList;
// 0x0028 (size: 0x50)
void OnHitCaptureBall(class AActor* Attacker);

}; // Size: 0x78
class UPalOtomoHolderComponentBase : public UActorComponent
{
FPalOtomoHolderComponentBaseOnCreatedCharacterContainerDelegate
OnCreatedCharacterContainerDelegate; // 0x00A0 (size: 0x10)
void OnCreatedCharacterContainer();
FPalOtomoHolderComponentBaseOnUpdateOtomoSlotDelegate
OnUpdateOtomoSlotDelegate; // 0x00B0 (size: 0x10)
void UpdateOtomoSlotDelegate(int32 SlotIndex, class
FPalOtomoHolderComponentBaseOnUpdateOtomoSlotWithActorDelegate
OnUpdateOtomoSlotWithActorDelegate; // 0x00C0 (size: 0x10)
void UpdateOtomoSlotDelegate(int32 SlotIndex, class
FPalOtomoHolderComponentBaseOnUpdateOtomoSlotWithInitializedParameterDelegate
OnUpdateOtomoSlotWithInitializedParameterDelegate; // 0x00D0 (size: 0x10)
void UpdateOtomoSlotWithInitializedParameterDelegate(class APalCharacter*
Character);
FPalOtomoHolderComponentBaseOnOtomoSpawnedDelegate OnOtomoSpawnedDelegate;
// 0x00E0 (size: 0x10)
void OtomoSpawnedDelegate(class AController* HolderController, class
APalCharacter* OtomoPal);
class UPalOtomoSpawnCollisionChecker* CollisionChecker;
// 0x00F0 (size: 0x8)
// 0x00F8 (size: 0x1)
class UPalIndividualCharacterContainer* CharacterContainer;
// 0x0100 (size: 0x8)
TArray<class UPalIndividualCharacterHandle*> CreatingHandleCache;
// 0x0108 (size: 0x10)
void UpdateOtomoSlotWithInitializedParameterDelegate__DelegateSignature(class
void UpdateOtomoSlotDelegate__DelegateSignature(int32 SlotIndex, class
class UPalIndividualCharacterHandle* TryGetSpawnedOtomoHandle();
class APalCharacter* TryGetSpawnedOtomo();
class APawn* TryGetOwnerControlledPawn();
class APalCharacter* TryGetOwnerControlledCharacter();
class APalCharacter* TryGetOtomoActorBySlotIndex(const int32 SlotIndex);
void TryGetLoadedOtomoData(bool& bLoaded, TMap<class FPalInstanceID, class
FPalIndividualCharacterSaveParameter>& OutParameterMap);
class APalCharacter* TryGetCurrentSelectPalActor();
bool TryGetContainer(class UPalIndividualCharacterContainer*& Container);
void TryFixAssignNearestWorkSelectedOtomo(const class AActor* HitActor);
void Tmp_EmptySlot(const FPalCharacterSlotId& SlotID);
void SpawnOtomoByLoad(int32 SlotIndex);
void SetSelectOtomoID_Internal(int32 Index);
void SetSelectOtomoID(int32 Index);
void SetOtomoOrder_ToServer(EPalOtomoPalOrderType OrderType);
void SetInteractComponent(class AActor* SpawnPal);
void OtomoSpawnedDelegate__DelegateSignature(class AController*
HolderController, class APalCharacter* OtomoPal);
void OnUpdateSlot(class UPalIndividualCharacterSlot* Slot, class
void OnUpdateIndividualActor(class UPalIndividualCharacterHandle* LastHandle);
void OnSpawnOtomoCallback_ServerInternal(FPalInstanceID ID);
void OnSpawnDebugOtomoCallback_ServerInternal(FPalInstanceID ID);
void OnReplicated_CharacterContainer_AllSlots(class
UPalIndividualCharacterContainer* Container);
void OnRep_CharacterContainer();
void OnInitializedCharacter(class APalCharacter* Character);
void OnCreatedCharacterContainer__DelegateSignature();
void OnCreatedCharacterContainer();
void OnChangeOtomoActive(class APalCharacter* Otomo, bool IsActive);
void LostOtomoByID_ToClient(FPalInstanceID ID);
bool IsValidCurrentSelectPalActor();
bool IsRidingBySpawnSlotID();
bool IsRidingBySelectSlotID();
bool IsFullMember();
bool IsDeadSelectedOtomo();
bool IsCreatedOtomoContainer();
bool IsControlledByPlayer();
bool IsALLEmpty();
bool IsAllDeadOtomo();
bool IsActivatedSelectOtomo();
void Initialize_ServerInternal();
void Initialize();
void IncrementSelectOtomoID_Internal();
void IncrementSelectOtomoID();
void InactiveOtomoByHandle_PreProcess(class UPalIndividualCharacterHandle*
Handle);
void InactivateCurrentOtomo();
FTransform GetTransform_SpawnPalNearTrainer();
int32 GetSpawnedOtomoID();
void GetSlots(TArray<class UPalIndividualCharacterSlot*>& Slots);
int32 GetSlotIndexByIndividualHandle(const class UPalIndividualCharacterHandle*
IndividualHandle);
int32 GetSelectedOtomoID();
int32 GetPreviousOtomoSlotID();
EPalOtomoPalOrderType GetOtomoOrder();
class UPalIndividualCharacterHandle* GetOtomoIndividualHandle(const int32
SlotIndex);
class UPalIndividualCharacterSlot*
GetOtomoIndividualCharacterSlot_Internal(const int32 SlotIndex);
class UPalIndividualCharacterSlot* GetOtomoIndividualCharacterSlot(const int32
SlotIndex);
int32 GetOtomoCount();
int32 GetNextOtomoSlotID();
int32 GetMaxOtomoNum();
class APalCharacter* GetEnemyWhenOtomoThrow(FVector OtomoAppearedLocation);
class UPalIndividualCharacterSlot* GetEmptySlot();
void GetAllIndividualHandle(TArray<class UPalIndividualCharacterHandle*>&
OutArray);
void DecrementSelectOtomoID_Internal();
void DecrementSelectOtomoID();
void CoopCallCommand();
void CallCancelCommand();
bool AddOtomoHandleToFreeSlot(class UPalIndividualCharacterHandle* Handle);
void AddLogOtomoPartnerSkill_Waza_ToClient(class AActor* Otomo, EPalLogType
PalLogType);
void AddLogOtomoPartnerSkill_ToClient(class AActor* Otomo, EPalLogType
PalLogType, int32 Value, bool AddSkillName);
bool ActivateCurrentOtomoNearThePlayer();
bool ActivateCurrentOtomo(FTransform SpawnTransform);
}; // Size: 0x118
class UPalOtomoSpawnCollisionChecker : public UObject

{
FTransform GetTransform_WhenSpawnPalNearTrainer(class AActor* Trainer);

FVector GetLocation_WhenSpawnPalSphgereThrow(FHitResult Hit, class APawn*
CurrentSelectPalActor);
}; // Size: 0x30
class UPalOtomoUiBase : public UPalUserWidget

{
EPalTribeID GetTribeIDFromClass(const TSubclassOf<class AActor>&

TargetActorClass);
}; // Size: 0x408
class UPalPartnerSkillParameterComponent : public UActorComponent

{
FPalPartnerSkillParameterComponentOnOverheat OnOverheat;
// 0x00A0 (size: 0x10)
void OnOverheat();
FPalPartnerSkillParameterComponentOnCoolDownCompleted OnCoolDownCompleted;
// 0x00B0 (size: 0x10)
void OnCoolDownCompleted();
FPalPartnerSkillParameterComponentOnEffectTimeChanged OnEffectTimeChanged;
// 0x00C0 (size: 0x10)
void OnEffectTimeChanged(FFixedPoint effectTime, FFixedPoint effectTimeMax);
FPalPartnerSkillParameterComponentOnCoolDownTimeChanged OnCoolDownTimeChanged;
// 0x00D0 (size: 0x10)
void OnCoolDownTimeChanged(FFixedPoint CoolDownTime, FFixedPoint
coolDownTimeMax);
FPalPartnerSkillParameterComponentOnStart OnStart;
// 0x00E0 (size: 0x10)
void OnStart();
FPalPartnerSkillParameterComponentOnStop OnStop;
// 0x00F0 (size: 0x10)
void OnStop();
FPalPartnerSkillParameterComponentOnToggleExecute OnToggleExecute;
// 0x0100 (size: 0x10)
void OnToggleExecute(bool IsExecuting);
FPalPartnerSkillParameterComponentOnSearchEffectExecute OnSearchEffectExecute;
// 0x0110 (size: 0x10)
void OnSearchEffect();
TArray<FPalDataTableRowName_ItemData> RestrictionItems;
// 0x0120 (size: 0x10)
FName SkillName;
// 0x0130 (size: 0x8)
EPalWazaID WazaID;
// 0x0138 (size: 0x1)
FFixedPoint effectTime;
// 0x013C (size: 0x4)
FFixedPoint effectTimeMax;
// 0x0140 (size: 0x4)
FFixedPoint ExecCost;
// 0x0144 (size: 0x4)
FFixedPoint IdleCost;
// 0x0148 (size: 0x4)
FFixedPoint IdleTime;
// 0x014C (size: 0x4)
FFixedPoint CoolDownTime;
// 0x0150 (size: 0x4)
FFixedPoint coolDownTimeMax;
// 0x0154 (size: 0x4)
bool bCanThrowPal;
// 0x0158 (size: 0x1)
bool bCanChangeWeapon;
// 0x0159 (size: 0x1)
bool bIsToggleKey;
// 0x015A (size: 0x1)
bool bIdlelCostDecreaseEveryFrame;
// 0x015B (size: 0x1)
bool bIsExecSkillContinuation;
// 0x015C (size: 0x1)
bool bIsRunning;
// 0x015D (size: 0x1)
bool bIsOverheat;
// 0x015E (size: 0x1)
bool bIsExecuting;
// 0x015F (size: 0x1)
class UPalCoopSkillModuleBase* SkillModule;
// 0x0160 (size: 0x8)
TArray<FPalPassivePartnerSkillIdAndParameters> PassiveSkills;
// 0x0168 (size: 0x10)
FPalPartnerSkillParameterRide RideParameter;
// 0x0178 (size: 0x8)
TSubclassOf<class APalFunnelCharacter> FunnelCharacterClass;
// 0x0180 (size: 0x8)
TSubclassOf<class APalAIController> FunnelControllerClass;
// 0x0188 (size: 0x8)
EPalWazaID FunnelAttackWazaID;
// 0x0190 (size: 0x1)
class UPalPartnerSkillPassiveSkill* PassiveSkill;
// 0x0198 (size: 0x8)
FName ActiveSkill_MainValue_Overview_EditorOnly;
// 0x01F0 (size: 0x8)
TArray<float> ActiveSkill_MainValueByRank;
// 0x01F8 (size: 0x10)
void Stop();
void Start();
void SetName(FName Name);
void SetDisableFlagsBySetting(bool isDisable);
void SetCoopFlag_ForServer(bool IsCoop);
void Recover();
void OnToggleExecute__DelegateSignature(bool IsExecuting);
void OnStop__DelegateSignature();
void OnStart__DelegateSignature();
void OnSearchEffect__DelegateSignature();
void OnOwnerCharacterSpawned(FPalInstanceID ID);
void OnOverheat__DelegateSignature();
void OnInactivatedAsPartner();
void OnExec();
void OnEffectTimeChanged__DelegateSignature(FFixedPoint effectTime, FFixedPoint
effectTimeMax);
void OnCoolDownTimeChanged__DelegateSignature(FFixedPoint CoolDownTime,
FFixedPoint coolDownTimeMax);
void OnCoolDownCompleted__DelegateSignature();
void OnComplated();
void OnActivatedAsPartner();
bool IsToggleKey();
bool IsRunning();
bool IsRestrictedByItems(class AActor* Trainer);
bool IsOverheat();
bool IsExistActiveSkill();
bool IsCoolDown();
float GetWazaPowerRate(EPalWazaID Waza);
FName GetSkillName();
void GetRideParameter(FPalPartnerSkillParameterRide& OutParam);
TArray<FPalDataTableRowName_ItemData> GetRestrictionItems();
FFixedPoint GetMainDamage();
float GetEffectTimeRatio();
FFixedPoint GetEffectTimeMax();
FFixedPoint GetEffectTime();
float GetCoolDownTimeRatio();
FFixedPoint GetCoolDownTimeMax();
FFixedPoint GetCoolDownTime();
float GetActiveSkillMainValueByRank();
void ForceOverheat();
void ExecDuring(float DeltaTime);
class UPalCoopSkillModuleBase* CreateSkillModule(TSubclassOf<class
UPalCoopSkillModuleBase> SkillModuleClass);
bool CanExec();
bool CanChangeWeapon();
void CallOnToggleExecute_ToAll(bool Execute);
void CallOnStop_ToAll();
void CallOnStartSearchEffect_ToAll(const FGuid& RequestPlayerUId, const
FPalCoopSkillSearchEffectParameter& EffectParam);
void CallOnStart_ToAll();
void CallOnOverheat_ToAll();
void CallOnEffectTimeChanged_ToAll(FFixedPoint effectTime, FFixedPoint
effectTimeMax);
void CallOnCoolDownTimeChanged_ToAll(FFixedPoint CoolDownTime, FFixedPoint
coolDownTimeMax);
void CallOnCoolDownCompleted_ToAll();
}; // Size: 0x208
class UPalPartnerSkillPassiveSkill : public UObject

{
FPalPartnerSkillPassiveSkillIsRestrictedDelegate IsRestrictedDelegate;
// 0x0028 (size: 0x10)
bool IsRestricted(class AActor* Trainer);
bool isReserving;
// 0x0038 (size: 0x1)
bool bIsRestricted;
// 0x0039 (size: 0x1)
bool bRequireWorkerWorkingPassiveSkill;
// 0x003A (size: 0x1)
bool bIsWorking;
// 0x003B (size: 0x1)
TArray<FPalPassivePartnerSkillIdAndParameters> PassiveSkills;
// 0x0040 (size: 0x10)
FPalPassivePartnerSkillStatus> SkillStatus; // 0x0050 (size: 0x50)
int32 CurrentRank;
// 0x00A0 (size: 0x4)
void OnWorkerAssignChanged(class UPalCharacterParameterComponent* Parameter);

void OnUpdateOtomoHolder(class APalCharacter* Character);
void OnUpdateInventoryContainer();
void OnReserveInactivated();
void OnReserveActivated();
void OnInactivatedAsOtomo();
void OnActivatedAsOtomo();
void ObserveWorking();
bool IsRestricted__DelegateSignature(class AActor* Trainer);
bool IsRestricted();
void Initialize(const TArray<FPalPassivePartnerSkillIdAndParameters>&
_PassiveSkills);
void InactivateWorkingSkill();
class APalPlayerController* GetTrainerController();
class APalCharacter* GetTrainerActor();
class ACharacter* GetTrainer();
int32 GetOtomoRank();
}; // Size: 0xF8
class UPalPassiveSkillComponent : public UActorComponent

{
FPalPassiveSkillComponentOnStartSkillEffectDelegate OnStartSkillEffectDelegate;
// 0x00A0 (size: 0x10)
void OnStartSkillEffect(EPalPassiveSkillEffectType EffectType, float Value);
FPalPassiveSkillComponentOnChangeSkillEffectValueDelegate
OnChangeSkillEffectValueDelegate; // 0x00B0 (size: 0x10)
void OnChangeSkillEffectValue(EPalPassiveSkillEffectType EffectType, float
Value);
FPalPassiveSkillComponentOnEndSkillEffectDelegate OnEndSkillEffectDelegate;
// 0x00C0 (size: 0x10)
void OnEndSkillEffect(EPalPassiveSkillEffectType EffectType);
TArray<FPalPassiveSkillEffectInfos> SkillInfos;
// 0x0120 (size: 0x10)
TArray<FPalPassiveSkillEffectInfos> SkillInfosMirror;
// 0x0130 (size: 0x10)
TMap<class EPalPassiveSkillEffectType, class EPalStatusID> SkillStatusMap;
// 0x0140 (size: 0x50)
void SetupSkillFromSelf(class UObject* OwnerObject, const TArray<FName>&

skillList);
void OverrideDamageInfoBySkill(FPalDamageInfo& inoutDamageInfo);
void OnStartSkillEffect__DelegateSignature(EPalPassiveSkillEffectType
EffectType, float Value);
void OnStartSkillEffect(EPalPassiveSkillEffectType EffectType, float Value);
void OnRep_SkillInfos();
void OnEndSkillEffect__DelegateSignature(EPalPassiveSkillEffectType
EffectType);
void OnEndSkillEffect(EPalPassiveSkillEffectType EffectType);
void OnChangeSkillEffectValue__DelegateSignature(EPalPassiveSkillEffectType
EffectType, float Value);
void OnChangeSkillEffectValue(EPalPassiveSkillEffectType EffectType, float
Value);
void AddSpecialAttackRateInfo(TArray<FPalSpecialAttackRateInfo>&
SpecialAttackRateInfos);
}; // Size: 0x1E0
class UPalPassiveSkillManager : public UObject

{
class UDataTable* PassiveSkillDataTable;
// 0x0028 (size: 0x8)
TMap<class FName, class FPalPassiveSkillDatabaseRow> PalAssignableSkillMap;
// 0x0030 (size: 0x50)
TMap<class FName, class FPalPassiveSkillDatabaseRow> RarePalAssignableSkillMap;
// 0x0080 (size: 0x50)
TMap<class FName, class FPalPassiveSkillDatabaseRow>
RangedWeaponAssignableSkillMap; // 0x00D0 (size: 0x50)
MeleeWeaponAssignableSkillMap; // 0x0120 (size: 0x50)
TMap<class FName, class FPalPassiveSkillDatabaseRow> ArmorAssignableSkillMap;
// 0x0170 (size: 0x50)
AccessoryAssignableSkillMap; // 0x01C0 (size: 0x50)
void OnCreatedDynamicItemDataInServer(class UPalDynamicItemDataBase*

CreatedItemData, const FPalItemCreateParameter& CreateParameter);
TArray<EPalPassiveSkillEffectType> GetSkillEffectTypes(FName SkillName);
bool GetSkillData(const FName& SkillName, FPalPassiveSkillDatabaseRow&
outSkillData);
TArray<FName> GetPassiveSkillNamesRowName(const TArray<FName>& passiveList);
TArray<FPalPassiveSkillEffect> GetPassiveSkillEffect(const FName& SkillName,
bool bTargetToSelf);
float GetParameterWithSkillEffect(float originalValue,
EPalPassiveSkillEffectType EffectType, const TArray<FPalPassiveSkillEffect>&
skillEffectList);
FName GetNameTextId(FName SkillName);
}; // Size: 0x210
class UPalPersistentSoundPlayer : public UObject

{
class UAkAudioEvent* AudioEvent;
// 0x0028 (size: 0x8)
int32 FadeDuration;
// 0x0030 (size: 0x4)
TWeakObjectPtr<class AActor> PlayActor;
// 0x0038 (size: 0x8)
}; // Size: 0x40
class UPalPettingPresset : public UObject

{
FPalPettingParameter SmallPreset;
// 0x0028 (size: 0xC)
FPalPettingParameter SmallMiddlePreset;
// 0x0034 (size: 0xC)
FPalPettingParameter MediumPreset;
// 0x0040 (size: 0xC)
FPalPettingParameter LargePreset;
// 0x004C (size: 0xC)
float GetDistance(class AActor* Pal);

float GetCameraHeight(class AActor* Pal);
float GetCameraCenterDistance(class AActor* Pal);
float GetCameraArmLength(class AActor* Pal);
}; // Size: 0x58
class UPalPhysicsDefine : public UObject

{
}; // Size: 0x28
class UPalPhysicsUtility : public UBlueprintFunctionLibrary

{
void SetCanEverAffectNavigation(class UActorComponent* Component, bool

bAffect);
}; // Size: 0x28
class UPalPlayerAccount : public UObject

{
FGuid PlayerUId;
// 0x0028 (size: 0x10)
EPalPlayerAccountState State;
// 0x0038 (size: 0x1)
// 0x0040 (size: 0x8)
FTransform LastSavedTransform;
// 0x0050 (size: 0x60)
class UPalPlayerOtomoData* OtomoData;
// 0x00B0 (size: 0x8)
class UPalPlayerDataCharacterMake* CharacterMakeData;
// 0x00B8 (size: 0x8)
class UPalPlayerInventoryData* InventoryData;
// 0x00C0 (size: 0x8)
class UPalPlayerDataPalStorage* PalStorage;
// 0x00C8 (size: 0x8)
class UPalTechnologyData* TechnologyData;
// 0x00D0 (size: 0x8)
class UPalPlayerRecordData* RecordData;
// 0x00D8 (size: 0x8)
// 0x00E0 (size: 0x1)
}; // Size: 0xF0
class UPalPlayerBattleSituation : public UObject

{
FPalPlayerBattleSituationOnBattleRankDownDelegate OnBattleRankDownDelegate;
// 0x0028 (size: 0x10)
void OnBattleRankDownDelegate(EPalPlayerBattleFinishType FinishType);
FPalPlayerBattleSituationOnEnemyAddRemoveDelegate OnEnemyAddRemoveDelegate;
// 0x0038 (size: 0x10)
void OnEnemyAddRemoveDelegate(EPalBattleBGMType Rank, bool IsAdd);
FPalPlayerBattleSituationOnChangeNearEnemyDelegate OnChangeNearEnemyDelegate;
// 0x0048 (size: 0x10)
void OnChangeNearEnemyDelegate(bool IsNearExist);
TMap<class FPalInstanceID, class FPalPlayerBattleEnemyInfo> BattleEnemyList;
// 0x0058 (size: 0x50)
bool IsNearCommonEnemy;
// 0x00A8 (size: 0x1)
float NearDistanceSqr;
// 0x00AC (size: 0x4)
FTimerHandle DistanceUpdateTimerHandle;
// 0x00B0 (size: 0x8)
}; // Size: 0xB8
class UPalPlayerDamageCamShakeRegulator : public UObject

{
class UDataTable* DamageCameraShakeTable;
// 0x0028 (size: 0x8)
}; // Size: 0x30
class UPalPlayerDataCharacterMake : public UObject

{
FName GetRandomHeadMeshName();
FName GetRandomHairMeshName();
FName GetRandomBodyMeshName();
void GetPresetMakeInfo(class UObject* WorldContextObject, const FName&
PresetName, FPalPlayerDataCharacterMakeInfo& OutMakeInfo);
FPalPlayerDataCharacterMakeInfo GetMakeData();
}; // Size: 0xC0
class UPalPlayerDataPalStorage : public UObject

{
int32 PageNum;
// 0x0028 (size: 0x4)
int32 SlotNumInPage;
// 0x002C (size: 0x4)
class UPalIndividualCharacterContainer* TargetContainer;
// 0x0030 (size: 0x8)
class UPalIndividualCharacterSlotsObserver* SlotObserver;
// 0x0038 (size: 0x8)
// 0x0040 (size: 0x10)
bool IsOpen;
// 0x0050 (size: 0x1)
void OnUpdateCharacterContainer_InServer();
void GetSlotsInPage(const int32 PageIndex, TArray<class
UPalIndividualCharacterSlot*>& Slots);
class UPalIndividualCharacterSlot* GetSlot(const int32 PageIndex, const int32
SlotIndex);
}; // Size: 0x58
class UPalPlayerDataStorage : public UObject

{
class UPalPlayerDataPalStorage* GetPalStorage();

void GetInventoryInfo(FPalPlayerDataInventoryInfo& outInventoryInfo);
class UPalItemContainerMultiHelper* GetInventoryContainers();
}; // Size: 0x28
class UPalPlayerGenderChanger : public UObject

{
FPlayerGenderParams MaleCharacterParams;
// 0x0028 (size: 0xA8)
FPlayerGenderParams FemaleCharacterParams;
// 0x00D0 (size: 0xA8)
bool bIsEpmtyFamaleParams;
// 0x0178 (size: 0x1)
bool bIsFamale;
// 0x0179 (size: 0x1)
}; // Size: 0x180
class UPalPlayerHeadAnimInstance : public UAnimInstance

{
FVector PlayerEyeLocationRight;
// 0x0348 (size: 0x18)
FVector PlayerEyeLocationLeft;
// 0x0360 (size: 0x18)
void SetPlayerEyeLocation(class USkeletalMesh* HeadMesh);

}; // Size: 0x380
class UPalPlayerInput : public UPlayerInput

{
FPalPlayerInputOnKeyConfigChanged OnKeyConfigChanged;
// 0x0498 (size: 0x10)
void OnKeyConfigChangedDelegate();
TSet<FKey> EnableKeys;
// 0x04A8 (size: 0x50)
TSet<FKey> DisableKeys;
// 0x04F8 (size: 0x50)
bool UpdateActionMapping(const FName InActionName, const FPalKeyConfigKeys&

NewKey, EPalKeyConfigCategory Category);
void ResetAxisKey(const FName InAxisName, EPalKeyConfigCategory Category,
EPalKeyConfigAxisFilterType FilterType);
void ResetActionKey(const FName InActionName, EPalKeyConfigCategory Category);
void OnKeyConfigChangedDelegate__DelegateSignature();
void OnChangeKeyConfig(const FPalKeyConfigSettings& PrevSettings, const
FPalKeyConfigSettings& NewSettings);
bool IsEnableKey(FKey Key, EPalKeyConfigCategory InputType);
void GetAxisMappingByName(const FName InAxisName, TArray<FInputAxisKeyMapping>&
OutMappings);
FPalKeyConfigKeys GetAxisConfigKeys(const FName InAxisName,
EPalKeyConfigCategory Category, EPalKeyConfigAxisFilterType FilterType);
void GetActionMappingByName(const FName InActionName,
TArray<FInputActionKeyMapping>& OutMappings);
FPalKeyConfigKeys GetActionConfigKeys(const FName InActionName,
EPalKeyConfigCategory Category);
void FiltterCategoryAxisMappings(EPalKeyConfigCategory Category,
EPalKeyConfigAxisFilterType FilterType, TArray<FInputAxisKeyMapping>& Mappings);
void FiltterCategoryActionMappings(EPalKeyConfigCategory Category,
TArray<FInputActionKeyMapping>& Mappings);
}; // Size: 0x548
class UPalPlayerInventory : public UPalItemInventoryBase
{
}; // Size: 0x28
class UPalPlayerInventoryData : public UObject

{
FPalPlayerInventoryDataOnUpdateInventoryContainerDelegate
OnUpdateInventoryContainerDelegate; // 0x0030 (size: 0x10)
void UpdateInventoryContainerDelegate(class UPalItemContainer* Container);
FPalPlayerInventoryDataOnUpdateEssentialContainerDelegate
OnUpdateEssentialContainerDelegate; // 0x0040 (size: 0x10)
void UpdateEssentialContainerDelegate(class UPalItemContainer* Container);
FPalPlayerInventoryDataOnUpdateLoadoutSlotDelegate OnUpdateLoadoutSlotDelegate;
// 0x0050 (size: 0x10)
void UpdateLoadoutSlotDelegate(class UPalItemSlot* itemSlot,
EPalPlayerInventoryType updatedLoadoutType);
FPalPlayerInventoryDataOnUpdateEquipmentSlotDelegate
OnUpdateEquipmentSlotDelegate; // 0x0060 (size: 0x10)
void UpdateEquipmentSlotDelegate(class UPalItemSlot* itemSlot,
FPalPlayerInventoryDataOnUpdateWeightInventoryDelegate
OnUpdateWeightInventoryDelegate; // 0x0070 (size: 0x10)
void UpdateWeightInventoryDelegate(float nowWeight);
FPalPlayerInventoryDataOnUpdateMaxWeightInventoryDelegate
OnUpdateMaxWeightInventoryDelegate; // 0x0080 (size: 0x10)
void UpdateMaxWeightInventoryDelegate(float maxWeight);
FPalPlayerInventoryDataOnOverWeightInventoryDelegate
OnOverWeightInventoryDelegate; // 0x0090 (size: 0x10)
void OverWeightInventoryDelegate(float nowWeight);
FPalPlayerInventoryDataOnFixedInventoryWeightDelegate
OnFixedInventoryWeightDelegate; // 0x00A0 (size: 0x10)
void FixedWeightInventoryDelegate(float nowWeight);
FPalPlayerInventoryDataOnMaxWeightBuffedDelegate OnMaxWeightBuffedDelegate;
// 0x00B0 (size: 0x10)
void MaxWeightBuffedDelegate();
FPalPlayerInventoryDataOnPickupItemDelegate OnPickupItemDelegate;
// 0x00C0 (size: 0x10)
void PickupItemDelegate(TArray<FPalItemAndNum>& ItemInfos);
FPalPlayerInventoryDataOnGetItemFromConvertItemMapObject
OnGetItemFromConvertItemMapObject; // 0x00D0 (size: 0x10)
void PickupItemDelegate(TArray<FPalItemAndNum>& ItemInfos);
FPalPlayerDataInventoryInfo inventoryInfo;
// 0x00E0 (size: 0x60)
FTimerHandle FullInventoryLogGuardTimerHandle;
// 0x0148 (size: 0x8)
float NowItemWeight;
// 0x0150 (size: 0x4)
float maxInventoryWeight;
// 0x0154 (size: 0x4)
float maxInventoryWeight_Cached;
// 0x0158 (size: 0x4)
class UPalItemContainerMultiHelper* InventoryMultiHelper;
// 0x0160 (size: 0x8)
float PassiveBuffedMaxWeight;
// 0x0168 (size: 0x4)
// 0x016C (size: 0x10)
class UPalMoneyData* moneyData;
// 0x0180 (size: 0x8)
class UAkAudioEvent* EquipmentBreakAudioEvent;
// 0x0188 (size: 0x8)
void UpdateWeightInventoryDelegate__DelegateSignature(float nowWeight);

void UpdateMaxWeightInventoryDelegate__DelegateSignature(float maxWeight);
void UpdateLoadoutSlotDelegate__DelegateSignature(class UPalItemSlot* itemSlot,
EPalPlayerInventoryType updatedLoadoutType);
void UpdateInventoryContainerDelegate__DelegateSignature(class
UPalItemContainer* Container);
void UpdateEssentialContainerDelegate__DelegateSignature(class
UPalItemContainer* Container);
void UpdateEquipmentSlotDelegate__DelegateSignature(class UPalItemSlot*
itemSlot, EPalPlayerEquipItemSlotType slotType);
bool TryRemoveEquipment(class UPalItemSlot* EquipSlot);
bool TryGetItemSlotFromEquipmentType(EPalPlayerEquipItemSlotType
equipmentSlotType, class UPalItemSlot*& outSlot);
bool TryGetItemIdBySlot(EPalPlayerEquipItemSlotType equipmentSlotType,
FPalItemId& outItemId);
EPalPlayerEquipItemSlotType TryGetEquipmentTypeFromStaticItemID(const FName&
StaticItemId);
bool TryGetEquipmentContainerIDFromStaticItemID(const FName& StaticItemId,
FPalContainerId& outContainerId);
bool TryGetEmptySlot(EPalPlayerInventoryType inventoryType, class
UPalItemSlot*& emptySlot);
bool TryGetContainerIdFromItemType(EPalItemTypeA itemTypeA, FPalContainerId&
outContainerId);
bool TryGetContainerIDFromInventoryType(const EPalPlayerInventoryType
inventoryType, FPalContainerId& outContainerId);
bool TryGetContainerFromStaticItemID(const FName& StaticItemId, class
UPalItemContainer*& OutContainer);
bool TryGetContainerFromInventoryType(const EPalPlayerInventoryType
inventoryType, class UPalItemContainer*& OutContainer);
bool TryEquipSlot(class UPalItemSlot* Slot);
void RequestTrashItemFromDropSlot_ServerInternal();
void RequestTrashItemFromDropSlot();
void RequestSortInventory_ServerInternal();
void RequestSortInventory();
void RequestFillSlotToTargetContainerFromInventory_ToServer(const
FPalContainerId& ToContainerId);
void RequestFillSlotToInventoryFromTargetContainer_ToServer(const
FPalContainerId& FromContainerId);
void RequestDropItemFromDropSlot_ServerInternal();
void RequestDropItemFromDropSlot();
void RequestAddItem(const FName StaticItemId, const int32 Count, bool
isAssignPassive);
void PickupItemDelegate__DelegateSignature(TArray<FPalItemAndNum>& ItemInfos);
void OverWeightInventoryDelegate__DelegateSignature(float nowWeight);
void OnUpdateLoadoutSlot(class UPalItemSlot* Slot);
void OnUpdateEssentialContainer(class UPalItemContainer* Container);
void OnUpdateEquipmentSlot_ForServer(class UPalItemSlot* Slot);
void OnUpdateEquipmentSlot(class UPalItemSlot* Slot);
void OnUpdateAnyEquipmentDurability(float OldDurability, float NewDurability);
void OnRep_maxInventoryWeight();
void OnRep_InventoryInfo();
void OnRep_BuffMaxWeight();
void OnOnUpdateStatusPoint(FName StatusName, int32 prevPoint, int32 newPoint);
void MaxWeightBuffedDelegate__DelegateSignature();
bool IsExistItem(const FName& StaticItemId);
bool IsEquipSlot(class UPalItemSlot* CheckSlot);
bool IsEquip(EPalPlayerEquipItemSlotType equipmentSlotType, const FName&
StaticItemId);
int32 GetUnlockedFoodEquipSlotNum();
float GetNowItemWeight();
void GetItemInfoByItemTypeA(TArray<EPalItemTypeA> itemTypeA,
TArray<FPalItemAndNum>& OutItemInfos);
EPalPlayerInventoryType GetInventoryTypeFromStaticItemID(const FName&
StaticItemId);
EPalPlayerInventoryType GetInventoryTypeFromItemTypeA(const EPalItemTypeA
itemTypeA);
void FixedWeightInventoryDelegate__DelegateSignature(float nowWeight);
int32 CountItemNum(const FName& StaticItemId);
bool CanEquip(EPalPlayerEquipItemSlotType equipmentSlotType, const FName&
StaticItemId);
EPalItemOperationResult AddItem_ServerInternal(const FName StaticItemId, const
int32 Count, bool isAssignPassive);
void AddFullInventoryLog_Client();
}; // Size: 0x190
class UPalPlayerLocalRecordData : public UObject

{
TMap<EPalTribeID, int32> Local_ActivateOtomoCount;
// 0x0028 (size: 0x50)
TMap<class EPalTribeID, class bool> Local_PalEncountFlag;
// 0x0078 (size: 0x50)
TMap<class EPalTribeID, class bool> Local_PalDexNewFlag;
// 0x00C8 (size: 0x50)
TMap<class FName, class bool> Local_NoteCheckedFlag;
// 0x0118 (size: 0x50)
TMap<EPalPlayerInventoryType, int32> Local_LoadoutSelectedIndexMap;
// 0x0168 (size: 0x50)
TMap<FName, int32> Local_NewUnlockedBuilds;
// 0x01B8 (size: 0x50)
bool Local_IsBuildMenuChecked;
// 0x0208 (size: 0x1)
TMap<FName, int32> Local_NPCTalkCountMap;
// 0x0210 (size: 0x50)
TMap<class FName, class bool> Local_NewUnlockedTechs;
// 0x0260 (size: 0x50)
TMap<class FName, class bool> Local_ShowedCutsceneFlag;
// 0x02B0 (size: 0x50)
int32 Local_PlayTime;
// 0x0300 (size: 0x4)
}; // Size: 0x308
class UPalPlayerManager : public UPalWorldSubsystem

{
FPalPlayerClassStructSet PlayerClassStructSet;
// 0x0088 (size: 0x28)
TMap<class FGuid, class UPalPlayerAccount*> PlayerAccountMap;
// 0x00B0 (size: 0x50)
TMap<class FGuid, class UPalLoginPlayer*> LoginPlayerMap;
// 0x0100 (size: 0x50)
}; // Size: 0x150
class UPalPlayerMenuUI : public UUserWidget

{
FPalItemSlotId SelectItemSlot;
// 0x0278 (size: 0x14)
bool IsDraging;
// 0x028C (size: 0x1)
void SetSelectedItemSlot(FPalItemSlotId SelectSlot);

void SetIsDraging(bool Draging);
void OpenWidget(TSubclassOf<class UUserWidget> WidgetClass, class UUserWidget*&
OutWidget, int32& ZOrder);
void OpenInventoryMenu();
void OpenChestMenu(class UPalItemContainer* ChestContainer);
void InitBindAxis();
FPalItemSlotId GetSelectedItemSlot();
bool GetIsDragingt();
void CreateDragWidget(FPalItemSlotId SlotID);
void CloseInventoryMenu();
void CloseChestMenu(class UPalItemContainer* ChestContainer);
void BackOneWidget();
void AddMouseYawInput(float Val);
void AddMousePitchInput(float Val);
}; // Size: 0x290
class UPalPlayerMenuUIManager : public UObject

{
class UPalPlayerMenuUI* PlayerMenuUI;
// 0x0040 (size: 0x8)
void ToggleInventoryWindow();
void Test_SetPlayerContainerID(const FPalContainerId& ContainerId);
FPalContainerId Test_GetPlayerContainerID();
void SelectItem(FPalItemSlotId SelectSlot);
}; // Size: 0x48
class UPalPlayerOtomoData : public UObject

{
FPalContainerId OtomoCharacterContainerId;
// 0x0028 (size: 0x10)
// 0x0038 (size: 0x1)
}; // Size: 0x40
class UPalPlayerPartyPalHolder : public UObject

{
class UPalIndividualCharacterHandle* FirstOtomoPal;
// 0x0028 (size: 0x8)
class UPalIndividualCharacterHandle* SecondOtomoPal;
// 0x0030 (size: 0x8)
TArray<class UPalIndividualCharacterHandle*> BenchMember;
// 0x0038 (size: 0x10)
float FirstCoolTimer;
// 0x0048 (size: 0x4)
float SecondCoolTimer;
// 0x004C (size: 0x4)
float CoolDownTime;
// 0x0050 (size: 0x4)
void UpdateCoolTimer(float DeltaTime);

void Test_SetClassArray(TArray<class TSubclassOf<APalCharacter>>
MonsterClassArray);
void SetUpPartyHolder(float CoolDownTime_Second);
void RestartCoolTime(bool SecondPal);
bool PawnOtmoIsPartyOtomo(bool SecondPal, class UPalIndividualCharacterHandle*
IDHandle);
bool IsUsableCommandSkill(bool SecondPal);
void GetPartyMember(TArray<class UPalIndividualCharacterHandle*>&
OutPartyMember);
class UPalIndividualCharacterHandle* GetOtomoPal(bool SecondPal);
float GetCoolTimeRate(bool SecondPal);
void ChangePalSlot(bool SecondPal);
}; // Size: 0x58
class UPalPlayerRecordData : public UObject

{
FPalPlayerRecordDataOnRelicNumUpdate OnRelicNumUpdate;
// 0x0028 (size: 0x10)
void OnRelicNumUpdateDelegate();
FPalPlayerRecordDataOnRelicNumAdd OnRelicNumAdd;
// 0x0038 (size: 0x10)
void OnRelicNumAddedDelegate(int32 AddNum);
TArray<TSoftClassPtr<UPalPlayerRecordDataTrigger>> RecordDataTriggerClassArray;
// 0x0048 (size: 0x10)
TArray<class UPalPlayerRecordDataTrigger*> RecordDataTriggerArray;
// 0x0058 (size: 0x10)
// 0x0068 (size: 0x10)
FPalPlayerRecordDataRepInfoArray_BoolVal TowerBossDefeatFlag;
// 0x0078 (size: 0x178)
FPalPlayerRecordDataRepInfoArray_BoolVal NormalBossDefeatFlag;
// 0x01F0 (size: 0x178)
int32 BossDefeatCount;
// 0x0368 (size: 0x4)
int32 TribeCaptureCount;
// 0x036C (size: 0x4)
FPalPlayerRecordDataRepInfoArray_IntVal PalCaptureCount;
// 0x0370 (size: 0x178)
FPalPlayerRecordDataRepInfoArray_BoolVal PaldeckUnlockFlag;
// 0x04E8 (size: 0x178)
// 0x0660 (size: 0x4)
// 0x0664 (size: 0x4)
// 0x0668 (size: 0x4)
FPalPlayerRecordDataRepInfoArray_BoolVal RelicObtainForInstanceFlag;
// 0x0670 (size: 0x178)
int32 RelicPossessNum;
// 0x07E8 (size: 0x4)
int32 RelicPossessNumMirror;
// 0x07EC (size: 0x4)
FPalPlayerRecordDataRepInfoArray_BoolVal NoteObtainForInstanceFlag;
// 0x07F0 (size: 0x178)
FPalPlayerRecordDataRepInfoArray_BoolVal FastTravelPointUnlockFlag;
// 0x0968 (size: 0x178)
FPalStageInstanceId EnteringStageInstanceId;
// 0x0AE0 (size: 0x14)
TArray<FGuid> BuildingObjectMapObjectInstanceIds;
// 0x0AF8 (size: 0x10)
FString Debug_EnteringStageDataLayerName;
// 0x0B08 (size: 0x10)
FString Debug_LastEnteredStageDataLayerName;
// 0x0B18 (size: 0x10)
void OnRep_RelicNum();
void OnRelicNumUpdateDelegate__DelegateSignature();
void OnRelicNumAddedDelegate__DelegateSignature(int32 AddNum);
void OnCompleteBuild_ServerInternal(class UPalMapObjectModel* MapObjectModel);
}; // Size: 0xB28
class UPalPlayerRecordDataInternals : public UObject

{
}; // Size: 0x28
class UPalPlayerRecordDataTrigger : public UObject

{
}; // Size: 0x28
class UPalPlayerRecordDataUtility : public UBlueprintFunctionLibrary

{
void SetRecordData_TribeIdFlag_ForServer(const class UObject*

WorldContextObject, FPalPlayerRecordDataRepInfoArray_BoolVal& RecordData, const
EPalTribeID Key);
void SetRecordData_TribeIdCount_ForServer(const class UObject*
WorldContextObject, FPalPlayerRecordDataRepInfoArray_IntVal& RecordData, const
EPalTribeID Key, const int32 Value);
void SetRecordData_Int_ForServer(const class UObject* WorldContextObject,
FPalPlayerRecordDataRepInfoArray_IntVal& RecordData, const FName Key, const int32
Value);
void SetRecordData_BossDefeat_ForServer(const class UObject*
WorldContextObject, FPalPlayerRecordDataRepInfoArray_BoolVal& RecordData, const
EPalBossType Key);
void SetRecordData_Bool_ForServer(const class UObject* WorldContextObject,
FPalPlayerRecordDataRepInfoArray_BoolVal& RecordData, const FName Key, const bool
bValue);
bool GetRecordData_TribeIdFlag(const FPalPlayerRecordDataRepInfoArray_BoolVal&
RecordData, const EPalTribeID Key);
int32 GetRecordData_TribeIdCount(const FPalPlayerRecordDataRepInfoArray_IntVal&
RecordData, const EPalTribeID Key);
int32 GetRecordData_Int(const FPalPlayerRecordDataRepInfoArray_IntVal&
RecordData, const FName Key);
int32 GetRecordData_BossDefeat(const FPalPlayerRecordDataRepInfoArray_BoolVal&
RecordData, const EPalBossType Key);
int32 GetRecordData_BoolCount(const FPalPlayerRecordDataRepInfoArray_BoolVal&
RecordData);
bool GetRecordData_Bool(const FPalPlayerRecordDataRepInfoArray_BoolVal&
RecordData, const FName Key);
}; // Size: 0x28
class UPalPlayerUtility : public UBlueprintFunctionLibrary

{
void WritePlayerGrappling(FPalNetArchive& Blackboard, const FVector&

HitLocatoin, const FVector& MoveEndLocation, const float& Speed);
void WritePlayerFeedItemTo(FPalNetArchive& Blackboard, const FPalItemSlotId&
itemSlotId, const int32& itemNum);
void ReadPlayerGrappling(const FPalNetArchive& Blackboard, FVector&
HitLocatoin, FVector& MoveEndLocation, float& Speed);
void ReadPlayerFeedItemTo(const FPalNetArchive& Blackboard, FPalItemSlotId&
itemSlotId, int32& itemNum);
}; // Size: 0x28
class UPalPoseableMeshComponent : public USkeletalMeshComponent

{
void SetBoneTransformByName(FName BoneName, const FTransform& InTransform,

TEnumAsByte<EBoneSpaces::Type> BoneSpace);
void SetBoneScaleByName(FName BoneName, FVector InScale3D,
void SetBoneRotationByName(FName BoneName, FRotator InRotation,
void SetBoneLocationByName(FName BoneName, FVector InLocation,
void ResetBoneTransformByName(FName BoneName);
FTransform GetBoneTransformByName(FName BoneName,
FVector GetBoneScaleByName(FName BoneName, TEnumAsByte<EBoneSpaces::Type>
BoneSpace);
FRotator GetBoneRotationByName(FName BoneName, TEnumAsByte<EBoneSpaces::Type>
BoneSpace);
FVector GetBoneLocationByName(FName BoneName, TEnumAsByte<EBoneSpaces::Type>
BoneSpace);
void CopyPoseFromSkeletalComponent(class USkeletalMeshComponent*
InComponentToCopy);
}; // Size: 0x1130
class UPalPrimaryGameLayoutBase : public UPrimaryGameLayout

{
void ShowLiftIcon();
void ShowFocusCursor(class UWidget* TargetWidget);
void ShowCommonReward(const FPalUICommonRewardDisplayData& RewardDisplayData);
void ShowCommonItemInfo(const FPalUICommonItemInfoDisplayData& DisplayData);
void SetupLiftIcon();
void HideLiftIcon();
void HideFocusCursor();
void HideCommonItemInfo();
void FadeOut(EPalFadeWidgetLayerType LayerType);
void FadeIn(EPalFadeWidgetLayerType LayerType, class
UPalHUDDispatchParameter_FadeWidget* FadeParameter);
}; // Size: 0x308
class UPalProceduralFoliageComponent : public UProceduralFoliageComponent

{
class UShapeComponent* SpawningShape;
// 0x00C8 (size: 0x8)
}; // Size: 0xD0
class UPalProgressBar : public UProgressBar

{
void SetFillImage(const FSlateBrush& NewImage);
}; // Size: 0x440
class UPalQuestBlock : public UObject

{
FPalQuestBlockOnUpdatedBlockDelegate OnUpdatedBlockDelegate;
// 0x0028 (size: 0x10)
void UpdatedBlockDelegate(class UPalQuestBlock* UpdatedQuestBlock);
FPalQuestBlockOnCompletedBlockDelegate OnCompletedBlockDelegate;
// 0x0038 (size: 0x10)
void CompletedBlockDelegate(class UPalQuestBlock* CompletedQuestBlock);
bool IsAutoComplete;
// 0x0048 (size: 0x1)
void UpdatedBlockDelegate__DelegateSignature(class UPalQuestBlock*

UpdatedQuestBlock);
void Setup();
void OnSetup_ForBP();
void OnSetup();
void OnComplete_ForBP();
void OnComplete();
void GetProgressText(FText& OutText);
void GetDescriptionText(FText& OutText);
void CompletedBlockDelegate__DelegateSignature(class UPalQuestBlock*
CompletedQuestBlock);
void Complete();
bool CanComplete();
void CallUpdateBlockDelegate_ForBP();
}; // Size: 0x50
class UPalQuestBlock_BaseCampLevel : public UPalQuestBlock

{
int32 RequireLevel;
// 0x0050 (size: 0x4)
int32 NowBaseCampLevel;
// 0x0054 (size: 0x4)
FTimerHandle CheckTimerHandle;
// 0x0058 (size: 0x8)
void OnTimer_CheckBaseCampLevel();
}; // Size: 0x60
class UPalQuestBlock_CheckBossDefeat : public UPalQuestBlock

{
EPalBossType CheckBossType;
// 0x0050 (size: 0x1)
// 0x0058 (size: 0x8)
void CheckFlag();
}; // Size: 0x60
class UPalQuestBlock_CheckPalCaptureNum : public UPalQuestBlock

{
int32 RequireCount;
// 0x0050 (size: 0x4)
FPalDataTableRowName_PalMonsterData CountPalName;
// 0x0054 (size: 0x8)
int32 NowCaptureCount;
// 0x005C (size: 0x4)
// 0x0060 (size: 0x8)
void CheckCount();
}; // Size: 0x68
class UPalQuestBlock_CheckTechnology : public UPalQuestBlock

{
FPalDataTableRowName_RecipeTechnologyData RequireTechnologyName;
// 0x0050 (size: 0x8)
void OnUnlockedAnyTechnology();
}; // Size: 0x58
class UPalQuestBlock_CollectItem : public UPalQuestBlock

{
}; // Size: 0x50
class UPalQuestBlock_CountBaseCamp : public UPalQuestBlock

{
int32 RequireCampCount;
// 0x0050 (size: 0x4)
int32 NowBaseCampCount;
// 0x0054 (size: 0x4)
// 0x0058 (size: 0x8)
void OnTimer_CheckBaseCamp();
}; // Size: 0x60
class UPalQuestBlock_CountBuild : public UPalQuestBlock

{
FPalDataTableRowName_MapObjectData RequireBuildObjectName;
// 0x0050 (size: 0x8)
int32 RequireBuildCount;
// 0x0058 (size: 0x4)
int32 NowBuildCount;
// 0x005C (size: 0x4)
int32 NowBlueprintCount;
// 0x0060 (size: 0x4)
TArray<TWeakObjectPtr<UPalMapObjectModel>> CheckMapObjectModels;
// 0x0068 (size: 0x10)
// 0x0078 (size: 0x8)
void OnTimer_CheckMapObject();
void OnRepMapObjectModel_Client(class UPalMapObjectModel* MapObjectModel);
void OnAddedMapObjectModel_Server(class UPalMapObjectModel* MapObjectModel,
const FVector& Vector);
}; // Size: 0x80
class UPalQuestBlock_CountPickupItem : public UPalQuestBlock

{
int32 RequireCount;
// 0x0050 (size: 0x4)
FPalDataTableRowName_ItemData DetectItemName;
// 0x0054 (size: 0x8)
int32 NowPickupCount;
// 0x005C (size: 0x4)
void OnPickupItem(TArray<FPalItemAndNum>& ItemInfos);

}; // Size: 0x60
class UPalQuestBlock_CountWorker : public UPalQuestBlock

{
int32 RequireWorkerCount;
// 0x0050 (size: 0x4)
int32 NowWorkerCount;
// 0x0054 (size: 0x4)
// 0x0058 (size: 0x8)
void OnTimer_CheckBaseCampWorker();
}; // Size: 0x60
class UPalQuestBlock_DetectCapturePal : public UPalQuestBlock

{
int32 RequireCount;
// 0x0050 (size: 0x4)
FPalDataTableRowName_PalMonsterData DetectPalName;
// 0x0054 (size: 0x8)
int32 NowCaptureCount;
// 0x005C (size: 0x4)
void OnCapturedPal(const FPalUIPalCaptureInfo& CaptureInfo);

}; // Size: 0x60
class UPalQuestBlock_DetectCraft : public UPalQuestBlock

{
int32 RequireCount;
// 0x0050 (size: 0x4)
FPalDataTableRowName_ItemData DetectItemName;
// 0x0054 (size: 0x8)
int32 NowCraftNumCount;
// 0x005C (size: 0x4)
void OnCraftItem(TArray<FPalItemAndNum>& ItemInfos);

}; // Size: 0x60
class UPalQuestBlock_DetectMeal : public UPalQuestBlock

{
int32 RequireCount;
// 0x0050 (size: 0x4)
int32 NowMealCount;
// 0x0054 (size: 0x4)
void OnTriedMeal();
}; // Size: 0x58
class UPalQuestBlock_OpenSurvivalGuide : public UPalQuestBlock

{
// 0x0050 (size: 0x8)
void OnTimer_CheckOpen();
}; // Size: 0x58
class UPalQuestBlock_UseStatusPoint : public UPalQuestBlock
{
void OnUpdateStatusPoint();
}; // Size: 0x50
class UPalQuestData : public UObject

{
FPalQuestDataOnUpdatedQuestDelegate OnUpdatedQuestDelegate;
// 0x0028 (size: 0x10)
void UpdatedQuestDelegate(class UPalQuestData* UpdatedQuest);
FPalQuestDataOnCompletedQuestDelegate OnCompletedQuestDelegate;
// 0x0038 (size: 0x10)
void CompleteQuestDelegate(class UPalQuestData* CompletedQuest);
class UPalQuestBlock* NowQuestBlock;
// 0x0048 (size: 0x8)
TArray<TSoftClassPtr<UPalQuestBlock>> QuestBlockList;
// 0x0060 (size: 0x10)
FPalCommonQuestRewardData CommonRewardData;
// 0x0070 (size: 0x58)
TSoftClassPtr<UPalQuestRewardGiver> CustomQuestRewardGiverClass;
// 0x00C8 (size: 0x30)
void UpdatedQuestDelegate__DelegateSignature(class UPalQuestData*

UpdatedQuest);
void ProgressInternal();
void OnUpdatedQuestBlock(class UPalQuestBlock* UpdatedBlock);
void OnCompletedQuestBlock(class UPalQuestBlock* CompletedBlock);
void Initialize(int32 BlockIndex, const FName& InQuestName);
void GetQuestDataName(FName& outName);
void GetQuestBlock(class UPalQuestBlock*& OutBlock);
int32 GetNowQuestBlockIndex();
void GetCustomRewardGiverClass(TSoftClassPtr<UPalQuestRewardGiver>& OutClass);
void GetCommonRewardData(FPalCommonQuestRewardData& OutData);
void CompleteQuestDelegate__DelegateSignature(class UPalQuestData*
CompletedQuest);
bool CompleteNowBlock();
}; // Size: 0xF8
class UPalQuestManager : public UObject

{
FPalQuestManagerOnUpdatedQuestDelegate OnUpdatedQuestDelegate;
// 0x0028 (size: 0x10)
void UpdatedAnyQuestDelegate(class UPalQuestData* UpdatedQuest);
FPalQuestManagerOnCompletedQuestDelegate OnCompletedQuestDelegate;
// 0x0038 (size: 0x10)
void CompletedAnyQuestDelegate(class UPalQuestData* CompletedQuest);
TMap<class FName, class UPalQuestData*> OrderedQuestMap;
// 0x0048 (size: 0x50)
TArray<FName> CompletedQuestNames;
// 0x0098 (size: 0x10)
class UDataTable* QuestDataSet;
// 0x00A8 (size: 0x8)
class UPalCommonQuestRewardGiver* CommonRewardGiver;
// 0x00B0 (size: 0x8)
void UpdatedAnyQuestDelegate__DelegateSignature(class UPalQuestData*

UpdatedQuest);
void OnUpdatedQuest(class UPalQuestData* UpdatedQuest);
void OnCompletedQuest(class UPalQuestData* CompletedQuest);
bool IsAllQuestComplete();
void CompletedAnyQuestDelegate__DelegateSignature(class UPalQuestData*
CompletedQuest);
}; // Size: 0xB8
class UPalQuestRewardGiver : public UObject

{
void TakeReward();
}; // Size: 0x28
class UPalRCONSubsystem : public UGameInstanceSubsystem

{
}; // Size: 0x1C0
class UPalRadarChartWidgetBase : public UPalCustomPrimitiveWidget

{
EPalRadarChartDrawType drawType;
// 0x0430 (size: 0x1)
int32 parameterNum;
// 0x0434 (size: 0x4)
bool isMinMaxValuePerParam;
// 0x0438 (size: 0x1)
TArray<int32> parameterValueMin;
// 0x0440 (size: 0x10)
TArray<int32> parameterValueMax;
// 0x0450 (size: 0x10)
FColor fillColor;
// 0x0460 (size: 0x4)
FColor maxValuefillColor;
// 0x0464 (size: 0x4)
FColor BorderColor;
// 0x0468 (size: 0x4)
float borderSize;
// 0x046C (size: 0x4)
bool isCheckParameterMaxValue;
// 0x0470 (size: 0x1)
void SetParameterValue(int32 Index, int32 Value);

int32 GetMinValue(int32 Index);
int32 GetMaxValue(int32 Index);
void BuildVertexData();
}; // Size: 0x478
class UPalRagdollPreset : public UObject

{
TArray<FName> LockBoneNames;
// 0x0028 (size: 0x10)
float LinearDamping;
// 0x0038 (size: 0x4)
float AngularDamping;
// 0x003C (size: 0x4)
}; // Size: 0x40
class UPalRandomIncidentActionBase : public UObject

{
FPalRandomIncidentActionBaseOnRandomIncidentActionNotify
OnRandomIncidentActionNotify; // 0x0030 (size: 0x10)
void OnRandomIncidentActionNotify(EPalRandomIncidentActionNotifyType
NotifyType);
bool bIsTickable;
// 0x0040 (size: 0x1)
void Terminate();
void Start();
void SetTickable(bool isTickable);
void SendNotify(EPalRandomIncidentActionNotifyType NotifyType);
void OnTerminate();
void OnStart();
void
OnRandomIncidentActionNotify__DelegateSignature(EPalRandomIncidentActionNotifyType
NotifyType);
void OnAllNpcSpawned();
void Initialize();
}; // Size: 0x48
class UPalRandomIncidentBase : public UPalIncidentBase

{
FPalRandomIncidentBaseOnEnterAnyArea OnEnterAnyArea;
// 0x0160 (size: 0x10)
void OnEnterAnyArea(EPalRandomIncidentSpawnerAreaType AreaType, int32
PlayerId);
FPalRandomIncidentBaseOnExitAnyArea OnExitAnyArea;
// 0x0170 (size: 0x10)
void OnExitAnyArea(EPalRandomIncidentSpawnerAreaType AreaType, int32 PlayerId);
bool bIsFinishWithIncidentSpawner;
// 0x0180 (size: 0x1)
EPalRandomIncidentSpawnerAreaType PrevEnterArea;
// 0x0181 (size: 0x1)
void SetDisableFlagForNPCSpawner(const FVector& Center, float Radius, const

FName& Name, bool isDisable);
void OnExitAnyArea__DelegateSignature(EPalRandomIncidentSpawnerAreaType
AreaType, int32 PlayerId);
void OnEnterAnyArea__DelegateSignature(EPalRandomIncidentSpawnerAreaType
AreaType, int32 PlayerId);
bool IsOutbreakTable(const class UDataTable* Table);
bool IsFinishWithIncidentSpawner();
int32 GetPlayerId();
class APalRandomIncidentNPCSpawner* GetNPCSpawner();
void CreateSpawnMonsterDataListFromOutbreakRow(const class UDataTable* Table,
TArray<FPalRandomIncidentSpawnMonsterData>& OutMonsterList, TArray<FName>& Names);
void BroadcastOnEnterAreaAndOnExitArea(int32 PlayerId);
}; // Size: 0x190
class UPalRandomIncidentLotteryBase : public UObject

{
float LotteryRate;
// 0x0028 (size: 0x4)
TArray<FPalRandomIncidentSpawnIncidentParameter> LotteryParameters;
// 0x0030 (size: 0x10)
bool LotteryIncident(FPalRandomIncidentSpawnIncidentParameter& OutResult);

float GetLotteryRate();
int32 GetLotteryParameters(TArray<FPalRandomIncidentSpawnIncidentParameter>&
OutParam);
}; // Size: 0x40
class UPalRecordTrigger_BossBattle : public UPalPlayerRecordDataTrigger

{
void OnLocalPlayerBossBattleSuccessed(class APalPlayerCharacter* LocalPlayer,

EPalBossType BossType);
}; // Size: 0x28
class UPalReplaceSetting : public UObject

{
TMap<class FName, class FName> CharacterIDReplacer;
// 0x0028 (size: 0x50)
}; // Size: 0x78
class UPalReplicationGraph : public UReplicationGraph

{
TArray<class UClass*> SpatializedClasses;
// 0x0570 (size: 0x10)
TArray<class UClass*> NonSpatializedChildClasses;
// 0x0580 (size: 0x10)
TArray<class UClass*> AlwaysRelevantClasses;
// 0x0590 (size: 0x10)
class UReplicationGraphNode_GridSpatialization2D* GridNode;
// 0x05A0 (size: 0x8)
class UReplicationGraphNode_ActorList* AlwaysRelevantNode;
// 0x05A8 (size: 0x8)
}; // Size: 0x690
class UPalReplicationGraphNode_AlwaysRelevant_ForConnection : public

UReplicationGraphNode
{
class AActor* LastPawn;
// 0x0270 (size: 0x8)
TArray<FAlwaysRelevantActorInfo> PastRelevantActors;
// 0x0278 (size: 0x10)
}; // Size: 0x290
class UPalReplicationGraphNode_PlayerStateFrequencyLimiter : public

UReplicationGraphNode
{
}; // Size: 0x78
class UPalRetainerBox : public URetainerBox

{
}; // Size: 0x198
class UPalReticleTargetUtility : public UObject

{
}; // Size: 0x28
class UPalRichTextBlockBase : public UCommonRichTextBlock

{
FDataTableRowHandle BindTextDatatableHandle;
// 0x08C8 (size: 0x10)
bool IsAutoTextSetWhenWidgetRebuilt;
// 0x08D8 (size: 0x1)
FName DefaultStyleName;
// 0x08DC (size: 0x8)
bool IsAutoAdjustScale;
// 0x08E4 (size: 0x1)
int32 MaxWidth;
// 0x08E8 (size: 0x4)
void SetText_GDKInternal(bool IsSuccess, FString OutString);

void Left(const int32 Count, FText& OutText);
int32 GetTextLengthWithoutTag();
FText GetBindedOriginalText();
}; // Size: 0x8F0
class UPalRichTextDecorator_TagText : public URichTextBlockDecorator

{
FString GetTextStringInternal(const class UObject* WorldContextObject, FName

ID);
FString GetTagName();
}; // Size: 0x28
class UPalRichTextIconDecorator : public URichTextBlockImageDecorator

{
class UDataTable* ControlKeyIconData;
// 0x0030 (size: 0x8)
}; // Size: 0x38
class UPalRideMarkerComponent : public UStaticMeshComponent

{
EPalRidePositionType RidePositionType;
// 0x05F0 (size: 0x1)
bool bIsAdjustRotation;
// 0x05F1 (size: 0x1)
bool bIsFixScale;
// 0x05F2 (size: 0x1)
bool bHiddenCharacterWhenAim;
// 0x05F3 (size: 0x1)
bool bDisableLookAtByRide;
// 0x05F4 (size: 0x1)
bool bDisableFullBodyIK_UniqueRide;
// 0x05F5 (size: 0x1)
TSubclassOf<class APalUniqueRideWeaponBase> UniqueRidePalWeaponClass;
// 0x05F8 (size: 0x8)
FPalDataTableRowName_PalMonsterData UniqueRidePalID;
// 0x0600 (size: 0x8)
FPalRideMarkerComponentOnChangeRiding OnChangeRiding;
// 0x0608 (size: 0x10)
void ChangeRiding(bool isEnable);
TWeakObjectPtr<class UPalRiderComponent> Rider;
// 0x061C (size: 0x8)
class UPalActiveSkillSlot* SkillSlot;
// 0x0628 (size: 0x8)
class APalUniqueRideWeaponBase* WeaponActor;
// 0x0630 (size: 0x8)
void SyncActiveSkill(class UPalIndividualCharacterParameter*
void SetVisibleWeapon();
void SetRidingFlag(bool bIsEnable);
bool IsRiding();
bool IsAdjustRotation();
FTransform GetRideSocketTransform(TEnumAsByte<ERelativeTransformSpace> space);
class APalCharacter* GetRiderCharacter();
FName GetAttackSocketName();
class UPalActiveSkillSlot* GetActiveSkillSlot();
void ChangeRiding__DelegateSignature(bool isEnable);
void CameraChangeActorActive(bool Active);
}; // Size: 0x640
class UPalRiderComponent : public UActorComponent

{
FPalRiderComponentOnRide OnRide;
// 0x00A0 (size: 0x10)
void OnRide(class AActor* RideActor);
FPalRiderComponentOnGetOff OnGetOff;
// 0x00B0 (size: 0x10)
void OnGetOff(class AActor* RideActor);
TWeakObjectPtr<class UPalRideMarkerComponent> RidingMarker;
// 0x00C0 (size: 0x8)
TMap<class EPalRidePositionType, class FRiderActionInfo> RideActionMap;
// 0x00C8 (size: 0x50)
class AController* FullRidePalController;
// 0x0118 (size: 0x8)
class UAnimMontage* RideShakingMontage;
// 0x0120 (size: 0x8)
FFlagContainer DisableRide;
// 0x0128 (size: 0x50)
FFlagContainer DisableGetOff;
// 0x0178 (size: 0x50)
FFlagContainer DisableAdjustRotation;
// 0x01C8 (size: 0x50)
FVector DefaultMeshLocation;
// 0x0218 (size: 0x18)
FFlagContainer DisableUniqueRideIK;
// 0x0230 (size: 0x50)
float DefaultJumpZVelocity;
// 0x028C (size: 0x4)
TMap<class EPalWeaponType, class FVector2D> BackRideLimit;
// 0x0290 (size: 0x50)
TMap<class FPalDataTableRowName_PalMonsterData, class
TSubclassOf<UPalUniqueRideAnimeAssetBase>> UniqueRideAnimBPClassMap; // 0x02E0
(size: 0x50)
TMap<class FName, class UPalUniqueRideAnimeAssetBase*> UniqueRideAnimeAssetMap;
// 0x0330 (size: 0x50)
void StopShakingMontage();
void SetRideMarker(class UPalRideMarkerComponent* Marker);
void SetDisableUniqueRideIK(FName flagName, bool isDisable);
void SetDisableRide(FName flagName, bool bIsDisable);
void SetDisableGetOff(FName flagName, bool bIsDisable);
void SetDisableAdjustRotation(FName flagName, bool bIsDisable);
void SetDefaultMeshLocation(FVector Location);
void RideClientRep(class UPalRideMarkerComponent* Marker);
bool Ride(class UPalRideMarkerComponent* Marker, bool bIsSkipAnimation);
void PlayShakingMontage(class UAnimMontage* overrideMontage, float PlayRate);
void OnStartInteractInClient(TScriptInterface<class
IPalInteractiveObjectComponentInterface> Object);
void OnStartInteractForServer();
void OnStartAim();
void OnSleepPlayer(int32 LastDamage);
void OnSleep(int32 LastDamage);
void OnRide__DelegateSignature(class AActor* RideActor);
void OnInactive();
void OnGetOff__DelegateSignature(class AActor* RideActor);
void OnEndInteractInClient();
void OnEndInteractForServer();
void OnEndAim();
void OnDeadPlayer(FPalDeadInfo DeadInfo);
void OnChangeActive(bool IsActive);
void OnCaptureStart();
bool IsRiding();
bool IsDisableRide();
bool IsDisableGetOff();
bool IsDisableAdjustRotation();
class UPalUniqueRideAnimeAssetBase* GetUniqueRideAnimeAsset();
class AActor* GetRindingActor();
bool GetRiderModelIsBackward();
class UPalRideMarkerComponent* GetRideMarker();
bool GetOff(bool bIsSkipAnimation, bool bNoAnimCancel);
FVector GetDefaultMeshLocation();
EPalRidePositionType GetCurrentRidePositionType();
void DettachRiderNoAnimation();
void DettachRider();
bool CanUniqueRideIK();
void AttachRiderNoAnimation();
bool AttachRider();
}; // Size: 0x380
class UPalSaveGameManager : public UObject

{
FPalSaveGameManagerOnStartedWorldAutoSave OnStartedWorldAutoSave;
// 0x0028 (size: 0x10)
void OnStartedWorldAutoSave();
FPalSaveGameManagerOnEndedWorldAutoSave OnEndedWorldAutoSave;
// 0x0038 (size: 0x10)
void OnEndedWorldAutoSave(bool IsSuccess);
FPalSaveGameManagerOnStartedLocalWorldAutoSave OnStartedLocalWorldAutoSave;
// 0x0048 (size: 0x10)
void OnStartedLocalWorldAutoSave();
FPalSaveGameManagerOnEndedLocalWorldAutoSave OnEndedLocalWorldAutoSave;
// 0x0058 (size: 0x10)
void OnEndedLocalWorldAutoSave(bool IsSuccess);
FPalSaveGameManagerOnStartedPlayerAutoSave OnStartedPlayerAutoSave;
// 0x0068 (size: 0x10)
void OnStartedPlayerAutoSave();
FPalSaveGameManagerOnEndedPlayerAutoSave OnEndedPlayerAutoSave;
// 0x0078 (size: 0x10)
void OnEndedPlayerAutoSave(bool IsSuccess);
class UPalWorldSaveGame* LoadedWorldSaveData;
// 0x0088 (size: 0x8)
class UPalLocalWorldSaveGame* LoadedLocalWorldSaveData;
// 0x0090 (size: 0x8)
class UPalWorldOptionSaveGame* LoadedWorldOptionSaveData;
// 0x0098 (size: 0x8)
FTimerHandle AutoSaveWorldDataTimerHandle;
// 0x00A0 (size: 0x8)
FTimerHandle AutoSaveLocalWorldDataTimerHandle;
// 0x00A8 (size: 0x8)
FString AutoSaveWorldDefaultName;
// 0x00B0 (size: 0x10)
TArray<TScriptInterface<IPalGameWorldDataSaveInterface>> GameSavers;
// 0x00C0 (size: 0x10)
TScriptInterface<class IPalGamePlayerDataSaveInterface> PlayerDataSaver;
// 0x00D0 (size: 0x10)
bool IsAppliedPlayerSaveData;
// 0x00E0 (size: 0x1)
FPalAsyncSaveProcessParallel WorldSaveProcess;
// 0x00E8 (size: 0x60)
bool bIsForceDisableAutoSave;
// 0x0158 (size: 0x1)
bool bIsUseBackupSaveData;
// 0x0159 (size: 0x1)
int32 NearSaveBackupNum;
// 0x015C (size: 0x4)
int32 MinutesSaveBackupNum;
// 0x0160 (size: 0x4)
int32 HourSaveBackupNum;
// 0x0164 (size: 0x4)
int32 DaySaveBackupNum;
// 0x0168 (size: 0x4)
void StartWorldDataAutoSave();
void StartLocalWorldDataAutoSave();
void OnStartedWorldAutoSave__DelegateSignature();
void OnStartedPlayerAutoSave__DelegateSignature();
void OnStartedLocalWorldAutoSave__DelegateSignature();
void OnFinishedWorldAsyncSaveGameInternal(FString SlotName, const int32
UserIndex, bool bSuccess, FString WorldName, FString Timestamp);
void OnEndedWorldAutoSave__DelegateSignature(bool IsSuccess);
void OnEndedPlayerAutoSave__DelegateSignature(bool IsSuccess);
void OnEndedLocalWorldAutoSave__DelegateSignature(bool IsSuccess);
bool IsValidWorldSaveDirectoryName_LocalData(const FString
WorldSaveDirectoryName);
bool IsValidWorldSaveDirectoryName(const FString WorldSaveDirectoryName);
bool IsValidWorldData(const FString WorldName);
bool IsValidLocalWorldData(const FString WorldName);
bool IsLoadedWorldOptionData();
bool IsLoadedWorldData();
bool IsLoadedLocalWorldData();
bool IsAppliedPlayerData();
TArray<FString> GetWorldNames();
TMap<class FString, class FPalWorldBaseInfoData> GetWorldBaseInfoMap();
int32 GetMaxWorldSaveDataNum();
class UPalWorldSaveGame* GetLoadedWorldSaveData();
class UPalWorldOptionSaveGame* GetLoadedWorldOptionSaveData();
class UPalLocalWorldSaveGame* GetLoadedLocalWorldSaveData();
}; // Size: 0x170
class UPalScrollBox : public UPanelWidget

{
FScrollBoxStyle WidgetStyle;
// 0x0170 (size: 0x350)
FScrollBarStyle WidgetBarStyle;
// 0x04C0 (size: 0x770)
class USlateWidgetStyleAsset* Style;
// 0x0C30 (size: 0x8)
class USlateWidgetStyleAsset* BarStyle;
// 0x0C38 (size: 0x8)
TEnumAsByte<EOrientation> Orientation;
// 0x0C40 (size: 0x1)
ESlateVisibility ScrollBarVisibility;
// 0x0C41 (size: 0x1)
EConsumeMouseWheel ConsumeMouseWheel;
// 0x0C42 (size: 0x1)
FVector2D ScrollbarThickness;
// 0x0C48 (size: 0x10)
FMargin ScrollbarPadding;
// 0x0C58 (size: 0x10)
bool AlwaysShowScrollbar;
// 0x0C68 (size: 0x1)
bool AlwaysShowScrollbarTrack;
// 0x0C69 (size: 0x1)
bool AllowOverscroll;
// 0x0C6A (size: 0x1)
bool bAnimateWheelScrolling;
// 0x0C6B (size: 0x1)
EPalDescendantScrollDestination NavigationDestination;
// 0x0C6C (size: 0x1)
float NavigationScrollPadding;
// 0x0C70 (size: 0x4)
EPalScrollWhenFocusChanges ScrollWhenFocusChanges;
// 0x0C74 (size: 0x1)
bool bAllowRightClickDragScrolling;
// 0x0C75 (size: 0x1)
float WheelScrollMultiplier;
// 0x0C78 (size: 0x4)
FPalScrollBoxOnUserScrolled OnUserScrolled;
// 0x0C80 (size: 0x10)
void OnUserScrolledEvent(float CurrentOffset);
void SetWheelScrollMultiplier(float NewWheelScrollMultiplier);

void SetScrollWhenFocusChanges(EPalScrollWhenFocusChanges
NewScrollWhenFocusChanges);
void SetScrollOffset(float NewScrollOffset);
void SetScrollBarVisibility(ESlateVisibility NewScrollBarVisibility);
void SetScrollbarThickness(const FVector2D& NewScrollbarThickness);
void SetScrollbarPadding(const FMargin& NewScrollbarPadding);
void SetOrientation(TEnumAsByte<EOrientation> NewOrientation);
void SetConsumeMouseWheel(EConsumeMouseWheel NewConsumeMouseWheel);
void SetAnimateWheelScrolling(bool bShouldAnimateWheelScrolling);
void SetAlwaysShowScrollbar(bool NewAlwaysShowScrollbar);
void SetAllowOverscroll(bool NewAllowOverscroll);
void ScrollWidgetIntoView(class UWidget* WidgetToFind, bool AnimateScroll,
EPalDescendantScrollDestination ScrollDestination, float Padding);
void ScrollToStart();
void ScrollToEnd();
float GetViewOffsetFraction();
float GetScrollOffsetOfEnd();
float GetScrollOffset();
void EndInertialScrolling();
}; // Size: 0xCB0
class UPalScrollBoxSlot : public UPanelSlot

{
FMargin Padding;
// 0x0038 (size: 0x10)
TEnumAsByte<EHorizontalAlignment> HorizontalAlignment;
// 0x0048 (size: 0x1)
TEnumAsByte<EVerticalAlignment> VerticalAlignment;
// 0x0049 (size: 0x1)
void SetVerticalAlignment(TEnumAsByte<EVerticalAlignment> InVerticalAlignment);

void SetPadding(FMargin InPadding);
void SetHorizontalAlignment(TEnumAsByte<EHorizontalAlignment>
InHorizontalAlignment);
}; // Size: 0x58
class UPalSetDefaultsCommandlet : public UCommandlet

{
}; // Size: 0x80
class UPalShooterAnimeAssetBase : public UObject

{
FWeaponAnimationInfo AnimeInfo;
// 0x0028 (size: 0x258)
void ChangeRideMontage(class UAnimMontage* NextAnim, EWeaponAnimationType

AnimType);
}; // Size: 0x280
class UPalShooterComponent : public UActorComponent

{
FPalShooterComponentOnChangeTargetDirectionDelegate
OnChangeTargetDirectionDelegate; // 0x00A8 (size: 0x10)
void ChangeTargetDirectionDelegate(FVector Direction);
FPalShooterComponentOnStartAim OnStartAim;
// 0x00B8 (size: 0x10)
void StartAimDelegate();
FPalShooterComponentOnEndAim OnEndAim;
// 0x00C8 (size: 0x10)
void EndAimDelegate();
FPalShooterComponentOnPullTrigger OnPullTrigger;
// 0x00D8 (size: 0x10)
void PullTriggerDelegate();
FPalShooterComponentOnReleaseTrigger OnReleaseTrigger;
// 0x00E8 (size: 0x10)
void ReturnTriggerDelegate();
FPalShooterComponentOnChangeState OnChangeState;
// 0x00F8 (size: 0x10)
void ChangeStateDelegate(bool IsAim, bool IsShoot);
FPalShooterComponentOnWeaponNotifyDelegate OnWeaponNotifyDelegate;
// 0x0108 (size: 0x10)
void OnWeaponNotifyDelegate(EWeaponNotifyType Type);
FPalShooterComponentOnEndShootingAnimationDelegate
OnEndShootingAnimationDelegate; // 0x0118 (size: 0x10)
void OnEndShootingAnimation(class UAnimMontage* Montage);
FPalShooterComponentOnChangeWeaponDelegate OnChangeWeaponDelegate;
// 0x0128 (size: 0x10)
void OnChangeWeapon(class APalWeaponBase* weapon);
FPalShooterComponentOnReloadStartDelegate OnReloadStartDelegate;
// 0x0138 (size: 0x10)
FPalShooterComponentOnReloadBulletDelegate OnReloadBulletDelegate;
// 0x0148 (size: 0x10)
void OnReloadBullet();
FPalShooterComponentOnUpdatedUsableHandFlagDelegate
OnUpdatedUsableHandFlagDelegate; // 0x0158 (size: 0x10)
void OnUpdatedUsableHandFlag(bool CanUseLeftHandFlag, bool
CanUseRightHandFlag);
float WalkSpeedMultiplierInAim;
// 0x0168 (size: 0x4)
float WalkSpeedMultiplierInHipShoot;
// 0x016C (size: 0x4)
float ChangeWeaponInterpTime;
// 0x0170 (size: 0x4)
TMap<class EPalWeaponType, class TSoftClassPtr<UPalShooterAnimeAssetBase>>
DefaultWeaponAnimeAssetBPSoftClassMap; // 0x0178 (size: 0x50)
TMap<class TSoftClassPtr<APalWeaponBase>, class
TSoftClassPtr<UPalShooterAnimeAssetBase>> OtherWeaponAnimeAssetBPSoftClassMap; //
0x01C8 (size: 0x50)
TMap<class TSoftClassPtr<APalWeaponBase>, class EPalWeaponType>
WeaponCategoryForPreLoad; // 0x0218 (size: 0x50)
bool IsUseBlurUpdate;
// 0x0268 (size: 0x1)
TMap<class EPalWeaponType, class UPalShooterAnimeAssetBase*>
DefaultWeaponAnimeAssetMap; // 0x0270 (size: 0x50)
TMap<class TSoftClassPtr<APalWeaponBase>, class UPalShooterAnimeAssetBase*>
OtherWeaponAnimeAssetMap; // 0x02C0 (size: 0x50)
TSet<EPalWeaponType> LoadedDefaultWeaponSet;
// 0x0310 (size: 0x50)
TSet<TSoftClassPtr<APalWeaponBase>> LoadedOtherWeaponSet;
// 0x0360 (size: 0x50)
TMap<class EWeaponAnimationType, class FWeaponNotifyAnimationInfo>
OverrideWeaponNotifyAnimationMap; // 0x03B0 (size: 0x50)
FVector targetDirection;
// 0x0400 (size: 0x18)
bool bIsAiming;
// 0x0418 (size: 0x1)
bool bIsShooting;
// 0x0419 (size: 0x1)
bool bIsRequestAim;
// 0x041A (size: 0x1)
bool bIsRequestPullTrigger;
// 0x041B (size: 0x1)
bool bIsReloading;
// 0x041C (size: 0x1)
FFlagContainer UseControllerRotationYawFlags;
// 0x0420 (size: 0x50)
class APalWeaponBase* HasWeapon;
// 0x0470 (size: 0x8)
class APalWeaponBase* CacheNextWeapon;
// 0x0478 (size: 0x8)
FWeaponAnimationInfo PrevWeaponAnimationInfo;
// 0x0480 (size: 0x258)
bool bIsDisableShootingTemporarily;
// 0x06D8 (size: 0x1)
FLayeredFlagContainer DisableAimFlag;
// 0x06F0 (size: 0x10)
FLayeredFlagContainer DisableShootFlag;
// 0x0700 (size: 0x10)
FLayeredFlagContainer DisableWeaponChange;
// 0x07B0 (size: 0x10)
FFlagContainer HiddenWeapon;
// 0x07C0 (size: 0x50)
float PullTriggerCountDown;
// 0x0960 (size: 0x4)
int32 PullTriggerCountDownCount;
// 0x0964 (size: 0x4)
float ElapsedTimeSinceWeaponChange;
// 0x0968 (size: 0x4)
EPalWeaponType OverrideWeaponType;
// 0x096C (size: 0x1)
bool bUnstoppable;
// 0x096D (size: 0x1)
bool bIsHoldTrigger;
// 0x096E (size: 0x1)
bool bBufferedInput;
// 0x096F (size: 0x1)
bool bIsShootingHold;
// 0x0970 (size: 0x1)
class APalWeaponBase* NPCWeapon;
// 0x0988 (size: 0x8)
float CurrentBulletBlurRate;
// 0x0990 (size: 0x4)
float RapidFireBlur;
// 0x0994 (size: 0x4)
FRandomStream RandomStream;
// 0x0998 (size: 0x8)
void StopWeaponChangeAnimation();
void StopReloadInternal();
void StopReload();
void StopPullTriggerAnime_forBP();
void StartAimDelegate__DelegateSignature();
void StartAim();
void SetUsedRightHand(FName flagName, bool bIsUsed);
void SetUsedLeftHand(FName flagName, bool bIsUsed);
void SetupInputComponent(class UInputComponent* InputComponent);
void SetTargetDirection_ToServer(FVector targetDirection);
void SetTargetDirection(const FVector& Direction);
void SetShootingHold(bool IsHold);
void SetOverrideWeaponType(EPalWeaponType Type);
void SetHiddenAttachWeapon(FName flagName, bool isHidden);
void SetDisableWeaponForUI(bool Disable);
void SetDisableWeaponChangeAnime(FName flagName, bool bIsUsed);
void SetDisableShootFlag_Layered(EPalShooterFlagContainerPriority Priority,
FName flagName, bool isDisable);
void SetDisableShootFlag(FName flagName, bool isDisable);
void SetDisableReloadFlag(FName flagName, bool isDisable);
void SetDisableLeftHandAttachFlag(FName flagName, bool isDisable);
void SetDisableEndAim(FName flagName, bool isDisable);
void SetDisableChangeWeaponFlag_Layered(EPalShooterFlagContainerPriority
Priority, FName flagName, bool isDisable);
void SetDisableChangeWeaponFlag(FName flagName, bool isDisable);
void SetDisableAimFlag_Layered(EPalShooterFlagContainerPriority Priority, FName
flagName, bool isDisable);
void SetDisableAimFlag(FName flagName, bool isDisable);
void ReturnTriggerDelegate__DelegateSignature();
void ResetOverrideWeaponType();
void ReloadWeaponInternal();
void ReloadWeapon();
void ReleaseTrigger();
void PullTriggerDelegate__DelegateSignature();
void PullTrigger();
void OnWeaponNotifyDelegate__DelegateSignature(EWeaponNotifyType Type);
void OnWeaponAnimationNotifyEnd(FName NotifyName, const
void OnWeaponAnimationNotifyBegin(FName NotifyName, const
void OnUpdatedUsableHandFlag__DelegateSignature(bool CanUseLeftHandFlag, bool
CanUseRightHandFlag);
void OnStartOwnerAction(const class UPalActionBase* action);
void OnReloadStart__DelegateSignature();
void OnReloadBullet__DelegateSignature();
void OnOwnerAnimInitialized();
void OnLanded(class UPalCharacterMovementComponent* Component, const
FHitResult& Hit);
void OnJump(class UPalCharacterMovementComponent* Component);
void OnEndShootingAnimation__DelegateSignature(class UAnimMontage* Montage);
void OnEndReloadAnimation(class UAnimMontage* Montage, bool bInterrupted);
void OnCrouch(class UPalCharacterMovementComponent* Component, bool bIsCrouch);
void OnChangeWeapon__DelegateSignature(class APalWeaponBase* weapon);
void OnChangeTargetDirection();
void OnChangeChangeImportance(EPalCharacterImportanceType Next);
bool IsShooting();
bool IsReloading();
bool IsPlayShootingAnimation();
bool IsHiddenAttachWeapon();
bool IsAiming();
class UPalShooterAnimeAssetBase* GetThrowAnimAsset();
FVector GetTargetDirection();
FWeaponAnimationInfo GetPrevWeaponAnimationInfo();
class APalWeaponBase* GetHasWeapon();
FWeaponAnimationInfo GetCurrentWeaponAnimationInfo();
FRidingAnimationInfo GetCurrentRidingAnimationInfo();
float GetCurrentBulletBlurRate();
float GetChangeWeaponAnimationWeight();
class UPalShooterAnimeAssetBase* GetBowAnimAsset();
void EndAimDelegate__DelegateSignature();
void EndAim();
void ChangeWeapon(class APalWeaponBase* weapon);
void ChangeTargetDirectionDelegate__DelegateSignature(FVector Direction);
void ChangeStateDelegate__DelegateSignature(bool IsAim, bool IsShoot);
void ChangeIsShooting(bool IsShooting);
void ChangeIsAiming(bool IsAiming);
bool CanWeaponChangeAnime();
bool CanUseWeapon(class APalWeaponBase* weapon);
bool CanUseRightHand();
bool CanUseLeftHand();
bool CanShoot();
bool CanReload();
bool CanLeftHandAttach();
bool CanChangeNextWeapon_Layered(EPalShooterFlagContainerPriority Priority);
bool CanChangeNextWeapon();
bool CanAutoAim();
bool CanAim();
void BowPullAnimeEnd();
void AttachWeapon_ForPartnerSkillPalWeapon_ToAll(class APalWeaponBase* weapon);
void AttachWeapon_ForNPC_ToAll(bool IsNotNull);
void AttachWeapon(class APalWeaponBase* weapon);
void AddRapidFireBlur();
}; // Size: 0x9A0
class UPalShooterSpringArmComponent : public UPalSpringArmComponent

{
float CameraInterpTime;
// 0x03A8 (size: 0x4)
float AimingCameraLagSpeed;
// 0x03AC (size: 0x4)
class UCurveFloat* LengthInterpCurve;
// 0x03B0 (size: 0x8)
class UCurveFloat* OffsetInterpCurve;
// 0x03B8 (size: 0x8)
float WalkCameraArmLength;
// 0x03C0 (size: 0x4)
FVector WalkCameraOffset;
// 0x03C8 (size: 0x18)
float HipShootCameraArmLength;
// 0x03E0 (size: 0x4)
FVector HipShootCameraOffset;
// 0x03E8 (size: 0x18)
float AimCameraArmLength;
// 0x0400 (size: 0x4)
FVector AimCameraOffset;
// 0x0408 (size: 0x18)
TMap<class EPalWeaponType, class FShooterSpringCameraParameter>
DefaultWeaponStandCameraParameterMap; // 0x0420 (size: 0x50)
TMap<class TSoftClassPtr<APalWeaponBase>, class FShooterSpringCameraParameter>
UniqueWeaponStandCameraParameterMap; // 0x0470 (size: 0x50)
float AirCameraArmLength;
// 0x04C0 (size: 0x4)
FVector AirCameraOffset;
// 0x04C8 (size: 0x18)
float AirHipShootCameraArmLength;
// 0x04E0 (size: 0x4)
FVector AirHipShootCameraOffset;
// 0x04E8 (size: 0x18)
float AirAimCameraArmLength;
// 0x0500 (size: 0x4)
FVector AirAimCameraOffset;
// 0x0508 (size: 0x18)
float FlyCameraArmLength;
// 0x0520 (size: 0x4)
FVector FlyCameraOffset;
// 0x0528 (size: 0x18)
float FlyHipShootCameraArmLength;
// 0x0540 (size: 0x4)
FVector FlyHipShootCameraOffset;
// 0x0548 (size: 0x18)
float FlyAimCameraArmLength;
// 0x0560 (size: 0x4)
FVector FlyAimCameraOffset;
// 0x0568 (size: 0x18)
float CrouchCameraArmLength;
// 0x0580 (size: 0x4)
FVector CrouchCameraOffset;
// 0x0588 (size: 0x18)
float CrouchHipShootCameraArmLength;
// 0x05A0 (size: 0x4)
FVector CrouchHipShootCameraOffset;
// 0x05A8 (size: 0x18)
float CrouchAimCameraArmLength;
// 0x05C0 (size: 0x4)
FVector CrouchAimCameraOffset;
// 0x05C8 (size: 0x18)
float SlidingCameraArmLength;
// 0x05E0 (size: 0x4)
FVector SlidingCameraOffset;
// 0x05E8 (size: 0x18)
float SlidingHipShootCameraArmLength;
// 0x0600 (size: 0x4)
FVector SlidingHipShootCameraOffset;
// 0x0608 (size: 0x18)
float SlidingAimCameraArmLength;
// 0x0620 (size: 0x4)
FVector SlidingAimCameraOffset;
// 0x0628 (size: 0x18)
float DeadCameraArmLength;
// 0x0640 (size: 0x4)
FVector DeadCameraOffset;
// 0x0648 (size: 0x18)
FFixedPoint64 PrevPlayerHp;
// 0x06A8 (size: 0x8)
float DefaultCameraLagSpeed;
// 0x06B0 (size: 0x4)
class UPalShooterComponent* ShooterComponent;
// 0x06B8 (size: 0x8)
class UPalCharacterMovementComponent* MoveComponent;
// 0x06C0 (size: 0x8)
class UPalCharacterParameterComponent* ParameterComponent;
// 0x06C8 (size: 0x8)
class UPalDamageReactionComponent* DamageReactionComponent;
// 0x06D0 (size: 0x8)
FFloatContainer ArmLengthScaleContainer;
// 0x06D8 (size: 0x10)
void UpdateCameraInterp(float DeltaTime);

void UnregisterAdditionalOffsets();
void UnregisterAdditionalOffset(const FName& flgName);
void SetCameraLengthScale(FName flagName, float Scale);
void ResetCameraInterp();
void ResetCameraDirection();
void RegisterAdditionalOffset(const FShooterSpringCameraAdditionalOffset&
Offset);
void OnUpdatePlayerHp(FFixedPoint64 nowHP, FFixedPoint64 nowMaxHP);
void OnStartAim();
void OnReleaseTrigger();
void OnPullTrigger();
void OnLanded(class UPalCharacterMovementComponent* Component, const
FHitResult& Hit);
void OnJump(class UPalCharacterMovementComponent* Component);
void OnFly(class UPalCharacterMovementComponent* Component);
void OnEndAim();
void OnDyingDeadEnd(class APalPlayerCharacter* PlayerCharacter);
void OnCompleteInitializeParameter(class APalCharacter* InCharacter);
void OnChangeSliding(class UPalCharacterMovementComponent* Component, bool
IsSliding);
void OnChangeShootState(bool IsAim, bool IsShooting);
void OnChangeGraphicsDelegate(const FPalOptionGraphicsSettings& PrevSettings,
const FPalOptionGraphicsSettings& NewSettings);
isCrouch);
FVector GetCurrentCameraOffset();
float GetCurrentCameraArmLength();
void ChangeArmParameter_forBP();
}; // Size: 0x700
class UPalShopBase : public UObject

{
FPalShopBaseOnUpdateAnyProduct OnUpdateAnyProduct;
// 0x0028 (size: 0x10)
void UpdateAnyProductDelegate();
FGuid MyShopID;
// 0x0038 (size: 0x10)
FName MyShopName;
// 0x0048 (size: 0x8)
TArray<class UPalShopProductBase*> ProductArray;
// 0x0050 (size: 0x10)
TMap<class FGuid, class UPalShopProductBase*> ProductMap_ForServer;
// 0x0060 (size: 0x50)
FTimerHandle RestockTimerHandle_ForServer;
// 0x00B0 (size: 0x8)
void UpdateAnyProductDelegate__DelegateSignature();
void OnUpdateAnyProductStock(int32 NowStock);
void OnUpdateAnyProductMaxStock(int32 MaxStock);
void OnTimerTrigger_Restock();
void OnRep_ProductArray();
void OnRep_MyShopName();
void GetId(FGuid& OutID);
void GetAllProduct(TArray<class UPalShopProductBase*>& OutProductArray);
}; // Size: 0xB8
class UPalShopManager : public UPalWorldSubsystem

{
FPalShopManagerOnRecievedBuyResultDelegate OnRecievedBuyResultDelegate;
// 0x0078 (size: 0x10)
void RecievedBuyResultDelegate(const EPalShopBuyResultType ResultType);
FPalShopManagerOnReceivedDroppedPalDataDelegate
OnReceivedDroppedPalDataDelegate; // 0x0088 (size: 0x10)
void ReceivedDroppedPalDataDelegate(const
TArray<FPalDroppedPalProductDataForShop>& ReceivedData);
TMap<class FGuid, class UPalShopBase*> CreatedItemShopMap_ForServer;
// 0x0098 (size: 0x50)
TMap<class FGuid, class UPalShopBase*> CreatedPalShopMap_ForServer;
// 0x00E8 (size: 0x50)
TArray<FPalDroppedPalProductDataForShop> LocalDroppedPalData;
// 0x0138 (size: 0x10)
class UPalShopProduct_LostPal* LostPalProduct_Tmp;
// 0x0148 (size: 0x8)
}; // Size: 0x150
class UPalShopProductBase : public UObject

{
FPalShopProductBaseOnUpdateNowStockNumDelegate OnUpdateNowStockNumDelegate;
// 0x0028 (size: 0x10)
void UpdateNowStockNumDelegate(int32 NowStock);
FPalShopProductBaseOnUpdateMaxStockNumDelegate OnUpdateMaxStockNumDelegate;
// 0x0038 (size: 0x10)
void UpdateMaxStockNumDelegate(int32 MaxStockNum);
FGuid MyProductID;
// 0x0048 (size: 0x10)
bool IsInfinityStockFlag;
// 0x0058 (size: 0x1)
int32 StockNum;
// 0x005C (size: 0x4)
int32 MaxStockNum;
// 0x0060 (size: 0x4)
bool IsValidProductFlag;
// 0x0064 (size: 0x1)
void UpdateNowStockNumDelegate__DelegateSignature(int32 NowStock);

void UpdateMaxStockNumDelegate__DelegateSignature(int32 MaxStockNum);
void OnRep_StockNum();
void OnRep_MaxStockNum();
bool IsValidProduct();
bool IsSoldout();
bool IsInfinityStock();
int32 GetRemainStockNum();
void GetProductNameText(FText& OutText);
int32 GetMaxStockNum();
int32 GetMaxBuyNum_LocalPlayer();
void GetId(FGuid& OutID);
bool CanBuy_LocalPlayer();
}; // Size: 0x68
class UPalShopProduct_LostPal : public UPalShopProduct_PalSaveParameter

{
}; // Size: 0x2A0
class UPalShopProduct_PalSaveParameter : public UPalShopProductBase

{
FPalIndividualCharacterSaveParameter ProductPalSaveParameter;
// 0x0068 (size: 0x218)
FGuid ReservedPlayerUID;
// 0x0280 (size: 0x10)
void OnCreatedBuyPal(FPalInstanceID CreatedPalInstanceID);

void GetProductPalParameter(FPalIndividualCharacterSaveParameter&
outParameter);
int32 GetPrice();
}; // Size: 0x290
class UPalShopProduct_TradeItem : public UPalShopProductBase

{
FName ProductStaticItemID;
// 0x0068 (size: 0x8)
float BuyRate;
// 0x0070 (size: 0x4)
int32 GetRequireMoney();
void GetProductStaticItemID(FName& OutStaticID);
}; // Size: 0x78
class UPalShopUtility : public UBlueprintFunctionLibrary

{
void LotteryItemShop(const class UObject* WorldContextObject, const FName&

ItemShopLotteryName, FName& OutShopName);
bool GetPalShopCreateData(const class UObject* WorldContextObject, const FName&
ShopName, FPalPalShopCreateDataRow& OutData);
bool GetItemShopCreateData(const class UObject* WorldContextObject, const
FName& ShopName, FPalItemShopCreateDataRow& OutData);
bool CreateNewPalShop(const class UObject* WorldContextObject, const
FPalPalShopCreateDataRow& createShopData, const FName& sharedShopKeyName, class
UPalShopBase*& outCreatedShop);
bool CreateNewItemShop(const class UObject* WorldContextObject, const
FPalItemShopCreateDataRow& createShopData, const FName& sharedShopKeyName, class
UPalShopBase*& outCreatedShop);
bool CanSellFromStaticItemIDAndNum(const class UObject* WorldContextObject,
const FPalStaticItemIdAndNum& staticItemIDAndNum, float SellRate);
bool CanSellFromSlotIdAndNum(const class UObject* WorldContextObject, const
FPalItemSlotIdAndNum& SlotIdAndNum, float SellRate);
int32 CalcPalSellPrice(const class UObject* WorldContextObject, const
FPalIndividualCharacterSaveParameter& SaveParameter, float SellRate);
int32 CalcItemSellPrice(const class UObject* WorldContextObject, const
FPalStaticItemIdAndNum& staticItemIDAndNum, float SellRate);
}; // Size: 0x28
class UPalSkeletalMeshComponent : public USkeletalMeshComponent

{
bool bCanRagdoll;
// 0x0F80 (size: 0x1)
float ClavicleAdjustDegree;
// 0x0F84 (size: 0x4)
bool bIsEnableGroundTilt;
// 0x0F88 (size: 0x1)
float PitchAngle;
// 0x0F8C (size: 0x4)
float RollAngle;
// 0x0F90 (size: 0x4)
float TiltingInterpTime;
// 0x0F94 (size: 0x4)
FVector DefaultLocation;
// 0x0F98 (size: 0x18)
FRotator DefaultRotator;
// 0x0FB0 (size: 0x18)
FVector BeginTiltVector;
// 0x0FC8 (size: 0x18)
FVector EndTiltVector;
// 0x0FE0 (size: 0x18)
float TiltTimer;
// 0x0FF8 (size: 0x4)
FPalSkeletalMeshComponentOnAppliedMakeInfo OnAppliedMakeInfo;
// 0x1000 (size: 0x10)
void AppliedMakeInfoDelegate(const class UPalSkeletalMeshComponent*
SkeletalMeshComponent);
FFlagContainer DisableTilt;
// 0x1010 (size: 0x50)
FFloatContainer ScaleFloatContainer;
// 0x1060 (size: 0x10)
FFloatContainer PitchFloatContainer;
// 0x1070 (size: 0x10)
FFloatContainer AnimRateScaleFloatContainer;
// 0x1080 (size: 0x10)
float DefaultAnimRateScale;
// 0x1090 (size: 0x4)
FVector DefaultScale3D;
// 0x1098 (size: 0x18)
EPalSkeletalMeshType PalSkeletalMeshType;
// 0x10B0 (size: 0x1)
float CharcterMakeMorphMax;
// 0x10B4 (size: 0x4)
FName ItemName;
// 0x10E8 (size: 0x8)
FName BodyTypeName;
// 0x10F0 (size: 0x8)
bool DisableChangeMesh_ByPlayerDead;
// 0x10F8 (size: 0x1)
EVisibilityBasedAnimTickOption DefaultTickOption;
// 0x1110 (size: 0x1)
FPalPlayerDataCharacterMakeInfo CharacterMakeInfo;
// 0x1114 (size: 0x94)
void SetTiltDisable(FName flagName, bool bIsDisable);

void SetRuntimeScale(FName flagName, float Scale);
void SetRuntimePitch(FName flagName, float Pitch);
void SetRuntimeAnimRateScale(FName flagName, float RateScale);
void SetDisableChangeMesh(bool Disable);
void SetCharacterMakeInfo(const FPalPlayerDataCharacterMakeInfo& Info);
void ResetTransformToDefault();
bool IsDisableTilt();
EPalSkeletalMeshType GetPalSkeletalMeshType();
float GetAnimRateScale();
void ChangeVisibilityAnimTick(EPalSkeletalTickLayer SkeletalTickLayer);
void AppliedMakeInfoDelegate__DelegateSignature(const class
UPalSkeletalMeshComponent* SkeletalMeshComponent);
}; // Size: 0x11B0
class UPalSkillDamageReactionComponent : public UActorComponent

{
FPalSkillDamageReactionComponentOnDamageDelegate OnDamageDelegate;
// 0x00A8 (size: 0x10)
void OnDamageDelegate(const FPalDamageInfo& DamageInfo);
// 0x00B8 (size: 0x8)
}; // Size: 0xC0
class UPalSoundEmitterComponent : public UActorComponent

{
void EmitSound(FName SoundFName, class AActor* EmitterCharacter, FVector

EmitLocation, float VolumeRate);
}; // Size: 0xA0
class UPalSoundPlayer : public UObject
{
FPalSoundPlayerAkCallbackOuter AkCallbackOuter;
// 0x0028 (size: 0x10)
CallbackInfo);
bool StopWhenOwnerDestroyed;
// 0x0038 (size: 0x1)
class USceneComponent* OwnerComponent;
// 0x0040 (size: 0x8)
// 0x0048 (size: 0x8)
FName OwnerAttachPointName;
// 0x0050 (size: 0x8)
FPalSoundPlayerAkCallback AkCallback;
// 0x0058 (size: 0x10)
CallbackInfo);
TMap<int32, FPalSoundPlayingParameter> PlaySoundParameters;
// 0x0068 (size: 0x50)
TMap<FName, float> OutputBusVolumes;
// 0x00B8 (size: 0x50)
void UpdateOutputBusBolume();
void Terminate();
void StopSound();
void StopByPlayingId(int32 PlayingID);
void SetWorldLocation(const FVector& Location);
void SetRTPCValue(const FName& Name, float Value, float interpolSec);
void SetPhysicalMaterial(TEnumAsByte<EPhysicalSurface> PhysicalSurface);
void SetOutputBusVolume(FName Name, float Volume);
void SetOcclusionRefreshInterval(float Interval);
void PostTrigger(FString Trigger);
int32 PlaySound(class UAkAudioEvent* AudioEvent, const FPalSoundOptions&
Options);
CallbackInfo);
void Initialize();
FVector GetWorldLocation();
FRotator GetOwnerRotation();
FVector GetOwnerLocation();
bool GetOutputBusVolume(FName Name, float& Volume);
void FadeOutByPlayingId(int32 PlayingID, int32 FadeOutDuration);
void ClearOutputBusVolume(FName Name);
}; // Size: 0x108
class UPalSoundPlayerComponent : public UActorComponent

{
// 0x00A0 (size: 0x30)
FPalSoundPlayerComponentOnGetAkOwnerComponent OnGetAkOwnerComponent;
// 0x00D0 (size: 0x10)
class USceneComponent* OnGetAkOwnerComponent();
// 0x00E0 (size: 0x8)
class USceneComponent* OnGetAkOwnerComponent__DelegateSignature();

void BeginPlay();
}; // Size: 0xE8
class UPalSoundPlayerInEditorComponent : public UActorComponent

{
// 0x00A0 (size: 0x30)
// 0x00D0 (size: 0x8)

}; // Size: 0xD8
class UPalSoundSlot : public UObject

{
TMap<class FPalDataTableRowName_SoundID, class UAkAudioEvent*> SoundMap;
// 0x0028 (size: 0x50)
TMap<int32, FPalDataTableRowName_SoundID> PlaySoundParameters;
// 0x0078 (size: 0x50)
// 0x00C8 (size: 0x8)
void Terminate();
void StopSoundBySoundId(const FPalDataTableRowName_SoundID& SoundId);
void StopSound();
void StopByPlayingId(int32 PlayingID);
void SetRTPCValue(const FName& Name, float Value, float interpolSec);
int32 PlaySoundByAkEvent(class UAkAudioEvent* AkEvent, const FPalSoundOptions&
Options);
int32 PlaySound(const FPalDataTableRowName_SoundID& ID, const FPalSoundOptions&
Options);
CallbackInfo);
bool IsPlayingBySoundId(const FPalDataTableRowName_SoundID& SoundId);
void Initialize();
class UAkAudioEvent* GetAkEvent(const FPalDataTableRowName_SoundID& ID);
}; // Size: 0xD0
class UPalSoundUtility : public UBlueprintFunctionLibrary

{
void StopSoundByActorWithSoundId(class AActor* Actor, const

FPalDataTableRowName_SoundID& ID);
void StopSoundByActor_Editor(class AActor* Actor);
void StopSoundByActor(class AActor* Actor);
class APalSoundDebugModel* SpawnSoundDebugModel(class UAkAudioEvent*
AudioEvent, const FVector& Location, const FRotator& Rotation, class UObject*
WorldObject);
void SetSwitchByActor(class AActor* Actor, FString SwitchGroup, FString
SwitchState);
void SetRTPCValueByActor(class AActor* Actor, const FName Name, float Value,
float interpolSec);
void SetPhysicalMaterial(class AActor* Actor, TEnumAsByte<EPhysicalSurface>
PhysicalSurface);
void PlaySoundByActor_Editor(class AActor* Actor, const
FPalDataTableRowName_SoundID& ID, const FPalSoundOptions& Option,
TSoftClassPtr<UPalSoundSlot> SoundSlotClass, TEnumAsByte<EPhysicalSurface>
PhysicalSurface);
void PlaySoundByActor(class AActor* Actor, const FPalDataTableRowName_SoundID&
ID, const FPalSoundOptions& Option);
bool PlayAkEventSoundByActor(class AActor* Actor, class UAkAudioEvent*
AkEvent);
void PalSoundUtilityBoolCallbackFunction__DelegateSignature(bool IsPlaying);
void IsSoundPlayingByActor(class AActor* Actor, const
FPalDataTableRowName_SoundID& ID, FIsSoundPlayingByActorCb cb);
}; // Size: 0x28
class UPalSpeedCollisionComponent : public USphereComponent

{
bool IsSelfEnable;
// 0x0560 (size: 0x1)
TArray<FPalInstanceID> HitPalList;
// 0x0568 (size: 0x10)
void OnAllActionEnd(const class UPalActionComponent* ActionComponent);

void OnActionBegin(const class UPalActionBase* action);
void DelayRemoveInterval();
}; // Size: 0x580
class UPalSpringArmComponent : public USpringArmComponent

{
TEnumAsByte<ECollisionChannel> WaterProbeChannel;
// 0x03A0 (size: 0x1)
}; // Size: 0x3B0
class UPalSquad : public UObject

{
FPalSquadOnSomeOneDeadDelegate OnSomeOneDeadDelegate;
// 0x0030 (size: 0x10)
void OnSomeOneDeadDelegate(FPalDeadInfo DeadInfo);
FPalSquadOnCombatPropagationDelegate OnCombatPropagationDelegate;
// 0x0040 (size: 0x10)
void OnCombatPropagationDelegate(class AActor* StartActor);
FPalSquadOnEscapePropagationDelegate OnEscapePropagationDelegate;
// 0x0050 (size: 0x10)
void EscapePropagationDelegate(class AActor* StartActor, class AActor*
TargetActor);
FPalInstanceID LeaderId;
// 0x0060 (size: 0x30)
TArray<FPalInstanceID> MemberIDList;
// 0x0090 (size: 0x10)
class UPalAIBlackboardBase* LeaderBB;
// 0x00A0 (size: 0x8)
void RemoveWhenDestoryActor(class AActor* DestoryActor);

void OnSomeOneDeadDelegate__DelegateSignature(FPalDeadInfo DeadInfo);
void OnCombatPropagationDelegate__DelegateSignature(class AActor* StartActor);
void GetMemberID(TArray<FPalInstanceID>& OutList);
void EscapeStart(class AActor* StartActor, class AActor* Target);
void EscapePropagationDelegate__DelegateSignature(class AActor* StartActor,
class AActor* TargetActor);
void DeadAndUpdateLeader(FPalDeadInfo DeadInfo);
void CombatStart(class AActor* StartActor);
void AddCharacter(FPalInstanceID PalInstanceID);
}; // Size: 0xA8
class UPalStageDefines : public UObject

{
}; // Size: 0x28
class UPalStageModelBase : public UObject

{
FPalStageInstanceId InstanceId;
// 0x0040 (size: 0x14)
TArray<FPalStagePlayerInfo> PlayerInfos;
// 0x0058 (size: 0x10)
void OnCompleteLoadStage_ServerInternal(class UPalStageModelBase*

TargetStageModel);
}; // Size: 0x68
class UPalStageModelBossBattle : public UPalStageModelBase

{
class UPalBossBattleInstanceModel* InstanceModel;
// 0x0068 (size: 0x8)
void OnRep_InstanceModel();
class UPalBossBattleInstanceModel* GetInstanceModel();
}; // Size: 0x70
class UPalStageModelDungeon : public UPalStageModelBase

{
class UPalDungeonInstanceModel* InstanceModel;
// 0x0068 (size: 0x8)
class UPalDungeonInstanceModel* GetInstanceModel();

}; // Size: 0x70
class UPalStageRegistrationParameterBase : public UObject

{
}; // Size: 0x40
class UPalStageRegistrationParameterBossBattle : public

UPalStageRegistrationParameterBase
{
}; // Size: 0x48
class UPalStageRegistrationParameterDungeon : public

UPalStageRegistrationParameterBase
{
}; // Size: 0x50
class UPalStageReplicator : public UPalGameStateReplicatorBase

{
FPalFastStageModelRepInfoArray RepInfoArray;
// 0x0028 (size: 0x148)
}; // Size: 0x1C0
class UPalStageUtility : public UBlueprintFunctionLibrary

{
}; // Size: 0x28
class UPalStageWorldSubsystem : public UPalWorldSubsystem

{
TMap<class FPalStageInstanceId, class UPalStageModelBase*> StageModelMap;
// 0x0070 (size: 0x50)
TMap<class UDataLayerAsset*, class FPalStageAreaInfo> StageAreaInfoMap;
// 0x00C0 (size: 0x50)
}; // Size: 0x110
class UPalStatModelPerformance : public UObject

{
void SetupInitializeStat(float FrameTime, float GameThreadTime, float

RenderThreadTime, float GPUTime);
void Initialize();
void Deinitialize();
}; // Size: 0x40
class UPalStatPalCount : public UObject

{
class UFont* FontObject;
// 0x0030 (size: 0x8)
}; // Size: 0x38
class UPalStateMachine : public UObject

{
TMap<class UClass*, class UPalStateMachineStateBase*> StateMap;
// 0x0028 (size: 0x50)
class UPalStateMachineStateBase* CurrentState;
// 0x0078 (size: 0x8)

void Start(UClass* StartClass);
class UPalStateMachineStateBase* GetCurrentState();
void Dispose();
void ChangeState(UClass* ToStateClass);
void AddState(class UPalStateMachineStateBase* State);
}; // Size: 0x88
class UPalStateMachineStateBase : public UObject

{
}; // Size: 0x30
class UPalStateMachineStateBase_BlueprintBase : public UPalStateMachineStateBase

{
void StateTick(float DeltaTime);

void StateExit();
void StateEnter();
}; // Size: 0x30
class UPalStaticArmorItemData : public UPalStaticItemDataBase

{
int32 AttackValue;
// 0x0158 (size: 0x4)
int32 DefenseValue;
// 0x015C (size: 0x4)
int32 HPValue;
// 0x0160 (size: 0x4)
int32 ShieldValue;
// 0x0164 (size: 0x4)
int32 GetShieldValue();
int32 GetHPValue();
int32 GetDefenseValue();
int32 GetAttackValue();
}; // Size: 0x168
class UPalStaticCharacterParameterComponent : public UActorComponent

{
TMap<class EPalAIActionType, class TSubclassOf<UPalAIActionBase>> AIActionMap;
// 0x00A0 (size: 0x50)
float CallApproachWalkSpeedMultiplier;
// 0x00F0 (size: 0x4)
TArray<class UAnimMontage*> RandomRestMontage;
// 0x00F8 (size: 0x10)
TArray<FPalRandomRestInfo> RandomRestMontageInfos;
// 0x0108 (size: 0x10)
TMap<class EPalGeneralAnimSequenceType, class UAnimSequence*>
GeneralAnimSequenceMap; // 0x0118 (size: 0x50)
TMap<class EPalGeneralMontageType, class UAnimMontage*> GeneralMontageMap;
// 0x0168 (size: 0x50)
TMap<class EPalGeneralBlendSpaceType, class UBlendSpace*> GeneralBlendSpaceMap;
// 0x01B8 (size: 0x50)
TMap<class EPalRagdollPresetType, class TSubclassOf<UPalRagdollPreset>>
RagdollPresetMap; // 0x0208 (size: 0x50)
TMap<class EPalActionType, class UAnimMontage*> ActionMontageMap;
// 0x0258 (size: 0x50)
TArray<class UAnimMontage*> EmoteList;
// 0x02A8 (size: 0x10)
TMap<class EPalWazaID, class TSoftClassPtr<UPalActionBase>>
WazaActionDeclarationMap; // 0x02B8 (size: 0x50)
TMap<class EPalWazaID, class TSubclassOf<UPalActionBase>>
WazaActionInstancedMap; // 0x0308 (size: 0x50)
float CaptureSuccessRate;
// 0x0358 (size: 0x4)
bool IsPal;
// 0x035C (size: 0x1)
float SkillEffectScale;
// 0x0360 (size: 0x4)
FVector SkillEffectOffsetScale;
// 0x0368 (size: 0x18)
float FollowSideDistanceRate;
// 0x0380 (size: 0x4)
TMap<TEnumAsByte<EPhysicalSurface>, FFootStampInfo> FootStampMap;
// 0x0388 (size: 0x50)
float StepVelocityXY;
// 0x03D8 (size: 0x4)
float StepVelocityZ;
// 0x03DC (size: 0x4)
FName HeadBoneName;
// 0x03E0 (size: 0x8)
FName PhysicsBodyRootName;
// 0x03E8 (size: 0x8)
FName ToolAttachBoneName;
// 0x03F0 (size: 0x8)
FVector2D HPGaugeUIOffset;
// 0x03F8 (size: 0x10)
float ExclamationMarkOffsetZ;
// 0x0408 (size: 0x4)
EPalMonsterMovementType MovementType;
// 0x040C (size: 0x1)
float Weight_KG;
// 0x0410 (size: 0x4)
int32 Mass_Scale;
// 0x0414 (size: 0x4)
float IsGroundCrossRange;
// 0x0418 (size: 0x4)
TMap<class EPalPhysicsBoneType, class FName> PhysicsBoneNameMap;
// 0x0420 (size: 0x50)
bool IsUncapturable;
// 0x0470 (size: 0x1)
bool IsBackWalkForwardAnime;
// 0x0471 (size: 0x1)
bool IsRightLeft_WakeupFromRagdoll;
// 0x0472 (size: 0x1)
FVector GetupMotion_UtubuseOrRight_0FramePelvisLocation;
// 0x0478 (size: 0x18)
FVector GetupMotion_AomukeOrLeft_0FramePelvisLocation;
// 0x0490 (size: 0x18)
FName Ragdoll_RightLeftGetup_ForwardTailName;
// 0x04A8 (size: 0x8)
FName Ragdoll_RightLeftGetup_RightLegName;
// 0x04B0 (size: 0x8)
EPalPettingSizeType PettingSize;
// 0x04B8 (size: 0x1)
float PettingDistance;
// 0x04BC (size: 0x4)
float PettingStartAddDistance;
// 0x04C0 (size: 0x4)
float PettingEndLeaveDistance;
// 0x04C4 (size: 0x4)
float PettingCameraCenterDistance_Override;
// 0x04C8 (size: 0x4)
float PettingCameraHeight_Override;
// 0x04CC (size: 0x4)
float PettingCameraArmLength_Override;
// 0x04D0 (size: 0x4)
EPalSizeType Size;
// 0x04D4 (size: 0x1)
float Ragdoll_GravityRate;
// 0x04D8 (size: 0x4)
bool IsLookatIKAble;
// 0x04DC (size: 0x1)
float SmallDamageAnimationApplyRate;
// 0x04E0 (size: 0x4)
float SmallDamageAnimationPlayRate;
// 0x04E4 (size: 0x4)
FShooterSpringCameraParameter CameraOffsetInLiftup;
// 0x04E8 (size: 0x20)
bool IsForcedTurnWhenDamageReaction;
// 0x0508 (size: 0x1)
bool DisableNPCDamageRolling;
// 0x0509 (size: 0x1)
float CapsuleHalfHeightDefault;
// 0x050C (size: 0x4)
// 0x0510 (size: 0x30)
FName AkAttachPointName;
// 0x0540 (size: 0x8)
TSoftClassPtr<UPalFootStepEffectAssetBase> PalFootStepEffectAssetClass;
// 0x0548 (size: 0x30)
FPalStaticCharacterInfo_SpawnItem SpawnItem;
// 0x0578 (size: 0x50)
// 0x05C8 (size: 0x8)
class UPalFootStepEffectAssetBase* PalFootStepEffectAssetCache;
// 0x05D0 (size: 0x8)
TSubclassOf<class UPalActionBase> MissWazaAction;
// 0x05D8 (size: 0x8)
bool IsBoss_Database;
// 0x05E0 (size: 0x1)
bool IsTowerBoss_Database;
// 0x05E1 (size: 0x1)
EPalSpawnedCharacterType SpawnedCharacterType;
// 0x05E2 (size: 0x1)
void SetSpawnedCharacterType(EPalSpawnedCharacterType SpawnedType);

void LoadWazaActionClass(EPalWazaID WazaID);
bool IsTowerBossPal();
bool IsSwimPal();
bool IsRarePal();
bool IsFlyPal();
bool IsBossPal_Database_ExceptRare();
bool IsBossPal_Database();
bool IgnoreLeanBack();
bool IgnoreBlowAway();
EPalSpawnedCharacterType GetSpawnedCharacterType();
FPalRandomRestInfo GetRandomRestInfo();
float GetCaptureRate_ByCharacterID();
class UAnimMontage* FindMontange(const EPalActionType ActionType, bool&
bExist);
}; // Size: 0x5E8
class UPalStaticConsumeItemData : public UPalStaticItemDataBase

{
int32 RestoreHP;
// 0x0158 (size: 0x4)
int32 RestoreSP;
// 0x015C (size: 0x4)
int32 RestoreSatiety;
// 0x0160 (size: 0x4)
int32 RestoreSanity;
// 0x0164 (size: 0x4)
EPalWazaID WazaID;
// 0x0168 (size: 0x1)
int32 GetRestoreSP();
int32 GetRestoreSatiety();
int32 GetRestoreSanity();
int32 GetRestoreHP();
}; // Size: 0x170
class UPalStaticItemDataAsset : public UDataAsset
{
TMap<class FName, class UPalStaticItemDataBase*> StaticItemDataMap;
// 0x0030 (size: 0x50)
TSoftClassPtr<AActor> UndefinedVisualBlueprintClassSoft;
// 0x0080 (size: 0x30)
}; // Size: 0xB0
class UPalStaticItemDataBase : public UObject

{
FName ID;
// 0x0028 (size: 0x8)
// 0x0030 (size: 0x30)
EPalItemTypeA TypeA;
// 0x0060 (size: 0x1)
EPalItemTypeB TypeB;
// 0x0061 (size: 0x1)
int32 Rank;
// 0x0064 (size: 0x4)
int32 Rarity;
// 0x0068 (size: 0x4)
int32 Price;
// 0x006C (size: 0x4)
int32 MaxStackCount;
// 0x0070 (size: 0x4)
int32 SortID;
// 0x0074 (size: 0x4)
TSubclassOf<class UPalDynamicItemDataBase> DynamicItemDataClass;
// 0x0078 (size: 0x8)
bool bNotConsumed;
// 0x0080 (size: 0x1)
// 0x0088 (size: 0x30)
TSoftObjectPtr<UStaticMesh> StaticMeshPath;
// 0x00B8 (size: 0x30)
TSoftClassPtr<AActor> VisualBlueprintClassSoft;
// 0x00E8 (size: 0x30)
EPalDropItemType DropItemType;
// 0x0118 (size: 0x1)
float Weight;
// 0x011C (size: 0x4)
float Durability;
// 0x0120 (size: 0x4)
FName PassiveSkill;
// 0x0124 (size: 0x8)
float CorruptionFactor;
// 0x012C (size: 0x4)
float FloatValue1;
// 0x0130 (size: 0x4)
FName OverrideNameMsgID;
// 0x0134 (size: 0x8)
// 0x013C (size: 0x8)
bool UseItem(class UPalDynamicItemDataBase* DynamicItemData, const class

bool IsCorruptible();
bool HasDynamicItemClass();
bool HasActorClass();
TSoftClassPtr<AActor> GetVisualBlueprintClass(const class UObject*
FName GetPassiveSkill();
void GetNameMsgId(FName& OutMsgID);
int32 GetMaxStackCount();
FName GetId();
TSubclassOf<class UPalDynamicItemDataBase> GetDynamicItemDataClass();
void GetDescriptionMsgId(FName& OutMsgID);
TSoftClassPtr<AActor> GetActorClass();
}; // Size: 0x158
class UPalStaticItemDataManager : public UObject

{
class UPalStaticItemDataAsset* StaticItemDataAsset;
// 0x0028 (size: 0x8)
}; // Size: 0x30
class UPalStaticItemDataTable : public UObject

{
class UPalStaticItemDataAsset* DataAsset;
// 0x0028 (size: 0x8)
}; // Size: 0x30
class UPalStaticLogCollector : public UObject

{
FGuid overInventoryWeightId;
// 0x0028 (size: 0x10)
class UPalLogManager* targetLogManager;
// 0x0038 (size: 0x8)
void RegisterLogCollectEvent_BP();
void OnReadyPlayerInventoryData(class UPalPlayerDataStorage*
PlayerDataStorage);
void OnOverWeightInventory(float nowWeight);
void OnFixedWeightInventory(float nowWeight);
void OnEndedWorldAutoSave(bool IsSuccess);
}; // Size: 0x40
class UPalStaticWeaponItemData : public UPalStaticItemDataBase

{
int32 MagazineSize;
// 0x0158 (size: 0x4)
// 0x015C (size: 0x4)
int32 AttackValue;
// 0x0160 (size: 0x4)
int32 DefenseValue;
// 0x0164 (size: 0x4)
int32 GetWeaponDefense();
int32 GetWeaponBaseDamage();
int32 GetMaxMagazineSize();
}; // Size: 0x168
class UPalStatusBase : public UObject
{
bool bIsEndStatus;
// 0x0028 (size: 0x1)
FStatusDynamicParameter DynamicParameter;
// 0x002C (size: 0xC)
EPalStatusID StatusId;
// 0x0038 (size: 0x1)
float Duration;
// 0x003C (size: 0x4)
bool bIsNerverEnd;
// 0x0040 (size: 0x1)
void TickStatus(float DeltaTime);

void SetHalfDurationTimer();
void OnEndStatus();
void OnBreakStatus();
void OnBeginStatus();
void OnBeginSomeStatus();
bool IsEndStatus();
class AActor* GetOwner();
}; // Size: 0x48
class UPalStatusCollectItem : public UPalStatusBase

{
FPalStaticItemIdAndNum CollectItemInfo;
// 0x0048 (size: 0xC)
void TickStatus_Implementation(float DeltaTime);

void SetCollectItemInfo(const FPalStaticItemIdAndNum& ItemIDAndNum);
void OnEndStatus_Implementation();
void OnBreakStatus_Implementation();
void OnBeginStatus_Implementation();
void OnBeginSomeStatus_Implementation();
bool IsThrown();
bool IsServer();
bool IsRestrictedByWorkerEvent();
bool IsRestrictedByWork();
bool IsLifted();
bool IsHealth();
class UPalPlayerInventoryData* GetOwnerPlayerInventoryData();
FPalStaticItemIdAndNum GetCollectItemInfo();
void DropItem(FName ItemId, int32 DropNum, FVector SpawnLocation, FVector
ReleaseDirection);
bool CanSpawnItem();
}; // Size: 0x58
class UPalStatusComponent : public UActorComponent

{
TMap<class EPalStatusID, class TSubclassOf<UPalStatusBase>> StatusMap;
// 0x00A0 (size: 0x50)
FPalStatusComponentOnAddStatus OnAddStatus;
// 0x00F0 (size: 0x10)
void OnAddStatus(const class UPalStatusComponent* StatusComponent, EPalStatusID
StatusId, class UPalStatusBase* Status);
FPalStatusComponentOnRemoveStatus OnRemoveStatus;
// 0x0100 (size: 0x10)
void OnRemoveStatus(const class UPalStatusComponent* StatusComponent,
EPalStatusID StatusId);
TArray<class UPalStatusBase*> ExecutionStatusList;
// 0x0110 (size: 0x10)
TArray<class UPalStatusBase*> ExecutionStatusListCache;
// 0x0120 (size: 0x10)
void SomeStatus_ToAll(EPalStatusID StatusId, FStatusDynamicParameter Param);

void RemoveStatus_ToServer(EPalStatusID StatusId, int32 issuerID);
void RemoveStatus(EPalStatusID StatusId);
void OnRep_ExecutionStatusList();
void OnRemoveStatus__DelegateSignature(const class UPalStatusComponent*
StatusComponent, EPalStatusID StatusId);
void OnAddStatus__DelegateSignature(const class UPalStatusComponent*
StatusComponent, EPalStatusID StatusId, class UPalStatusBase* Status);
class UPalStatusBase* GetExecutionStatusCache(EPalStatusID StatusId);
class UPalStatusBase* GetExecutionStatus(EPalStatusID StatusId);
void BeginPlay();
void AddStatusParameter(EPalStatusID StatusId, FStatusDynamicParameter Param);
void AddStatus_ToServer(EPalStatusID StatusId, FStatusDynamicParameter Param,
int32 issuerID);
void AddStatus(EPalStatusID StatusId);
}; // Size: 0x130
class UPalStatusHungerTypeUtility : public UBlueprintFunctionLibrary

{
bool IsHunger(EPalStatusHungerType Type);

}; // Size: 0x28
class UPalStatusLifeSteal : public UPalStatusBase

{
void OnLifeSteal(int32 Damage);

int32 CalucRecoverPoint(int32 Damage);
}; // Size: 0x48
class UPalStatus_StaminaControl : public UPalStatusBase

{
bool IsLocalPlayerOrPal;
// 0x0048 (size: 0x1)
bool IsPreCliming;
// 0x0049 (size: 0x1)
void DecreaseStepStamina();
void DecreaseJumpStamina(class UPalCharacterMovementComponent* Movement);
}; // Size: 0x50
class UPalSyncTeleportComponent : public UActorComponent

{
FPalSyncTeleportComponentOnPlayerMovedClientDelegate
OnPlayerMovedClientDelegate; // 0x00B8 (size: 0x10)
void SyncTeleportPlayerMovedDynamicDelegate();
FPalSyncTeleportComponentOnPlayerMoveCompleteClientDelegate
OnPlayerMoveCompleteClientDelegate; // 0x00C8 (size: 0x10)
void SyncTeleportPlayerMovedDynamicDelegate();
class UAkAudioEvent* DefaultStartSE;
// 0x00D8 (size: 0x8)
class UPalHUDDispatchParameter_FadeWidget* FadeParameter;
// 0x00E0 (size: 0x8)
void SyncTeleportPlayerMovedDynamicDelegate__DelegateSignature();
void SyncTeleport_ToClient(const FPalSyncTeleportRequestParameter& Parameter);
void SyncTeleport(const FPalSyncTeleportRequestParameter& Parameter);
void RequestSyncTeleportStart_ToServer(const FPalSyncTeleportRequestParameter&
Parameter);
void RequestSyncTeleportMove_ToServer();
void RequestSyncTeleportEnd_ToServer();
void ReceiveSyncTeleportStartResult_ToClient(bool bIsSuccess);
void ReceiveSyncTeleportMoveResult_ToClient(bool bIsSuccess);
void ReceiveSyncTeleportEnd_ToClient(bool bIsSuccess);
void OnEndSyncTeleportFadeOut();
void OnEndSyncTeleportFadeIn();
bool IsTeleporting();
FQuat GetTeleportRotation();
FVector GetTeleportLocation();
}; // Size: 0x150
class UPalTalkWidgetParameter : public UPalHUDDispatchParameterBase

{
class UDataTable* talkDataTable;
// 0x0038 (size: 0x8)
FName startTalkSequence;
// 0x0040 (size: 0x8)
class AActor* talker;
// 0x0048 (size: 0x8)
class UPalIncidentBase* talkIncident;
// 0x0050 (size: 0x8)
bool IsCancel;
// 0x0058 (size: 0x1)
}; // Size: 0x60
class UPalTalkWindowWidgetBase : public UPalUserWidgetOverlayUI

{
class UPalNPCTalkSystem* talkSystem;
// 0x0430 (size: 0x8)
void ShowChoice(const TArray<FName>& choiceTextIDList);

void SetTalkerName(const FName& Text);
void SetMainTextList(const TArray<FName>& textIDList);
void RequestClose();
EPalNPCTalkSelectedChoiceResult NotifyChoiceIndex(int32 Index);
bool HasArguments();
void CreateTextAppliedArgments(const FText& OrgText, FText& OutText);
void AddArgument(FString Key, const FText& Text);
}; // Size: 0x448
class UPalTechnologyData : public UObject

{
FPalTechnologyDataOnUpdateTechnologyPoint OnUpdateTechnologyPoint;
// 0x0028 (size: 0x10)
void OnUpdateTechnologyPoint(int32 TechnologyPoint);
FPalTechnologyDataOnUpdateBossTechnologyPoint OnUpdateBossTechnologyPoint;
// 0x0038 (size: 0x10)
void OnUpdateTechnologyPoint(int32 TechnologyPoint);
FPalTechnologyDataOnUnlockedAnyTechnology OnUnlockedAnyTechnology;
// 0x0048 (size: 0x10)
void OnUnlockedAnyTechnology();
FPalTechnologyDataOnNewUnlockedUpdate OnNewUnlockedUpdate;
// 0x0058 (size: 0x10)
void OnNewUnlockedUpdateDelegate();
FPalTechnologyDataSet technologyDataSet;
// 0x0068 (size: 0x18)
FPalTechnologyDataTableRowBase emptyTechnologyData;
// 0x0080 (size: 0x40)
FPalTechnologyRecipeUnlockDataTableRow emptyRecipeTechnologyData;
// 0x00C0 (size: 0x60)
TArray<FName> UnlockedTechnologyNameArray;
// 0x0120 (size: 0x10)
// 0x0130 (size: 0x10)
// 0x0140 (size: 0x4)
int32 bossTechnologyPoint;
// 0x0144 (size: 0x4)
TArray<FName> DefaultLockRecipeNameArray;
// 0x0148 (size: 0x10)
TArray<FName> DefaultLockBuildObjectNameArray;
// 0x0158 (size: 0x10)
void RequestUnlockRecipeTechnology(const FName& UnlockTechnologyName);

void RequestAddTechnologyPointByItem(const FPalItemSlotId& ConsumeSlotId);
void RemoveNewUnlockedFlag(const FName& technologyName);
void OnUpdateTechnologyPoint__DelegateSignature(int32 TechnologyPoint);
void OnUpdateLocalPlayerLevel(int32 addLevel, int32 nowLevel);
void OnUnlockedAnyTechnology__DelegateSignature();
void OnRep_UnlockedTechnologyNameArray();
void OnRep_TechnologyPoint();
void OnRep_BossTechnologyPoint();
void OnNewUnlockedUpdateDelegate__DelegateSignature();
bool IsUnlockRecipeTechnology(const FName& technologyName);
bool IsUnlockCraftRecipe(const FName& craftRecipeName);
bool IsUnlockBuildObject(const FName& BuildObjectId);
bool IsUnlockableRecipeTechnology(const FName& technologyName);
bool IsNewUnlockedTechnology(const FName& technologyName);
bool IsNewUnlockedBuild_Radial(const FName& BuildName);
bool IsExistNewUnlockedTechnology();
int32 GetTechnologyPoints();
FText GetTechnologyName(const FName& technologyName);
FText GetTechnologyDesc(const FName& technologyName);
FPalTechnologyDataTableRowBase GetTechlonogyBaseData(const FName&
technologyName);
TArray<FName> GetRecipeTechnologyRowNameArray();
FPalTechnologyRecipeUnlockDataTableRow GetRecipeTechlonogy(const FName&
technologyName);
int32 GetBossTechnologyPoints();
void FilteringUnlockedRecipe(const TArray<FName>& OriginalResipeIdArray,
TArray<FName>& OutRecipeIdArray);
void CheckNewUnlockedFlag_Radial(const FName& BuildName);
}; // Size: 0x168
class UPalTemperatureComponent : public UBoxComponent

{
FPalTemperatureComponentOnChangeTemperatureDelegate
OnChangeTemperatureDelegate; // 0x0578 (size: 0x10)
void OnChangeTemperatureDelegate(int32 NextTemperature);
int32 CurrentTemperature;
// 0x05D8 (size: 0x4)
FName SelfKeyName;
// 0x05DC (size: 0x8)
void RemoveHeatSource(FName UniqueName);

void OnChangeTemperatureDelegate__DelegateSignature(int32 NextTemperature);
void OnChangeHour();
int32 GetCurrentTemperature();
void CallOnChangeTemperature(int32 Next);
void CallAllDelegate();
void AddHeatSourceInfo(FName UniqueName, FPalHeatSourceInfo HeatInfo);
void AddHeatSource(FName UniqueName, int32 HeatLevel);
}; // Size: 0x5F0
class UPalTextBlockBase : public UCommonTextBlock

{
FDataTableRowHandle BindTextDatatableHandle;
// 0x0368 (size: 0x10)
bool IsAutoTextSetWhenWidgetRebuilt;
// 0x0378 (size: 0x1)
bool IsAutoAdjustScale;
// 0x0379 (size: 0x1)
int32 MaxWidth;
// 0x037C (size: 0x4)
void UpdateRowName(const FName RowName);

void SetText_GDKInternal(bool IsSuccess, FString OutString);
FText GetBindedOriginalText();
bool BP_ReflectText();
}; // Size: 0x380
class UPalTimeManager : public UPalWorldSubsystem

{
FPalTimeManagerOnNightStartDelegate OnNightStartDelegate;
// 0x0080 (size: 0x10)
void OnNightStartDelegate();
FPalTimeManagerOnNightEndDelegate OnNightEndDelegate;
// 0x0090 (size: 0x10)
void OnNightEndDelegate();
FPalTimeManagerOnPreNightSkipDelegate OnPreNightSkipDelegate;
// 0x00A0 (size: 0x10)
void OnNightSkipDelegate();
FPalTimeManagerOnNightSkipDelegate OnNightSkipDelegate;
// 0x00B0 (size: 0x10)
void OnNightSkipDelegate();
FPalTimeManagerOnChangeHoursDelegate OnChangeHoursDelegate;
// 0x00C0 (size: 0x10)
void OnChangeHoursDelegate();
FPalTimeManagerOnChangeMinutesDelegate OnChangeMinutesDelegate;
// 0x00D0 (size: 0x10)
void OnChangeMinutesDelegate();
TArray<class APalPlayerCharacter*> SleepingPlayers;
// 0x0100 (size: 0x10)
FTimerHandle NightSkipTimerHandle;
// 0x0128 (size: 0x8)
void TimerEventDelegate__DelegateSignature();
void SetGameTime_FixDay(const int32 NextHour);
void RemoveSleepPlayer(class APalPlayerCharacter* Player);
FString PalTimeSecondsToString(float InSeconds);
void OnNightStartDelegate__DelegateSignature();
void OnNightSkipDelegate__DelegateSignature();
void OnNightEndDelegate__DelegateSignature();
void OnChangeMinutesDelegate__DelegateSignature();
void OnChangeHoursDelegate__DelegateSignature();
FString GetDebugTimeString();
float GetDayTimePassRate();
int32 GetCurrentPalWorldTime_Second();
int32 GetCurrentPalWorldTime_Minute();
int32 GetCurrentPalWorldTime_Hour();
int32 GetCurrentPalWorldTime_Day();
float GetCurrentPalWorldHoursFloat();
EPalOneDayTimeType GetCurrentDayTimeType();
void ClearTimer(const class UObject* WorldContextObject, const FPalTimerHandle&
Handle);
FPalTimerHandle AddTimerEventBySpan(const FAddTimerEventBySpanDelegate&
Delegate, const float Hours, const float Minutes, const float Seconds);
void AddSleepPlayer(class APalPlayerCharacter* Player);
}; // Size: 0x130
class UPalTimerPointLightComponent : public UPointLightComponent

{
class UCurveFloat* LightCurve;
// 0x0418 (size: 0x8)
bool bIsLocalOnly;
// 0x0420 (size: 0x1)
float DefaultIntensity;
// 0x0424 (size: 0x4)
FFlagContainer DisableFlag;
// 0x0428 (size: 0x50)
FFlagContainer EnableWhenDayTimeFlag;
// 0x0478 (size: 0x50)
void SetEnableWhenDayTime(FName Key, bool Enable);

void CheckOtomoPal_AndSetRange(class APalCharacter* SelfCharacter);
}; // Size: 0x4D0
class UPalToolUtility : public UBlueprintFunctionLibrary

{
void CopyFileOverride(FString sourceFileName, FString destFileName);

}; // Size: 0x28
class UPalTutorialManager : public UPalWorldSubsystem

{
FPalTutorialManagerOnTutorialTriggered OnTutorialTriggered;
// 0x0078 (size: 0x10)
void TutorialTriggerDelegate(FDataTableRowHandle TutorialMsg);
TArray<class UPalTutorialTriggerBase*> TutorialTriggers;
// 0x0088 (size: 0x10)
class UDataTable* MsgDataTable;
// 0x0098 (size: 0x8)
class UDataTable* TutorialTriggersDataTable;
// 0x00A0 (size: 0x8)
void TutorialTriggerDelegate__DelegateSignature(FDataTableRowHandle
TutorialMsg);
void TutorialTrigger_Common(EPalTutorialTriggerConditionType TriggerType);
void TutorialTrigger_Capture(FPalUIPalCaptureInfo CaptureInfo, bool
CaptureSuccess);
}; // Size: 0xF8
class UPalTutorialQuestManager : public UPalQuestManager

{
TArray<FPalOrderedQuestSaveData> CachedOrderedQuestSaveData;
// 0x00B8 (size: 0x10)
}; // Size: 0xC8
class UPalTutorialTriggerBase : public UObject

{
bool Checked;
// 0x0028 (size: 0x1)
bool CanTriggerMultiple;
// 0x0029 (size: 0x1)
FDataTableRowHandle TutorialMsgID;
// 0x0030 (size: 0x10)
EPalTutorialTriggerType GetType();
}; // Size: 0x40
class UPalTutorialTrigger_AddItem : public UPalTutorialTriggerBase

{
TArray<FName> StaticItemIds;
// 0x0040 (size: 0x10)
EPalItemTypeB ItemCategory;
// 0x0050 (size: 0x1)
// 0x0054 (size: 0x8)
}; // Size: 0x60
class UPalTutorialTrigger_Capture : public UPalTutorialTriggerBase

{
EPalTutorialTriggerConditionType TriggerType;
// 0x0040 (size: 0x1)
int32 TriggerCount;
// 0x0044 (size: 0x4)
}; // Size: 0x48
class UPalTutorialTrigger_Common : public UPalTutorialTriggerBase

{
// 0x0040 (size: 0x1)
}; // Size: 0x48
class UPalTutorialTrigger_Individual : public UPalTutorialTriggerBase

{
// 0x0040 (size: 0x1)
}; // Size: 0x48
class UPalTutorialTrigger_Respawn : public UPalTutorialTriggerBase
{
TArray<EPalLocationType> LocationTypes;
// 0x0040 (size: 0x10)
}; // Size: 0x50
class UPalUIActionWidgetBase : public UCommonActionWidget

{
void OverrideImage(FSlateBrush OverrideBrush);

FText GetLocalizedDisplayText();
}; // Size: 0x450
class UPalUIActionWidgetForPlayerInput : public UPalUserWidget

{
FName BindInputActionName;
// 0x0408 (size: 0x8)
FName OverrideMouseInputActionName;
// 0x0410 (size: 0x8)
FName OverridePadInputActionName;
// 0x0418 (size: 0x8)
int32 OverrideInputType;
// 0x0420 (size: 0x4)
void UpdateImage(FSlateBrush newBrush);

void UnbindInputMethodChangeEvent();
void OnKeyConfigChanged();
void ChangeOverrideType(int32 Type);
void ChangeOverridePadBindActionName(const FName& NewActionName);
void ChangeOverrideMouseBindActionName(const FName& NewActionName);
void ChangeBindActionName(const FName& NewActionName);
void BindInputMethodChangeEvent();
}; // Size: 0x428
class UPalUIAimReticleBase : public UPalUserWidget

{
void TickDisplayOutline(const FHitResult& HitResult);

void IsAssignableToHitResult(const FHitResult& HitResult, class
UPalCharacterParameterComponent* checkCharacterParam,
FPalUIAimReticleMapObjectAssignableData& outAssignableData);
}; // Size: 0x410
class UPalUIBaseCampManageModel : public UObject

{
TSubclassOf<class UPalUIPalBoxModel> PalBoxClass;
// 0x0028 (size: 0x8)
class UPalUIPalBoxModel* PalBox;
// 0x0030 (size: 0x8)
TSubclassOf<class UPalUIBaseCampWorkersModel> BaseCampWorkersClass;
// 0x0038 (size: 0x8)
class UPalUIBaseCampWorkersModel* BaseCampWorkers;
// 0x0040 (size: 0x8)
TSubclassOf<class UPalUIBaseCampWaitersModel> BaseCampWaitersClass;
// 0x0048 (size: 0x8)
class UPalUIBaseCampWaitersModel* BaseCampWaiters;
// 0x0050 (size: 0x8)
TSubclassOf<class UPalUIBaseCampPartyModel> BaseCampPartyClass;
// 0x0058 (size: 0x8)
class UPalUIBaseCampPartyModel* BaseCampParty;
// 0x0060 (size: 0x8)
void MoveWaiterToWorker(const int32 SlotIndex);

void MoveSlotToPosses(class UPalIndividualCharacterSlot* Slot);
void MoveSlotToParty(class UPalIndividualCharacterSlot* Slot);
void MoveSlotToLost(class UPalIndividualCharacterSlot* Slot);
void Initialize(const FGuid& BaseCampId);
}; // Size: 0x68
class UPalUIBaseCampPartyModel : public UObject

{
void SelectHandleSlot(const int32 DisplayIndex, const EPalItemSlotPressType

PressType);
int32 GetSlotCountInPage();
TArray<class UPalIndividualCharacterSlot*> GetCurrentPageSlots();
}; // Size: 0x28
class UPalUIBaseCampTaskBase : public UPalUserWidgetOverlayUI

{
TSubclassOf<class UPalBaseCampTaskChecker> baseCampTaskCheckerClass;
// 0x0430 (size: 0x8)
FGuid BaseCampId;
// 0x0438 (size: 0x10)
int32 lastCheckedBaseCampLevel;
// 0x0448 (size: 0x4)
class UPalBaseCampTaskChecker* taskChecker;
// 0x0450 (size: 0x8)
bool TryBaseCampLevelUp();
void SetTargetBaseCampID(const FGuid& TargetBaseCampId);
bool IsCampLevelMax();
bool GetNowLevelTaskData(FPalBaseCampTaskDataSet& outTaskData);
class UPalBaseCampModel* GetBaseCampModel();
bool CheckTask(FPalBaseCampTaskCheckedData& outChedckedData);
}; // Size: 0x458
class UPalUIBaseCampWaitersModel : public UObject

{

PressType);
}; // Size: 0x28
class UPalUIBaseCampWorkerListModel : public UObject

{
FPalUIBaseCampWorkerListModelOnUpdatePageDelegate OnUpdatePageDelegate;
// 0x0028 (size: 0x10)
void UpdatePageDelegate(class UPalUIBaseCampWorkerListModel* Model);
FGuid BaseCampId;
// 0x0038 (size: 0x10)
FGuid CurrentDisplayBaseCampId;
// 0x0048 (size: 0x10)
void UpdatePageDelegate__DelegateSignature(class UPalUIBaseCampWorkerListModel*
Model);
PressType);
void SelectFirstEmptyHandleSlot();
void GetCurrentPageSlots(TArray<class UPalIndividualCharacterSlot*>& OutSlots);
FGuid GetCurrentDisplayBaseCampId();
FString GetBaseCampName();
}; // Size: 0x58
class UPalUIBaseCampWorkersModel : public UObject

{
FPalUIBaseCampWorkersModelOnUpdatePageDelegate OnUpdatePageDelegate;
// 0x0028 (size: 0x10)
void UpdatePageDelegate(class UPalUIBaseCampWorkersModel* Model);
int32 CurrentPageIndex;
// 0x0048 (size: 0x4)
void UpdatePageDelegate__DelegateSignature(class UPalUIBaseCampWorkersModel*

Model);
void ToPage(const int32 PageIndex);
PressType);
void SelectFirstEmptyHandleSlot();
int32 GetWholePageCount();
class UPalBaseCampModel* GetBaseCampModel(const int32 PageIndex);
}; // Size: 0x50
class UPalUIBuildModel : public UObject

{
FName ForceBuildPalBoxTextId;
// 0x0028 (size: 0x8)
void StartDismantleMode(const int32 LastSelectedIndex, bool bFromRadialMenu);

void StartBuildObject(const FName BuildObjectId, bool bFromRadialMenu);
void OnOpenMenu();
void OnConfimAlert_ForceBuildPalBox(const bool bDialogBool);
void GetBuildObjectDataArrayForTypeAByTypeB(const EPalBuildObjectTypeA TypeA,
TArray<FPalBuildObjectDataSetTypeB>& OutArray);
void FinishDismantleMode();
}; // Size: 0x30
class UPalUIBuildProgressWorldHUD : public UPalUserWidgetWorldHUD

{
// 0x0408 (size: 0x8)
void SetProgress(class UPalWorkProgress* Work);

void OnUpdatedAssignCharacter(class UPalWorkBase* TargetWork);
void OnRequestClose(class UPalBuildProcess* Process);
void CloseSelf();
void BindUpdateAssingedCharacterDelegate();
}; // Size: 0x410
class UPalUIBuilding : public UPalUserWidgetStackableUI
{
void BuildObjectSuccessed();
void BuildObjectFailed(const int32 ResultIntValue);
}; // Size: 0x420
class UPalUIBuildingModel : public UObject

{
// 0x0028 (size: 0x8)
void Setup(const FName InBuildObjectId);

void RotateTarget(const bool bRight);
void OnUpdateInventory(class UPalItemContainer* Container);
void FinishBuilding();
void Dispose();
void BuildObject(const bool bContinuously);
}; // Size: 0x30
class UPalUIBuildingParameter : public UPalHUDDispatchParameterBase

{
int32 BuildObjectId;
// 0x0038 (size: 0x4)
}; // Size: 0x40
class UPalUICharacterDisplayModel : public UObject

{
FPalUICharacterDisplayModelOnUpdateDelegate OnUpdateDelegate;
// 0x0028 (size: 0x10)
void UpdateDelegate(class UPalUICharacterDisplayModel* Model);
TArray<class UPalIndividualCharacterSlot*> DisplaySlots;
// 0x0038 (size: 0x10)
TArray<FPalInstanceID> NotSelectableIndividualIds;
// 0x0048 (size: 0x10)
void UpdateDelegate__DelegateSignature(class UPalUICharacterDisplayModel*

Model);
bool IsSelectable(const int32 DisplayIndex);
int32 GetSlotCount();
void GetDisplaySlots(TArray<class UPalIndividualCharacterSlot*>& OutSlots);
}; // Size: 0x68
class UPalUICharacterHPGaugeBase : public UPalUserWidget

{
void UpdateVisibility();
void UpdateText();
void UpdatePosition();
void SetupGaugeColor();
void SetupEvents();
void SetTargetCharacter(class APalCharacter* TargetCharacter);
void SetHPPercent(float Percent);
void OnRequestClose();
}; // Size: 0x408
class UPalUICharacterMakeBase : public UPalUserWidgetOverlayUI

{
void RequestChangePlayerName(FString NewPlayerName);
bool GetPlayerMakeInfo(FPalPlayerDataCharacterMakeInfo& OutMakeInfo);
void ApplyMakeInfoToPlayerData(const FPalPlayerDataCharacterMakeInfo&
MakeInfo);
}; // Size: 0x430
class UPalUICharacterStatus : public UPalUserWidgetOverlayUI

{
void RemoveActiveSkill(class UPalIndividualCharacterHandle* targetHandle,

EPalWazaID targetWazaID);
void DropCharacter(class UPalIndividualCharacterHandle* targetHandle);
void ChangeNickname(class UPalIndividualCharacterHandle* targetHandle, const
FText& newNickName);
void ChangeActiveSkill(class UPalIndividualCharacterHandle* targetHandle,
EPalWazaID changeWazaID, EPalWazaID newWazaID);
void AddActiveSkill(class UPalIndividualCharacterHandle* targetHandle,
EPalWazaID newWazaID);
}; // Size: 0x430
class UPalUICompassIconBase : public UPalUserWidget

{
}; // Size: 0x408
class UPalUIConvertItemModel : public UObject

{
class UPalUIProductSettingModel* ProductSettingModel;
// 0x0028 (size: 0x8)
TWeakObjectPtr<class UPalMapObjectConvertItemModel> WeakConvertItemModel;
// 0x0030 (size: 0x8)
void UpdateProductSetting_TransportToStorage(const bool bOn);

void UpdateProductSetting();
bool TryGetConcreteModel(class UPalMapObjectConvertItemModel*& Model);
void StartProduction();
void Initialize(class UPalMapObjectConvertItemModel* InModel);
FText GetBuildObjectName();
EPalUIConvertItemRequestStartResponse CanStartProduction();
void CancelProduct();
}; // Size: 0x38
class UPalUIDamageTextBase : public UPalUserWidget

{
FPalUIDamageTextBaseOnRequestCloseDelegate OnRequestCloseDelegate;
// 0x0408 (size: 0x10)
void RequestCloseDelegate(class UPalUIDamageTextBase* selfWidget);
float DisplayTime;
// 0x0418 (size: 0x4)
float displayTimer;
// 0x041C (size: 0x4)
EPalDamageTextSeq nowSeq;
// 0x0420 (size: 0x1)
// 0x0428 (size: 0x18)
void UpdatePosition(const FVector& targetWorldLocation);

void StartDisplay(float inDisplayTime);
void SetTargetWorldLocation(const FVector& NewLocation);
void SetDamageValue(int32 InValue);
void SetDamageColor(const FSlateColor& inColor);
void ResetTimer();
void RequestCloseDelegate__DelegateSignature(class UPalUIDamageTextBase*
selfWidget);
void OnRequestClose();
}; // Size: 0x440
class UPalUIDelayGaugeCalculator : public UObject

{
FPalUIDelayGaugeCalculatorOnStartDelayGaugeTimerDelegate
OnStartDelayGaugeTimerDelegate; // 0x0028 (size: 0x10)
void StartDelayGaugeTimerDelegate();
FPalUIDelayGaugeCalculatorOnEndDelayGaugeDelegate OnEndDelayGaugeDelegate;
// 0x0038 (size: 0x10)
void EndDelayGaugeDelegate();
class UProgressBar* mainBar;
// 0x0048 (size: 0x8)
class UProgressBar* subBar;
// 0x0050 (size: 0x8)
float delayGaugeTimer;
// 0x0058 (size: 0x4)
float delayGaugeStartTime;
// 0x005C (size: 0x4)
float delayGaugeProgressPerSecond;
// 0x0060 (size: 0x4)
void Update(float DeltaTime);

void StartDelayGaugeTimerDelegate__DelegateSignature();
void Setup(class UProgressBar* inMainBar, class UProgressBar* inSubBar);
void SetPercentForce(float Percent);
void SetPercent(float Percent);
void EndDelayGaugeDelegate__DelegateSignature();
}; // Size: 0x68
class UPalUIDialogBase : public UPalUserWidgetOverlayUI

{
}; // Size: 0x430
class UPalUIDismantling : public UPalUserWidgetStackableUI

{
void DismantleObjectSuccessed();
void DismantleObjectFailed();
}; // Size: 0x420
class UPalUIDismantlingModel : public UObject

{
// 0x0028 (size: 0x8)
void Setup();
void FinishDismantling();
void Dispose();
void DismantleObject(const bool bContinuously);
}; // Size: 0x30
class UPalUIGameOver : public UPalUserWidgetOverlayUI
{
bool IsExistRespawnLocation();
}; // Size: 0x430
class UPalUIGuildMenu : public UPalUserWidgetOverlayUI

{
void RequestExitGuild();
void RequestChangeGuildName(FString NewGuildName);
void RequestChangeAdmin(const FGuid& TargetPlayerUId);
void RequestBanPlayer(const FGuid& TargetPlayerUId);
void OnUpdatedMemberInfo_Binded(const class UPalGroupGuildBase* Guild, const
FGuid& PlayerUId, const FPalGuildPlayerInfo& PlayerInfo);
void OnUpdatedMemberInfo(const FGuid& PlayerUId, const
FPalUIGuildMemberDisplayInfo& PlayerInfo);
void OnUpdatedGuildName_Binded(FString NewGuildName);
void OnUpdatedGuildName(FString NewGuildName);
void OnRemovedMemberInfo(const FGuid& PlayerUId);
bool IsExistPlayer(const FGuid& PlayerUId);
bool IsAdminLocalPlayer();
class UPalGroupGuildBase* GetMyGuild();
void GetGuildName(FString& OutGuildName);
void GetGuildMemberInfo(TMap<class FGuid, class FPalUIGuildMemberDisplayInfo>&
OutDisplayInfoMap);
void GetAdminPlayerUId(FGuid& OutAdminPlayerUId);
bool CanExitGuild();
}; // Size: 0x430
class UPalUIHUDLayoutBase : public UCommonActivatableWidget

{
void VisibilityOverride(ESlateVisibility changedVisibility);

void RemoveWorldHUD(class UPalUserWidgetWorldHUD* Widget);
void RemoveHUD(class UPalUserWidget* Widget);
void AddWorldHUD(class UPalUserWidgetWorldHUD* Widget);
void AddHUD(class UPalUserWidget* Widget, const int32 ZOrder);
}; // Size: 0x3C8
class UPalUIInGameGeneralDispatchEventReciever : public UPalUserWidget

{
void OpenDismantlingUIFromRadialMenu(const int32 LastSelectedIndex);

void OpenDismantlingUI();
void OpenBuildingUIFromRadialMenu(const FName BuildObjectId);
void OpenBuildingUI(const FName BuildObjectId);
void CloseDismantlingUI();
void CloseBuildingUI();
}; // Size: 0x408
class UPalUIInGameInputListener : public UPalUserWidgetStackableUI

{
void OpenBuildRadialMenuWithSelectedIndex(const int32 SelectedIndex);

void OpenBuildRadialMenu(const FName BuildObjectId);
void OpenBuildMenu(const int32 BuildObjectTypeA);
}; // Size: 0x420
class UPalUIInGameMainMenuBuildModel : public UObject
{
void Setup();
void Dispose();
}; // Size: 0x28
class UPalUIInGameMainMenuInventoryModel : public UObject

{
}; // Size: 0x28
class UPalUIInGameMainMenuModel : public UObject

{
}; // Size: 0x28
class UPalUIInputGuard : public UPalUserWidget

{
void OnTriggerReleaseGuardInput();
}; // Size: 0x408
class UPalUIInsideBaseCampCanvas : public UPalUserWidget

{
FPalUIInsideBaseCampCanvasOnEnterPalBoxAreaDelegate OnEnterPalBoxAreaDelegate;
// 0x0408 (size: 0x10)
void OnEnterPalBoxAreaDelegate();
FPalUIInsideBaseCampCanvasOnLeavePalBoxAreaDelegate OnLeavePalBoxAreaDelegate;
// 0x0418 (size: 0x10)
void OnLeavePalBoxAreaDelegate();
class UPalBaseCampTaskChecker* taskChecker;
// 0x0428 (size: 0x8)
float palboxAreaRange;
// 0x0430 (size: 0x4)
TSubclassOf<class UPalLogWidgetBase> allTaskCompletedLogClass;
// 0x0438 (size: 0x8)
FGuid lastInsideBaseCampID;
// 0x0440 (size: 0x10)
TMap<class FPalDataTableRowName_ItemData, class
FPalInsideBaseCampUI_DisplayItemInfo> displayItemInfoMap; // 0x0450 (size: 0x50)
FPalBaseCampTaskCheckedData CachedTaskCheckData;
// 0x04A0 (size: 0x60)
void UnregisterTaskProgressEvent(const class UPalBaseCampModel* Model);

void ResetCachedTaskCheckData();
void RemoveAllTaskCompletedLog();
void RegisterTaskProgressEvent();
void OnNotAvailableInsideBaseCampMapObjectConcreteModel(class
UPalMapObjectConcreteModelBase* ConcreteModel);
void OnLeavePalBoxAreaDelegate__DelegateSignature();
void OnEnterPalBoxAreaDelegate__DelegateSignature();
void OnAvailableInsideBaseCampMapObjectConcreteModel(class
UPalMapObjectConcreteModelBase* ConcreteModel);
bool GetTaskData(FPalBaseCampTaskDataSet& outTaskData);
void GetBaseCampPalSlots(TArray<class UPalIndividualCharacterSlot*>& OutSlots);
int32 GetBaseCampPalBedCount();
bool CheckTask(FPalBaseCampTaskCheckedData& outCheckedData);
void CheckItemNum(TMap<FName, int64>& outItemNumMap, int64& outFoodNum);
void CheckInsidePalBox();
}; // Size: 0x518
class UPalUIInventoryEquipment : public UPalUserWidget

{
void SwapItemSlot(class UPalItemSlot* SlotA, class UPalItemSlot* SlotB);

void SwapEquipmentByLiftItem(EPalPlayerEquipItemSlotType slotType);
void RequestUpdatePlayerStatusPoint(const TMap<FName, int32>& AddPointMap);
void QuickSortInventory();
}; // Size: 0x458
class UPalUIInventoryModel : public UObject

{
FPalUIInventoryModelOnUpdateContainerContentDelegate
OnUpdateContainerContentDelegate; // 0x0028 (size: 0x10)
void UpdateContainerContentDelegate();
FPalUIInventoryModelOnFinishedItemTrashDelegate OnFinishedItemTrashDelegate;
// 0x0038 (size: 0x10)
void FinishedItemTrashDelegate(bool Result);
FPalUIInventoryModelOnFinishedItemDropDelegate OnFinishedItemDropDelegate;
// 0x0048 (size: 0x10)
void FinishedItemDropDelegate(bool Result);
class UPalItemContainerMultiHelper* InventoryContainers;
// 0x0058 (size: 0x8)
FPalItemSlotId tmpLiftedItemSlotId;
// 0x0060 (size: 0x14)
FPalItemAndNum tmpLiftedItemAndNum;
// 0x0074 (size: 0x2C)
void UpdateContainerContentDelegate__DelegateSignature();
void TryMoveSlotToInventory(class UPalItemSlot* fromSlot, bool tryAutoEquip);
void TryMoveContainerToInventory(class UPalItemContainer* fromContainer, bool
tryAutoEquip);
bool TryGetInventoryContainer(const EPalPlayerInventoryType Type, class
void TryFillSlotToTargetContainerFromInventory(const FPalContainerId&
ToContainerId);
void TryFillSlotToInventoryFromTargetContainer(const FPalContainerId&
FromContainerId);
void TrashLiftUpItem();
void TrashItemFromDropSlot();
void Setup();
void SelectItemSlot(const FPalItemSlotId SlotID, const EPalItemSlotPressType
PressType);
void ResetLiftItem();
void RequestSortInventory();
void OnFinishedTrashItemDialog(bool Result);
void OnFinishedTrashItemAlert(bool Result);
void OnFinishedDropItem(bool Result);
bool IsExistItems(TArray<FPalStaticItemIdAndNum> RequiredItems);
void FinishedItemTrashDelegate__DelegateSignature(bool Result);
void FinishedItemDropDelegate__DelegateSignature(bool Result);
void DropLiftUpItem();
void DropItemFromDropSlot();
void Dispose();
bool CheckLiftItemTypeB(EPalItemTypeB checkType);
bool CheckLiftItemTypeA(EPalItemTypeA checkType);
}; // Size: 0xA0
class UPalUIItemBoxModel : public UObject

{
}; // Size: 0x28
class UPalUIItemPossessStatusIndicator : public UPalUserWidgetWorldHUD

{
}; // Size: 0x408
class UPalUIItemPossessStatusIndicatorParameter : public

{
class UPalIndividualCharacterHandle* TargetCharacter;
// 0x0038 (size: 0x8)
}; // Size: 0x40
class UPalUIItemShopBase : public UPalUserWidgetOverlayUI

{
bool TrySteal(const FGuid& buyProductID, const int32 stealNum);

bool TrySell(const TArray<class UPalItemSlot*>& SellItemSlots);
bool TryBuy(const FGuid& buyProductID, const int32 BuyNum);
bool GetMyShop(class UPalShopBase*& OutShop);
}; // Size: 0x460
class UPalUIJoinGameBase : public UPalUserWidgetOverlayUI

{
bool bIsShowIgnoreVersionServer;
// 0x0430 (size: 0x1)
TArray<FString> OfficialServerIPRangeList;
// 0x0438 (size: 0x10)
TArray<FPalUIServerDisplayData> CachedServerDisplayInfo;
// 0x0448 (size: 0x10)
void RequestOfficialServerIPRange();
void RequestGetServerList(EPalUIServerListFilterType Type, FString Region, bool
IsCleanCache, bool NextPage);
void OnCompleteOfficialServerIPRange(const FString ResponseBody, bool
bResponseOK, int32 ResponseCode);
void OnCompleteGetServerListEvent();
void OnCompleteFindSessions(bool IsSuccess, const
void ConnectServerByAddress(FString Address, int32 Port);
void ConnectServer(const FPalUIServerDisplayData& ServerDisplayData);
void CollectServerDisplayInfo(const FPalUIServerDataCollectInfo& CollectInfo,
TArray<FPalUIServerDisplayData>& OutServerInfo);
}; // Size: 0x458
class UPalUIJoinGameInputCodeBase : public UPalUserWidgetOverlayUI

{
FString CahcedInputInviteCode;
// 0x0430 (size: 0x10)
void VerifyPassword(FString InputPassword);

void VerifyInviteCode(FString InputCode);
void OnNotifyVerifyPassword(bool IsMatchPassword);
void OnNotifyVerifyInviteCode(bool IsValidCode, bool IsRequirePassword);
void OnCompletedJoinSession(bool IsSuccess, JoinSessionResultType Type);
void OnCompletedFindSessions(bool IsSuccess, const
}; // Size: 0x440
class UPalUILiftSlotModel : public UObject

{
FPalUILiftSlotModelOnUpdateDelegate OnUpdateDelegate;
// 0x0028 (size: 0x10)
void OnUpdateDelegate();
FPalUILiftSlotModelOnUpdateHandleSlotDelegate OnUpdateHandleSlotDelegate;
// 0x0038 (size: 0x10)
void OnUpdateHandleSlotDelegate(class UPalIndividualCharacterSlot*
TargetHandleSlot);
FPalUILiftSlotModelOnUpdateIconDelegate OnUpdateIconDelegate;
// 0x0048 (size: 0x10)
void OnUpdateIconDelegate(TSoftObjectPtr<UTexture2D> IconTexture);
FPalUILiftSlotModelOnUpdateCountDelegate OnUpdateCountDelegate;
// 0x0058 (size: 0x10)
void OnUpdateCountDelegate(int32 Count);
FPalUILiftSlotModelOnFailedItemOperationDelegate OnFailedItemOperationDelegate;
// 0x0068 (size: 0x10)
void OnFailedItemOperationDelegate();
FPalItemSlotId ItemSourceSlotId;
// 0x0078 (size: 0x14)
FPalItemAndNum ItemInfo;
// 0x008C (size: 0x2C)
class UPalIndividualCharacterSlot* CharacterSlot;
// 0x00D0 (size: 0x8)

Type);
void SelectCharacterSlot(const FPalCharacterSlotId SlotID, const
EPalItemSlotPressType Type);
void ResetLiftItem();
void OnUpdateLiftItemSourceSlot(class UPalItemSlot* Slot);
void OnUpdateLiftHandleSlot(class UPalIndividualCharacterSlot* Slot, class
void OnUpdateIconDelegate__DelegateSignature(TSoftObjectPtr<UTexture2D>
IconTexture);
void OnUpdateHandleSlotDelegate__DelegateSignature(class
UPalIndividualCharacterSlot* TargetHandleSlot);
void OnUpdateDelegate__DelegateSignature();
void OnUpdateCountDelegate__DelegateSignature(int32 Count);
void OnFailedItemOperationDelegate__DelegateSignature();
bool IsLift();
}; // Size: 0xF0
class UPalUILoadOutModel : public UObject

{
EPalPlayerInventoryType draggedTargetContainerType;
// 0x0028 (size: 0x1)
bool TryGetContainer(EPalPlayerInventoryType targetType, class

PressType);
bool CanSetItem(const FPalItemData& ItemData);
}; // Size: 0x30
class UPalUILocalWorldSelectBase : public UPalUserWidgetOverlayUI
{
TMap<class FString, class FPalWorldBaseInfoData> LoadedBaseInfoMap;
// 0x0430 (size: 0x50)
bool SelectWorld(FString WorldSaveDirectoryName, FString WorldName,

FPalOptionWorldSaveData& OptionWorldData);
void GetWorldDisplayInfo(TMap<class FString, class
FPalUILocalWorldDisplayData>& OutDisplayInfo);
TArray<FPalUILocalWorldDisplayData> GetSortedWorldDisplayInfoArray(const
TMap<class FString, class FPalUILocalWorldDisplayData>& DisplayInfoMap);
bool DeleteWorld(FString WorldSaveDirectoryName);
}; // Size: 0x480
class UPalUIManager : public UObject

{
}; // Size: 0x28
class UPalUIManagerSubsystem : public UGameUIManagerSubsystem

{
}; // Size: 0x78
class UPalUIMapObjectHPWorldHUD : public UPalUserWidgetWorldHUD

{
}; // Size: 0x408
class UPalUIMapObjectStatusIndicatorBase : public UPalUserWidgetWorldHUD

{
EPalWorkSuitability GetWorkSuitability();
}; // Size: 0x408
class UPalUIMapObjectStatusIndicatorParameterBase : public

{
class UPalMapObjectConcreteModelBase* GetConcreteModel();

}; // Size: 0x48
class UPalUINPCHPGaugeCanvasBase : public UPalUserWidget

{
}; // Size: 0x408
class UPalUIOffScreenLoupeBase : public UPalUserWidget

{
float displayDotBorder;
// 0x0408 (size: 0x4)
bool isWaitedClose;
// 0x040C (size: 0x1)
bool isOverrideVisibility;
// 0x040D (size: 0x1)
bool isRequestedDisplay;
// 0x040E (size: 0x1)
ESlateVisibility overrideVisibility;
// 0x040F (size: 0x1)
FVector targetWorldLocation;
// 0x0410 (size: 0x18)
FVector2D projectedScreenPosition;
// 0x0428 (size: 0x10)
FVector2D calcedScreenPosition;
// 0x0438 (size: 0x10)
FVector2D widgetSize;
// 0x0448 (size: 0x10)
void SetOverrideVisibility(ESlateVisibility NewVisibility);

void ResetOverrideVisibility();
void RequestHide();
void RequestDisplay();
void OnRequestedClose();
bool IsEnableLoupe();
void GetTargetWorldLocation(FVector& outVector);
void GetTargetWidgetSize(FVector2D& outVector);
void CloseSelf();
void CalcScreenPosition();
}; // Size: 0x458
class UPalUIOtomoListModel : public UObject

{
FPalUIOtomoListModelOnSelectSlotDelegate OnSelectSlotDelegate;
// 0x0028 (size: 0x10)
void SelectSlotDelegate(class UPalUIOtomoListModel* Model, const int32
SlotIndex, const EPalItemSlotPressType PressType);
FPalUIOtomoListModelOnUpdateSlotDelegate OnUpdateSlotDelegate;
// 0x0038 (size: 0x10)
void UpdateSlotDelegate(class UPalUIOtomoListModel* Model);
void UpdateSlotDelegate__DelegateSignature(class UPalUIOtomoListModel* Model);

void SelectSlotDelegate__DelegateSignature(class UPalUIOtomoListModel* Model,
const int32 SlotIndex, const EPalItemSlotPressType PressType);
PressType);
void GetCurrentPageSlots(TArray<class UPalIndividualCharacterSlot*>& OutSlots);
}; // Size: 0x48
class UPalUIPalBoxBase : public UPalUserWidgetOverlayUI

{
void TryMoveToOtomo(class UPalIndividualCharacterSlot* MoveSlot);

void TryMoveToBox(class UPalIndividualCharacterSlot* MoveSlot);
void TryMoveToBaseCamp(class UPalIndividualCharacterSlot* MoveSlot);
void TryLoosePal(class UPalIndividualCharacterSlot* targetSlot);
void SetPagePalBoxList(int32 newPage);
void SetBaseCampId(const FGuid& BaseCampId);
void SelectCharacterSlot(class UPalIndividualCharacterSlot* targetSlot, const
EPalItemSlotPressType PressType);
void RequestSortBox(EPalCharacterContainerSortType SortType);
void OnUpdateWorkerCapacity(class UPalIndividualCharacterContainer* Container);
void OnUpdatePageWorkerList(const TArray<class UPalIndividualCharacterSlot*>&
slotList);
void OnUpdatePagePalBoxList(int32 nowPage, const TArray<class
UPalIndividualCharacterSlot*>& slotList);
int32 GetBoxMaxPageNum();
void ChangePrevPagePalBoxList();
void ChangeNextPagePalBoxList();
void CancelLift();
}; // Size: 0x448
class UPalUIPalBoxModel : public UObject

{
FPalUIPalBoxModelOnUpdatePageDelegate OnUpdatePageDelegate;
// 0x0028 (size: 0x10)
void UpdatePageDelegate(class UPalUIPalBoxModel* Model);
// 0x0038 (size: 0x4)
void UpdatePageDelegate__DelegateSignature(class UPalUIPalBoxModel* Model);

void ToPrevPage();
void ToNextPage();
PressType);
}; // Size: 0x40
class UPalUIPalBoxTerminalManageModel : public UObject

{
TSubclassOf<class UPalUIPalBoxModel> PalBoxClass;
// 0x0028 (size: 0x8)
class UPalUIPalBoxModel* PalBox;
// 0x0030 (size: 0x8)
TSubclassOf<class UPalUIBaseCampWorkersModel> BaseCampWorkersClass;
// 0x0038 (size: 0x8)
class UPalUIBaseCampWorkersModel* BaseCampWorkers;
// 0x0040 (size: 0x8)
TSubclassOf<class UPalUIBaseCampPartyModel> BaseCampPartyClass;
// 0x0048 (size: 0x8)
class UPalUIBaseCampPartyModel* BaseCampParty;
// 0x0050 (size: 0x8)
void MoveSlotToWorker(class UPalIndividualCharacterSlot* Slot);

void Initialize(const FGuid& BaseCampId);
}; // Size: 0x58
class UPalUIPalCharacterRankUpModel : public UObject

{
FPalUIPalCharacterRankUpModelOnUpdateTargetSlotDelegate
OnUpdateTargetSlotDelegate; // 0x0028 (size: 0x10)
void ModelDelegate(class UPalUIPalCharacterRankUpModel* Model);
FPalUIPalCharacterRankUpModelOnUpdateResourceSlotDelegate
OnUpdateResourceSlotDelegate; // 0x0038 (size: 0x10)
FPalUIPalCharacterRankUpModelOnUpdateSelectModeDelegate
OnUpdateSelectModeDelegate; // 0x0048 (size: 0x10)
FPalContainerId LocalContainerId;
// 0x0058 (size: 0x10)
TSubclassOf<class UPalUIPalStorageModel> PalStorageModelClass;
// 0x0068 (size: 0x8)
class UPalUIPalStorageModel* PalStorageModel;
// 0x0070 (size: 0x8)
EPalUIPalCharacterRankUpSelectMode SelectMode;
// 0x0078 (size: 0x1)
bool ToggleResourceCharacter(class UPalIndividualCharacterHandle* Handle);

void Setup(class UPalHUDDispatchParameter_CharacterRankUp* Parameter);
void SelectTargetCharacter(class UPalIndividualCharacterHandle* Handle);
void SelectResourcesAuto(const EPalUIPalCharacterRankUpSelectResourceType
SelectType);
bool SelectResourceCharacterTo(class UPalIndividualCharacterHandle* Handle,
const int32 ToResourceSlotIndex);
void OnUpdateTargetSlot(class UPalIndividualCharacterReferenceSlot* Slot,
FPalInstanceID LastIndividualId);
void OnUpdateTargetCharacterRank(const int32 nowRank, const int32 oldRank);
void OnUpdateResourceSlot(class UPalIndividualCharacterReferenceSlot* Slot,
FPalInstanceID LastIndividualId);
void OnClickTargetCharacterSlot();
void OnClickResourceCharacterSlot(const int32 SlotIndex);
void ModelDelegate__DelegateSignature(class UPalUIPalCharacterRankUpModel*
Model);
bool IsSelectableSlotInternal(const class UPalIndividualCharacterSlot* Slot);
void InvokeRankUp();
class UPalIndividualCharacterReferenceSlot* GetTargetSlot();
class UPalIndividualCharacterReferenceSlot* GetSlot(const int32 SlotIndex);
void GetResourceSlots(TArray<class UPalIndividualCharacterSlot*>& Slots);
void Dispose();
CreatePredicateTargetCharacterParameter();
void ClearSelected();
void ClearResourceCharacters();
EPalUIPalCharacterRankUpRequestResult CanInvokeRankUp();
}; // Size: 0x90
class UPalUIPalFarmSelectCropModel : public UObject

{
}; // Size: 0x28
class UPalUIPalFoodBoxModel : public UObject

{
}; // Size: 0x28
class UPalUIPalShopBase : public UPalUserWidgetOverlayUI

{
void UpdateLocalLostPalProduct();
bool TrySell(const TArray<class UPalIndividualCharacterSlot*> SellPalSlots);
bool TryBuy(const FGuid& buyProductID);
void RequestCollectLocalLostPalData();
bool GetPalStorageSlots(class UPalIndividualCharacterContainer*& OutContainer);
bool GetMyShop(class UPalShopBase*& OutShop);
}; // Size: 0x460
class UPalUIPalStorageManageModel : public UObject

{
// 0x0028 (size: 0x10)
TSubclassOf<class UPalUIPalStorageModel> PalStorageClass;
// 0x0038 (size: 0x8)
class UPalUIPalStorageModel* PalStorage;
// 0x0040 (size: 0x8)
TSubclassOf<class UPalUIPalStorageManageRightModel> PalStorageManageRightClass;
// 0x0048 (size: 0x8)
class UPalUIPalStorageManageRightModel* PalStorageManageRight;
// 0x0050 (size: 0x8)
void MoveSlotToWorker(class UPalIndividualCharacterSlot* Slot);

void Initialize(const FGuid& InOwnerBaseCampId);
}; // Size: 0x58
class UPalUIPalStorageManageRightModel : public UObject

{
FPalUIPalStorageManageRightModelOnUpdatePageDelegate OnUpdatePageDelegate;
// 0x0028 (size: 0x10)
void UpdatePageDelegate(class UPalUIPalStorageManageRightModel* Model);
// 0x0038 (size: 0x10)
EPalPalStorageManageRightType CurrentPageType;
// 0x0048 (size: 0x1)
TSubclassOf<class UPalUIBaseCampWorkerListModel> BaseCampWorkerListClass;
// 0x0050 (size: 0x8)
class UPalUIBaseCampWorkerListModel* BaseCampWorkerList;
// 0x0058 (size: 0x8)
TSubclassOf<class UPalUIOtomoListModel> OtomoListClass;
// 0x0060 (size: 0x8)
class UPalUIOtomoListModel* OtomoList;
// 0x0068 (size: 0x8)
void UpdatePageDelegate__DelegateSignature(class
UPalUIPalStorageManageRightModel* Model);
void ToPrevPage();
void ToNextPage();
bool CanMoveToPrev();
bool CanMoveToNext();
}; // Size: 0x70
class UPalUIPalStorageModel : public UObject

{
FPalUIPalStorageModelOnUpdatePageDelegate OnUpdatePageDelegate;
// 0x0028 (size: 0x10)
void UpdatePageDelegate(class UPalUIPalStorageModel* Model);
// 0x0038 (size: 0x4)
class UPalUICharacterDisplayModel* DisplayModel;
// 0x0040 (size: 0x8)
void UpdatePageDelegate__DelegateSignature(class UPalUIPalStorageModel* Model);

void ToPrevPage();
void ToPage(const int32 PageIndex, const bool bForce);
void ToNextPage();
PressType);
void OnOperatedByOuter();
FPalContainerId GetTargetContainerId();
bool CanMoveToPrev();
bool CanMoveToNext();
}; // Size: 0x48
class UPalUIPaldex : public UPalUserWidgetOverlayUI

{
TMap<class FName, class FPalUIPaldex_DisplayInfo> DisplayInfoMap;
// 0x0430 (size: 0x50)
TArray<FPalUIPaldex_DisplayInfo> displayInfoArray;
// 0x0480 (size: 0x10)
void CreateDisplayInfo();
}; // Size: 0x490
class UPalUIPlayerEquipment : public UPalUserWidgetOverlayUI

{
void SwapItemSlot(class UPalItemSlot* SlotA, class UPalItemSlot* SlotB);

void SwapEquipment(EPalPlayerEquipItemSlotType slotType, class UPalItemSlot*
fromSlot);
void SetDisableEquipmentHeadMeshFlag(bool isDisable);
void RemoveItemSlot(class UPalItemSlot* targetSlot, class UPalItemSlot*
toSlot);
void RemoveEquipment(EPalPlayerEquipItemSlotType slotType, class UPalItemSlot*
toSlot);
}; // Size: 0x430
class UPalUIPlayerRadialMenuBase : public UPalUserWidget

{
void SelectedFeed(const FPalItemSlotId& itemSlotId, const int32 itemNum);

void OpenOtomoFeedInventory();
}; // Size: 0x408
class UPalUIProductSettingModel : public UObject

{
FPalUIProductSettingModelOnUpdateRecipeDelegate OnUpdateRecipeDelegate;
// 0x0028 (size: 0x10)
void UpdateSettingDelegate(class UPalUIProductSettingModel* Model);
FPalUIProductSettingModelOnUpdateProductNumDelegate OnUpdateProductNumDelegate;
// 0x0038 (size: 0x10)
FPalUIProductSettingModelOnUpdateDelegate OnUpdateDelegate;
// 0x0048 (size: 0x10)
FText TargetMapObjectName;
// 0x0058 (size: 0x18)
FName SelectedRecipeId;
// 0x0070 (size: 0x8)
FName FocusedRecipeId;
// 0x0078 (size: 0x8)
int32 ProductNum;
// 0x0080 (size: 0x4)
TWeakObjectPtr<class UPalMapObjectEnergyModule> WeakEnergyModule;
// 0x0084 (size: 0x8)
void UpdateSettingDelegate__DelegateSignature(class UPalUIProductSettingModel*

Model);
bool TryGetEnergyModule(class UPalMapObjectEnergyModule*& Module);
void SetProductNumByInput(int32 InputNum);
void SetMaxProduction();
void SetInfiniteProduction();
void SetFocusedRecipe(const FName RecipeID);
void SelectRecipe(const FName RecipeID);
void ResetProductNum();
void OnUpdateInventory(class UPalItemContainerMultiHelper*
IInventoryContainers);
void NotifyUpdateForce();
bool IsProductNumInfinite();
void IncreaseProductNum();
void GetRequiredMaterialInfos(TArray<FPalStaticItemIdAndNum>&
RequiredMaterialInfos);
FName GetRecipeId();
FPalItemRecipe GetRecipe();
int32 GetProductNum();
void DecreaseProductNum();
float CalcWorkAmount();
int32 CalcMaxProductableNum();
int32 CalcConsumeEnergy();
}; // Size: 0x90
class UPalUIRadialMenuWidgetBase : public UPalUserWidget

{
FPalUIRadialMenuWidgetBaseOnChangeSelectedIndex OnChangeSelectedIndex;
// 0x0408 (size: 0x10)
void ChangeSelectedIndexDelegate(int32 newIndex, int32 prevIndex);
float IgnoreMouseLength;
// 0x0418 (size: 0x4)
int32 menuNum;
// 0x041C (size: 0x4)
int32 shiftDegree;
// 0x0420 (size: 0x4)
float detectPadAxisBorder;
// 0x0424 (size: 0x4)
float nowArrowRadian;
// 0x0428 (size: 0x4)
int32 nowSelectedIndex;
// 0x042C (size: 0x4)
TArray<float> menuAreaStartRadian;
// 0x0430 (size: 0x10)
TArray<float> menuAreaEndRadian;
// 0x0440 (size: 0x10)
void UpdateSelectedIndex_ForPad();
void UpdateSelectedIndex_ForMouse(const FVector2D& MousePosition, const
FVector2D& CenterPosition);
void UpdateSelectedIndex_ForceAxis(const FVector2D& Axis);
void SetSelectedIndexForce(int32 Index);
float RecalculateRadian(float inRadian);
void ClearSelectedIndex();
void ChangeSelectedIndexDelegate__DelegateSignature(int32 newIndex, int32
prevIndex);
void CalculateRadialMenuArea(float parentDegreeAngle);
void BuildRadialMenuWidget();
}; // Size: 0x450
class UPalUIRecipeTechnologyDetailButton : public UPalUITechnologyDetailButton

{
}; // Size: 0x408
class UPalUIRecoverPalBase : public UPalUserWidgetOverlayUI
{
void SelectCharacterSlot(class UPalIndividualCharacterSlot* targetSlot, const

EPalItemSlotPressType PressType);
}; // Size: 0x430
class UPalUIRecoverPalStatusIndicator : public UPalUIMapObjectStatusIndicatorBase

{
}; // Size: 0x408
class UPalUIRecoverPalStatusIndicatorParameter : public

UPalUIMapObjectStatusIndicatorParameterBase
{
bool TryGetConcreteModel(class UPalMapObjectRecoverOtomoModel*& ConcreteModel);

}; // Size: 0x48
class UPalUIRepairItemBase : public UPalUserWidgetOverlayUI

{
class UPalMapObjectRepairItemModel* RepairItemModel;
// 0x0430 (size: 0x8)
void RequestRepair(const TArray<class UPalItemSlot*>& TargetItemSlotArray);

void OnRecievedRepairResult(bool IsSuccess);
void CollectRepairInfo(const TArray<class UPalItemSlot*>& TargetItemSlotArray,
TArray<FPalStaticItemIdAndNum>& OutRequiredMaterials, bool& OutCanRepair);
void CollectRepairableSlot(TArray<class UPalItemSlot*>& OutRepairableSlots);
}; // Size: 0x438
class UPalUISelectItemInventoryBase : public UPalUserWidgetOverlayUI

{
}; // Size: 0x430
class UPalUISelectNumParameter : public UPalHUDDispatchParameterBase

{
FPalUISelectNumParameterComplateCallBack complateCallBack;
// 0x0038 (size: 0x10)
void PalUISelecteNumComplateDelegate(EPalUISelectNumResult ResultType, int32
selectedNum);
FPalUISelectNumParameterChangedNumCallBacl changedNumCallBacl;
// 0x0048 (size: 0x10)
void PalUISelectNumChangedNumDelegate(int32 nowSelectedNum);
int32 MinNum;
// 0x0058 (size: 0x4)
int32 MaxNum;
// 0x005C (size: 0x4)
int32 defaultNum;
// 0x0060 (size: 0x4)
FVector2D Position;
// 0x0068 (size: 0x10)
void InvokeComplateCallback(EPalUISelectNumResult Result, int32 selectedNum);

void InvokeChangedNumCallback(int32 selectedNum);
}; // Size: 0x78
class UPalUISelectNumWidgetBase : public UPalUserWidgetOverlayUI

{
}; // Size: 0x430
class UPalUIShopInventoryModel : public UPalUIInventoryModel

{
}; // Size: 0xA0
class UPalUIStatusModel : public UObject

{
FPalUIStatusModelOnChangeSelectedIndexDelegate OnChangeSelectedIndexDelegate;
// 0x0028 (size: 0x10)
void ChangedIndex();
TArray<class UPalIndividualCharacterHandle*> palHandles;
// 0x0038 (size: 0x10)
void OnClickedPalIcon(int32 Index);

void Initialize(const TArray<class UPalIndividualCharacterHandle*>& Handles);
uint8 GetNowSelectedIndex();
int32 GetDisplaySpeed(int32 Index);
int32 GetDisplayShotAttack(int32 Index);
EPalStatusPhysicalHealthType GetDisplayPhysicalHealthType(int32 Index);
bool GetDisplayPassiveSkillList(int32 Index, TArray<FName>& OutArray);
uint8 GetDisplayPalNum();
class UPalIndividualCharacterHandle* GetDisplayPalHandle(uint8 Index);
int32 GetDisplayNowExp(int32 Index);
void GetDisplayNickName(int32 Index, FString& outName);
int32 GetDisplayNextExp(int32 Index);
int32 GetDisplayMeleeAttack(int32 Index);
float GetDisplayMaxHunger(int32 Index);
FFixedPoint64 GetDisplayMaxHP(int32 Index);
int32 GetDisplayLevel(int32 Index);
float GetDisplayHunger(int32 Index);
FFixedPoint64 GetDisplayHP(int32 Index);
EPalElementType GetDisplayElementType2(int32 Index);
EPalElementType GetDisplayElementType1(int32 Index);
int32 GetDisplayEatingHabits(int32 Index);
int32 GetDisplayDefence(int32 Index);
FText GetDisplayDefaultName(int32 Index);
FText GetDisplayCoopActionName(int32 Index);
FText GetDisplayActiveSkillName(int32 Index, int32 skillIndex);
void ChangeNickname(int32 Index, FString newNickName);
void ChangeIndex(uint8 Index);
void ChangedIndex__DelegateSignature();
}; // Size: 0x50
class UPalUITechnologyDetailButton : public UPalUserWidget

{
}; // Size: 0x408
class UPalUITitleBase : public UPalUserWidgetStackableUI

{
}; // Size: 0x420
class UPalUIUtility : public UBlueprintFunctionLibrary

{
void SetVisibilityHUD(const class UObject* WorldContextObject, bool IsVisible);

void SetNumberToSeparatedTextBlock(const class UObject* WorldContextObject,
const TArray<int32>& numberArray, TArray<class UPalTextBlockBase*>& textBlockArray,
float topZeroTextOpacity);
void SetEnableCommonUIInput(const class UObject* WorldContextObject, bool
isEnable);
void SetCustomSlateNavigation(const class UObject* WorldContextObject, const
FPalSlateNavigationSetting& NavigationSetting);
void ResetSlateNavigation(const class UObject* WorldContextObject);
bool IsShiftDown_ForUI();
bool IsRightShiftDown_ForUI();
bool IsRightControlDown_ForUI();
bool IsRightAltDown_ForUI();
bool IsLeftShiftDown_ForUI();
bool IsLeftControlDown_ForUI();
bool IsLeftAltDown_ForUI();
bool IsControlDown_ForUI();
bool IsAltDown_ForUI();
void GetWorkSuitabilityNameWithMaterialSubType(const class UObject*
WorldContextObject, const EPalWorkSuitability WorkSuitability, const
EPalMapObjectMaterialSubType MaterialSubType, FText& outName);
void GetWorkSuitabilityName(const class UObject* WorldContextObject, const
EPalWorkSuitability WorkSuitability, FText& outName);
void GetWorkSickName(const class UObject* WorldContextObject, const
EPalBaseCampWorkerSickType SickType, FText& outName);
bool GetWorkNameFromHandle(const class UObject* WorldContextObject, class
UPalIndividualCharacterHandle* targetHandle, FText& outName);
void GetWorkName(const class UObject* WorldContextObject, const EPalWorkType
WorkType, FText& outName);
bool GetWorkingDetailNameFromHandle(const class UObject* WorldContextObject,
class UPalIndividualCharacterHandle* targetHandle, FText& outName);
void GetWorkingDetailName(const class UObject* WorldContextObject, const
EPalWorkType WorkType, FText& outName);
void GetWorkerComment(const class UObject* WorldContextObject, class
UPalIndividualCharacterHandle* targetHandle, FText& outName);
void GetWazaName(const class UObject* WorldContextObject, EPalWazaID WazaID,
FText& outName);
void GetWazaDesc(const class UObject* WorldContextObject, EPalWazaID WazaID,
FText& outDesc);
void GetWaitForWorkableDetailName(const class UObject* WorldContextObject,
const EPalWorkType WorkType, FText& outName);
bool GetUIInputActionRowHandle(const class UObject* WorldContextObject, const
FName& ActionName, FDataTableRowHandle& outHandle);
void GetUIDisplayPalCondition(const class UObject* WorldContextObject,
TArray<EPalUIConditionType>& OutArray, class UPalIndividualCharacterHandle*
targetHandle);
void GetTechnologyDescription(const class UObject* WorldContextObject, const
FName& technologyName, FText& OutDescription);
int32 GetPlayerInframeRenderTargetResolution();
void GetPassiveSkillName(const class UObject* WorldContextObject, const FName&
PassiveSkillId, FText& outName);
void GetPartnerSkillName(const class UObject* WorldContextObject, const FName&
CharacterID, FText& OutText);
void GetPalShortDescription(const class UObject* WorldContextObject, const
FName& CharacterID, FText& outName);
bool GetPalRestrictItemID(const class UObject* WorldContextObject, const FName&
CharacterID, FName& ItemId);
void GetPalLongDescription(const class UObject* WorldContextObject, const
void GetPalGenusCategoryName(const class UObject* WorldContextObject,
EPalGenusCategoryType GenusCategory, FText& outName);
void GetPalFirstActivatedInfo(const class UObject* WorldContextObject, const
void GetPalElementTypeName(const class UObject* WorldContextObject,
EPalElementType ElementType, FText& outName);
int32 GetPalConditionUrgency(const class UObject* WorldContextObject,
EPalUIConditionType Condition);
void GetPalConditionName(const class UObject* WorldContextObject, const
EPalUIConditionType ConditionType, FText& outName);
void GetPalConditionDesc(const class UObject* WorldContextObject, const
EPalUIConditionType ConditionType, FText& outDesc);
FSlateBrush GetMappedKeyIcon(const class UObject* WorldContextObject, const
FName InputActionName, ECommonInputType InputType, EPalKeyConfigAxisFilterType
FilterType);
void GetMapObjectOperationResultText(const class UObject* WorldContextObject,
const EPalMapObjectOperationResult operationType, FText& outName);
FName GetMapObjectNameTextId(const class UObject* WorldContextObject, const
FName& MapObjectName);
void GetMapObjectName(const class UObject* WorldContextObject, const FName&
MapObjectName, FText& outName);
FSlateBrush GetKeyIconByKey(const class UObject* WorldContextObject, const FKey
Key, ECommonInputType InputType);
void GetItemTypeAName(const class UObject* WorldContextObject, const
EPalItemTypeA itemTypeA, FText& outName);
void GetItemName(const class UObject* WorldContextObject, const FName&
StaticItemId, FText& outName);
void GetItemDescription(const class UObject* WorldContextObject, const FName&
StaticItemId, FText& outName);
void GetInventoryCategoryName(const class UObject* WorldContextObject,
EPalPlayerInventoryType inventoryType, FText& outName);
void GetFormatedFirstActivatedInfoText(const class UObject* WorldContextObject,
class APalCharacter* Character, FText& outFormatedText);
void GetBuildObjectDesc(const class UObject* WorldContextObject, const FName&
buildObjectName, FText& outDesc);
void GetBuildObjectCategoryBName(const class UObject* WorldContextObject, const
EPalBuildObjectTypeB TypeB, FText& outName);
void GetBuildObjectCategoryAName(const class UObject* WorldContextObject, const
EPalBuildObjectTypeA TypeA, FText& outName);
void GetBaseCampEventName(const class UObject* WorldContextObject, const
EPalBaseCampWorkerEventType EventType, FText& outName);
void GetAllTagFromText(const class UObject* WorldContextObject, const FText&
targetText, TArray<FString>& outTagArray);
class UPalUserWidget* FindOwningActivatableWidget(const class UObject*
WorldContextObject, const class UWidget* Widget);
float ConvertReviveTimerToUIDisplayRemainReviveTime(const class UObject*
WorldContextObject, float ReviveTimer);
}; // Size: 0x28
class UPalUIWorkerSimpleDetailCanvas : public UPalUserWidget

{
void UnbindWorkerEvent(class UPalIndividualCharacterHandle* workerHandle);

void UnbindBaseCampEvent(class UPalBaseCampModel* targetCampModel);
void OnRequestOpenDetail(class AActor* TargetActor);
void OnRequestCloseDetail();
void OnEndInteractWorker(class AActor* Actor, TScriptInterface<class
void OnBeginInteractWorker(class AActor* Actor, TScriptInterface<class
void OnAddedNewWorker(class UPalIndividualCharacterHandle* workerHandle);
void BindWorkerEvent(class UPalIndividualCharacterHandle* workerHandle);
void BindBaseCampEvent(class UPalBaseCampModel* targetCampModel);
}; // Size: 0x408
class UPalUIWorldHUDWidgetCanvas : public UPalUserWidget

{
void RemoveWidget(class UPalUserWidgetWorldHUD* Widget);

void AddWidget(class UPalUserWidgetWorldHUD* Widget);
}; // Size: 0x408
class UPalUIWorldMap : public UPalUserWidgetOverlayUI

{
void RegisterRespawnLocation(const FVector& RespawnLocation);

void Debug_SetLocation(const FVector& Location);
void CreateWorldMapData(EPalWorldMapType worldMapType);
}; // Size: 0x430
class UPalUIWorldSettingBase : public UPalUserWidgetOverlayUI

{
FPalOptionWorldSettings OriginalSetting;
// 0x0430 (size: 0x128)
void OnCompletedSaveSetting(bool IsSuccess);

bool CompleteSetting(const FPalOptionWorldSettings& NewSetting);
}; // Size: 0x558
class UPalUniqueRideAnimeAssetBase : public UObject

{
FVector IKPoleLocation_Hand_R;
// 0x0028 (size: 0x18)
FVector IKPoleLocation_Hand_L;
// 0x0040 (size: 0x18)
FVector IKPoleLocation_Foot_R;
// 0x0058 (size: 0x18)
FVector IKPoleLocation_Foot_L;
// 0x0070 (size: 0x18)
bool DisableLeftHandIK_BallMotion;
// 0x0088 (size: 0x1)
class UAnimSequence* RidingAnimation;
// 0x0090 (size: 0x8)
class UAnimMontage* RidingAnimation_Ball_Aim;
// 0x0098 (size: 0x8)
class UAnimMontage* RidingAnimation_Ball_Fire;
// 0x00A0 (size: 0x8)
FWeaponNotifyAnimationInfo WeaponNotifyAnimInfo_Ball_Aim;
// 0x00B0 (size: 0x58)
FWeaponNotifyAnimationInfo WeaponNotifyAnimInfo_Ball_Fire;
// 0x0108 (size: 0x58)
class UAnimSequence* GetRideAnimSequence();

}; // Size: 0x160
class UPalUniqueSkillModule : public UObject

{
class APalCharacter* ActionCharacter;
// 0x0028 (size: 0x8)
class AActor* ActionTarget;
// 0x0030 (size: 0x8)
void TickModule(float DeltaTime);
void SetActionTarget(class AActor* Target);
void SetActionCharacter(class APalCharacter* Character);
void OnEndModule();
void OnBeginModule();
class AActor* GetActionTarget();
class APalCharacter* GetActionCharacter();
}; // Size: 0x38
class UPalUserWidget : public UPalActivatableWidget

{
bool bSyncPlayerInventory;
// 0x03D0 (size: 0x1)
class UPalHUDDispatchParameterBase* Param;
// 0x03E8 (size: 0x8)
TArray<FPalUIActionBindData> BindedActionHandles;
// 0x03F8 (size: 0x10)
void VisibilityOverride(ESlateVisibility changedVisibility);

void UnregisterActionBinding(FPalUIActionBindData& BindingData);
void RequestInventorySync(bool bOpen);
FPalUIActionBindData RegisterActionBinding_NotConcume(const FName& ActionName,
bool IsDisplayActionBar, TEnumAsByte<EInputEvent> InputType,
FRegisterActionBinding_NotConcumeCallback Callback);
FPalUIActionBindData RegisterActionBinding(const FName& ActionName, bool
IsDisplayActionBar, TEnumAsByte<EInputEvent> InputType,
FRegisterActionBindingCallback Callback);
FGuid Push(TSubclassOf<class UPalUserWidgetOverlayUI> WidgetClass, class
void OnSetup_AfterCreatedPlayer();
void OnSetup();
void OnClosed();
bool IsSameWidget(const FGuid& checkID);
class UPalHUDDispatchParameterBase* GetParam();
class UUserWidget* FindParentWidget(TSubclassOf<class UUserWidget> Class);
}; // Size: 0x408
class UPalUserWidgetHierarchical : public UPalUserWidget

{
}; // Size: 0x408
class UPalUserWidgetOverlayUI : public UPalUserWidgetStackableUI

{
bool IsEnableCancelAction;
// 0x0420 (size: 0x1)
FPalUIActionBindData CancelInputHandle;
// 0x0424 (size: 0x4)
FPalUIActionBindData EscInputHandle;
// 0x0428 (size: 0x4)
void ResetCancelAction();
void OverrideCancelAction(bool IsDisplayActionBar, TEnumAsByte<EInputEvent>
InputType, FOverrideCancelActionCallback Callback);
void ClearCancelAction();
}; // Size: 0x430
class UPalUserWidgetStackableUI : public UPalUserWidgetHierarchical

{
class UAkAudioEvent* OpenAkEvent;
// 0x0408 (size: 0x8)
class UAkAudioEvent* CloseAkEvent;
// 0x0410 (size: 0x8)
void OnPreClose();
void OnPostClose();
void OnClose();
class UAkAudioEvent* GetOpenAkEvent();
class UAkAudioEvent* GetCloseAkEvent();
void Close();
}; // Size: 0x420
class UPalUserWidgetTimerGaugeBase : public UPalUserWidgetWorldHUD

{
FTimerHandle targetTimerHandle;
// 0x0408 (size: 0x8)
float Time;
// 0x0410 (size: 0x4)
void VisibilityForceHidden(ESlateVisibility changedVisibility);

void SetGaugeText(const FText& Text);
void SetGaugePercent(float Percent);
}; // Size: 0x418
class UPalUserWidgetWorldHUD : public UPalUserWidget

{
void RemoveSelf();
void OnRequestRemove();
}; // Size: 0x408
class UPalUtility : public UBlueprintFunctionLibrary

{
void UpdatePlayerCharacterParameter(const class APalCharacter* Character);

void UpdateLocalPlayerParameter(const class UObject* WorldContextObject);
void UnlockBaseCampLevelAchievement(const class UObject* WorldContextObject,
const int32 Level);
void UnlockAchievement(const class UObject* WorldContextObject, FString
AchievementId, const int32 Progress);
bool TryGetHeadWorldPosition(class APalCharacter* Character, FVector&
OutLocation);
FString ToPointerAddress(const class UObject* Obj);
void TeleportToPlayerByIndex(class APalPlayerController* Controller, int32
PlayerIndex);
void TeleportInitLocation(class APalPlayerCharacter* Target);
bool TeleportAroundLoccation(class APalCharacter* Target, const FVector&
Location, const FQuat& Rotation);
bool Teleport(class APalCharacter* Target, const FVector& Location, const
FQuat& Rotation, const bool bNoCheck, const bool bAroundCheck);
bool SynchronizedGroup(const class UObject* WorldContextObject, class
UPalIndividualCharacterHandle* FromHandle, class UPalIndividualCharacterHandle*
ToHandle);
FString SteamLanguageNameToCultureName(const class UObject* WorldContextObject,
FString SteamLanguageName);
bool SphereOverlapLimitVolume(const class UObject* WorldContextObject,
EPalLimitVolumeFlag LimitVolumeFlag, const FVector Center, const float Radius);
void SpectatorOn(const class UObject* WorldContextObject);
void SpectatorOff(const class UObject* WorldContextObject);
class AController* SpawnControllerAndPossess(TSubclassOf<class AController>
ControllerClass, class APawn* ControlActor);
bool SpawnActorBroadcast(const class UObject* WorldContextObject, UClass*
actorClass, class AActor* NetworkOwner, class AActor* Owner, FName Name, FTransform
SpawnTransform, TSubclassOf<class AController> Controller, FGuid& SpawnGUID,
FSpawnActorBroadcastSpawnDelegate SpawnDelegate);
void SortActorListByLabel(TArray<class AActor*>& ActorList);
void ShowUI(const class UObject* WorldContextObject, const
EPalWidgetBlueprintType WBPType, class UPalHUDDispatchParameterBase* Parameter);
void SetYawApplyRate(class AActor* Actor, float Rate, FName flagName);
void SetVoiceID(class AActor* TargetActor, int32 VoiceID);
void SetVisibleComponentInDataLayer(const class UObject* WorldContextObject,
class UDataLayerInstance* TargetDataLayer, bool bEnable);
void SetUnRidingCharacterCollision(class APalCharacter* Character);
FTransform SetTransformQuat(FTransform TargetTransform, FQuat NewQuat);
FTimerHandle SetTimerWithGaugeWidget(class UObject* Object, const
FPalTimerGaugeWidgetCreateInfo& createInfo);
void SetTelemetry(const class UObject* WorldContextObject, const FName& Key,
FString Value, FName Namespace);
void SetStatusPoint(class UPalIndividualCharacterHandle* Handle, FName
StatusName, int32 Point);
void SetSpeedCollisionEnable(class AActor* Actor, bool bEnable);
void SetRidingCharacterCollision(class APalCharacter* Character);
void SetPassword(const class UObject* WorldContextObject, FString Password);
void SetOtomoCollisionProfile(class APalCharacter* Character);
void SetOpacityForCharacter(class AActor* Character, float opacityIntensity);
void SetMoveDisableFlag(class AActor* Actor, bool isDisable, FName flagName);
void SetHPByRateToHandle(class UPalIndividualCharacterHandle* Handle, float
Rate);
void SetHPByRateToCharacter(class APalCharacter* Character, float Rate);
void SetFolderPathForBP(class AActor* TargetActor, FName FolderName);
void SetEnableSkyCreator(const class UObject* WorldContextObject, bool
bEnable);
void SetEnableCameraFade(class AActor* Character, bool bIsEnable);
void SetCoopFlag(class APalCharacter* Trainer, class APalCharacter* Otomo, bool
bIsEnable);
void SetCharacterRagdollForNooseTrap(class APalCharacter* Character);
void SetCharacterRagdollForLiftup(class APalCharacter* Character);
void SetCharacterRagdoll(class APalCharacter* Character, bool IsKeepGravity,
bool KeepRootCollision);
void SetCharacterLocationAtMainMeshFoot(class APalCharacter* Character, const
FVector& Location);
void SetBodyPartsGenerateOverlapEvents(class APalCharacter* Character, bool
isEnable);
void SetBodyPartsCollisionProfile(class APalCharacter* Character, const FName
ProfileName);
void SetBodyPartsCollisionEnable(class APalCharacter* Character, bool bEnable);
void SetActorQuat(class AActor* TargetActor, FQuat NewQuat);
void SendSystemToPlayerChat(const class UObject* WorldContextObject, FString
Message, const FGuid& ReceiverPlayerUId);
void SendSystemAnnounce(const class UObject* WorldContextObject, FString
Message);
FText SelectText(const FText& A, const FText& B, bool bPickA);
float RSign(const float V);
bool RideTo(class AActor* RiderActor, class AActor* RidePal, bool
bIsSkipAnimation);
void ReturnOtomoPalToHolder(const class AController* TargetController);
void ResetBodyPartsCollisionProfileToDefault(class APalCharacter* Character);
void RemoveAroundInfoCollectorComponent(class APalCharacter* Target);
void RefreshRagdollSkeletalMesh(class APalCharacter* Character);
void RefreshParameterForCharacterAndHoldOtomo(class APalCharacter* Character);
bool ProjectWorldToScreenBehindCamera(class APlayerController* Player, const
FVector& WorldPosition, FVector2D& ScreenPosition, bool& bTargetBehindCamera, bool
bPlayerViewportRelative);
void ProcessDeadAction(class APalCharacter* Character);
void ProcessDamageAndPlayEffectsByDamageInfo(class AActor* Attacker, class
AActor* Defender, const FPalDamageInfo& DamageInfo, bool bIsEnableHitEffect);
void ProcessDamageAndPlayEffects(class AActor* Attacker, class AActor*
Defender, const FPalMakeDamageInfo& MakeDamageInfo);
bool PointOvelapLimitVolume(const class UObject* WorldContextObject,
EPalLimitVolumeFlag LimitVolumeFlag, FVector Location);
void PlayWorldCameraShake(const class UObject* WorldContextObject,
TSubclassOf<class UCameraShakeBase> Shake, FVector Epicenter, float InnerRadius,
float OuterRadius, float Falloff, bool bOrientShakeTowardsEpicenter);
void PlayMontageByMinLength(class ACharacter* Character, class UAnimMontage*
Montange, float MinLength);
void PlayMontageByFixLength(class ACharacter* Character, class UAnimMontage*
Montange, float FixLength);
bool PlayActionByWazaID(class AActor* actionActor, class AActor* TargetActor,
EPalWazaID WazaID);
bool PlayAction(class AActor* actionActor, class AActor* TargetActor,
EPalActionType ActionType);
void Play2MontageByFixLength(class ACharacter* Character, class UAnimMontage*
Montange, float FixLength, class UAnimMontage* LoopMontange);
void PalCaptureSuccess(class APalPlayerCharacter* AttackerPlayer, class
APalCharacter* Monster);
bool PalAIMoveToTargetLocation(class APalAIController* Controller, FVector
Goal);
bool PalAIMoveToTargetActor(class APalAIController* Controller, class AActor*
Target);
bool NotContainsAny(const TArray<class UObject*> SourceArray, const
TArray<class UObject*> FindElms);
FFixedPoint64 NextPointCalculate(FFixedPoint64 CurrentPoint, FFixedPoint64
CurrentMax, FFixedPoint64 NextMax);
FPalDamageInfo MakeDamageInfoByWazaType(class AActor* Attacker, class AActor*
Defencer, const class USceneComponent* AttackerHitComponent, const class
USceneComponent* DefenderHitComponent, const FVector& HitLocation, TArray<int32>
FoliageIndex, EPalWazaID WazaType, EPalBlowVelocityOwner BlowOwner, FVector
NativeBlowVelocity, int32 referenceIndex, float DamageRatePerCollision);
FPalDamageInfo MakeDamageInfo(const FPalMakeDamageInfo& MakeDamageInfo);
bool LotteryInt(const int32 ProbabilityPercentage);
bool LotteryFloat(const float ProbabilityPercentage);
void LoadIconToImageDelegate__DelegateSignature(class UImage* ImageWidget,
class UTexture2D* Texture);
void LoadIconToImage(const class UObject* WorldContextObject,
TSoftObjectPtr<UTexture2D> TexturePath, class UImage* TargetImage,
FLoadIconToImageCallback Callback);
bool LineTraceToTarget_ForAIAttack(class AActor* SelfActor, class AActor*
Target);
void KillCharacter_NotDamageToEquipItem(class APalCharacter* Character);
void JudgePalCapture_TryAllPhase(const class UPalIndividualCharacterHandle*
targetHandle, const class UPalIndividualCharacterHandle* throwCharacterHandle,
int32 captureItemLevel, TArray<bool>& outJudgeFlagArray, bool Robbery);
bool JudgePalCapture(class AActor* Pal);
bool IsXSX(const class UObject* WorldContextObject);
bool IsXB1(const class UObject* WorldContextObject);
bool IsWorldOwner(const class UObject* WorldContextObject);
bool IsWinGDK(const class UObject* WorldContextObject);
bool IsWindows(const class UObject* WorldContextObject);
bool IsWildNPC(const class AActor* Actor);
bool IsValidInstanceID(const FPalInstanceID& ID);
bool IsValid_ThreadSafe(class UObject* Object);
bool IsUGCFilter();
bool IsUGCBlocked(const class UObject* WorldContextObject);
bool IsSteamDeck(const class UObject* WorldContextObject);
bool IsSneakAttackSuccessByLocation(const FVector& HitLocation, const class
AActor* Defender);
bool IsSleepTimeForWildLife(class APalAIController* Controller, float
sleepStartHours, float sleepEndHours);
bool IsServerPlayerUID(const class UObject* WorldContextObject, FGuid
PlayerUId);
bool IsServer(const class UObject* WorldContextObject);
bool IsPointOnBase(const class UObject* WorldContextObject, const FVector&
Point, const TArray<class AActor*>& IgnoreActors, const
TEnumAsByte<EDrawDebugTrace::Type> DrawDebugType, const float DrawDebugDuration);
bool IsPointInDoor(const class UObject* WorldContextObject, const FVector&
Point, const TArray<class AActor*>& IgnoreActors, const
bool IsPlayerControlActor(class AActor* CheckActor);
bool IsPIEUsingPlayerStart();
bool IsPalMonster(const class AActor* Actor);
bool IsPalCharacter(class AActor* Actor);
bool IsOtomo(const class AActor* Actor);
bool IsOpenListenServer(const class UObject* WorldContextObject);
bool IsNearTwoPoint(FVector point1, FVector point2, float Distance, bool
ignoreHeight);
bool IsNearTwoActorWithRootRadius(const class AActor* actor1, const class
AActor* actor2, float Distance, bool ignoreHeight);
bool IsNearTwoActorWithRadius(const class AActor* actor1, const class AActor*
actor2, float Distance, bool ignoreHeight);
bool IsNearTwoActor(const class AActor* actor1, const class AActor* actor2,
float Distance, bool ignoreHeight);
bool IsMultiplayRestricted(const class UObject* WorldContextObject);
bool IsMultiplayer(const class UObject* WorldContextObject);
bool IsLocalPlayerCampPal(const class AActor* Actor);
bool IsLocalControlActorOrPalmi(class AActor* CheckActor);
bool IsLocalControlActor(const class AActor* CheckActor);
bool IsLive(class AActor* Actor);
bool IsInClientConnection(const class UObject* WorldContextObject);
bool IsIgnoreNetworkVersionCheck(const class UObject* WorldContextObject);
bool IsHairAttachAccessory(const class UObject* WorldContextObject, const
FName& EquipmentArmorName);
bool IsGDK(const class UObject* WorldContextObject);
bool IsFriend(const class AActor* ActorA, const class AActor* ActorB);
bool IsForceQuitOnDisconnect(const class UObject* WorldContextObject);
bool IsExistsInDoor(class AActor* TargetActor, const
bool IsEnemy(const class AActor* ActorA, const class AActor* ActorB);
bool IsEnableBotLocationFlag(const class UObject* WorldContextObject);
bool IsElementWeak(EPalElementType AttackType, EPalElementType defenceType);
bool IsElementStrong(EPalElementType AttackType, EPalElementType defenceType);
bool IsEditorPreviewActor(class AActor* Actor);
bool IsEditorBuild();
bool IsDying(class AActor* Actor);
bool IsDevelopmentBuild();
bool IsDestructionByCompleteBuilt(const class UObject* WorldContextObject);
bool IsDedicatedServer(const class UObject* WorldContextObject);
bool IsDead(class AActor* Actor);
bool IsClientDedicatedServer(const class UObject* WorldContextObject);
bool IsCanPlaySinglePlay();
bool IsCanPlayInviteCode();
bool IsCanPlayDedicatedServer(const class UObject* WorldContextObject);
bool IsCanOpenExternalWebSite();
bool IsBuildBotBaseCamp(const class UObject* WorldContextObject);
bool IsBotMode(const class UObject* WorldContextObject);
bool IsBotEnterDungeon(const class UObject* WorldContextObject);
bool IsBaseCampPal(const class AActor* Actor);
bool IsApplicablePowerOnlyToDamageValue(class AActor* Reciever);
bool IsApplicableDamage(class UObject* Causer, class AActor* Receiver, class
UPrimitiveComponent* ReceivedComponent);
bool IsAllLevelLoaded(const class UObject* WorldContextObject);
bool IsAliveFriendPlayers_ByUId(const class UObject* WorldContextObject, FGuid
PlayerUId);
bool IsAIAttackAbleByPlayerCamera(const class AActor* SelfActor, const class
bool InWazaMaxRange(class APalCharacter* Attacker, EPalWazaID Waza, FVector
TargetLocation, float TargetRadius);
void InitializeHumanBoneInfo(class UPalAnimInstance* AnimInstance);
bool InFanShapAndDitance(const class AActor* SelfActor, const class AActor*
TargetActor, float Degree, float Distance);
bool InFanShapAimTarget(const class AActor* SelfActor, const class AActor*
TargetActor, float Degree);
bool InFanShap_TargetLocation(const class AActor* SelfActor, const FVector
TargetLocation, float Degree);
bool InFanShap_PlayerCamera(const class AActor* SelfActor, const class
APalPlayerCharacter* Player, float Degree);
bool InFanShap(const class AActor* SelfActor, const class AActor* TargetActor,
float Degree);
bool InConeShapAndDitance_PreThreshold_Actor(const class AActor* SelfActor,
const class AActor* TargetActor, float Threshold, float Distance);
bool InConeShapAndDitance_PreThreshold(FVector SelfLocation, FRotator
SelfRotator, FVector TargetLocation, float Threshold, float Distance);
bool InConeShapAndDitance_Actor(const class AActor* SelfActor, const class
AActor* TargetActor, float Degree, float Distance);
bool InConeShapAndDitance(FVector SelfLocation, FRotator SelfRotator, FVector
TargetLocation, float Degree, float Distance);
void HeadBillboardEffectSetTransform(class APalCharacter* Character, class
USceneComponent* Effect, const FVector AddOffset);
bool HasAliveFriendPlayers(class AActor* My);
void GiveExpToAroundPlayerCharacter(const class UObject* WorldContextObject,
const FVector& Center, float Radius, float Exp, bool bCallDelegate);
void GiveExpToAroundCharacter(const class UObject* WorldContextObject, const
FVector& Center, float Radius, float Exp, TSubclassOf<class APalCharacter>
CharacterClass, bool bCallDelegate);
class UPalWorldSecuritySystem* GetWorldSecuritySystem(const class UObject*
class UPalWorldObjectRecordWorldSubsystem* GetWorldObjectRecorder(const class
float GetWorkSpeed(class APalCharacter* Character);
class UPalWorkProgressManager* GetWorkProgressManager(const class UObject*
void GetWeakElementType(EPalElementType type1, EPalElementType type2,
TArray<EPalElementType>& OutArray);
int32 GetWeakCount_ForUI(EPalElementType AttackElementType, EPalElementType
defenceTypeA, EPalElementType defenceTypeB, EPalAttackType AttackType,
EPalBodyPartsType BodyPartsType);
int32 GetWeakCount(EPalElementType AttackElementType, EPalElementType
defenceTypeA, EPalElementType defenceTypeB);
class UPalWazaDatabase* GetWazaDatabase(const class UObject*
class UPalVisualEffectDataBase* GetVisualEffectDatabase(const class UObject*
class UPalTutorialManager* GetTutorialManager(const class UObject*
void GetTribeIDNameFromParameter(const class UObject* WorldContextObject, class
UPalIndividualCharacterParameter* IndividualParameter, FName& outTribeIDName);
void GetTribeIDNameFromCharacterID(const class UObject* WorldContextObject,
const FName& CharacterID, FName& outTribeIDName);
EPalTribeID GetTribeIDFromCharacterID(const class UObject* WorldContextObject,
const FName& CharacterID);
FQuat GetTransformQuat(const FTransform SourceTransform);
class APalPlayerController* GetTrainerPlayerController_ForServer(class AActor*
Monster);
class APalPlayerCharacter* GetTrainerPlayer(const class AActor* Monster);
class UPalTimeManager* GetTimeManager(const class UObject* WorldContextObject);
class UPalTechnologyData* GetTechnologyDataByPlayerUID(const class UObject*
WorldContextObject, FGuid PlayerUId);
int32 GetStatusPoint(class UPalIndividualCharacterHandle* Handle, FName
StatusName);
void GetStatUnitResult(const class UObject* WorldContextObject, float&
FrameTime, float& GameThreadTime, float& RenderThreadTime, float& GPUTime);
class USignificanceManager* GetSignificanceManager(const class UObject*
class UPalShopManager* GetShopManager(const class UObject* WorldContextObject);
FString GetServerWorldDisplayName(const class UObject* WorldContextObject);
class UPalSaveGameManager* GetSaveGameManager(const class UObject*
float GetSafeZero(float Value);
float GetRTTJitter(const class UObject* WorldContextObject);
FTransform GetRelativeTransformFromRoot(class USceneComponent* SceneComponent);
class UPalPlayerRecordData* GetRecordDataByPlayerUID(const class UObject*
class UPalRCONSubsystem* GetRCONSubsystem(const class UObject*
float GetRangeToGround(class AActor* Actor);
void GetRandomPointList(int32 pointNum, int32 maxLoopCount, float minXPos,
float maxXPos, float minYPos, float maxYPos, float SizeX, float SizeY,
FRandomStream RandomStream, TArray<FVector2D>& outPointArray);
FGuid GetPlayerUIDByActor(const class AActor* playerActor);
class APalPlayerState* GetPlayerStateByPlayer(const class APalPlayerCharacter*
Player);
class APalPlayerState* GetPlayerState(const class AActor* Player);
class UPalPlayerManager* GetPlayerManager(const class UObject*
TArray<FString> GetPlayerListDisplayMessages(const class UObject*
FString GetPlayerListDisplayMessage(const class UObject* WorldContextObject);
FGuid GetPlayerGUIDByPlayerUIDOrSteamId(const class UObject*
WorldContextObject, FString PlayerUIdORSteamId);
int32 GetPlayerEquipmentShield(const class UObject* WorldContextObject, FGuid
PlayerUId);
void GetPlayerEquipmentPassiveList(const class UObject* WorldContextObject,
FGuid PlayerUId, TArray<FName>& outPassiveList);
int32 GetPlayerEquipmentHP(const class UObject* WorldContextObject, FGuid
PlayerUId);
int32 GetPlayerEquipmentDefense(const class UObject* WorldContextObject, FGuid
PlayerUId);
class UPalPlayerDataStorage* GetPlayerDataStorage(const class UObject*
class APalPlayerController* GetPlayerControllerByPlayerId(const class UObject*
WorldContextObject, const int32 PlayerId);
class APawn* GetPlayerControlledPawn(const class UObject* WorldContextObject);
class APalCharacter* GetPlayerControlledCharacter(const class UObject*
class APalPlayerCharacter* GetPlayerCharacterByPlayerIndex(const class UObject*
WorldContextObject, const int32 PlayerIndex);
class ACharacter* GetPlayerCharacterByPlayerId(const class UObject*
WorldContextObject, const int32 PlayerId);
class APalPlayerCharacter* GetPlayerCharacter(const class UObject*
EPalSupportedPlatformType GetPlatformType(const class UObject*
FName GetPhysicsRootBoneName(class AActor* Character);
FName GetPhysicsBoneName(class AActor* Character, EPalPhysicsBoneType
boneType);
int32 GetPhysicsBoneIndex(class AActor* Character, EPalPhysicsBoneType
boneType);
TEnumAsByte<EPhysicalSurface> GetPhysicalSurfaceTypeByActor(class AActor*
SelfActor, FName SocketName, const FVector& OffsetSt, const FVector& OffsetEd,
bool& bHit);
TEnumAsByte<EPhysicalSurface> GetPhysicalSurfaceType(const class UObject*
WorldContextObject, const FVector& RayStart, const FVector& RayEnd, bool& bHit);
FString GetPassword(const class UObject* WorldContextObject);
class UPalPassiveSkillManager* GetPassiveSkillManager(const class UObject*
class UPalPlayerDataPalStorage* GetPalStorageDataByPlayerUID(const class
UObject* WorldContextObject, FGuid PlayerUId);
class UPalObjectCollector* GetPalObjectCollector(const class UObject*
void GetPalMonsters(const class UObject* WorldContextObject, TArray<class
APalCharacter*>& OutCharacters);
class APalPlayerCharacter* GetPalmi(const class UObject* WorldContextObject);
void GetPalIconInfoByCharacterID(class UObject* WorldContextObject, const
FPalDataTableRowName_PalMonsterData& CharacterID, TSoftObjectPtr<UTexture2D>&
outIcon, bool& outIsRare, bool& outIsBoss);
class UPalGameWorldSettings* GetPalGameWorldSettings();
class APalGameStateInGame* GetPalGameStateInGame(const class UObject*
class APalGameState* GetPalGameState(const class UObject* WorldContextObject);
class APalGameMode* GetPalGameMode(const class UObject* WorldContextObject);
class UPalGameInstance* GetPalGameInstance(const class UObject*
class UPalDebugSetting* GetPalDebugSetting();
class UPalCheatManager* GetPalCheatManager(const class UObject*
void GetPalCharacters(const class UObject* WorldContextObject, TArray<class
TArray<int32> GetOverlapFoliageIndexByComponent(class UPrimitiveComponent*
AttackComponent, class UPrimitiveComponent* FolageComponent);
float GetOutPacketLoss(const class UObject* WorldContextObject);
class UPalOtomoHolderComponentBase* GetOtomoHolderComponent(const class
class UPalOtomoHolderComponentBase* GetOtomoHolderByOtomoPal(class AActor*
OtomoPal);
FPalOptionWorldSettings GetOptionWorldSettings(const class UObject*
class UPalOptionSubsystem* GetOptionSubsystem(const class UObject*
FPalOptionGraphicsSettings GetOptionGraphicsSettings(const class UObject*
bool GetOffFromPal(class AActor* RiderActor, bool bIsSkipAnimation, bool
bNoAnimCancel);
int32 GetNumPlayers(const class UObject* WorldContextObject);
class UPalNPCManager* GetNPCManager(const class UObject* WorldContextObject);
class APalNetworkTransmitter* GetNetworkTransmitterByPlayerId(const class
UObject* WorldContextObject, const int32 PlayerId);
class APalNetworkTransmitter* GetNetworkTransmitterByPlayerCharacter(class
APalPlayerCharacter* Player);
class APalNetworkTransmitter* GetNetworkTransmitter(const class UObject*
float GetNearstPlayerDistance2D(const class UObject* WorldContextObject,
FVector Location);
class APalCharacter* GetNearestEnemyByLocation_FrontPlayerCamera(FVector
Location, class APalCharacter* myCharacter, class APalPlayerCharacter* Player,
float InDegree, float InDistance, float InHeight);
class APalCharacter* GetNearestEnemyByLocation(FVector Location, class
APalCharacter* myCharacter, float& OutMinRange);
class APalMapObject* GetNearestEnemyBuildObject(class AActor* Character);
float GetMontageSectionLengthDefault(class UAnimMontage* Montange);
float GetMontageSectionLength(class UAnimMontage* Montange, FName SectionName);
void GetMontageNotifyStates(class UAnimMontage* Montange, TArray<class
UAnimNotifyState*>& outStates, FName SectionName);
class UPalMoneyData* GetMoneyDataByPlayerUID(const class UObject*
class UPalMasterDataTables* GetMasterDataTables(const class UObject*
class UPalMapObjectManager* GetMapObjectManager(const class UObject*
class USkeletalMeshComponent* GetMainMeshByActor(class AActor* Actor);
class UPalLogManager* GetLogManager(const class UObject* WorldContextObject);
class UPalLocationManager* GetLocationManager(const class UObject*
class UPalWorldMapUIData* GetLocalWorldMapData(const class UObject*
class UPalTechnologyData* GetLocalTechnologyData(const class UObject*
class UPalPlayerRecordData* GetLocalRecordData(const class UObject*
FGuid GetLocalPlayerUID(const class UObject* WorldContextObject);
class APalPlayerState* GetLocalPlayerState(const class UObject*
int32 GetLocalPlayerID(const class UObject* WorldContextObject);
class APlayerController* GetLocalPlayerController(const class UObject*
class UPalPlayerDataPalStorage* GetLocalPalStorageData(const class UObject*
class UPalPlayerInput* GetLocalPalPlayerInput(const class UObject*
class UPalMoneyData* GetLocalMoneyData(const class UObject*
class UPalPlayerInventoryData* GetLocalInventoryData(const class UObject*
class UPalItemIDManager* GetItemIDManager(const class UObject*
class UPalItemContainerManager* GetItemContainerManager(const class UObject*
class UPalPlayerInventoryData* GetInventoryDataByPlayerUID(const class UObject*
class UPalInvaderManager* GetInvaderManager(const class UObject*
float GetInPacketLoss(const class UObject* WorldContextObject);
bool GetInitializedPlayerSaveParemter(const class UObject* WorldContextObject,
const int32 Level, FPalIndividualCharacterSaveParameter& outParameter);
bool GetInitializedCharacterSaveParemter_DebugDefaultParamSetup(const class
UObject* WorldContextObject, const FName CharacterID, const FName UniqueNPCID,
const int32 Level, const FGuid& OwnerPlayerUId,
FPalIndividualCharacterSaveParameter& outParameter, bool
DisableRandomPassiveSkilll, TArray<EPalWazaID> WazaList, TArray<FName>
PassiveSkillList, int32 Rank, bool RarePalAble);
bool GetInitializedCharacterSaveParemter(const class UObject*
WorldContextObject, const FName CharacterID, const FName UniqueNPCID, const int32
Level, const FGuid& OwnerPlayerUId, FPalIndividualCharacterSaveParameter&
outParameter, bool DisableRandomPassiveSkill, bool RarePalAble);
FPalInstanceID GetIndividualIDByActor(const class AActor* Actor);
FPalInstanceID GetIndividualID(const class UPalIndividualCharacterHandle*
Handle);
GetIndividualCharacterParameterByActor(class AActor* Actor);
class UPalIndividualCharacterHandle* GetIndividualCharacterHandleByActor(class
AActor* Actor);
class UPalIncidentSystem* GetIncidentSystem(const class UObject*
void GetHumanNPCs(const class UObject* WorldContextObject, TArray<class
class UPalHUDService* GetHUDService(const class UObject* WorldContextObject);
FName GetHairAttachAccessorySocketName(const class UObject* WorldContextObject,
const FName& HairEquipmentName, const FName& BodyTypeName);
class UPalGroupManager* GetGroupManager(const class UObject*
class UPalGameSetting* GetGameSetting(const class UObject* WorldContextObject);
class UPalFunnelCharacterManager* GetFunnelCharacterManager(const class
FVector GetFloorLocationByActor(class AActor* TargetActor);
FVector GetFloorHitLocationByActor(class AActor* TargetActor);
FString GetFirstLine(FString SourceString);
class UPalExpDatabase* GetExpDatabase(const class UObject* WorldContextObject);
FVector GetExclamationMarkLocation(const class APalCharacter* TargetCharacter);
class UPalEventNotifySystem* GetEventNotifySystem(const class UObject*
TEnumAsByte<ECollisionChannel>
GetEngineCollisionChannelByPalTraceType(EPalTraceTypeQuery Type);
TEnumAsByte<ECollisionChannel>
GetEngineCollisionChannelByPalObjectType(EPalObjectTypeQuery Type);
TEnumAsByte<ECollisionChannel> GetEngineCollisionChannel(EPalObjectTypeQuery
channnel);
TArray<class APalCharacter*> GetEnemiesByLocation(const class UObject*
WorldContextObject, FVector Location, class APalCharacter* myCharacter, float
minDistance, float MaxDistance);
float GetElementMultiplay(const class UObject* WorldContextObject,
EPalElementType AttackElementType, EPalElementType defenceTypeA, EPalElementType
defenceTypeB);
EHumanBone GetEHumanBoneFromBoneName(FName BoneName);
FString GetDisplayVersion(const class UObject* WorldContextObject);
FVector GetDiffVelocity(class AActor* A, class AActor* B);
class UObject* GetDefaultObjectByBlueprint(class UObject* bp);
class UObject* GetDefaultObject(UClass* ObjectClass);
int32 GetDebugEnemySpawnCountForBot(const class UObject* WorldContextObject);
int32 GetDebugBotBaseCampWorkerCount(const class UObject* WorldContextObject);
FName GetDebugBotBaseCampMode(const class UObject* WorldContextObject);
class UPalDeathPenaltyManager* GetDeathPenaltyManager(const class UObject*
class UPalDeadBodyManager* GetDeadBodyManager(const class UObject*
class UPalDatabaseCharacterParameter* GetDatabaseCharacterParameter(const class
class UPalDamagePopUpManager* GetDamagePopUpManager(const class UObject*
EPalWorkSuitability GetCurrentWorkSuitability(class APalCharacter* Character);
class UPalCoopSkillSearchSystem* GetCoopSkillSearchSystem(const class UObject*
class AController* GetController(const class UObject* WorldContextObject, class
AActor* Actor);
bool GetClipboard(FString& String);
UClass* GetClassFromBlueprintAsset(const FAssetData& Asset);
float GetCharacterRadius(const class AActor* Actor);
class UPalCharacterParameterStorageSubsystem*
GetCharacterParameterStorageSubsystem(const class UObject* WorldContextObject);
class UPalCharacterManager* GetCharacterManager(const class UObject*
bool GetCharacterMakeInfoFromLocalPlayer(const class UObject*
WorldContextObject, FPalPlayerDataCharacterMakeInfo& OutMakeInfo);
class UPalCharacterImportanceManager* GetCharacterImportanceManager(const class
FName GetCharacterIDReplacedName(FName originalID);
FName GetCharacterIDFromTribeID(const EPalTribeID TribeID);
FName GetCharacterIDFromCharacter(const class APalCharacter* Character);
class UPalCharacterContainerManager* GetCharacterContainerManager(const class
void GetCharacterApartFromPlayer(const class UObject* WorldContextObject,
TArray<class APalCharacter*>& OutCharacters);
void GetCalculatedCaptureRate(const class UObject* WorldContextObject, float
baseRate, TArray<float>& outCalculatedRateArray);
class UProjectileMovementComponent* GetBulletProjectileComponent(const
TSubclassOf<class APalBullet>& bulletClass);
class UPalBulletCreator* GetBulletCreator(const class UObject*
class UPalBossBattleManager* GetBossBattleManager(const class UObject*
FName GetBoneNameFromEHumanBone(EHumanBone humanBone);
EPalBodyPartsType GetBodyPartsType(const class UActorComponent* Component);
FTransform GetBodyLocation(class AActor* Character, EPalBodyLocationType
bodyLocationType);
class UPalBattleManager* GetBattleManager(const class UObject*
class UPalBaseCampManager* GetBaseCampManager(const class UObject*
class UPalAudioSettingSystem* GetAudioSettingSystem(const class UObject*
FVector GetAttackTargetLocation(const class AActor* Attacker, const class
bool GetAttachInformationByBodyLocation(class AActor* Character,
EPalBodyLocationType bodyLocationType, class USceneComponent*& AttachComponent,
FName& attachBoneName, FTransform& attachRelativeTransform);
class UPalAssetStreamableManager* GetAssetStreamableManager(const class
bool GetArrivableLocation(class UObject* WorldContextObject, const FVector&
StartLocation, const FVector& TargetLocation, const float OffsetZUp, const float
OffsetZUnder, EPalTraceTypeQuery TraceTypeQuery, const float Range, FVector&
OutLocation, float& OutDistance, TEnumAsByte<EDrawDebugTrace::Type> DrawDebugType);
void GetAllPlayerStates(const class UObject* WorldContextObject, TArray<class
APalPlayerState*>& OutPlayerStates);
void GetAllPlayerCharacters(const class UObject* WorldContextObject,
TArray<class APalCharacter*>& OutPlayers);
void GetAllControlledCharacters(const class UObject* WorldContextObject,
TArray<class APalCharacter*>& OutCharacters);
FName GetAkComponentAttachName(class AActor* Character);
FString GetAdminPasswordForCmdline(const class UObject* WorldContextObject);
FQuat GetActorQuat(const class AActor* SourceActor);
void GetActorByGrid(class UObject* WorldContextObject, TSubclassOf<class
AActor> actorClass, FVector2D minPoint, FVector2D maxPoint, int32 gridXMax, int32
gridYMax, int32 gridXNum, int32 gridYNum, TArray<class AActor*>& OutActors);
TArray<FPalKeyAction> GetActionsByKey(const class UObject* WorldContextObject,
FKey Key);
void GeneralTurnToActor_WithMovementRotationSpeed(class AActor* TurnActor,
const class AActor* GoalDirectionActor, float DeltaTime);
void GeneralTurnToActor(class AActor* TurnActor, const class AActor*
TargetActor, float LerpSpeed, float DeltaTime);
void GeneralTurnLinearToActor(class AActor* TurnActor, const class AActor*
TargetActor, float LerpSpeed, float DeltaTime);
void GeneralTurnLinear(class AActor* TurnActor, FVector GoalDirection, float
AngleDegreeSpeed, float DeltaTime);
void GeneralTurn_WithMovementRotationSpeed(class AActor* TurnActor, FVector
GoalDirection, float DeltaTime);
void GeneralTurn(class AActor* TurnActor, FVector GoalDirection, float
LerpSpeed, float DeltaTime);
class APalCharacter* FindRiderByRidingActor(const class AActor* RidingActor);
class APalCharacter* FindOwnerPalCharacter(const class UObject* startObject);
class AActor* FindOwnerActor(const class UObject* startObject);
class AActor* FindHomingTarget_ForPlayer(class APalPlayerCharacter* Player,
float MinRange, float MaxRange, float InFrontDegree);
FText EnumToLocalizedText(const class UObject* WorldContextObject, FString
EnumStr, const EPalLocalizeTextCategory TextCategory, const FString TextIdPrefix);
void EmitSoundForAIListener(FName SoundFName, class AActor* EmitterCharacter,
FVector EmitLocation, float VolumeRate);
void Editor_AddCharacterToImportanceManager(class APalCharacter* Character);
void DropItem_FromOtomoCutMeat(const class AActor* Otomo, const class AActor*
Trainer);
void DropItem_FromEnemyDeath(const class AActor* EnemyActor, const class
AActor* LastAttacker);
void DropCharactersCircularly_ServerInternal(const class UObject*
WorldContextObject, const TArray<class UPalIndividualCharacterHandle*>&
IndividualHandles, const FVector& Location, const FPalDropCharacterExtraParameter
ExtraParameter);
void DropCharacter_ServerInternal(const class UObject* WorldContextObject,
const FPalInstanceID& IndividualId, FVector DropLocation, const FGuid&
RequestPlayerUId);
void DialogWithParameter(const class UObject* WorldContextObject, class
UPalDialogParameterDialog* Parameter);
void Dialog(const class UObject* WorldContextObject, const FText Message, const
EPalDialogType DialogType, FDialogCallback Callback, const bool bNegativeDefault);
void DestroyActorIncludingAttachedActors(class AActor* Actor);
FVector CutVectorByLength(FVector Vector, float Length);
FVector CutVectorByAngle(FVector Target, FVector BaseAxis, float
maxAngleDegree);
void CreateUNKO(class APalCharacter* Character, int32 Count);
TEnumAsByte<ETraceTypeQuery> ConvertToTraceTypeQuery(EPalTraceTypeQuery Type);
TEnumAsByte<EPhysicalSurface> ConvertToPhysicalSurface(EPalPhysicalSurface
Type);
TEnumAsByte<EObjectTypeQuery> ConvertToObjectTypeQuery(EPalObjectTypeQuery
Type);
FString Convert_PalInstanceIDToString(FPalInstanceID ID);
bool ContainsOnlyIn(const TArray<class UObject*> SourceArray, const
TArray<class UObject*> TargetElms, class UObject* Target);
bool ContainsAny(const TArray<class UObject*> SourceArray, const TArray<class
UObject*> FindElms);
bool ClipboardCopy(FString String);
void ClearCharacterRagdoll(class APalCharacter* Character);
bool CanUseTargetMedicine(const class UObject* WorldContextObject, class
UPalIndividualCharacterParameter* IndividualParameter, const class
UPalStaticItemDataBase* Item);
bool CanSpawnDashEffect(class AActor* dashActor);
bool CanNooseTrap(class AActor* Actor);
bool CanAdjustActorToFloor(class AActor* TargetActor, float UpOffset, FVector&
OutLocation);
void CalcSceneComponentBounds(TArray<class USceneComponent*> SceneComps, FBox&
OutBounds);
FRotator CalcRotationGeneralTurnLinear(const FVector& InForwardDirection, const
FVector& InRightDirection, const float CurrentYaw, const FVector& InGoalDirection,
float AngleDegreeSpeed, float DeltaTime, const float YawRate);
int32 CalcRemainBattleTime(FDateTime TimeLimit);
int32 CalcNPCWeaponDamage(const class APalWeaponBase* weapon);
int32 CalcDamageCharacter(const FPalDamageInfo& DamageInfo, const class AActor*
Defender, const FPalCalcCharacterDamageInfo& CharacterDamageInfo);
int32 CalcDamage(const FPalDamageInfo& DamageInfo, const class AActor*
Defender);
float CalcCaptureRateByStatus(const class AActor* TargetPal);
FVector CalcBlowVelocity(EPalBlowVelocityOwner VelocityType, const class
AActor* Attacker, const class USceneComponent* HitComponent, FVector HitLocation,
const class AActor* Defender, FVector NativeVelocity);
bool BoxOvelapLimitVolume(const class UObject* WorldContextObject,
EPalLimitVolumeFlag LimitVolumeFlag, const FVector BoxPos, FVector BoxExtent, const
FQuat& Rot);
void ApplyGuildColorForCharacter(FLinearColor Color, class APalCharacter*
Character);
float AngleBetweenVector(FVector A, FVector B, bool IsDegree);
float Angle180from360Degree(float Degree);
void AlertWithCallback(const class UObject* WorldContextObject, const FText
Message, FAlertWithCallbackCallback Callback);
void Alert(const class UObject* WorldContextObject, const FText Message);
class AActor* AdjustActorToFloor(class AActor* TargetActor, float UpOffset);
void AddForceWithMassScale(class APalCharacter* TargetCharacter, FVector Force,
FName BoneName, bool IsImplus);
void AddDownForceAllRigidBody(class APalCharacter* TargetCharacter, float
Rate);
}; // Size: 0x28
class UPalVenderDataComponent : public UActorComponent

{
FPalVenderDataComponentOnRegisteredItemShopDelegate
OnRegisteredItemShopDelegate; // 0x00A0 (size: 0x10)
void RegisteredItemShopDelegate();
FPalVenderDataComponentOnRegisteredPalShopDelegate OnRegisteredPalShopDelegate;
// 0x00B0 (size: 0x10)
void RegisteredPalShopDelegate();
FGuid MyShopID;
// 0x00C0 (size: 0x10)
int32 ItemShopRestockMinute;
// 0x00D0 (size: 0x4)
EPalShopLotteryType itemShopLotteryType;
// 0x00D4 (size: 0x1)
FPalDataTableRowName_ItemShopLotteryData itemShopSimpleLotteryTableName;
// 0x00D8 (size: 0x8)
TMap<class EPalShopLotteryBiomeType, class
FPalDataTableRowName_ItemShopLotteryData> itemShopBiomeLotteryTableMap; // 0x00E0
(size: 0x50)
int32 PalShopRestockMinute;
// 0x0130 (size: 0x4)
EPalShopLotteryType palShopLotteryType;
// 0x0134 (size: 0x1)
FPalDataTableRowName_PalShopCreateData palShopSimpleLotteryTableName;
// 0x0138 (size: 0x8)
TMap<class EPalShopLotteryBiomeType, class
FPalDataTableRowName_PalShopCreateData> palShopBiomeLotteryTableMap; // 0x0140
(size: 0x50)
class UPalShopBase* MyItemShop;
// 0x0190 (size: 0x8)
class UPalShopBase* MyPalShop;
// 0x0198 (size: 0x8)
bool TryGetPalShop(class UPalShopBase*& OutShop);

bool TryGetItemShop(class UPalShopBase*& OutShop);
void SetupShopData();
void RegisteredPalShopDelegate__DelegateSignature();
void RegisteredItemShopDelegate__DelegateSignature();
void OnRep_MyPalShop();
void OnRep_MyItemShop();
bool IsValidPalShop();
bool IsValidItemShop();
}; // Size: 0x1A0
class UPalVisualEffectBase : public UObject

{
bool bIsEndVisualEffect;
// 0x0028 (size: 0x1)
bool bCanDeleteInstance;
// 0x0029 (size: 0x1)
FPalVisualEffectBaseOnCompleteDelegate OnCompleteDelegate;
// 0x0030 (size: 0x10)
void OnComplete(class UPalVisualEffectBase* VisualEffect);
TArray<EPalVisualEffectID> ConflictIDList;
// 0x0040 (size: 0x10)
EPalVisualEffectID VisualEffectID;
// 0x0050 (size: 0x1)
FPalVisualEffectDynamicParameter DynamicParameter;
// 0x0058 (size: 0x10)
void TickVisualEffect(float DeltaTime);
void TerminatingTickVisualEffect(float DeltaTime);
void OnEndVisualEffect();
void OnDeleteInstance();
void OnComplete__DelegateSignature(class UPalVisualEffectBase* VisualEffect);
void OnBreakVisualEffect(bool bByConflict);
void OnBeginVisualEffect();
bool IsEndVisualEffect();
class AActor* GetOwner();
TArray<class UMaterialInstanceDynamic*> GetMainMeshMaterials();
class USkeletalMeshComponent* GetMainMesh();
float GetFloatParameter(FName Name, float DefaultValue);
TArray<EPalVisualEffectID> GetConflictIDList();
void GetAllMesh(TArray<class USceneComponent*>& OutComponent);
bool CanDeleteInstance();
}; // Size: 0x68
class UPalVisualEffectComponent : public UActorComponent

{
TMap<class EPalVisualEffectID, class TSoftClassPtr<UPalVisualEffectBase>>
VisualEffectClass_OverrideMap; // 0x00A0 (size: 0x50)
FPalVisualEffectComponentOnAddVisualEffectDelegate OnAddVisualEffectDelegate;
// 0x00F0 (size: 0x10)
void OnAddVisualEffect(const class UPalVisualEffectComponent*
VisualEffectComponent, EPalVisualEffectID VisualEffectID, class
UPalVisualEffectBase* VisualEffect);
FPalVisualEffectComponentOnRemoveVisualEffectDelegate
OnRemoveVisualEffectDelegate; // 0x0100 (size: 0x10)
void OnRemoveVisualEffect(const class UPalVisualEffectComponent*
VisualEffectComponent, EPalVisualEffectID VisualEffectID);
FPalVisualEffectComponentOnCompleteVisualEffectDelegate
OnCompleteVisualEffectDelegate; // 0x0110 (size: 0x10)
void OnCompleteVisualEffect(const class UPalVisualEffectComponent*
VisualEffectComponent, EPalVisualEffectID VisualEffectID, class
UPalVisualEffectBase* VisualEffect);
TArray<class UPalVisualEffectBase*> ExecutionVisualEffects;
// 0x0120 (size: 0x10)
TArray<class UPalVisualEffectBase*> TerminatingVisualEffects;
// 0x0130 (size: 0x10)
void RemoveVisualEffectForActor_Local(class AActor* Actor, EPalVisualEffectID

VisualEffectID);
void RemoveVisualEffectForActor(class AActor* Actor, EPalVisualEffectID
VisualEffectID);
void RemoveVisualEffectByConflict_ToServer(EPalVisualEffectID VisualEffectID,
int32 issuerID);
void RemoveVisualEffectByConflict_ToALL(EPalVisualEffectID VisualEffectID,
int32 issuerID);
void RemoveVisualEffect_ToServer(EPalVisualEffectID VisualEffectID, int32
issuerID);
void RemoveVisualEffect_ToALL(EPalVisualEffectID VisualEffectID, int32
issuerID);
void RemoveVisualEffect_Local(EPalVisualEffectID VisualEffectID);
void RemoveVisualEffect(EPalVisualEffectID VisualEffectID);
void RemoveConflictVisualEffect(EPalVisualEffectID VisualEffectID);
void OnRemoveVisualEffect__DelegateSignature(const class
UPalVisualEffectComponent* VisualEffectComponent, EPalVisualEffectID
VisualEffectID);
void OnCompleteVisualEffect__DelegateSignature(const class
VisualEffectID, class UPalVisualEffectBase* VisualEffect);
void OnAddVisualEffect__DelegateSignature(const class
VisualEffectID, class UPalVisualEffectBase* VisualEffect);
void BeginPlay();
class UPalVisualEffectBase* AddVisualEffectForActor_Local(class AActor* Actor,
EPalVisualEffectID VisualEffectID, FPalVisualEffectDynamicParameter Parameter);
class UPalVisualEffectBase* AddVisualEffectForActor(class AActor* Actor,
EPalVisualEffectID VisualEffectID, FPalVisualEffectDynamicParameter Parameter);
void AddVisualEffect_ToServer(EPalVisualEffectID VisualEffectID, const
FPalVisualEffectDynamicParameter& Parameter, int32 issuerID);
void AddVisualEffect_ToALL(EPalVisualEffectID VisualEffectID, const
FPalVisualEffectDynamicParameter& Parameter, int32 issuerID);
class UPalVisualEffectBase* AddVisualEffect_Local(EPalVisualEffectID
VisualEffectID, const FPalVisualEffectDynamicParameter& Parameter);
class UPalVisualEffectBase* AddVisualEffect(EPalVisualEffectID VisualEffectID,
const FPalVisualEffectDynamicParameter& Parameter);
}; // Size: 0x140
class UPalVisualEffectDataBase : public UObject

{
TMap<class EPalVisualEffectID, class TSoftClassPtr<UPalVisualEffectBase>>
VisualEffectClassDataReference; // 0x0028 (size: 0x50)
class UMaterialParameterCollection* MosaicMaterialParameterCollection;
// 0x0078 (size: 0x8)
TMap<class EPalVisualEffectID, class TSubclassOf<UPalVisualEffectBase>>
VisualEffectClassDataAsset; // 0x0080 (size: 0x50)
FName GetMosaicKeyName();
}; // Size: 0xD8
class UPalWaitInfoWorldHUDParameter : public UPalHUDDispatchParameterBase

{
// 0x0038 (size: 0x8)
bool isWaiting;
// 0x0040 (size: 0x1)
}; // Size: 0x48
class UPalWazaDatabase : public UObject

{
class UDataTable* WazaDataTable;
// 0x0028 (size: 0x8)
TMap<class EPalAdditionalEffectType, class EPalStatusID>
AdditionalEffectToStatusID; // 0x0030 (size: 0x50)
class UDataTable* WazaMasterLevel_DataTable;
// 0x0080 (size: 0x8)
class UDataTable* WazaMasterTamago_DataTable;
// 0x0088 (size: 0x8)
bool IsExistMasterrableWaza_BetweenLevel(FName CharacterID, int32 StartLevel,

int32 EndLevel);
void GetMasterrableWaza_BetweenLevel(FName CharacterID, int32 StartLevel, int32
EndLevel, TMap<EPalWazaID, int32>& OutMap);
bool FindWazaForBP(EPalWazaID Type, FPalWazaDatabaseRaw& OutData);
}; // Size: 0x90
class UPalWeaponFilter : public UPalHitFilter
{
float BlowSpeed;
// 0x0158 (size: 0x4)
float BlowUpRate;
// 0x015C (size: 0x4)
float DamageRate;
// 0x0160 (size: 0x4)
bool IsBlow;
// 0x0164 (size: 0x1)
// 0x0168 (size: 0x8)
}; // Size: 0x170
class UPalWidgetAnimationArray : public UObject

{
class UUserWidget* TargetWidget;
// 0x0028 (size: 0x8)
TMap<class FName, class UWidgetAnimation*> AnimationMap;
// 0x0030 (size: 0x50)
float multiplyTimeScale;
// 0x0080 (size: 0x4)
void StopAnimation(const FName& animationName);

void StopAllAnimation();
void SetTimeScale(float TimeScale);
void PlayOneShotReverse(const FName& animationName);
void PlayOneShotPingPong(const FName& animationName);
void PlayOneshot(const FName& animationName);
void PlayLoopReverse(const FName& animationName);
void PlayLoopPingPong(const FName& animationName);
void PlayLoop(const FName& animationName);
void PauseAnimation(const FName& animationName);
void Initialize(class UUserWidget* inTargetWidget);
void GetAnimationNameArray(TArray<FName>& OutArray);
}; // Size: 0x88
class UPalWidgetTimerGaugeParameter : public UPalHUDDispatchParameterBase

{
FTimerHandle TimerHandle;
// 0x0038 (size: 0x8)
float Time;
// 0x0040 (size: 0x4)
FName bindActionName;
// 0x0044 (size: 0x8)
bool IsHide;
// 0x004C (size: 0x1)
}; // Size: 0x50
class UPalWildDrinkWaterSpot : public UObject

{
bool IsReserved;
// 0x0028 (size: 0x1)
FVector SpotActorLocation;
// 0x0030 (size: 0x18)
TArray<FVector> PalGoalLocations;
// 0x0048 (size: 0x10)
bool SetAssignPointToMember(TArray<class AActor*> MemberList);

FVector GetActorLocation();
}; // Size: 0x58
class UPalWildPalDrinkWaterSpotProvider : public UObject

{
TMap<class FGuid, class UPalWildDrinkWaterSpot*> DrinkWaterSpotList;
// 0x0028 (size: 0x50)
bool RequestReservation(class AActor* LeaderPal, FVector WildPalSpawnerCenter,

int32 MemberNum, FGuid& OutSpotID);
class UPalWildDrinkWaterSpot* FindSpot(FGuid SpotID);
void CancelReservation(FGuid SpotID);
void AddDrinkWaterSpot(FVector ActorLocation, TArray<FVector> GoalLocations);
}; // Size: 0x78
class UPalWildSpawnerDataTable : public UObject

{
TArray<FPalSpawnerGroupInfo> CreateGroupList(TArray<FPalWildSpawnerDatabaseRow>
DataList);
}; // Size: 0x28
class UPalWorkAssign : public UObject

{
FPalWorkAssignHandleId HandleId;
// 0x0028 (size: 0x18)
FPalInstanceID AssignedIndividualId;
// 0x0040 (size: 0x30)
EPalWorkWorkerState State;
// 0x0070 (size: 0x1)
bool bFixed;
// 0x0071 (size: 0x1)
EPalWorkWorkerWorkingState WorkingState;
// 0x0072 (size: 0x1)
FVector LocalRandomWorkLocation;
// 0x0078 (size: 0x18)
bool IsWorking();
bool IsWorkable();
bool IsFixed();
bool IsAssignedIndividualId(const FPalInstanceID& IndividualId);
bool IsAssigned();
EPalWorkWorkerWorkingState GetWorkingState();
FGuid GetWorkId();
EPalWorkWorkerState GetState();
int32 GetLocationIndex();
FPalWorkAssignHandleId GetId();
class UPalIndividualCharacterParameter* GetAssignedIndividualParameter();
FPalInstanceID GetAssignedIndividualId();
class UPalIndividualCharacterHandle* GetAssignedIndividualHandle();
}; // Size: 0x90
class UPalWorkAssign_LevelObject : public UPalWorkAssign

{
FGuid TargetMapObjectModelId;
// 0x0090 (size: 0x10)
}; // Size: 0xA0
class UPalWorkAssign_MonsterFarm : public UPalWorkAssign

{
FFloatCounter ActionIntervalTimer;
// 0x0090 (size: 0x8)
FVector WalkTargetLocation;
// 0x0098 (size: 0x18)
FPalStaticItemIdAndNum SpawnItemInfoPerAction;
// 0x00C8 (size: 0xC)
int32 SpawnActionWholeCount;
// 0x00D4 (size: 0x4)
int32 SpawnActionCurrentCount;
// 0x00D8 (size: 0x4)
}; // Size: 0xE0
class UPalWorkAssign_OnlyJoinAndWalkAround : public UPalWorkAssign

{
// 0x0090 (size: 0x18)
}; // Size: 0xC0
class UPalWorkBase : public UObject

{
FPalWorkBaseOnDisposeDelegate OnDisposeDelegate;
// 0x0030 (size: 0x10)
void NotifyWorkDelegate(class UPalWorkBase* Work);
FPalWorkBaseOnFinishWorkInServerDelegate OnFinishWorkInServerDelegate;
// 0x0040 (size: 0x10)
FPalWorkBaseOnReflectFinishWorkDelegate OnReflectFinishWorkDelegate;
// 0x0050 (size: 0x10)
FPalWorkBaseOnUpdateAssignedCharacterDelegate
OnUpdateAssignedCharacterDelegate; // 0x0060 (size: 0x10)
FPalWorkBaseOnUpdateCurrentStateDelegate OnUpdateCurrentStateDelegate;
// 0x0070 (size: 0x10)
FPalWorkBaseOnRequiredAssignWorkDelegate OnRequiredAssignWorkDelegate;
// 0x0080 (size: 0x10)
void WorkAssignRequirementDelegate(class UPalWorkBase* Work, const
FPalWorkBaseOnAssignWorkDelegate OnAssignWorkDelegate;
// 0x0090 (size: 0x10)
IndividualId);
FPalWorkBaseOnUnassignWorkDelegate OnUnassignWorkDelegate;
// 0x00A0 (size: 0x10)
IndividualId);
FPalWorkBaseOnStartWorkDelegate OnStartWorkDelegate;
// 0x00B0 (size: 0x10)
IndividualId);
FPalWorkBaseOnEndWorkDelegate OnEndWorkDelegate;
// 0x00C0 (size: 0x10)
IndividualId);
// 0x00D0 (size: 0x80)
FName AssignDefineDataId;
// 0x0150 (size: 0x8)
EPalWorkType OverrideWorkType;
// 0x0158 (size: 0x1)
TArray<FPalWorkAssignLocalLocation> AssignLocations;
// 0x0160 (size: 0x10)
// 0x0174 (size: 0x10)
FGuid OwnerMapObjectModelId;
// 0x0184 (size: 0x10)
FGuid OwnerMapObjectConcreteModelId;
// 0x0194 (size: 0x10)
EPalWorkBehaviourType BehaviourType;
// 0x01A4 (size: 0x1)
EPalWorkAssignableFixedType AssignableFixedType;
// 0x01A5 (size: 0x1)
bool bAssignableOtomo;
// 0x01A6 (size: 0x1)
bool bCanTriggerWorkerEvent;
// 0x01A7 (size: 0x1)
bool bCanStealAssign;
// 0x01A8 (size: 0x1)
FGuid ID;
// 0x01AC (size: 0x10)
EPalWorkProgressState CurrentState;
// 0x01BC (size: 0x1)
class UPalWorkProgressTransformBase* Transform;
// 0x01C0 (size: 0x8)
FPalFastWorkAssignRepInfoArray AssignRepInfoArray;
// 0x01C8 (size: 0x148)
bool bGroupRaycastStartOffsetOrigin;
// 0x0310 (size: 0x1)
void WorkAssignUpdateDelegate__DelegateSignature(class UPalWorkBase* Work,

void WorkAssignRequirementDelegate__DelegateSignature(class UPalWorkBase* Work,
const FPalWorkAssignRequirementParameter& RequirementParameter);
void NotifyWorkDelegate__DelegateSignature(class UPalWorkBase* Work);
void IssueNotifierLog_WorkStart(const class UPalCharacterParameterComponent*
CharacterParameter);
bool IsExistAssignableSlot(const class UPalIndividualCharacterHandle*
AssignIndividualHandle, const bool bByFixedAssign);
bool IsAssignedCharacter(const class UPalIndividualCharacterHandle*
IndividualHandle);
bool IsAssignableFixedOnly();
FText GetWorkName();
FGuid GetWorkId();
void GetWorkAssignInfo(TArray<FPalWorkAssignInfo>& OutWorkAssignInfo);
void GetWorkableElementTypeNames(TArray<FText>& outElementNames);
FGuid GetId();
void GetGenusCategorieNames(TArray<FText>& outGenusCategorieNames);
void GetAssignedCharacters(TArray<class UPalIndividualCharacterSlot*>&
IndividualSlots);
EPalWorkAssignableFixedType GetAssignableFixedType();
}; // Size: 0x320
class UPalWorkBootUp : public UPalWorkBase

{
FPalWorkBootUpOnBootUpInServerDelegate OnBootUpInServerDelegate;
// 0x0318 (size: 0x10)
void ReturnSelfMulticastDelegate(class UPalWorkBootUp* Self);
}; // Size: 0x340
class UPalWorkDefense : public UPalWorkBase

{
TSubclassOf<class UPalAIActionBaseCampDefenseBase> DefenseAIActionClass;
// 0x0318 (size: 0x8)
TSubclassOf<class UPalActionBase> DefenseWaitActionClass;
// 0x0320 (size: 0x8)
EPalWorkDefenseCombatType DefenseCombatType;
// 0x0328 (size: 0x1)
TWeakObjectPtr<class UPalMapObjectDefenseModelBase> WeakDefenseModel;
// 0x032C (size: 0x8)
TWeakObjectPtr<class UPalMapObjectDefenseBulletLauncherModel>
WeakDefenseBulletLauncherModel; // 0x0334 (size: 0x8)
}; // Size: 0x340
class UPalWorkDefine : public UBlueprintFunctionLibrary

{
}; // Size: 0x28
class UPalWorkEffectComponent : public UNiagaraComponent

{
// 0x07D0 (size: 0x4)
bool bActiveFX;
// 0x07D4 (size: 0x1)
void OnWorkStarted(class UPalWorkBase* Work, const FPalInstanceID&

IndividualId);
void OnWorkEnded(class UPalWorkBase* Work, const FPalInstanceID& IndividualId);
void OnRep_ActiveFX();
}; // Size: 0x7E0
class UPalWorkFacingComponent : public UArrowComponent

{
}; // Size: 0x550
class UPalWorkForLevelObject : public UPalWorkBase

{
}; // Size: 0x320
class UPalWorkMonsterFarm : public UPalWorkBase

{
FFloatInterval ActionIntervalSeconds;
// 0x0318 (size: 0x8)
}; // Size: 0x340
class UPalWorkOnlyJoin : public UPalWorkBase
{
}; // Size: 0x320
class UPalWorkOnlyJoinAndWalkAround : public UPalWorkBase

{
}; // Size: 0x340
class UPalWorkProgress : public UPalWorkBase

{
FPalWorkProgressOnUpdateWorkAmountInServerDelegate
OnUpdateWorkAmountInServerDelegate; // 0x0320 (size: 0x10)
void NotifyWorkProgressDelegate(class UPalWorkProgress* WorkProgress);
FPalWorkProgressOnReflectWorkAmountDelegate OnReflectWorkAmountDelegate;
// 0x0330 (size: 0x10)
void NotifyWorkProgressDelegate(class UPalWorkProgress* WorkProgress);
float RequiredWorkAmount;
// 0x0340 (size: 0x4)
float CurrentWorkAmount;
// 0x0344 (size: 0x4)
float CurrentWorkAmountByLocalPlayer;
// 0x0348 (size: 0x4)
TArray<FGuid> WorkingPlayerUIds;
// 0x0350 (size: 0x10)
int32 WorkExp;
// 0x0360 (size: 0x4)
float AutoWorkSelfAmountBySec;
// 0x0364 (size: 0x4)
bool bNotAllowReactionOnWorkComplete;
// 0x0368 (size: 0x1)
float ProgressTimeSinceLastTick;
// 0x036C (size: 0x4)
void OnRep_CurrentWorkAmount();
void NotifyWorkProgressDelegate__DelegateSignature(class UPalWorkProgress*
WorkProgress);
bool IsCompleted();
float GetRequiredWorkAmount();
int32 GetRemainWorkPredicateTime();
float GetRemainWorkAmount();
float GetProgressRate();
float GetCurrentWorkAmount();
}; // Size: 0x370
class UPalWorkProgressManager : public UPalWorldSubsystem

{
TMap<class FGuid, class UPalWorkBase*> WorkMap_InServer;
// 0x00B0 (size: 0x50)
TMap<class FName, class FPalWorkAssignDefineData> WorkAssignDefineMap;
// 0x0160 (size: 0x50)
FPalWorkAssignDefineData NotWorkableAssignDefine;
// 0x01B0 (size: 0x38)
FPalWorkAssignDefineData BuildAssignDefine;
// 0x01E8 (size: 0x38)
TArray<TEnumAsByte<EObjectTypeQuery>> SearchWorkObjectObjectTypes;
// 0x0220 (size: 0x10)
TMap<class EPalWorkType, class EPalActionType> WorkCompleteActionMap;
// 0x0230 (size: 0x50)
TMap<class FName, class FGuid> LevelObjectWorkIdMap;
// 0x0280 (size: 0x50)
TArray<class UPalWorkBase*> MoveCheckWorkList_InServer_Async;
// 0x02D0 (size: 0x10)
TArray<class UPalWorkBase*> MovedWorkList_InServer_Async;
// 0x02E0 (size: 0x10)
int32 MoveCheckProcessIndex;
// 0x02F0 (size: 0x4)
int32 MoveCheckMaxNumPerFrame;
// 0x02F4 (size: 0x4)
int32 WorkTickInvokeMaxNumInOneTick;
// 0x02F8 (size: 0x4)
TMap<EPalWorkType, int32> WorkTypeAssignPriorityMap;
// 0x0300 (size: 0x50)
void WorkDelegate__DelegateSignature(class UPalWorkBase* Work);

class UPalWorkBase* GetWorkByAssignId(const FPalWorkAssignHandleId&
WorkAssignId);
class UPalWorkAssign* GetWorkAssign(const FPalWorkAssignHandleId&
WorkAssignId);
class UPalWorkBase* GetWork(const FGuid& WorkId);
}; // Size: 0x388
class UPalWorkProgressTransformBase : public UObject

{
}; // Size: 0x28
class UPalWorkProgressTransformCharacter : public UPalWorkProgressTransformBase

{
// 0x0028 (size: 0x30)
FTransform TransformCache;
// 0x0060 (size: 0x60)
}; // Size: 0xC0
class UPalWorkProgressTransformMapObject : public UPalWorkProgressTransformBase

{
// 0x0028 (size: 0x10)
FTransform TransformCache;
// 0x0040 (size: 0x60)
bool bCached;
// 0x00A0 (size: 0x1)
bool bShouldSearchForFoliage;
// 0x00AC (size: 0x1)
}; // Size: 0xB0
class UPalWorkProgressTransformStatic : public UPalWorkProgressTransformBase

{
// 0x0030 (size: 0x60)
}; // Size: 0x90
class UPalWorkProgressUtility : public UBlueprintFunctionLibrary

{
float WorkAmountToManMonth(const class UObject* WorldContextObject, const float

WorkAmount);
}; // Size: 0x28
class UPalWorkRemoveMapObjectEffect : public UPalWorkBase

{
EPalStatusID TargetEffectType;
// 0x0318 (size: 0x1)
}; // Size: 0x320
class UPalWorkRepair : public UPalWorkBase

{
FGuid ConnectToModelInstanceId;
// 0x032C (size: 0x10)
TArray<class UPalMapObjectModel*> ConnectedModels;
// 0x0340 (size: 0x10)
}; // Size: 0x360
class UPalWorkReviveCharacter : public UPalWorkBase

{
FPalInstanceID TargetIndividualId;
// 0x0318 (size: 0x30)
}; // Size: 0x350
class UPalWorkSuitabilityUtility : public UBlueprintFunctionLibrary

{
}; // Size: 0x28
class UPalWorkTransportItemInBaseCamp : public UPalWorkBase

{
EPalWorkTransportItemType TransportType;
// 0x0318 (size: 0x1)
float ApproachFailedTimeout;
// 0x031C (size: 0x4)
}; // Size: 0x340
class UPalWorkTypeUtility : public UBlueprintFunctionLibrary

{
}; // Size: 0x28
class UPalWorkUtility : public UBlueprintFunctionLibrary

{
bool BP_TryGetWorkLocation(const class UPalWorkBase* Target, FVector&

OutLocation);
FVector BP_GetWorkLocation(const class UPalWorkBase* Target);
}; // Size: 0x28
class UPalWorldBaseInfoSaveDataUtility : public UBlueprintFunctionLibrary

{
FString GetWorldName(const FPalWorldBaseInfoSaveData& SaveData);

}; // Size: 0x28
class UPalWorldBaseInfoSaveGame : public USaveGame

{
int32 Version;
// 0x0028 (size: 0x4)
// 0x0030 (size: 0x8)
FPalWorldBaseInfoSaveData SaveData;
// 0x0038 (size: 0x28)
}; // Size: 0x60
class UPalWorldHUDDisplayInfo : public UObject

{
FPalWorldHUDParameter Parameter;
// 0x0028 (size: 0x68)
FGuid ID;
// 0x0090 (size: 0x10)
bool bDisposeFlag;
// 0x00A0 (size: 0x1)
FGuid WidgetId;
// 0x00A4 (size: 0x10)
}; // Size: 0xB8
class UPalWorldMapUIData : public UObject

{
FPalWorldMapUIDataOnUnlockedMap OnUnlockedMap;
// 0x0028 (size: 0x10)
void UnlockedMapDelegate(const FName& unlockedRegionId, const int32 PlayerId);
class UTextureRenderTarget2D* MaskRenderTarget;
// 0x0038 (size: 0x8)
class UTexture2D* MaskTexture;
// 0x0040 (size: 0x8)
TArray<uint8> cachedTextureRawData;
// 0x0060 (size: 0x10)
TMap<class FName, class bool> unlockedRegionMap;
// 0x0070 (size: 0x50)
class UDataTable* worldMapDataTable;
// 0x00C0 (size: 0x8)
FName currentPlayMapName;
// 0x00C8 (size: 0x8)
bool UnlockMap(const FName& regionId, const int32 PlayerId);

void UnlockedMapDelegate__DelegateSignature(const FName& unlockedRegionId,
const int32 PlayerId);
bool IsUnlockedMap(const FName& regionId);
void GetUnlockedMapData(TMap<class FName, class bool>& outMapData);
bool GetCurrentPlayMapUIData(FPalWorldMapUIDataTableRow& OutData);
FName GetCurrentPlayMapName();
}; // Size: 0xD0
class UPalWorldObjectRecordWorldSubsystem : public UPalWorldSubsystem

{
TMap<class UClass*, class UPalWorldObjectRecorderBase*> RecorderMap;
// 0x0078 (size: 0x50)
class UPalWorldObjectRecorderBase* BP_GetRecorder(const class UObject*

WorldContextObject, const TSubclassOf<class UPalWorldObjectRecorderBase>
TargetClass);
}; // Size: 0xC8
class UPalWorldObjectRecord_MapObjectSpawnerInStage : public
UPalWorldObjectRecorderBase
{
TMap<class FPalStageInstanceId, class
FPalWorldObjectRecordData_MapObjectSpawnerInStage>
RecordDataMapByStageInstanceId; // 0x0028 (size: 0x50)
}; // Size: 0x78
class UPalWorldObjectRecorderBase : public UObject

{
}; // Size: 0x28
class UPalWorldOptionSaveGame : public USaveGame

{
int32 Version;
// 0x0028 (size: 0x4)
// 0x0030 (size: 0x8)
FPalOptionWorldSaveData OptionWorldData;
// 0x0038 (size: 0x128)
}; // Size: 0x160
class UPalWorldPlayerSaveGame : public USaveGame

{
int32 Version;
// 0x0028 (size: 0x4)
// 0x0030 (size: 0x8)
FPalWorldPlayerSaveData SaveData;
// 0x0040 (size: 0x4B0)
}; // Size: 0x4F0
class UPalWorldSaveGame : public USaveGame

{
int32 Version;
// 0x0028 (size: 0x4)
// 0x0030 (size: 0x8)
FPalWorldSaveData worldSaveData;
// 0x0038 (size: 0x3A0)
}; // Size: 0x3D8
class UPalWorldSecurityCrimeInstance : public UObject

{
FGuid InstanceId;
// 0x0028 (size: 0x10)
FName CrimeId;
// 0x0038 (size: 0x8)
FGuid TargetId;
// 0x0040 (size: 0x10)
}; // Size: 0x50
class UPalWorldSecurityDefine : public UBlueprintFunctionLibrary

{
}; // Size: 0x28
class UPalWorldSecurityLawBase : public UObject

{
FPalDataTableRowName_CrimeMasterData CrimeId;
// 0x0028 (size: 0x8)
bool bInvalid;
// 0x0030 (size: 0x1)
float CrimeStateMaintainDurationBase;
// 0x0034 (size: 0x4)
bool bNotUseReleaseTimer;
// 0x0038 (size: 0x1)
}; // Size: 0x40
class UPalWorldSecurityLawTrigger : public UPalWorldSecurityLawBase

{
}; // Size: 0x40
class UPalWorldSecurityLawTrigger_AreaInvasion : public UPalWorldSecurityLawTrigger

{
void OnNotifiedEventEnd(class AActor* InvasionActor, const FGuid&

AreaInstanceId);
void OnNotifiedEvent(class AActor* InvasionActor, const FGuid& AreaInstanceId);
bool Condition(class AActor* InvasionActor, class
UPalIndividualCharacterHandle*& CriminalHandle);
}; // Size: 0x40
class UPalWorldSecurityLawTrigger_CharacterDamaged : public

UPalWorldSecurityLawTrigger
{
void OnNotifiedEvent(const FPalDamageResult& DamageResult);

bool Condition(const FPalDamageResult& DamageResult, class
UPalIndividualCharacterHandle*& CriminalHandle);
}; // Size: 0x40
class UPalWorldSecurityLawTrigger_ItemMove : public UPalWorldSecurityLawTrigger

{
void OnNotifiedEvent(const FPalItemOperationInfo_Move& EventInfo);

bool Condition(const FPalItemOperationInfo_Move& EventInfo);
}; // Size: 0x40
class UPalWorldSecuritySystem : public UPalWorldSubsystem

{
FPalWorldSecuritySystemOnReportCriminalDelegate OnReportCriminalDelegate;
// 0x0098 (size: 0x10)
void ReportCriminalDelegate(class UPalIndividualCharacterHandle*
CriminalHandle, FPalWorldSecurityWantedStateInfo WantedStateInfo);
FPalWorldSecuritySystemOnReleaseWantedDelegate OnReleaseWantedDelegate;
// 0x00A8 (size: 0x10)
void ReleaseWantedDelegate(class UPalIndividualCharacterHandle*
CriminalHandle);
FPalWorldSecuritySystemOnRegisterdAreaTriggerDelegate
OnRegisterdAreaTriggerDelegate; // 0x00B8 (size: 0x10)
void RegisterdAreaTriggerDelegate(class APalTriggerAreaBase* TriggerBase);
FName LawClassDirectoryPath;
// 0x00C8 (size: 0x8)
TArray<class UPalWorldSecurityLawBase*> Laws;
// 0x00D0 (size: 0x10)
FGuid GroupID;
// 0x00E0 (size: 0x10)
TMap<class FPalInstanceID, class FPalCrimeStateInfo> IndividualCrimeStateMap;
// 0x00F0 (size: 0x50)
TMap<class FPalInstanceID, class FPalWorldSecurityWantedStateInfo>
IndividualWantedStateMap; // 0x0140 (size: 0x50)
TMap<class FGuid, class UPalWorldSecurityCrimeInstance*> CrimeInstanceMap;
// 0x0190 (size: 0x50)
TArray<TWeakObjectPtr<APalTriggerAreaBase>> WeakTriggerAreaList;
// 0x01E0 (size: 0x10)
TMap<class FGuid, class UPalIndividualCharacterHandle*> CriminalMap;
// 0x01F0 (size: 0x50)
void ReportCriminalDelegate__DelegateSignature(class
UPalIndividualCharacterHandle* CriminalHandle, FPalWorldSecurityWantedStateInfo
WantedStateInfo);
void ReportCriminal(class UPalIndividualCharacterHandle* CriminalHandle, class
UPalIndividualCharacterHandle* ReporterHandle);
void ReleaseWantedDelegate__DelegateSignature(class
UPalIndividualCharacterHandle* CriminalHandle);
void ReleaseWanted(class UPalIndividualCharacterHandle* CriminalHandle);
void ReleaseCrime(class UPalIndividualCharacterHandle* CriminalHandle, const
FGuid& CrimeInstanceId);
void RegisterdAreaTriggerDelegate__DelegateSignature(class APalTriggerAreaBase*
TriggerBase);
class APalTriggerAreaBase* GetNearestTriggerArea(FVector Location);
FName GetCrimeIdByCrimeInstanceId(const FGuid& CrimeInstanceId);
}; // Size: 0x248
class UPalWorldSecurityUtility : public UBlueprintFunctionLibrary

{
bool IsWantedCharacter(class APalCharacter* Target);

bool IsCriminalCharacter(class APalCharacter* Target);
bool FindCriminalsInSight(class APalCharacter* Target, TArray<class
APalCharacter*>& Criminals);
}; // Size: 0x28
class UPalWorldSubsystem : public UWorldSubsystem

{
bool bShouldCreate;
// 0x0038 (size: 0x1)
TArray<class TSubclassOf<UWorldSubsystem>> PrerequisiteWorldSubsystemList;
// 0x0040 (size: 0x10)
}; // Size: 0x70
class UReactivePropertyFloatUtility : public UObject

{
void BindProperty(FReactivePropertyFloat& Property, FBindPropertyDelegate

Delegate);
}; // Size: 0x28
#endif

Palworld Props

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Palworld Props

Uploaded by

Copyright:

Available Formats

#ifndef UE4SS_SDK_Pal_HPP

struct FCharacterParameterRepInfo : public FFastArraySerializerItem

struct FDelegateTickFunction : public FTickFunction

struct FFastCharacterParameterRepInfoArray : public FFastArraySerializer

struct FFastPalBaseCampRepInfoArray : public FFastArraySerializer

struct FFastPalLocationRepInfoArray : public FFastArraySerializer

struct FPalAIMoveRequest : public FAIMoveRequest

struct FPalAxisKeyConfigKeys : public FPalKeyConfigKeys

struct FPalBPClassDataRow : public FTableRowBase

struct FPalBaseCampLevelMasterData : public FTableRowBase

struct FPalBaseCampPassiveEffectRepInfo : public FFastArraySerializerItem

struct FPalBaseCampRepInfo : public FFastArraySerializerItem

struct FPalBaseCampSaveData : public FPalBinaryMemory

struct FPalBaseCampSaveData_Module : public FPalBinaryMemory

struct FPalBaseCampSaveData_Module_PassiveEffect : public FPalBinaryMemory

struct FPalBaseCampSaveData_WorkCollection : public FPalBinaryMemory

struct FPalBaseCampSaveData_WorkerDirector : public FPalBinaryMemory

struct FPalBaseCampTaskDataSet_TableRow : public FTableRowBase

struct FPalBaseCampWorkerEventMasterData : public FTableRowBase

struct FPalBaseCampWorkerSickMasterData : public FTableRowBase

struct FPalBuildObjectData : public FTableRowBase

struct FPalBuildObjectIconData : public FTableRowBase

struct FPalCaptureBonusExpRaw : public FTableRowBase

struct FPalCapturedCageInfoDatabaseRow : public FTableRowBase

struct FPalCharacterContainerSaveData : public FPalBinaryMemory

struct FPalCharacterCreationColorPresetDataRow : public FTableRowBase

struct FPalCharacterCreationEyeMaterialDataRow : public FTableRowBase

struct FPalCharacterCreationMakeInfoPresetDataRow : public FTableRowBase

struct FPalCharacterCreationMeshPresetDataRow : public FTableRowBase

struct FPalCharacterCreationPresetDataRow : public FTableRowBase

struct FPalCharacterIconDataRow : public FTableRowBase

struct FPalCharacterParameterDatabaseRow : public FTableRowBase

struct FPalCharacterSlotSaveData : public FPalBinaryMemory

struct FPalCharacterUpgradeMasterData : public FTableRowBase

struct FPalCombiUniqueDatabaseRow : public FTableRowBase

struct FPalContainerBelongInfo : public FPalBelongInfo

struct FPalCrimeMasterData : public FTableRowBase

struct FPalDropItemDatabaseRow : public FTableRowBase

struct FPalDungeonEnemySpawnerData : public FTableRowBase

struct FPalDungeonItemSpawnerData : public FTableRowBase

struct FPalDungeonLevelData : public FTableRowBase

struct FPalDungeonSpawnAreaData : public FTableRowBase

struct FPalDynamicItemSaveData : public FPalBinaryMemory

struct FPalEditorItemActorClassTableRow : public FTableRowBase

struct FPalEditorItemDynamicClassTableRow : public FTableRowBase

struct FPalEditorItemIconTableRow : public FTableRowBase

struct FPalEditorItemStaticClassTableRow : public FTableRowBase

struct FPalEditorItemStaticMeshTableRow : public FTableRowBase

struct FPalExpDatabaseRaw : public FTableRowBase

struct FPalFastBaseCampPassiveEffectRepInfoArray : public FFastArraySerializer

struct FPalFastGuildPlayerInfoRepInfoArray : public FFastArraySerializer

struct FPalFastMapObjectModelEffectRepInfoArray : public FFastArraySerializer

struct FPalFastMapObjectModuleRepInfoArray : public FFastArraySerializer

struct FPalFastStageModelRepInfoArray : public FFastArraySerializer

struct FPalFastWorkAssignRepInfoArray : public FFastArraySerializer

struct FPalFieldLotteryName : public FTableRowBase

struct FPalFoliageInstanceRepInfoArray : public FFastArraySerializer

struct FPalFoliageInstanceSaveData : public FPalBinaryMemory

struct FPalFoliageMasterData : public FTableRowBase

struct FPalFoliageSaveData : public FPalBinaryMemory

struct FPalFoliageTypeReference : public FTableRowBase

struct FPalGameProgressPresetDataTableRow : public FTableRowBase

struct FPalGroupSaveData : public FPalBinaryMemory